# MotionGenesis™ Help

### Copyright © 2009-2026 Motion Genesis LLC. All rights reserved.

    Interface (type  Help Interface  for quick tips):
     !  Clear  Echo  Help  List  GetMemory  Pause  Run  Quit  Save  if
    -------------------------------------------------------------------------------
    Pre-defined symbols (type  HELP SYNTAX  for syntax help):
     pi imaginary  true false  % %%   0>   0>>   1>>   >   >>   :=   &  []
     t  tInitial  tFinal  tStep  absError
    -------------------------------------------------------------------------------
    Mathematical functions  (type  HELP MathFunctions  for more help):
     abs   exp    log   log10   factorial  squared  sqrt   Spline
     cos   sin    tan   cosh    sinh       tanh     acos   asin    atan   atan2
     ceil  floor  int   round   sign       max      min            RandomInteger
     cosDegrees   sinDegrees    tanDegrees acosDegrees     ...     atan2Degrees
    -------------------------------------------------------------------------------
    Mathematical commands (work on scalars, vectors, and matrices):
     D Dt DtDt  Evaluate        EvaluateToNumber  Exclude   Include  RoundDigits
     Integrate  GetCoefficient  GetRhs   GetTaylorSeries  Linearize  ReplaceString
    -------------------------------------------------------------------------------
    Mathematical simplification (work on scalars, vectors, and matrices):
     Expand  Epsilon   Explicit  Factor  FactorLinear  FactorQuadratic  Zee
    -------------------------------------------------------------------------------
    Logical functions:
     if true false  IsContainSymbol  IsSimplifyEqual IsSimplifyZero IsSimplifyTrue
     Strcmp  Strcmpi  IsNegative  IsNegativeOr0  IsPositiveOr0  IsPositive
    -------------------------------------------------------------------------------
    Roots, solving equations, and setting ordinary derivatives
     GetCubicRoots  GetQuadraticRoots  GetPolynomialRoots  ...
     Solve          SolveDt            SolveSetInput       SolveSetInputDt
     SetDt  SolveQuadraticPositiveRoot  SolveQuadraticPositiveRootDt ...
    -------------------------------------------------------------------------------
    Mathematical declarations:
     Constant   Variable   Specified   pi   ImaginaryNumber   IndependentVariable
     SetGeneralizedSpeed   SetGeneralizedCoordinate
    -------------------------------------------------------------------------------
    Physical declarations:
     NewtonianFrame   RigidBody   RigidFrame   Point   Particle    System
    -------------------------------------------------------------------------------
    Mass, center of mass, inertia, and charge:
     GetMass              SetMass              GetCharge           SetCharge
     GetCMPosition        GetCMVelocity        GetCMAcceleration
     GetInertiaDyadic     GetInertiaMatrix     GetMomentOfInertia  SetInertia
     GetProductOfInertia  GetRadiusOfGyration  GetInertiaVector    SetMassInertia
    -------------------------------------------------------------------------------
    Vectors and dyadics:
     Cross                   Dot                          Dyadic   Express
     GetAngleBetweenVectors  GetAngleBetweenUnitVectors   GetBasisVector
     GetMagnitude            GetMagnitudeSquared
     GetUnitVector           Vector
    -------------------------------------------------------------------------------
    Matrices:
     GetColumns      GetDeterminant      GetDiagonalMatrix   GetEigen   GetNorm
     GetElement []   GetIdentityMatrix   GetInverse          GetRows    GetTrace
     GetTranspose    GetZeroMatrix       Matrix              Convolve   SVD
    -------------------------------------------------------------------------------
    Rotational kinematics (rotation matrices, angular velocity/acceleration):
     Rotate                  RotateX  RotateY  RotateZ   RotateNegativeX   ...
     GetRotationMatrix       SetRotationMatrix           SetRotationMatrixODE
     GetAngularVelocity      SetAngularVelocity          GetAngularSpeed  ...
     GetAngularAcceleration  SetAngularAcceleration SetAngularVelocityAcceleration
    -------------------------------------------------------------------------------
    Translational kinematics (position, velocity, acceleration)
     Translate        SetPositionVelocity        SetVelocityAcceleration
     SetPosition      GetPosition   GetDistance  GetDistanceSquared
     SetVelocity      GetVelocity   GetSpeed     GetElongation
     SetAcceleration  GetAcceleration            GetVelocityJacobian  ...
    -------------------------------------------------------------------------------
    Forces:
     AddForce              AddForceDamper AddForceElectrostatic  AddForceGravity
     AddForceInverseSquare AddForceSpring AddForceLinearActuator GetResultantForce
    -------------------------------------------------------------------------------
    Torque and Moments:
     AddTorque   AddTorqueDamper   GetMomentOfForces   GetResultantTorque
    -------------------------------------------------------------------------------
    Potential energy, work, and power
     GetForceGravityPotentialEnergy         GetForceSpringPotentialEnergy
     GetForceElectrostaticPotentialEnergy   GetForceInverseSquarePotentialEnergy
     SetWorkODE                             GetPower
    -------------------------------------------------------------------------------
    Kinetic energy and angular/translational (linear) momentum (also see Gyrostat):
     GetKineticEnergy
     GetAngularMomentum GetTranslationalMomentum GetGeneralizedMomentum
    -------------------------------------------------------------------------------
    Statics and dynamics commands:
     GetStatics    GetStaticsKane    GetStaticsLagrange    Constrain
     GetDynamics   GetDynamicsKane   GetDynamicsLagrange
    -------------------------------------------------------------------------------
    Units and unit conversions:
     ConvertUnits   GetUnitSystem   SetUnitSystem
    -------------------------------------------------------------------------------
    Code languages and commands: .c,  .m,  .f,  .for,  ...
     ODE   Solve   Input   Output   OutputPlot   Plot   Animate
     Code  Algebraic  Nonlinear
    -------------------------------------------------------------------------------
    Old commands (for backward compatibility only).
     Angvel  KinDiffs  Dircos  FrStar  Gyrostat  Simprot  V1PT V2PTS A1PT A2PTS
    -------------------------------------------------------------------------------
    Defaults  (type  DEFAULTS  for a list of defaults):
     SetAutoDifferentiate  SetAutoEpsilon    SetAutoExpress     SetAutoFactor
     SetAutoLinearize      SetAutoOverwrite  SetAutoRhs         SetAutoSimplify
     SetAutoTaylorSeries   SetAutoZee        SetBasisSubscripts SetCmSymbol
     SetComplex            SetDigits         SetDefaults        AUTOLEV
     SetLineStepping       SetLineWidth      SetPauseOnWarning  SetUnitSystem
     SetWorkingDirectory   GetEnvironmentValue
    -------------------------------------------------------------------------------
    Type  HELP NAME  for help with NAME; e.g.,  HELP SYNTAX

#### >

    >    >>    >>>

     Purpose:  >    at the end of a name identifies the name as a vector.
               >>   at the end of a name identifies the name as a dyadic.
               >>>  at the end of a name identifies the name as a triadic.

    Syntax 1:  nameA>    is treated as a vector.
    Syntax 2:  nameB>>   is treated as a dyadic.
    Syntax 3:  nameC>>>  is treated as a triadic or higher-order polyadic.

     Related:  0>  0>>  1>>  Vector  Dyadic

       (1) %--------------------------------------------------------------------
       (2) % Example:  >   >>   >>>   0>   0>>   0>>>
       (3) %--------------------------------------------------------------------
       (4) RigidFrame  A
       (5) v> = 2*Ax> + 3*Ay> + 4*Az>                % >    denotes a vector
    -> (6) v> = 2*Ax> + 3*Ay> + 4*Az>

       (7) d>> = 2*Ax>*Ax> + 3*Ay>*Az>               % >>   denotes a dyadic
    -> (8) d>> = 2*Ax>*Ax> + 3*Ay>*Az>

       (9) t>>> = 2*Ax>*Ax>*Ax> + 3*Ax>*Ay>*Az>      % >>>  denotes a triadic
    -> (10) t>>> = 2*Ax>*Ax>*Ax> + 3*Ax>*Ay>*Az>

       (11) v0> = Cross(  Ax>,  Ax> )                 % 0>   denotes the zero vector.
    -> (12) v0> = 0>

       (13) d0>> = Cross(  Ax> * Ay>,   Ay> )         % 0>>  denotes the zero dyadic.
    -> (14) d0>> = 0>>

       (15) t0>>> = Cross(  Ax> * Ay> * Az>,  Az> )   % 0>>> denotes the zero triadic.
    -> (16) t0>>> = 0>>>

#### 0>

    0>    0>>    0>>>    0>>>>    ...  etc

     Purpose:  0>    is the zero vector  (0 magnitude and a direction).
               0>>   is the zero dyadic  (0 magnitude and two directions).
               0>>>  is the zero triadic (0 magnitude and three directions).

    Syntax 1:  0>            Note:  0>    is a vector, NOT equal to scalar 0.
    Syntax 2:  0>>           Note:  0>>   is equivalent to 0> * 0>
    Syntax 3:  0>>>          Note:  0>>>  is equivalent to 0> * 0> * 0>
    Syntax 4:  0>>>>         Note:  0>>>> is equivalent to 0> * 0> * 0> * 0>

     Related:  >  >>  >>>  0>  0>>  1>>  Vector Dyadic

       (1) %--------------------------------------------------------------------
       (2) % Example:  >   >>   >>>   0>   0>>   0>>>
       (3) %--------------------------------------------------------------------
       (4) RigidFrame  A
       (5) v> = 2*Ax> + 3*Ay> + 4*Az>                % >    denotes a vector
    -> (6) v> = 2*Ax> + 3*Ay> + 4*Az>

       (7) d>> = 2*Ax>*Ax> + 3*Ay>*Az>               % >>   denotes a dyadic
    -> (8) d>> = 2*Ax>*Ax> + 3*Ay>*Az>

       (9) t>>> = 2*Ax>*Ax>*Ax> + 3*Ax>*Ay>*Az>      % >>>  denotes a triadic
    -> (10) t>>> = 2*Ax>*Ax>*Ax> + 3*Ax>*Ay>*Az>

       (11) v0> = Cross(  Ax>,  Ax> )                 % 0>   denotes the zero vector.
    -> (12) v0> = 0>

       (13) d0>> = Cross(  Ax> * Ay>,   Ay> )         % 0>>  denotes the zero dyadic.
    -> (14) d0>> = 0>>

       (15) t0>>> = Cross(  Ax> * Ay> * Az>,  Az> )   % 0>>> denotes the zero triadic.
    -> (16) t0>>> = 0>>>

#### 1>>

    1>>

     Purpose:  1>>  is the unit dyadic whose defining property is
               Dot( 1>>, anyVector> ) = anyVector>

      Syntax:  1>>

     Related:  >  >>  >>>  0>  0>>  1>>  Vector Dyadic

       (1) %--------------------------------------------------------------------
       (2) % Example:  1>>   Unit dyadic
       (3) %--------------------------------------------------------------------
       (4) RigidFrame A
       (5) v> = Dot(  1>>,   2*Ax> + 3*Ay> + 4*Az>  )
    -> (6) v> = 2*Ax> + 3*Ay> + 4*Az>

       (7) d>> = Cross(  1>>,   Ax>  )
    -> (8) d>> = -Ay>*Az> + Az>*Ay>

#### !

    !

     Purpose:  Opens an operating system command shell or
               issues an operating system command.

    Syntax 1:  !
    Syntax 2:  !OperatingSystemCommand

       Input:  OperatingSystemCommand -- a command that can be interpreted
               by the operating system (e.g., Windows, OSX, Unix).
               For example, to display the time, type: !time
               To list the files in the current Windows directory, type: !dir
               To list the files in the current Unix directory, type: !ls

    Output 1:  Opens an operating system command shell.
               Note:  Type EXIT at the operating system prompt to exit from
               the operating system shell and return to the program workspace.

    Output 2:  Passes OperatingSystemCommand to the operating system.

      Remark:  Since OperatingSystemCommand may include the  ;  character
               it must appear on its own input line -- and not on a line
               that has multiple statements separated by a ;, e.g., not as
               !dir *.txt;  !dir *.tex

      Remark:  You may be prompted to type 4 letters before the operating system
               command will be performed.

     Related:  !  %  &  Clear  List  Pause  Quit  Run  Save  GetDefaults

    --------------------------------------------------------------------
     Example:  !
    --------------------------------------------------------------------
       (1) !dir

       (1) %--------------------------------------------------------------------
       (2) % Example: List the files ending with "txt" in the current working directory.
       (3) %--------------------------------------------------------------------

#### %

     %  or  %%

     Purpose:  Marks the beginning of a comment.
               Marks the beginning of a comment that is to be incorporated
               in a C, Fortran, or MATLAB programs.

    Syntax 1:  %  Put your comment here
    Syntax 2:  %% Put a comment to be written to code here.

     Remark:   A regular comment is a sequence of characters beginning with  %
               Characters following  %  are otherwise ignored.
               A code comment is a sequence of characters beginning with  %%
               Characters after  %%  are written to C, Fortran, or MATLAB codes.

     Related:  !  %  &  Clear  List  Pause  Quit  Run  Save  GetDefaults

       (1) %--------------------------------------------------------------------
       (2) % Example:  %   Marks a comment in a MotionGenesis script.
       (3) %--------------------------------------------------------------------
       (4) %    File: SomeFileName.txt
       (5) % Purpose: Biomechanic analysis of human motion in deep space.
       (6) %
       (7) %--------------------------------------------------------------------
       (8) % Example:  %%  Marks a comment to be written to C, Fortran, or MATLAB programs.
       (9) %--------------------------------------------------------------------
       (10) %%  if( x == 2 )
       (11) %%    y = sin(x+2);
       (12) %%  else
       (13) %%    y = cos(x+3);

#### &

     &

     Purpose:  The ampersand  &  is the multi-line continuation symbol.
               It instructs the program to read the next line in a file.
               & is not useful for keyboard input.

     Related:  !  %  &  Clear  List  Pause  Quit  Run  Save  GetDefaults

       (1) %--------------------------------------------------------------------
       (2) % Example 1:  Line continuation with a scalar expression.
       (3) %--------------------------------------------------------------------
       (4) a =  0 +  1 +  2 +  3 +  4 +  5 +  6 +  7 +  8   &
             + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18   &
             + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28
    -> (5) a = 378

       (6) %--------------------------------------------------------------------
       (7) % Example 2:  Line continuation to beautify matrix input.
       (8) %--------------------------------------------------------------------
       (9) Fred = [ 1, 2, 3, 4;   &
                    5, 6, 7, 8;   &
                    9, 7, 5, 3]
    -> (10) Fred = [1, 2, 3, 4;  5, 6, 7, 8;  9, 7, 5, 3]

#### +

     +  or  -

     Purpose:  Adds or subtracts scalars, matrices, vectors, dyadics, etc.
               +  Declares a real scalar as inherently non-negative.
               -  Declares a real scalar as inherently non-positive.

    Syntax 1:  a + b   returns the sum of a and b.
               a - b   returns a + (-b).
    Syntax 2:  Constant  m+
    Syntax 3:  Constant  n-

     Input 1:  a, b -- scalars or matrices or vectors or dyadics, etc.
     Input 2:  m:  an inherently non-negative (0 or positive) scalar.
     Input 3:  n:  an inherently non-positive (0 or negative) scalar.

      Remark:  Inherently non-negative or non-positive scalars affect
               simplification with abs, sqrt, etc.

     Related:  +  -  *  /  ^  sign  Constant  Variable  Specified  abs  sqrt

       (1) %--------------------------------------------------------------------
       (2) % Example 1:  +  -  (scalars)
       (3) %--------------------------------------------------------------------
       (4) Constant  a,  b,  m+,  n-
       (5) s1 = 2 + 2 + a
    -> (6) s1 = 4 + a

       (7) s2 = 9 - 2 - b
    -> (8) s2 = 7 - b

       (9) y = abs(m) + abs(m) + sqrt(m^2)
    -> (10) y = 3*m

       (11) z = abs(n) + abs(n) + sqrt(n^2)
    -> (12) z = -3*n

       (13) %--------------------------------------------------------------------
       (14) % Example 2:  +  -  (matrices)
       (15) %--------------------------------------------------------------------
       (16) mat1 = [1, 2;  3, 4]  +  [a, b;  m, n]
    -> (17) mat1 = [1 + a, 2 + b;  3 + m, 4 + n]

       (18) mat2 = mat1 - mat1
    -> (19) mat2 = [0, 0;  0, 0]

       (20) %--------------------------------------------------------------------
       (21) % Example 3:  +  -  (vectors)
       (22) %--------------------------------------------------------------------
       (23) RigidFrame  F
       (24) v> = a*Fx> + b*Fy>
    -> (25) v> = a*Fx> + b*Fy>

       (26) vSum> = v> + v>
    -> (27) vSum> = 2*a*Fx> + 2*b*Fy>

       (28) vDiff> = v> - v>
    -> (29) vDiff> = 0>

#### *

     *  or  /

     Purpose:  Multiplies scalars, matrices, vectors, dyadics, etc., or
               divides these quantities by a scalar.

    Syntax 1:  a * b   returns a multiplied by b.
    Syntax 2:  a / s   returns a divided by the scalar s.

       Input:  a, b -- scalars or matrices or vectors or dyadics, etc.
               s    -- scalar.

     Related:  +  -  *  /  ^  sqrt

       (1) %--------------------------------------------------------------------
       (2) % Example 1:  *  /  (scalars)
       (3) %--------------------------------------------------------------------
       (4) Constant  a, b
       (5) s1 = 8 * 2 * a
    -> (6) s1 = 16*a

       (7) s2 = 8 / 2 / b
    -> (8) s2 = 4/b

       (9) %--------------------------------------------------------------------
       (10) % Example 2:  *  /  (matrices)
       (11) %--------------------------------------------------------------------
       (12) mat1 = [a, b;  t, cos(t)] * a
    -> (13) mat1 = [a^2, a*b;  a*t, a*cos(t)]

       (14) mat2 = [a, b;  t, cos(t)] / a
    -> (15) mat2 = [1, b/a;  t/a, cos(t)/a]

       (16) mat3 = mat1 * mat2
    -> (17) mat3 = [a^2 + b*t, b*(a+cos(t));  t*(a+cos(t)), b*t + cos(t)^2]

       (18) %--------------------------------------------------------------------
       (19) % Example 3:  *  /  (vectors)
       (20) %--------------------------------------------------------------------
       (21) RigidFrame  F
       (22) v1> = (a*Fx> + b*Fy>) * t
    -> (23) v1> = a*t*Fx> + b*t*Fy>

       (24) v2> = (a*Fx> + b*Fy>) / t
    -> (25) v2> = a/t*Fx> + b/t*Fy>

       (26) dyadic>> = v1> * v2>
    -> (27) dyadic>> = a^2*Fx>*Fx> + a*b*Fx>*Fy> + a*b*Fy>*Fx> + b^2*Fy>*Fy>

#### ^

     ^

     Purpose:  Exponentiation of a scalar.

      Syntax:  a ^ b    returns a raised to the power b.

      Remark:  a ^ 0.5  returns sqrt(a).
               sqrt(-1) returns the imaginary number.

       Input:  a, b -- scalars or scalar expressions.

     Related:  +  -  *  /  ^  sqrt

       (1) %--------------------------------------------------------------------
       (2) % Example 1:  ^  (scalars)
       (3) %--------------------------------------------------------------------
       (4) Constant  a, b
       (5) s1 = -8^2 * a^b
    -> (6) s1 = -64*a^b

       (7) s2 = (-1)^(0.5) * a^(0.5)
    -> (8) s2 = imaginary*sqrt(a)

       (9) %--------------------------------------------------------------------
       (10) % Example 2:  ^  (vectors)
       (11) %--------------------------------------------------------------------
       (12) RigidFrame  F
       (13) v1> = a*Fx> + b*Fy>
    -> (14) v1> = a*Fx> + b*Fy>

       (15) v1Squared = MagnitudeSquared( v1> )
    -> (16) v1Squared = a^2 + b^2

#### =

    =   :=   +=   *=   /=   ^=    SetDt  SetNoDt

     Purpose:  Assignment operators.

    Syntax 1:  A  = B
    Syntax 2:  A := B
    Syntax 3:  A += B
    Syntax 4:  A *= B
    Syntax 5:  A /= B
    Syntax 6:  A ^= B
    Syntax 7:  SetDt( A = B )
    Syntax 8:  SetNoDt( A = B )

       Input:  A -- the name of a scalar, vector, dyadic, triadic, or matrix.
               B -- a scalar, vector, dyadic, triadic or matrix expression.

    Output 1:  Assigns A = B.
    Output 2:  Assigns A = B,          overwriting any previous assignment of A.
    Output 3:  Assigns A = Rhs(A) + B, overwriting any previous assignment of A.
    Output 4:  Assigns A = Rhs(A) * B, overwriting any previous assignment of A.
    Output 5:  Assigns A = Rhs(A) / B, overwriting any previous assignment of A.
    Output 6:  Assigns A = Rhs(A) ^ B, overwriting any previous assignment of A.
    Output 7:  Assigns A = B  and tries to differentiate to assign A', A'', etc.
    Output 8:  Assigns A = B  and does not differentiate to assign A', A'', etc.

     Related:  SetAutoDifferentiate  SetAutoOverwrite
               SetDt  Solve  SolveDt  SolveSetInput  SolveSetInputDt  ...
               SolveQuadraticPositiveRoot  SolveQuadraticPositiveRootDt  ...
               SetDt  SetNoDt   =   :=   +=   *=   /=   ^=

       (1) %--------------------------------------------------------------------
       (2) % Example 1:  :=  (assign overwrite operator)
       (3) %--------------------------------------------------------------------
       (4) x = sin(t)
    -> (5) x = sin(t)

       (6) x := t^5
    -> (7) x = t^5

       (8) %--------------------------------------------------------------------
       (9) % Example 2:  +=  (assign addition operator)
       (10) %--------------------------------------------------------------------
       (11) x += 2
    -> (12) x = 2 + t^5

       (13) %--------------------------------------------------------------------
       (14) % Example 3:  *=  (assign multiply operator)
       (15) %--------------------------------------------------------------------
       (16) x *= 3
    -> (17) x = 6 + 3*t^5

       (18) %--------------------------------------------------------------------
       (19) % Example 4:  /=  (assign divide operator)
       (20) %--------------------------------------------------------------------
       (21) x /= 10
    -> (22) x = 0.6 + 0.3*t^5

       (23) %--------------------------------------------------------------------
       (24) % Example 5:  ^=  (assign power operator)
       (25) %--------------------------------------------------------------------
       (26) x ^= 0.5
    -> (27) x = 0.5477226*sqrt(2+t^5)

#### absError

    absError  relError  tInitial  tFinal  tStep  printIntScreen  printIntFile

    absError:  Controls numerical integration error (for ODEs) and
               allowed error in solutions to nonlinear algebraic equations.
               absError is a small positive number compared to variables
               being numerically integrated (e.g., via the ODE command)
               or numerically solved (e.g., via the Solve command).

               For numerically integration, absError should be set to
               10^(-8) * xSmall,  where xSmall is the estimated smallest
               maximum absolute value of the variables being integrated.
               The default value of absError (e.g., absError = 1.0E-7) can
               be changed (with optional units) via the Input command, e.g.,
               Input  absError = 1.0E-5

    relError:  To override the usually _adequate_ default value, set relError
               to  10^(-d),  where d is the desired number of accurate digits
               for numerical integration (e.g., ODE command).  For example:
               Input  relError = 1.0E-7

               relError is a small non-negative number (0 <= relError <= 0.01),
               has no units, and is generally less than  10^(-n)  where n is
               governed by the SetDigits command (i.e., the number of significant
               digits displayed by the program and the code it generates).

    tInitial:  For numerical integration (e.g., ODE command), the default
               initial (start) value of the independent variable (time t) is
               tInitial = 0  and can be changed via the Input command, e.g.,
               Input  tInitial = -3.2 sec

    tFinal:    For numerical integration (e.g., ODE command), the default
               final (stop) value of the independent variable (time t) is
               tFinal = 0  and can be changed via the Input command, e.g.,
               Input  tFinal = 5.4 sec

    tStep:     For numerical integration (e.g., ODE command), the maximum
               numerical integration stepsize (time-step) is a positive or
               negative number (forward or backward integration) and its
               default value, e.g., 0.01*(tFinal-tInitial), can be changed via
               Input  tStep = 0.002 seconds

    printIntScreen:  For numerical integration (e.g., ODE), this nonnegative
               integer (which has no units and a default value of 1) affects the
               interval = tStep * printIntScreen  for OUTPUT to the screen.
               To suppress screen Output, set printIntScreen = 0 via
               Input  printIntScreen = 0

    printIntFile:   Similar to printIntScreen (no units and default value of 1)
               except  tStep * printIntFile  affects Output to Files.
               To suppress OUTPUT to files, set  printIntFile = 0  via
               Input  printIntFile = 0

      Remark:  For FORTRAN codes, printIntScreen also controls printIntFile and
               printIntScreen = 0  is identical to printIntScreen = 1.

      Remark:  Solutions are approximate.  Acccuracy tends to improve as the
               input value assigned to absError and/or relError gets smaller.

     Related:  ODE  Solve  Input  Output  OutputPlot  Plot  Animate
               t  tInitial  tFinal  tStep  absError  printIntScreen  printIntFile
               Solve  SolveDt  SolveSetInput  SolveSetInputDt  ...

       (1) %--------------------------------------------------------------------
       (2) % Example: absError, relError, tInitial, tFinal, tStep, ...
       (3) %--------------------------------------------------------------------
       (4) Variable x'' = 2*sin(x)
    -> (5) x'' = 2*sin(x)

       (6) Input x = 1 m,  x' = 0 m/s
       (7) Input absError = 1E-5 cm,  relError = 1E-7
       (8) Input tInitial = -3 sec,  tFinal = 2 sec,  tStep = 0.02 sec
       (9) Input printIntScreen = 1,  printIntFile = 0
       (10) Output  t sec,  x m,  x' m/s,  x'' m/s^2
       (11) ODE() odePendulumExample

#### abs

    abs

     Purpose:  Returns the absolute value of a real scalar expression
               or the modulus of a complex expression.

      Syntax:  abs( scalarExpression )

       Input:  scalarExpression -- a real or complex scalar expression.

      Output:  Returns the absolute value of scalarExpression

      Remark:  Use  abs           for absolute value of a real or complex scalar.
               Use  GetMagnitude  for the magnitude of a vector.
               Use  GetNorm       for the 2-norm of a real row or column matrix.

     Related:  ImaginaryNumber  MathFunctions
               GetMagnitude     GetMagnitudeSquared     abs     GetNorm

       (1) %--------------------------------------------------------------------
       (2) % Example 1: abs   (real scalar expressions)
       (3) %--------------------------------------------------------------------
       (4) A = abs( -3 )
    -> (5) A = 3

       (6) B = abs(3+t)
    -> (7) B = abs(3+t)

       (8) %--------------------------------------------------------------------
       (9) % Example 2: abs   (complex scalar expressions)
       (10) %--------------------------------------------------------------------
       (11) C = abs( 4 + 3*GetImaginaryNumber() )
    -> (12) C = 5

       (13) D = abs( t - 3*GetImaginaryNumber() )
    -> (14) D = abs(t-3*imaginary)

#### acos

    acos

     Purpose:  Returns the inverse cosine of a scalar expression.

    Syntax 1:  acos( scalarExpression )
    Syntax 2:  acosDegrees( realNumber )

       Input:  scalarExpression -- a real or complex scalar expression.
               realNumber -- expression that resolves to a real number.

    Output 1:  Radian measure of the inverse cosine of scalarExpression.
    Output 2:  Degree measure of the inverse cosine of realNumber.

     Related:  ConvertUnits  ImaginaryNumber  MathFunctions
               cos  sin  tan  acos  asin  atan  atan2  cosDegrees  ...

       (1) %--------------------------------------------------------------------
       (2) % Example 1: acos   (real scalar expressions)
       (3) %--------------------------------------------------------------------
       (4) angleInRadians = acos( 0.5 )
    -> (5) angleInRadians = 1.047198

       (6) angleInDegrees = acosDegrees( 0.5 )
    -> (7) angleInDegrees = 60

       (8) Arad = acos(0.5+2*t)
    -> (9) Arad = acos(0.5+2*t)

       (10) Adeg = acos(0.5+2*t) * ConvertUnits(rad,deg)
    -> (11) Adeg = 57.29578*acos(0.5+2*t)

       (12) %--------------------------------------------------------------------
       (13) % Example 2: acos   (complex scalar expressions)
       (14) %--------------------------------------------------------------------
       (15) B = acos( 3*GetImaginaryNumber() )
    -> (16) B = 1.570796 - 1.818446*imaginary

       (17) C = acos( t - 3*GetImaginaryNumber() )
    -> (18) C = acos(t-3*imaginary)

#### asin

    asin

     Purpose:  Returns the inverse sine of a scalar expression.

    Syntax 1:  asin( scalarExpression )
    Syntax 2:  asinDegrees( realNumber )

       Input:  scalarExpression -- a real or complex scalar expression.
               realNumber -- expression that resolves to a real number.

    Output 1:  Radian measure of the inverse sine of scalarExpression.
    Output 2:  Degree measure of the inverse sine of realNumber.

     Related:  ConvertUnits  ImaginaryNumber  MathFunctions
               cos  sin  tan  acos  asin  atan  atan2  cosDegrees  ...

       (1) %--------------------------------------------------------------------
       (2) % Example 1: asin   (real scalar expressions)
       (3) %--------------------------------------------------------------------
       (4) angleInRadians = asin( 0.5 )
    -> (5) angleInRadians = 0.5235988

       (6) angleInDegrees = asinDegrees( 0.5 )
    -> (7) angleInDegrees = 30

       (8) Arad = asin(0.5+2*t)
    -> (9) Arad = asin(0.5+2*t)

       (10) Adeg = asin(0.5+2*t) * ConvertUnits(rad,deg)
    -> (11) Adeg = 57.29578*asin(0.5+2*t)

       (12) %--------------------------------------------------------------------
       (13) % Example 2: asin   (complex scalar expressions)
       (14) %--------------------------------------------------------------------
       (15) B = asin( 3*GetImaginaryNumber() )
    -> (16) B = 1.818446*imaginary

       (17) C = asin( t - 3*GetImaginaryNumber() )
    -> (18) C = asin(t-3*imaginary)

#### atan

    atan or atan2

     Purpose:  Returns the inverse tangent of a scalar expression or the
               the numerical value of the two-argument inverse tangent.

    Syntax 1:  atan( scalarExpression )
    Syntax 2:  atanDegrees( realNumber )
    Syntax 3:  atan2( y, x )
    Syntax 4:  atan2Degrees( y, x )

       Input:  scalarExpression -- a real or complex scalar expression.
               realNumber -- an expression that resolves to a real number.
               y -- an expression that resolves to a real number
               x -- an expression that resolves to a real number

    Output 1:  Radian measure of the inverse tangent of scalarExpression.
    Output 2:  Degree measure of the inverse tangent of realNumber.
    Output 3:  The angle theta that satisfies the equations:

               sin(theta) = y/(x^2+y^2)   undefined if x = y = 0.
               cos(theta) = x/(x^2+y^2)   undefined if x = y = 0.

    Output 3:  theta in radians in the range -pi  to pi.
    Output 4:  theta in degrees in the range -180 to 180.

     Related:  ConvertUnits  ImaginaryNumber  MathFunctions
               cos  sin  tan  acos  asin  atan  atan2  cosDegrees  ...

       (1) %--------------------------------------------------------------------
       (2) % Example 1: atan   (real scalar expressions)
       (3) %--------------------------------------------------------------------
       (4) angleRadians = atan( 1.0 )
    -> (5) angleRadians = 0.7853982

       (6) angleDegrees = atanDegrees( 1.0 )
    -> (7) angleDegrees = 45

       (8) atanRad = atan(0.5+2*t)
    -> (9) atanRad = atan(0.5+2*t)

       (10) atanDeg = atan(0.5+2*t) * ConvertUnits(rad,deg)
    -> (11) atanDeg = 57.29578*atan(0.5+2*t)

       (12) %--------------------------------------------------------------------
       (13) % Example 2: atan   (complex scalar expressions)
       (14) %--------------------------------------------------------------------
       (15) B = atan( 3*GetImaginaryNumber() )
    -> (16) B = 0.25*imaginary

       (17) C = atan( t - 3*GetImaginaryNumber() )
    -> (18) C = atan(t-3*imaginary)

       (19) %--------------------------------------------------------------------
       (20) % Example 3: atan2  (real numerical arguments only)
       (21) %--------------------------------------------------------------------
       (22) angleInRadians = atan2(  3,  3 )
    -> (23) angleInRadians = 0.7853982

       (24) angleInDegrees = atan2Degrees(  3,  3 )
    -> (25) angleInDegrees = 45

       (26) angleQuadrant2 = atan2Degrees(  3, -3 )
    -> (27) angleQuadrant2 = 135

       (28) angleQuadrant3 = atan2Degrees( -3, -3 )
    -> (29) angleQuadrant3 = -135

       (30) angleQuadrant4 = atan2Degrees( -3,  3 )
    -> (31) angleQuadrant4 = -45

       (32) angle4Degrees  = atan2( -3, 3 ) * ConvertUnits( rad, deg )
    -> (33) angle4Degrees = -45

#### AddForce

    AddForce   ResetForce

     Purpose:  Adds (or resets) force on a point or particle.

    Syntax 1:  Q.AddForce(       forceVec> )  same as Force_Q>   += forceVec>
    Syntax 2:  Q.AddForce(   P,  forceVec> )  same as Force_Q_P> += forceVec>
    Syntax 3:  Q.ResetForce(     forceVec> )  same as Force_Q>   := forceVec>
    Syntax 4:  Q.ResetForce( P,  forceVec> )  same as Force_Q_P> := forceVec>

       Input:  Q -- the name of a point or particle.
               P -- the name of a point or particle.
               forceVec> -- a force vector.

    Output 1:  Adds  forceVec>  to  Force_Q>    (accumulates force on Q).
    Output 2:  Adds  forceVec>  to  Force_Q_P>  (accumulates force on Q from P).
    Output 3:  Force_Q>    is reset to  forceVec>.
    Output 4:  Force_Q_P>  is reset to  forceVec>.

      Remark:  Syntax 1 is for "external" forces applied to Q.
               Force_Q>  denotes the contact and distance forces on Q that are
               "external" to all objects in any system under consideration
               (and perhaps also external to the NewtonianFrame).
               Syntax 1 is frequently used for external forces such as Earth's
               gravity, air-resistance, contact forces with roads, etc.
        Note:  Q.GetResultantForce()  accounts for both  Force_Q>  and all
               action/reaction forces on Q such as Force_Q_P>, Force_Q_S>, etc.

      Remark:  Syntax 2 is for  "action/reaction"  forces applied to Q from P
               that fully obey Newton's 3rd law (action/reaction), meaning
               forceVec>  MUST  be parallel to the line joining P and Q.
               Syntax 2 is frequently used for translational springs/dampers,
               ropes, rods, planetary gravity, charged particles, etc.
        Note:  Avoid Syntax 2 if forceVec> is not parallel to line PQ.
               Instead use:  Q.AddForce( forceVec> );   P.AddForce( -forceVec> )
        Note:  Q.GetResultantForce(P)  returns  Force_Q_P> - Force_P_Q>.
               Force_Q_P> denotes a force on Q from P.
               Force_P_Q> denotes a force on P from Q.

      Remark:  When sensible, use Syntax 2 instead of Syntax 1 as it efficiently
               accounts for action/reaction forces by knowing whether P and Q
               are internal, external, or mixed for the system under consideration.

      Remark:  If Q is a point of a RigidFrame or RigidBody B, declare it as
               Point Q(B).  This helps with subsequent velocity/acceleration
               and force/moment calculations.

     Related:  AddForce  AddForceDamper  AddForceElectrostatic  AddForceGravity
               AddForceInverseSquare  AddForceLinearActuator  AddForceSpring
               AddTorque  AddTorqueDamper
               GetMomentOfForces  GetResultantForce  GetResultantTorque
               GetForceGravityPotentialEnergy  GetForceSpringPotentialEnergy
               GetStatics   GetStaticsKane   GetStaticsLagrange
               GetDynamics  GetDynamicsKane  GetDynamicsLagrange

       (1) %--------------------------------------------------------------------
       (2) % Example 1: AddForce  (add force to a point or particle)
       (3) %--------------------------------------------------------------------
       (4) RigidBody  A, B
       (5) Ao.AddForce( Ax> + 2*Ay> )
    -> (6) Force_Ao> = Ax> + 2*Ay>

       (7) Ao.AddForce( 3*Az> )
    -> (8) Force_Ao> = Ax> + 2*Ay> + 3*Az>

       (9) Acm.AddForce( 4*Ax> + 5*Ay>  + 6*Az> )
    -> (10) Force_Acm> = 4*Ax> + 5*Ay> + 6*Az>

       (11) ResultantForceOnA> = A.GetResultantForce()
    -> (12) ResultantForceOnA> = 5*Ax> + 7*Ay> + 9*Az>

       (13) %--------------------------------------------------------------------
       (14) % Example 2: AddForce (action/reaction with two points/particles)
       (15) %--------------------------------------------------------------------
       (16) Ao.AddForce( Bo,  3*Az> )
    -> (17) Force_Ao_Bo> = 3*Az>

       (18) ResultantForceBoFromAo> = Bo.GetResultantForce( Ao )
    -> (19) ResultantForceBoFromAo> = -3*Az>

       (20) ResultantForceOnAo> = Ao.GetResultantForce()
    -> (21) ResultantForceOnAo> = Ax> + 2*Ay> + 6*Az>

       (22) Acm.AddForce( Bcm,  6*Az> )
    -> (23) Force_Acm_Bcm> = 6*Az>

       (24) ResultantForceOnA> := A.GetResultantForce()
    -> (25) ResultantForceOnA> = 5*Ax> + 7*Ay> + 18*Az>

       (26) ResultantForceOnB> := B.GetResultantForce()
    -> (27) ResultantForceOnB> = -9*Az>

       (28) ResultantForceOnS> := System.GetResultantForce()
    -> (29) ResultantForceOnS> = 5*Ax> + 7*Ay> + 9*Az>

       (30) %--------------------------------------------------------------------
       (31) % Example 3+4: ResetForce (reset force on a point or particle)
       (32) %--------------------------------------------------------------------
       (33) Ao.ResetForce( sin(t)*Ax> )
    -> (34) Force_Ao> = sin(t)*Ax>

       (35) Ao.ResetForce( Bo,  cos(t)*Az> )
    -> (36) Force_Ao_Bo> = cos(t)*Az>

#### AddForceDamper

    AddForceDamper

     Purpose:  Applies damper forces between two points.

    Syntax 1:  Q.AddForceDamper( P, b )
    Syntax 2:  Q.AddForceDamper( P, b, elongationExponent )

       Input:  Q -- the name of a point.
               P -- the name of a point.
               b -- the damper constant (scalar)
               elongationExponent -- the exponent on the damper's elongation

    Output 1:  Adds a damper force on Q from P whose magnitude is equal to
               b * elongation  where elongation is the time-derivative of
               the distance between Q and P.

    Output 2:  Adds a damper force on Q from P whose magnitude is equal to
               b * elongation^elongationExponent.

      Remark:  Q's position vector from P must be available.

      Remark:  If Q is a point of a RigidFrame or RigidBody B, declare it as
               Point Q(B).  This helps with subsequent velocity/acceleration
               and force/moment calculations.

     Related:  AddForce  AddForceDamper  AddForceElectrostatic  AddForceGravity
               AddForceInverseSquare  AddForceLinearActuator  AddForceSpring
               AddTorque  AddTorqueDamper
               GetMomentOfForces  GetResultantForce  GetResultantTorque
               GetForceGravityPotentialEnergy  GetForceSpringPotentialEnergy
               GetStatics   GetStaticsKane   GetStaticsLagrange
               GetDynamics  GetDynamicsKane  GetDynamicsLagrange

       (1) %--------------------------------------------------------------------
       (2) % Example 1: AddForceDamper
       (3) %--------------------------------------------------------------------
       (4) NewtonianFrame N
       (5) Particle  P1
       (6) Variable  x', y'
       (7) Constant  b
       (8) P1.SetPositionVelocity( No, x*Nx> )
    -> (9) p_No_P1> = x*Nx>
    -> (10) v_P1_N> = x'*Nx>

       (11) P1.AddForceDamper( No, b )
    -> (12) Force_P1_No> = -b*x'*Nx>

       (13) %--------------------------------------------------------------------
       (14) % Example 2: AddForceDamper
       (15) %--------------------------------------------------------------------
       (16) Particle  Q1
       (17) Q1.SetPositionVelocity( P1, y*Ny> )
    -> (18) p_P1_Q1> = y*Ny>
    -> (19) v_Q1_N> = x'*Nx> + y'*Ny>

       (20) Q1.AddForceDamper( P1, b )
    -> (21) Force_Q1_P1> = -b*y'*Ny>

       (22) Q1.AddForceDamper( No, b )
    -> (23) Force_Q1_No> = -b*x*(x*x'+y*y')/(x^2+y^2)*Nx> - b*y*(x*x'+y*y')/(x^2+y^2)*Ny>

       (24) %--------------------------------------------------------------------
       (25) % Example 3: AddForceDamper
       (26) %--------------------------------------------------------------------
       (27) Particle  P2
       (28) P2.SetPositionVelocity( No, x*Nx> )
    -> (29) p_No_P2> = x*Nx>
    -> (30) v_P2_N> = x'*Nx>

       (31) P2.AddForceDamper( No, b, 3 )
    -> (32) Force_P2_No> = -b*x'^3*Nx>

       (33) %--------------------------------------------------------------------
       (34) % Example 4: AddForceDamper
       (35) %--------------------------------------------------------------------
       (36) Particle  Q2
       (37) Q2.SetPositionVelocity( P2, y*Ny> )
    -> (38) p_P2_Q2> = y*Ny>
    -> (39) v_Q2_N> = x'*Nx> + y'*Ny>

       (40) Q2.AddForceDamper( P2, b, 2 )
    -> (41) Force_Q2_P2> = -b*y^3*y'^2/abs(y)^3*Ny>

#### AddForceElectrostatic

    AddForceElectrostatic

     Purpose:  Applies an inverse-square electrostatic force on two points.

      Syntax:  Q.AddForceElectrostatic( P, k )

       Input:  Q -- the name of a point
               P -- the name of a point
               k -- scalar representing the electrostatic proportionality
                    constant, approximately 8.9875518E+09 N*m^2/Coulomb^2.

      Output:  Adds an inverse-square-law electrostatic force to Q from P.

      Remark:  Ensure charges are assigned to Q and P with the commands:
               Q.SetCharge(...)  and  P.SetCharge(...).

      Remark:  The NIST approximation for k is 8.9875518E+09 N*m^2/Coulomb^2.

      Remark:  If Q is a point of a RigidFrame or RigidBody B, declare it as
               Point Q(B).  This helps with subsequent velocity/acceleration
               and force/moment calculations.

     Related:  AddForce  AddForceDamper  AddForceElectrostatic  AddForceGravity
               AddForceInverseSquare  AddForceLinearActuator  AddForceSpring
               AddTorque  AddTorqueDamper
               GetMomentOfForces  GetResultantForce  GetResultantTorque
               GetForceGravityPotentialEnergy  GetForceSpringPotentialEnergy
               GetForceElectrostaticPotentialEnergy  GetCharge  SetCharge
               GetStatics   GetStaticsKane   GetStaticsLagrange
               GetDynamics  GetDynamicsKane  GetDynamicsLagrange

       (1) %--------------------------------------------------------------------
       (2) % Example 1: AddForceElectrostatic  (horizontal 1D)
       (3) %--------------------------------------------------------------------
       (4) NewtonianFrame N
       (5) Particle  A
       (6) Variable  xA
       (7) Constant  k
       (8) No.SetCharge( chargeN )
       (9) A.SetCharge(  chargeA )
       (10) A.SetPosition( No, xA*Nx> )
    -> (11) p_No_A> = xA*Nx>

       (12) A.AddForceElectrostatic( No, k )
    -> (13) Force_A_No> = chargeA*chargeN*k*xA/abs(xA)^3*Nx>

       (14) %--------------------------------------------------------------------
       (15) % Example 2: AddForceElectrostatic  (planar 2D)
       (16) %--------------------------------------------------------------------
       (17) Particle  P, Q
       (18) Variable  x, y
       (19) P.SetCharge( 10 )
       (20) Q.SetCharge( 20 )
       (21) Q.SetPosition( P, x*Nx> + y*Ny> )
    -> (22) p_P_Q> = x*Nx> + y*Ny>

       (23) Q.AddForceElectrostatic( P, k )
    -> (24) Force_Q_P> = 200*k*x/(x^2+y^2)^1.5*Nx> + 200*k*y/(x^2+y^2)^1.5*Ny>

#### AddForceGravity

    AddForceGravity

     Purpose:  Applies a force associated with the resultant force produced
               by a uniform parallel gravitational field, to the mass center
               of a massive object (e.g., a Particle or RigidBody) or to all
               particles and/or mass centers of all rigid bodies in a System.

               Applies an inverse-square law gravitational force on a
               Particle from another Particle.

    Syntax 1:  Object.AddForceGravity( gVector )
    Syntax 2:  Q.AddForceGravity( P, G )

       Input:  Object -- the name of a Particle, RigidBody, or System.

               gVector -- A vector directed locally downward and whose magnitude
                          is the local gravitational acceleration constant.
               Q -- the name of a Particle.
               P -- the name of a Particle.
               G -- a scalar representing the universal gravitational constant.
                    currently estimated by NIST as 6.6732E-11 N*m^2/kg^2.

    Output 1:  Adds a uniform local gravity force to Object (e.g, a Particle or
               the mass center of a RigidBody or all massive objects in a System),
               and returns the sum of all gravity forces added to Object.

    Output 2:  Adds a universal gravitational force (inverse square law) to
               Particle Q from Particle P, and returns the force added to Q.
               Note: Q's position vector from P must be available.

      Remark:  Ensure mass is assigned to appropriate particles and bodies
               before issuing an AddForceGravity command.

               NIST defines Earth's gravity acceleration as 9.80665 m/sec^2.
               The NIST approximation for G is 6.6732E-11 N*m^2/kg^2.
               The mass of the Earth is approximately 5.97E24 kg.
               The mass of the Moon  is approximately 7.34E22 kg.
               Earth's equatorial radius is approximately 6356 km (3949.4 miles).

      Remark:  If Q is a point of a RigidFrame or RigidBody B, declare it as
               Point Q(B).  This helps with subsequent velocity/acceleration
               and force/moment calculations.

     Related:  AddForce  AddForceDamper  AddForceElectrostatic  AddForceGravity
               AddForceInverseSquare  AddForceLinearActuator  AddForceSpring
               AddTorque  AddTorqueDamper
               GetMomentOfForces  GetResultantForce  GetResultantTorque
               GetForceGravityPotentialEnergy  GetForceSpringPotentialEnergy
               GetStatics   GetStaticsKane   GetStaticsLagrange
               GetDynamics  GetDynamicsKane  GetDynamicsLagrange

       (1) %--------------------------------------------------------------------
       (2) % Example 1: AddForceGravity  (Uniform "local" gravity)
       (3) %--------------------------------------------------------------------
       (4) NewtonianFrame N
       (5) Particle  P, Q
       (6) RigidBody B
       (7) P.SetMass( mP )
       (8) Q.SetMass( mQ )
       (9) B.SetMass( mB )
       (10) System.AddForceGravity( -9.8*Ny> )
    -> (11) Force_Bcm> = -9.8*mB*Ny>
    -> (12) Force_P> = -9.8*mP*Ny>
    -> (13) Force_Q> = -9.8*mQ*Ny>

       (14) ResultantGravityForce> = System.GetResultantForce()
    -> (15) ResultantGravityForce> = (-9.8*mB-9.8*mP-9.8*mQ)*Ny>

       (16) %--------------------------------------------------------------------
       (17) % Example 2: AddForceGravity  (Inverse-square "universal" gravity)
       (18) %--------------------------------------------------------------------
       (19) Constant  G
       (20) Variable  x, y
       (21) Q.SetPosition( P, x*Nx> + y*Ny> )
    -> (22) p_P_Q> = x*Nx> + y*Ny>

       (23) Q.AddForceGravity( P, G )
    -> (24) Force_Q_P> = -mP*mQ*G*x/(x^2+y^2)^1.5*Nx> - mP*mQ*G*y/(x^2+y^2)^1.5*Ny>

#### AddForceInverseSquare

    AddForceInverseSquare

     Purpose:  Applies an inverse-square force on a point from another point.

      Syntax:  Q.AddForceInverseSquare( P, coef )

       Input:  Q -- the name of a point.
               P -- the name of a point.
               coef -- a scalar expression.

      Output:  Adds an inverse square force to point Q from point P, and
               returns the force added to particle Q.
               Note: Q's position vector from P must be available.

      Remark:  The force is calculated as:
               coef / Q.GetDistanceSquared(P) * Q.GetUnitVector(P)

      Remark:  A positive coef corresponds to a repulsive force
               (a repulsive force pushes Q away from P), whereas
               a negative coef corresponds to an attractive force,
               (an attractive force pulls Q towards P).

      Remark:  If Q is a point of a RigidFrame or RigidBody B, declare it as
               Point Q(B).  This helps with subsequent velocity/acceleration
               and force/moment calculations.

     Related:  AddForce  AddForceDamper  AddForceElectrostatic  AddForceGravity
               AddForceInverseSquare  AddForceLinearActuator  AddForceSpring
               AddTorque  AddTorqueDamper
               GetMomentOfForces  GetResultantForce  GetResultantTorque
               GetForceGravityPotentialEnergy  GetForceSpringPotentialEnergy
               GetForceElectrostaticPotentialEnergy
               GetStatics   GetStaticsKane   GetStaticsLagrange
               GetDynamics  GetDynamicsKane  GetDynamicsLagrange

       (1) %--------------------------------------------------------------------
       (2) % Example: AddForceInverseSquare
       (3) %--------------------------------------------------------------------
       (4) NewtonianFrame N
       (5) Particle  P, Q
       (6) Variable  x, y
       (7) Q.SetPosition( P, x*Nx> + y*Ny> )
    -> (8) p_P_Q> = x*Nx> + y*Ny>

       (9) Q.AddForceInverseSquare( P, 8 )
    -> (10) Force_Q_P> = 8*x/(x^2+y^2)^1.5*Nx> + 8*y/(x^2+y^2)^1.5*Ny>

#### AddForceLinearActuator

    AddForceLinearActuator

     Purpose:  Applies a linear actuator force between two points.

    Syntax:    Q.AddForceLinearActuator( P, FActuator )

       Input:  Q -- the name of a point.
               P -- the name of a point.
               FActuator -- scalar measure of the force on Q from P.

      Output:  Adds a force on Q from P whose magnitude is FActuator.
               When FActuator is positive, the actuator pushes Q away from P,
               i.e., the actuator force is directed towards Q from P.

      Remark:  Q's position vector from P must be available.

      Remark:  If Q is a point of a RigidFrame or RigidBody B, declare it as
               Point Q(B).  This helps with subsequent velocity/acceleration
               and force/moment calculations.

     Related:  AddForce  AddForceDamper  AddForceElectrostatic  AddForceGravity
               AddForceInverseSquare  AddForceLinearActuator  AddForceSpring
               AddTorque  AddTorqueDamper
               GetMomentOfForces  GetResultantForce  GetResultantTorque
               GetForceGravityPotentialEnergy  GetForceSpringPotentialEnergy
               GetStatics   GetStaticsKane   GetStaticsLagrange
               GetDynamics  GetDynamicsKane  GetDynamicsLagrange

       (1) %--------------------------------------------------------------------
       (2) % Example 1: AddForceLinearActuator  (on particle A from point No)
       (3) %--------------------------------------------------------------------
       (4) NewtonianFrame N
       (5) Particle  A
       (6) Variable  xA
       (7) Specified Fx
       (8) A.SetPosition( No, xA*Nx> )
    -> (9) p_No_A> = xA*Nx>

       (10) A.AddForceLinearActuator( No, Fx )
    -> (11) Force_A_No> = Fx*xA/abs(xA)*Nx>

       (12) %--------------------------------------------------------------------
       (13) % Example 2: AddForceLinearActuator  (on particle Q from particle P)
       (14) %--------------------------------------------------------------------
       (15) Particle  P, Q
       (16) Variable  x, y
       (17) Specified F
       (18) Q.SetPosition( P, x*Nx> + y*Ny> )
    -> (19) p_P_Q> = x*Nx> + y*Ny>

       (20) Q.AddForceLinearActuator( P, F )
    -> (21) Force_Q_P> = F*x/sqrt(x^2+y^2)*Nx> + F*y/sqrt(x^2+y^2)*Ny>

#### AddForceSpring

    AddForceSpring

     Purpose:  Applies spring forces between two points.

    Syntax 1:  Q.AddForceSpring( P, k, Ln )
    Syntax 2:  Q.AddForceSpring( P, k, Ln, stretchExponent )

       Input:  Q -- the name of a point.
               P -- the name of a point.
               k -- the spring constant (scalar)
               Ln -- the spring's natural length (scalar)
               stretchExponent -- the exponent on the spring's stretch (scalar)

    Output 1:  Adds a spring force on Q from P whose magnitude is k * stretch
               where stretch = L-Ln  and  L  is the distance between Q and P.
               The spring pulls Q towards P (spring force is directed from Q to P).

    Output 2:  Adds a spring force on Q from P whose magnitude is equal to
               k * stretch^stretchExponent.

      Remark:  Q's position vector from P must be available.

      Remark:  If Q is a point of a RigidFrame or RigidBody B, declare it as
               Point Q(B).  This helps with subsequent velocity/acceleration
               and force/moment calculations.

     Related:  AddForce  AddForceDamper  AddForceElectrostatic  AddForceGravity
               AddForceInverseSquare  AddForceLinearActuator  AddForceSpring
               AddTorque  AddTorqueDamper
               GetMomentOfForces  GetResultantForce  GetResultantTorque
               GetForceGravityPotentialEnergy  GetForceSpringPotentialEnergy
               GetStatics   GetStaticsKane   GetStaticsLagrange
               GetDynamics  GetDynamicsKane  GetDynamicsLagrange

       (1) %--------------------------------------------------------------------
       (2) % Example 1: AddForceSpring  (natural length is 0)
       (3) %--------------------------------------------------------------------
       (4) NewtonianFrame N
       (5) Particle  P1, Q1
       (6) Variable  x, y
       (7) Constant  k, Ln
       (8) Q1.SetPosition( P1, x*Nx> )
    -> (9) p_P1_Q1> = x*Nx>

       (10) Q1.AddForceSpring( P1, k, 0 )
    -> (11) Force_Q1_P1> = -k*x*Nx>

       (12) %--------------------------------------------------------------------
       (13) % Example 2: AddForceSpring  (natural length Ln)
       (14) %--------------------------------------------------------------------
       (15) Particle  P2, Q2
       (16) Q2.SetPosition( P2, x*Nx> )
    -> (17) p_P2_Q2> = x*Nx>

       (18) Q2.AddForceSpring( P2, k, Ln )
    -> (19) Force_Q2_P2> = -k*x*(1-Ln/abs(x))*Nx>

       (20) %--------------------------------------------------------------------
       (21) % Example 3: AddForceSpring  (natural length Ln and exponent 3)
       (22) %--------------------------------------------------------------------
       (23) Particle  P3, Q3
       (24) Q3.SetPosition( P3, y*Ny> )
    -> (25) p_P3_Q3> = y*Ny>

       (26) Q3.AddForceSpring( P3, k, Ln, 3 )
    -> (27) Force_Q3_P3> = k*y*(Ln-abs(y))^3/abs(y)*Ny>

       (28) %--------------------------------------------------------------------
       (29) % Example 4: AddForceSpring  (position vector with two components)
       (30) %--------------------------------------------------------------------
       (31) Particle  P4, Q4
       (32) Q4.SetPosition( P4, x*Nx> + y*Ny> )
    -> (33) p_P4_Q4> = x*Nx> + y*Ny>

       (34) Q4.AddForceSpring( P4, k, Ln )
    -> (35) Force_Q4_P4> = -k*x*(1-Ln/sqrt(x^2+y^2))*Nx> - k*y*(1-Ln/sqrt(x^2+y^2))*Ny>

#### AddTorque

    AddTorque  ResetTorque

     Purpose:  Adds (or resets) torque to a RigidFrame or RigidBody.

    Syntax 1:  B.AddTorque(       torqueVec> )  same as Torque_B>   += torqueVec>
    Syntax 2:  B.AddTorque(   A,  torqueVec> )  same as Torque_B_A> += torqueVec>
    Syntax 3:  B.ResetTorque(     torqueVec> )  same as Torque_B>   := torqueVec>
    Syntax 4:  B.ResetTorque( A,  torqueVec> )  same as Torque_B_A> := torqueVec>

       Input:  B, A -- names of a RigidFrame or RigidBody.
               torqueVec> -- a torque vector.

    Output 1:  Adds  torqueVec>  to  Torque_B>    (accumulates torque on B).
    Output 2:  Adds  torqueVec>  to  Torque_B_A>  (accumulates torque on B from A).
    Output 3:  Torque_B>    is reset to  torqueVec>.
    Output 4:  Torque_B_A>  is reset to  torqueVec>.

      Remark:  Syntax 1 is for "external" torques applied to B.
               Torque_B> denotes the torque associated with contact/distance forces
               on B that are "external" to any system under consideration
               (and perhaps also external to the NewtonianFrame).
        Note:  B.GetResultantTorque()  accounts for both  Torque_B>  and all
               action/reaction torques on B such as Torque_B_A>, Torque_B_C>, etc.

      Remark:  Syntax 2 is for "action/reaction" torques applied to B from A and is
               frequently used for torque motors, torsional springs/dampers, etc.
        Note:  B.GetResultantTorque(A)  returns  Torque_B_A> - Torque_A_B>.
               Torque_B_A> denotes a torque on B from A.
               Torque_A_B> denotes a torque on A from B.

      Remark:  When sensible, use Syntax 2 instead of Syntax 1 as it efficiently
               accounts for action/reaction torques by knowing whether B and A
               are internal, external, or mixed for the system under consideration.

     Related:  AddForce  AddForceDamper  AddForceElectrostatic  AddForceGravity
               AddForceInverseSquare  AddForceLinearActuator  AddForceSpring
               AddTorque  AddTorqueDamper
               GetMomentOfForces  GetResultantForce  GetResultantTorque
               GetForceGravityPotentialEnergy  GetForceSpringPotentialEnergy
               GetStatics   GetStaticsKane   GetStaticsLagrange
               GetDynamics  GetDynamicsKane  GetDynamicsLagrange

       (1) %--------------------------------------------------------------------
       (2) % Example 1: AddTorque  (add torque to a RigidFrame or RigidBody)
       (3) %--------------------------------------------------------------------
       (4) RigidBody  B
       (5) B.AddTorque( Bx> + 2*By> )
    -> (6) Torque_B> = Bx> + 2*By>

       (7) B.AddTorque( 3*Bz> )
    -> (8) Torque_B> = Bx> + 2*By> + 3*Bz>

       (9) %--------------------------------------------------------------------
       (10) % Example 2: AddTorque (action/reaction with two rigid objects)
       (11) %--------------------------------------------------------------------
       (12) RigidFrame A
       (13) B.AddTorque( A,  Ax> + 2*Ay> )
    -> (14) Torque_B_A> = Ax> + 2*Ay>

       (15) ResultantTorqueOnA> := A.GetResultantTorque()
    -> (16) ResultantTorqueOnA> = -Ax> - 2*Ay>

       (17) ResultantTorqueOnB> := B.GetResultantTorque()
    -> (18) ResultantTorqueOnB> = Ax> + 2*Ay> + Bx> + 2*By> + 3*Bz>

       (19) %--------------------------------------------------------------------
       (20) % Example: ResetTorque (reset torque on a RigidFrame or RigidBody)
       (21) %--------------------------------------------------------------------
       (22) B.ResetTorque( sin(t)*Bx> )
    -> (23) Torque_B> = sin(t)*Bx>

       (24) B.ResetTorque( A,  cos(t)*Az> )
    -> (25) Torque_B_A> = cos(t)*Az>

#### AddTorqueDamper

    AddTorqueDamper

     Purpose:  Adds damper torque to a RigidFrame or RigidBody.

    Syntax 1:  B.AddTorqueDamper( A, b )
    Syntax 2:  B.AddTorqueDamper( A, b, angularRateExponent )

       Input:  B, A -- names of a RigidFrame or RigidBody.
               b -- the damper constant (scalar)
               angularRateExponent -- the exponent on the damper's angular rate

    Output 1:  Adds a damper torque on B from A equal to -b * w_B_A>.

    Output 2:  Adds a damper torque on B from A whose magnitude is equal to
               b * angularRate^angularRateExponent  where angularRate is the
               magnitude of B's angular velocity in A.  The direction of the
               damper torque is opposite B's angular velocity in A.

     Related:  AddForce  AddForceDamper  AddForceElectrostatic  AddForceGravity
               AddForceInverseSquare  AddForceLinearActuator  AddForceSpring
               AddTorque  AddTorqueDamper
               GetMomentOfForces  GetResultantForce  GetResultantTorque
               GetForceGravityPotentialEnergy  GetForceSpringPotentialEnergy
               GetStatics   GetStaticsKane   GetStaticsLagrange
               GetDynamics  GetDynamicsKane  GetDynamicsLagrange

       (1) %--------------------------------------------------------------------
       (2) % Example 1: AddTorqueDamper
       (3) %--------------------------------------------------------------------
       (4) NewtonianFrame N
       (5) RigidBody A
       (6) Variable  qA'
       (7) Constant  b    % Damping constant
       (8) A.SetAngularVelocity( N, qA'*Az> )
    -> (9) w_A_N> = qA'*Az>

       (10) A.AddTorqueDamper( N, b )
    -> (11) Torque_A_N> = -b*qA'*Az>

       (12) %--------------------------------------------------------------------
       (13) % Example 2: AddTorqueDamper  (with angular-rate exponent)
       (14) %--------------------------------------------------------------------
       (15) RigidBody B
       (16) Variable  qB'
       (17) B.SetAngularVelocity( A, qB'*By> )
    -> (18) w_B_A> = qB'*By>

       (19) B.AddTorqueDamper( A, b, 3 )
    -> (20) Torque_B_A> = -b*qB'^3*By>

       (21) %--------------------------------------------------------------------
       (22) % Example 3: AddTorqueDamper  (angular-velocity with three components)
       (23) %--------------------------------------------------------------------
       (24) RigidBody  C
       (25) Variable   wx, wy, wz
       (26) C.SetAngularVelocity( N, wx*Cx> + wy*Cy> + wz*Cz> )
    -> (27) w_C_N> = wx*Cx> + wy*Cy> + wz*Cz>

       (28) C.AddTorqueDamper( N, b, 2 )
    -> (29) Torque_C_N> = -b*wx*sqrt(wx^2+wy^2+wz^2)*Cx> - b*wy*sqrt(wx^2+wy^2+wz^2)*Cy>
            - b*wz*sqrt(wx^2+wy^2+wz^2)*Cz>

#### Animate

    Animate

     Purpose:  Creates output for objects to be animated by a computer graphic
               visualization program, e.g., MGView (Web) or ANIMAKE (Windows/PC).

    Syntax 1:  Animate( N, O,  A,B,C, ... )
    Syntax 2:  Animate( N, O )
    Syntax 3:  Animate()

       Input:  N -- the name of a RigidFrame or RigidBody
               O -- the name of a Point or Particle
               A,B,C -- names of Point, Particle, RigidFrame, or RigidBody

    Output 1:  If  A  is a RigidFrame or RigidBody, calculates rotation matrix N_A,
               position vector p_O_Ao>, and corresponding Output statements.

               If  A  is a Point or Particle, calculates position vector p_O_A> and
               creates corresponding Output statements.

    Output 2:  Rotation matrices for all rigid frames/bodies Xi (i=1,2, ...) and
               position vectors from point O to points Xio (i=1,2, ...)
               and corresponding Output statements.

    Output 3:  Same as Output 2 where N is the NewtonianFrame and O is
               the NewtonianFrame origin (e.g., No).

     Related:  ODE  Solve  Input  Output  OutputPlot  Plot  Animate
               ConvertUnits  GetUnitSystem  SetUnitSystem  SetDigits

       (1) %--------------------------------------------------------------------
       (2) % Example: Animate  (double pendulum on a cart)
       (3) %--------------------------------------------------------------------
       (4) NewtonianFrame N
       (5) Particle       A        % Cart
       (6) RigidBody      B, C     % Two pendulums
       (7) Point          BC       % Pin-joint Point connecting B and C
       (8) Variable       xA'      % Differential equation governs xA
       (9) %--------------------------------
       (10) %   Rotational kinematics
       (11) B.SetRotationMatrixZ( N, t )
    -> (12) B_N = [cos(t), sin(t), 0;  -sin(t), cos(t), 0;  0, 0, 1]

       (13) C.SetRotationMatrixZ( B, 2*t )
    -> (14) C_B = [cos(2*t), sin(2*t), 0;  -sin(2*t), cos(2*t), 0;  0, 0, 1]

       (15) %--------------------------------
       (16) %   Translational kinematics
       (17) xA' = exp(sin(t));      % Actuator connects A to No
    -> (18) xA' = exp(sin(t))

       (19) A.SetPosition( No, xA*Nx> )
    -> (20) p_No_A> = xA*Nx>

       (21) Bo.SetPosition( A, -0.5*By> )
    -> (22) p_A_Bo> = -0.5*By>

       (23) BC.SetPosition( A, -By> )
    -> (24) p_A_BC> = -By>

       (25) Co.SetPosition( BC, -0.5*Cy> )
    -> (26) p_BC_Co> = -0.5*Cy>

       (27) %--------------------------------
       (28) Animate( N, No, A,B,C )
    -> (29) p_No_A = [xA;  0;  0]
    -> (30) p_No_Bo = [0.5*sin(t) + xA;  -0.5*cos(t);  0]
    -> (31) p_No_Co = [sin(t) + 0.5*sin(3*t) + xA;  -cos(t) - 0.5*cos(3*t);  0]
    -> (32) N_C = [cos(3*t), -sin(3*t), 0;  sin(3*t), cos(3*t), 0;  0, 0, 1]

       (33) Input xA = 0.234, tFinal=0.2
       (34) ODE() DoublePendulumOnCart

       (35) %--------------------------------
       (36) %   In response to the ODE command, Output is listed on screen:
       (37) %   Note: Units of GetLengthUnit may be associated with P_No_A[i], ...
       (38) %
       (39) %Output 1: t, P_No_A[1],  P_No_A[2],  P_No_A[3]
       (40) %Output 2: t, P_No_Bo[1], P_No_Bo[2], P_No_Bo[3],
       (41) %          N_B[1,1] NoUnits, N_B[1,2] NoUnits, N_B[1,3] NoUnits,
       (42) %          N_B[2,1] NoUnits, N_B[2,2] NoUnits, N_B[2,3] NoUnits,
       (43) %          N_B[3,1] NoUnits, N_B[3,2] NoUnits, N_B[3,3] NoUnits
       (44) %Output 3: t, P_No_Co[1], P_No_Co[2], P_No_Co[3],
       (45) %          N_C[1,1] NoUnits, N_C[1,2] NoUnits, N_C[1,3] NoUnits,
       (46) %          N_C[2,1] NoUnits, N_C[2,2] NoUnits, N_C[2,3] NoUnits,
       (47) %          N_C[3,1] NoUnits, N_C[3,2] NoUnits, N_C[3,3] NoUnits

#### ceil

    ceil   floor

     Purpose:  Returns the ceiling or floor of a real scalar expression.

    Syntax 1:  ceil( realScalarExpression )
    Syntax 2:  floor( realScalarExpression )

       Input:  realScalarExpression -- a real scalar expression.

    Output 1:  Ceiling of realScalarExpression, i.e., the smallest
               integer greater than or equal to realScalarExpresion.

    Output 2:  Floor of realScalarExpression, i.e., the largest
               integer less than or equal to realScalarExpresion.

      Remark:  The sign function can combine with ceil or floor for if statements:
               isPositive      = ceil(  sign(t)/2 )              % Returns 0 or  1.
               isPositiveOr0   = ceil(  sign(t)/2 + 0.1 )        % Returns 0 or  1.
               isNegative      = floor( sign(t)/2 )              % Returns 0 or -1.
               isTGreaterThan5 = ceil( sign(t-5) / 2 )           % Returns 0 or  1.
               isTLessThan9    = ceil( sign(9-t) / 2 )           % Returns 0 or  1.
               isTBetween5And9 = isTGreaterThan5 * isTLessThan9  % Returns 0 or  1.

     Related:  ceil  floor  int  max  min  round  RoundDigits  sign  MathFunctions
               IsNegative  IsNegativeOr0  IsPositiveOr0  IsPositive

       (1) %--------------------------------------------------------------------
       (2) % Example: ceil
       (3) %--------------------------------------------------------------------
       (4) A = ceil(  2.9999 )
    -> (5) A = 3

       (6) B = ceil(  3.0001 )
    -> (7) B = 4

       (8) C = ceil( -2.9999 )
    -> (9) C = -2

       (10) D = ceil( -3.0001 )
    -> (11) D = -3

       (12) E = ceil( 2.9 + t )
    -> (13) E = ceil(2.9+t)

       (14) isPositiveA = Evaluate( ceil( sign(t)/2 ),  t =  200   )
    -> (15) isPositiveA = 1

       (16) isPositiveB = Evaluate( ceil( sign(t)/2 ),  t = -200   )
    -> (17) isPositiveB = 0

       (18) isPositiveC = Evaluate( ceil( sign(t)/2 ),  t =  0     )
    -> (19) isPositiveC = 0

       (20) isPositiveD = Evaluate( ceil( sign(t)/2 ),  t =  1E-21 )
    -> (21) isPositiveD = 1

       (22) isPositiveE = Evaluate( ceil( sign(t)/2 ),  t = -1E-21 )
    -> (23) isPositiveE = 0

       (24) isNonNegativeA = Evaluate( ceil( sign(t)/2 + 1E-200 ),  t =  0     )
    -> (25) isNonNegativeA = 1

       (26) isNonNegativeB = Evaluate( ceil( sign(t)/2 + 1E-200 ),  t =  1E-21 )
    -> (27) isNonNegativeB = 1

       (28) isNonNegativeC = Evaluate( ceil( sign(t)/2 + 1E-200 ),  t = -1E-21 )
    -> (29) isNonNegativeC = 0

       (30) %--------------------------------------------------------------------
       (31) % Example: floor
       (32) %--------------------------------------------------------------------
       (33) F = floor(  2.9999 )
    -> (34) F = 2

       (35) G = floor(  3.0001 )
    -> (36) G = 3

       (37) H = floor( -2.9999 )
    -> (38) H = -3

       (39) I = floor( -3.0001 )
    -> (40) I = -4

       (41) J = floor( 2.9 + t )
    -> (42) J = floor(2.9+t)

       (43) isNegativeA = Evaluate( floor( sign(t)/2 ),  t =  200   )
    -> (44) isNegativeA = 0

       (45) isNegativeB = Evaluate( floor( sign(t)/2 ),  t = -200   )
    -> (46) isNegativeB = -1

       (47) isNegativeC = Evaluate( floor( sign(t)/2 ),  t =  0     )
    -> (48) isNegativeC = 0

       (49) isNegativeD = Evaluate( floor( sign(t)/2 ),  t =  1E-21 )
    -> (50) isNegativeD = 0

       (51) isNegativeE = Evaluate( floor( sign(t)/2 ),  t = -1E-21 )
    -> (52) isNegativeE = -1

       (53) isNonPositiveA = Evaluate( floor( sign(t)/2 - 1E-200 ),  t =  0     )
    -> (54) isNonPositiveA = -1

       (55) isNonPositiveB = Evaluate( floor( sign(t)/2 - 1E-200 ),  t =  1E-21 )
    -> (56) isNonPositiveB = 0

       (57) isNonPositiveC = Evaluate( floor( sign(t)/2 - 1E-200 ),  t = -1E-21 )
    -> (58) isNonPositiveC = -1

       (59) %--------------------------------------------------------------------
       (60) % Example: Combine the sign function with ceil or floor for if statements.
       (61) %--------------------------------------------------------------------
       (62) isTLessThan9 = ceil( sign(9-t) / 2 )
    -> (63) isTLessThan9 = ceil(0.5*sign(9-t))

       (64) isTGreaterThan5 = ceil( sign(t-5) / 2 )
    -> (65) isTGreaterThan5 = ceil(0.5*sign(-5+t))

       (66) isTBetween5And9 = isTGreaterThan5 * isTLessThan9
    -> (67) isTBetween5And9 = isTGreaterThan5*isTLessThan9

       (68) forceA = isTLessThan9    * 88    % if t < 9, forceA = 88 else forceA = 0.
    -> (69) forceA = 88*isTLessThan9

       (70) forceB = isTGreaterThan5 * 77    % if t > 5, forceB = 77 else forceB = 0.
    -> (71) forceB = 77*isTGreaterThan5

       (72) forceC = isTBetween5And9 * 66    % if 5 < t < 9, forceC = 66 else forceC = 0.
    -> (73) forceC = 66*isTBetween5And9

#### Clear

    Clear

     Purpose:  Clears the workspace by restarting the program.
               Re-runs designated lines from the workspace.

    Syntax 1:  Clear
    Syntax 2:  Clear lineNumber

       Input:  lineNumber -- designates the first line number to be
               deleted after the program restarts.  lineNumber must
               be smaller than the current line number.

    Output 1:  Clears the workspace and restarts the program.

    Output 2:  Restarts the program and re-executes all input lines
               preceding line lineNumber.

      Remark:  The CLEAR command may not be available on all computers.

     Related:  !  %  &  Clear  List  Pause  Quit  Run  Save  GetDefaults
               ClearInput  ClearOutput  ClearOutputPlot  ClearOutputEncode

    --------------------------------------------------------------------
     Example:  Clear
    --------------------------------------------------------------------
       (1) a = 2
    -> (2) a = 2

       (3) b = 3
    -> (4) b = 3

       (5) Clear

#### Constant

    Constant  or  ConstantEncode

     Purpose:  Declares the names of constants.

    Syntax 1:  Constant        a,  b,  c+,  d-
    Syntax 2:  Constant        g = 9.8 m/s^2
    Syntax 3:  Constant        I = m*L^2
    Syntax 4:  ConstantEncode  switchLogic = 1 noUnits
    Syntax 5:  Constant()

       Input:  a -- name that starts with a letter, followed by a reasonable
                    number of alphanumeric characters (similarly for b, c, d).
               a, b  are regarded as REAL constants unless SetComplex is ON.
               c+    declares c as a real non-negative constant so  abs(c) =  c.
               d-    declares d as a real non-positive constant so  abs(d) = -d.

    Output 2:  g = 9.8  m/s^2  -- declares g as a constant with INPUT 9.8 m/s^2.
    Output 3:  I = m*L^2       -- declares I as a constant assigned to m*L^2.
                            (m*L^2 should be a number or a constant expression).

    Output 4:  ConstantEncode forces MATLAB(R), C, and Fortran programs to include
               quantities that may not otherwise appear due to code-optimization.

    Output 5:  Creates an array of all names declared as Constant.

       (1) %--------------------------------------------------------------------
       (2) % Example: Constant
       (3) %--------------------------------------------------------------------
       (4) Constant a, b, c+, d-
       (5) Constant e{0:3}           % Declares e0, e1, e2, e3
       (6) Constant f{1:2, 1:3}      % Declares f11, f12, f13, f21, f22, f23
       (7) Constant g = 9.8  m/s^2   % Same as  Constant g;  Input g = 9.8 m/s^2
       (8) Constant h = 5 noUnits    % Same as  Constant h;  Input h = 5 noUnits
       (9) Constant k = a * b * abs(c) * abs(d)
    -> (10) k = -a*b*c*d

       (11) RigidBody  B
       (12) B.SetMass( m = 20 kg )    % Same as  B.SetMass(m);  Input m = 20 kg
       (13) B.SetInertia( Bcm,  Ixx, Iyy = 3 kg*m^2,  Izz = Ixx + Iyy )
    -> (14) Izz = Ixx + Iyy

       (15) arrayOfConstants = Constant()
    -> (16) arrayOfConstants = [a;  b;  c;  d;  e0;  e1;  e2;  e3;  f11;  f12;  f13;
            f21;  f22;  f23;  g;  h;  Ixx;  Iyy;  Izz;  k;  m]

#### ConvertUnits

    ConvertUnits

     Purpose:  Calculates units conversion factors.

    Syntax 1:  ConvertUnits(   Units1, Units2 )
               ConvertUnits( s Units1, Units2 )
    Syntax 2:  ConvertUnits(   Units1, GetUnitSystem )
               ConvertUnits( s Units1, GetUnitSystem )
    Syntax 3:  ConvertUnits(   GetUnitSystem, Units2 )
               ConvertUnits( s GetUnitSystem, Units2 )

       Input:  Units1, Units2 -- expressions consisting of names of units
                                 together with the operators *, /, and ^

               s -- a scalar expression (e.g., a number, constant, variable).

    Output 1:  Conversion factor from Units1 to Units2 or
               s * ConvertUnits( Units1 * Units2)

    Output 2:  Conversion factor from Units1 to the units of SetUnitSystem or
               s * ConvertUnits( Units1 * GetUnitSystem )

    Output 3:  Conversion factor from the units of SetUnitSystem to Units2 or
               s * ConvertUnits( GetUnitSystem, Units2 )

      Remark:  Units expressions may include the following names:
               GetMassUnit, GetLengthUnit, GetTimeUnit, GetAngleUnit,
               which stand for, respectively, the current name assigned by
               SetUnitSystem to the units of mass, length, and time, and
               "radian" (which is always associated with GetAngleUnit).

     Related:  ODE  Solve  Input  Output  OutputPlot  Plot  Animate
               ConvertUnits  GetUnitSystem  SetUnitSystem
               GetMassUnit   GetLengthUnit  GetTimeUnit  GetAngleUnit
               Constant,     SetMass,       SetInertia

       (1) %--------------------------------------------------------------------
       (2) %Example: ConvertUnits
       (3) %--------------------------------------------------------------------
       (4) inchToCentimeter = ConvertUnits( inch, cm )
    -> (5) inchToCentimeter = 2.54

       (6) ounceMassToMilligram = ConvertUnits( ozm, mg )
    -> (7) ounceMassToMilligram = 28349.52

       (8) poundForceToNewton = ConvertUnits( lbf, Newton )
    -> (9) poundForceToNewton = 4.448222

       (10) sevenMPHToMeterPerSecond =  7 * ConvertUnits( MPH,  m/sec )
    -> (11) sevenMPHToMeterPerSecond = 3.12928

       (12) sixtyMPHToMeterPerSecond = ConvertUnits( (30+30) MPH,  m/sec )
    -> (13) sixtyMPHToMeterPerSecond = 26.8224

       (14) tMinuteToSecond = ConvertUnits( t minutes,  seconds )
    -> (15) tMinuteToSecond = 60*t

#### Convolve

    Convolve

     Purpose:  Convolves two one-dimensional matrices

      Syntax:  Convolve( M, N )

       Input:  M -- one-dimensional matrix having m elements.
               N -- one-dimensional matrix having n element.

      Output:  One-dimensional matrix of m + n - 1 elements,  whose ith-element
               is the sum of the products of the jth element of M and the kth
               element of N such that j + k - 1 = i

      Remark:  If M and N are expressions (not matrices) returns the
               the product of M and N, i.e., returns M*N.

       (1) %--------------------------------------------------------------------
       (2) % Example: Convolve
       (3) %--------------------------------------------------------------------
       (4) Constant  m1,m2,m3, n1,n2
       (5) y = Convolve( [m1,m2,m3], [n1,n2] )
    -> (6) y = [m1*n1, m1*n2 + m2*n1, m2*n2 + m3*n1, m3*n2]

#### cos

    cos and sec

     Purpose:  Returns the cosine or secant of a scalar expression.

    Syntax 1:  cos(x)  or  sec(x)
    Syntax 2:  cosDegrees( realNumberDeg )

       Input:  x -- the radian measure of a real or complex scalar expression.
               realNumberDeg -- expression that resolves to a real number.

    Output 1:  cos(x) returns the cosine of x.
               sec(x) returns the cosecant of x, which is 1/cos(x).
    Output 2:  Cosine of realNumberDeg.

     Related:  ConvertUnits  ImaginaryNumber  MathFunctions
               cos  sin  tan  acos  asin  atan  atan2  cosDegrees  ...

       (1) %--------------------------------------------------------------------
       (2) % Example 1: cos, sec   (real scalar expressions)
       (3) %--------------------------------------------------------------------
       (4) A = cos( pi/3 )
    -> (5) A = 0.5

       (6) B = cosDegrees( 60 )
    -> (7) B = 0.5

       (8) C = cos(t) + cos( t * ConvertUnits(deg,rad) )
    -> (9) C = cos(t) + cos(0.01745329*t)

       (10) D = sec( pi/3 ) + cos(0.5+2*t) + sec(t^2)
    -> (11) D = 2 + sin(2.070796+2*t) + 1/cos(t^2)

       (12) %--------------------------------------------------------------------
       (13) % Example 2: cos, sec   (complex scalar expressions)
       (14) %--------------------------------------------------------------------
       (15) E = cos( 2 + 3*GetImaginaryNumber() )
    -> (16) E = -4.189626 - 9.109228*imaginary

       (17) F = cos( 3*GetImaginaryNumber() + t )
    -> (18) F = cos(3*imaginary+t)

       (19) G = sec( GetImaginaryNumber() )
    -> (20) G = 0.6480543

#### cosh

    cosh,  sinh,  tanh

     Purpose:  Returns the hyperbolic cosine, sine, or tangent.

    Syntax 1:  cosh( scalarExpression )
    Syntax 2:  sinh( scalarExpression )
    Syntax 3:  tanh( scalarExpression )

       Input:  scalarExpression -- a real or complex scalar expression.

    Output 1:  Hyperbolic cosine  of scalarExpression.
    Output 2:  Hyperbolic sine    of scalarExpression.
    Output 3:  Hyperbolic tangent of scalarExpression.

     Remark:   cosh(x) = ( exp(x) + exp(-x) ) / 2
               sinh(x) = ( exp(x) - exp(-x) ) / 2
               tanh(x) = sinh(x) / cosh(x)
               cosh(x)^2 - sinh(x)^2 = 1
               D( cosh(x), x ) = sinh(x)
               D( sinh(x), x ) = cosh(x)
               D( tanh(x), x ) = 1 - tanh(x)^2 = 1 / cosh(x)^2

     Related:  ImaginaryNumber  MathFunctions
               cos  sin  tan  acos  asin  atan  atan2  cosDegrees  ...

       (1) %--------------------------------------------------------------------
       (2) % Example 1: cosh, sinh, tanh   (real scalar expressions)
       (3) %--------------------------------------------------------------------
       (4) A = sinh(2) + cosh(3) + tanh(4)
    -> (5) A = 14.69385

       (6) B = sinh(1+2*t) + cosh(3+4*t) + tanh(5+6*t)
    -> (7) B = sinh(1+2*t) + cosh(3+4*t) + tanh(5+6*t)

       (8) %--------------------------------------------------------------------
       (9) % Example 2: cosh, sinh, tanh   (complex scalar expressions)
       (10) %--------------------------------------------------------------------
       (11) C = cosh( 2 + 3*GetImaginaryNumber() )
    -> (12) C = -3.724546 + 0.5118226*imaginary

       (13) D = sinh( 2 + 3*GetImaginaryNumber() )
    -> (14) D = -3.590565 + 0.5309211*imaginary

       (15) E = tanh( 2 + 3*GetImaginaryNumber() )
    -> (16) E = 0.9653859 - 0.009884375*imaginary

       (17) F = sinh(3*imaginary+t) + cosh(3*imaginary+t)
    -> (18) F = sinh(3*imaginary+t) + cosh(3*imaginary+t)

#### Cross

    Cross   or    Dot

     Purpose:  Forms the cross-product or dot-product for vectors, dyadics, etc.

    Syntax 1:  Cross( vA, vB )
    Syntax 2:    Dot( vA, vB )

       Input:  vA -- a vector, dyadic, triadic, or a matrix of these.
               vB -- a vector, dyadic, triadic, or a matrix of these.

    Output 1:  Cross-product of vA and vB.
    Output 2:    Dot-product of vA and vB.

      Remark:  When vA and vB are matrices, perform operations in the order defined
               by matrix multiplication. For the 2x3 matrix vA and 3x5 matrix vB,
               Cross( vA, vB )  returns a 2x5 matrix (similarly for Dot).

     Related:  GetMagnitude           GetMagnitudeSquared
               GetDistance            GetDistanceSquared
               GetSpeed               GetSpeedSquared
               GetAngularSpeed        GetAngularSpeedSquared      ConvertUnits
               GetAngleBetweenVectors GetAngleBetweenUnitVectors  Rotate
               GetUnitVector          Vector  Dyadic  Matrix      Cross  Dot

       (1) %--------------------------------------------------------------------
       (2) % Example 1: Cross( vector, vector )     Dot( vector, vector )
       (3) %--------------------------------------------------------------------
       (4) RigidFrame A
       (5) Constant   x, y, z
       (6) v> = x*Ax> + y*Ay> + z*Az>
    -> (7) v> = x*Ax> + y*Ay> + z*Az>

       (8) w> =   Ax> + 2*Ay> + 3*Az>
    -> (9) w> = Ax> + 2*Ay> + 3*Az>

       (10) vCrossw> = Cross( v>, w> )
    -> (11) vCrossw> = (3*y-2*z)*Ax> + (z-3*x)*Ay> + (2*x-y)*Az>

       (12) vDotw = Dot( v>,  w> )
    -> (13) vDotw = x + 2*y + 3*z

       (14) %--------------------------------------------------------------------
       (15) % Example 2: Cross( vector, dyadic )     Dot(  vector, dyadic )
       (16) %--------------------------------------------------------------------
       (17) d>> = Ay>*Ax> - 2*Az>*Az>
    -> (18) d>> = Ay>*Ax> - 2*Az>*Az>

       (19) dCrossv>> = Cross( d>>, v> )
    -> (20) dCrossv>> = -z*Ay>*Ay> + y*Ay>*Az> + 2*y*Az>*Ax> - 2*x*Az>*Ay>

       (21) dDotv> = Dot( d>>, v> )
    -> (22) dDotv> = x*Ay> - 2*z*Az>

       (23) %--------------------------------------------------------------------
       (24) % Example 3: Cross( vector, matrixOfVectors )  Dot( vector, matrixOfVectors )
       (25) %--------------------------------------------------------------------
       (26) vCrossMatrix = Cross( v>,  [w>; t*Ax> + sin(t)*Ay>] )
    -> (27) vCrossMatrix[1] = (3*y-2*z)*Ax> + (z-3*x)*Ay> + (2*x-y)*Az>
    -> (28) vCrossMatrix[2] = -z*sin(t)*Ax> + z*t*Ay> + (x*sin(t)-y*t)*Az>

       (29) vDotMatrix   =   Dot( v>,  [w>; t*Ax> + sin(t)*Ay>] )
    -> (30) vDotMatrix = [x + 2*y + 3*z;  x*t + y*sin(t)]

       (31) %--------------------------------------------------------------------
       (32) % Example 4: Cross( matrixOfVectors, vector )  Dot( matrixOfVectors, vector )
       (33) %--------------------------------------------------------------------
       (34) matrixCrossV = Cross( [w>; t*Ax> + sin(t)*Ay>],  v> )
    -> (35) matrixCrossV[1] = (2*z-3*y)*Ax> + (3*x-z)*Ay> + (y-2*x)*Az>
    -> (36) matrixCrossV[2] = z*sin(t)*Ax> - z*t*Ay> + (y*t-x*sin(t))*Az>

       (37) matrixDotV   =   Dot( [w>; t*Ax> + sin(t)*Ay>],  v> )
    -> (38) matrixDotV = [x + 2*y + 3*z;  x*t + y*sin(t)]

       (39) %--------------------------------------------------------------------
       (40) % Example 5: Cross( MatrixOfVectors, MixedMatrixWithDyadicAndVector )
       (41) %--------------------------------------------------------------------
       (42) MCrossN = Cross( [Ax>; Ay>],  [Ax>, Ay>*Az>] )
    -> (43) MCrossN = [0>, Az>*Az>;  -Az>, 0>>]

       (44) MDotN   =   Dot( [Ax>; Ay>],  [Ax>, Ay>*Az>] )
    -> (45) MDotN = [1, 0>;  0, Az>]

#### Derivative

    Derivative

     Purpose:  Forms the ordinary or partial derivative of a scalar, vector, or
               dyadic expression or a matrix of such expressions.

     See help: Dt  for more information on ordinary derivatives.
               D   for more information on partial  derivatives.

     Related:  D  Dt  DtDt  Integrate  GetPartials  GetJacobian  MathFunctions

#### Dt

    Dt

     Purpose:  Forms the ordinary derivative of a scalar, vector, or dyadic
               expression or a matrix of such expressions.

    Syntax 1:  Dt(     scalarOrMatrixExpression )
    Syntax 2:  Dt(     vectorOrMatrixExpression,  refFrame )
    Syntax 3:  DtDt(   scalarOrMatrixExpression )
    Syntax 4:  DtDt(   vectorOrMatrixExpression,  refFrame )
    Syntax 5:  DtDtDt( scalarOrMatrixExpression )
    Syntax 6:  DtDtDt( vectorOrMatrixExpression,  refFrame )

       Input:  scalarOrMatrixExpression -- a scalar expression or matrix
                                           of scalar expressions.
               vectorOrMatrixExpression -- a scalar, vector, or dyadic expression
                                           or matrix of such expressions.
               refFrame -- a reference frame (e.g., RigidFrame or RigidBody)

    Output 1:  1st-ordinary derivative of scalarOrMatrixExpression.
    Output 2:  1st-ordinary derivative of vectorOrMatrixExpression in refFrame.
    Output 3:  2nd-ordinary derivative of scalarOrMatrixExpression.
    Output 4:  2nd-ordinary derivative of vectorOrMatrixExpression in refFrame.
    Output 5:  3rd-ordinary derivative of scalarOrMatrixExpression.
    Output 6:  3rd-ordinary derivative of vectorOrMatrixExpression in refFrame.

      Remark:  The prime symbol ' denotes implicit ordinary differentiation with
               respect to the independent variable (which is t by default).
               For example, x' denotes dx/dt (e.g., ordinary time-derivative of x).

      Remark:  DtDt is preferable to DDt.  DtDtDt is preferable to DDDt.

     Related:  D  Dt  DtDt  DtDtDt  Integrate  MathFunctions
               SetDt  Solve  SolveDt  SolveSetInput  SolveSetInputDt  ...
               SolveQuadraticPositiveRoot  SolveQuadraticPositiveRootDt  ...

       (1) %--------------------------------------------------------------------
       (2) % Example 1:  Dt( scalarExpression, name )
       (3) %--------------------------------------------------------------------
       (4) s = sin(t)
    -> (5) s = sin(t)

       (6) s1stDerivative = Dt( s )
    -> (7) s1stDerivative = cos(t)

       (8) s2ndDerivative = DtDt( s )
    -> (9) s2ndDerivative = -sin(t)

       (10) s3rdDerivative = DtDtDt( s )
    -> (11) s3rdDerivative = -cos(t)

       (12) %--------------------------------------------------------------------
       (13) % Example 2:  Dt( matrixExpression, name )
       (14) %--------------------------------------------------------------------
       (15) Variable  x'', y''
       (16) m = [1, 2*t;  3*x, 4*y^2]
    -> (17) m = [1, 2*t;  3*x, 4*y^2]

       (18) m1stDerivative = Dt( m )
    -> (19) m1stDerivative = [0, 2;  3*x', 8*y*y']

       (20) m2ndDerivative = DtDt( m )
    -> (21) m2ndDerivative = [0, 0;  3*x'', 8*y'^2 + 8*y*y'']

       (22) %--------------------------------------------------------------------
       (23) % Example 3:  Dt( vectorExpression, refFrame )
       (24) %--------------------------------------------------------------------
       (25) RigidFrame A
       (26) v> = Vector( A, 3*x, y^2, 0 )
    -> (27) v> = 3*x*Ax> + y^2*Ay>

       (28) v1stDerivativeInA> = Dt( v>, A )
    -> (29) v1stDerivativeInA> = 3*x'*Ax> + 2*y*y'*Ay>

       (30) v2ndDerivativeInA> = DtDt( v>, A )
    -> (31) v2ndDerivativeInA> = 3*x''*Ax> + (2*y'^2+2*y*y'')*Ay>

       (32) %--------------------------------------------------------------------
       (33) % Example 4:  Dt( tensorExpression, refFrame )
       (34) %--------------------------------------------------------------------
       (35) DtOfTensorInA = Dt( [s, v>], A )
    -> (36) DtOfTensorInA = [cos(t), 3*x'*Ax> + 2*y*y'*Ay>]

#### D

    D

     Purpose:  Forms the partial derivative of a scalar, vector, or dyadic
               expression or a matrix of such expressions.

    Syntax 1:  D( scalarOrMatrixExpression, X )
    Syntax 2:  D( vectorOrMatrixExpression, X, refFrame )

       Input:  scalarOrMatrixExpression -- a scalar expression or matrix
                                           of scalar expressions.
               vectorOrMatrixExpression -- a scalar, vector, or dyadic expression
                                           or matrix of such expressions.
               X -- the name of a scalar or a matrix of scalar names.
               refFrame -- a reference frame (e.g., a RigidFrame or RigidBody).

     Output 1: Partial derivative of scalarOrMatrixExpression with respect to X.
     Output 2: Partial derivative of vectorOrMatrixExpression with respect to X in
               refFrame.

     Related:  D  Dt  DtDt  Integrate  GetPartials  GetJacobian  MathFunctions

       (1) %--------------------------------------------------------------------
       (2) % Example 1:  D( scalarExpression, name )
       (3) %--------------------------------------------------------------------
       (4) Variable x, y
       (5) s = sin(t) + 3*x + y^2
    -> (6) s = sin(t) + 3*x + y^2

       (7) DsDx = D( s, x )
    -> (8) DsDx = 3

       (9) DsDt = D( s, t )
    -> (10) DsDt = cos(t)

       (11) y = exp(t)
    -> (12) y = exp(t)

       (13) DsDt := D( s, t )
    -> (14) DsDt = cos(t) + 2*exp(t)*y

       (15) %--------------------------------------------------------------------
       (16) % Example 2:  D( matrixExpression, name )
       (17) %--------------------------------------------------------------------
       (18) matrix = [1, 2*t;  3*x, 4*y^2;  x*y, t^3]
    -> (19) matrix = [1, 2*t;  3*x, 4*y^2;  x*y, t^3]

       (20) DmDx = D( matrix, x )
    -> (21) DmDx = [0, 0;  3, 0;  y, 0]

       (22) DmDt = D( matrix, t )
    -> (23) DmDt = [0, 2;  0, 8*exp(t)*y;  exp(t)*x, 3*t^2]

       (24) %--------------------------------------------------------------------
       (25) % Example 3:  D( scalarExpression, matrixOfNames )
       (26) %--------------------------------------------------------------------
       (27) DsDxyt = D( s,  [x, y, t] )
    -> (28) DsDxyt = [3, 2*y, cos(t) + 2*exp(t)*y]

       (29) %--------------------------------------------------------------------
       (30) % Example 4:  D( matrixExpression, matrixOfNames )
       (31) %--------------------------------------------------------------------
       (32) DmDxyt = D( matrix, [x; y] )
    -> (33) DmDxyt = [0;  3 + 8*y;  y]

       (34) %--------------------------------------------------------------------
       (35) % Example 5:  D( vectorExpression, name, refFrame )
       (36) %--------------------------------------------------------------------
       (37) RigidFrame A
       (38) v> = Vector( A, 3*x, y^2, 0 )
    -> (39) v> = 3*x*Ax> + y^2*Ay>

       (40) DvDy_inA> = D( v>,  y,  A )
    -> (41) DvDy_inA> = 2*y*Ay>

#### GetJacobian

    GetJacobian   GetVelocityJacobian   GetAngularVelocityJacobian (IN DEVELOPMENT)

     Purpose:  Forms a Jacobian whose elements are partial derivatives, e.g.,
               partial derivatives of velocity with respect to generalized speeds.

    Syntax 1:  GetJacobian( scalarTensorMatrix1D, X )
    Syntax 2:  GetJacobian( scalarTensorMatrix1D, X, refFrame )
    Syntax 3:  Q.GetVelocityJacobian(         refFrame )
               B.GetAngularVelocityJacobian(  refFrame )
    Syntax 4:  Q.GetVelocityJacobian(         refFrame, X )
               B.GetAngularVelocityJacobian(  refFrame, X )
    Syntax 5:  Bp.GetSpatialVelocityJacobian( refFrame )
               Bp.GetSpatialVelocityJacobian( refFrame, X )

       Input:  scalarTensorMatrix1D -- a scalar, vector, or dyadic expression or a
                                   1D (one-dimensional) matrix of such expressions.
               X -- the name of a scalar or 1D matrix of these -- e.g., a variable.
               refFrame -- a reference frame (e.g., a RigidFrame or RigidBody).
               Q -- the name of a Point.
               B -- the name of a RigidFrame or RigidBody.
               Bp -- the name of a point fixed on rigid body or rigid frame B.

    Output 1:  n x m matrix of partial derivatives of the scalar portions of
               scalarTensorMatrix1D with respect to X.
               Herein: n = dimension of scalarTensorMatrix1D,  m = dimension of X.

    Output 2:  n x m matrix of partial derivatives of scalarTensorMatrix1D
               with respect to X in refFrame.

    Output 3:  1 x m matrix of partial derivatives of Q's velocity in refFrame with
               respect to the m scalars named in the command SetGeneralizedSpeed.
               Similarly for B's angular velocity in refFrame.

    Output 4:  1 x m matrix of partial derivatives of the scalar portions of
               Q's velocity in refFrame with respect to X.
               Similarly for B's angular velocity in refFrame.

    Output 5:  Matrix whose first row is B.GetAngularVelocityJacobian(...) and
               whose second row is Bp.GetVelocityJacobian(...),  where
               B is the RigidFrame or RigidBody to which point Bp is fixed.

     Related:  GetVelocity           GetRelativeVelocity
               GetPartialVelocity    GetPartialAngularVelocity
               GetVelocityRemainder  GetAngularVelocityRemainder
               GetVelocityJacobian   GetAngularVelocityJacobian    D, Dt  ...

#### GetPartialVelocity

    GetPartials  GetPartialVelocity  GetPartialAngularVelocity

     Purpose:  Forms partial velocities and partial angular velocities.

    Syntax 1:  Q.GetPartialVelocity( refFrame )
               Q.GetPartialVelocity( refFrame, generalizedSpeedi )
    Syntax 2:  B.GetPartialAngularVelocity( refFrame )
               B.GetPartialAngularVelocity( refFrame, generalizedSpeedi )
    Syntax 3:  GetPartialVelocity( scalarOrTensorExpression )
               GetPartialVelocity( scalarOrTensorExpression, generalizedSpeedi )

       Input:  Q -- name of a Point.
               B -- name of a RigidFrame or RigidBody.
               refFrame -- name of a RigidFrame or RigidBody.
               scalarOrTensorExpression -- scalar, vector, or dyadic expression.
               generalizedSpeedi -- name of a generalized speed.

    Output 1:  Column matrix of Q's partial velocities in refFrame or
               Q's partial velocity in refFrame for generalizedSpeedi.

    Output 2:  Column matrix of B's partial angular velocities in refFrame or
               B's partial angular velocity in refFrame for generalizedSpeedi.

    Output 3:  Column matrix of partial velocities for scalarOrTensorExpression or
               the partial velocity associated with generalizedSpeedi.

      Remark:  If using the old/deprecated command  SetDefaults( AUTOLEV ),
               the returned quantity may depend on whether the command is
               issued before or after the CONSTRAIN command.

     Related:  GetVelocity           GetRelativeVelocity
               GetPartialVelocity    GetPartialAngularVelocity
               GetVelocityRemainder  GetAngularVelocityRemainder
               GetVelocityJacobian   GetAngularVelocityJacobian    D, Dt  ...

       (1) %--------------------------------------------------------------------
       (2) % Example: GetPartialVelocity and GetPartialAngularVelocity
       (3) %--------------------------------------------------------------------
       (4) NewtonianFrame N
       (5) RigidBody      B        % Sphere
       (6) Point          BN(B)    % Point of B in contact with N
       (7) %----------------------------------------------------------
       (8) Constant  R
       (9) Variable  x',  y'
       (10) Variable  wx,  wy,  wz
       (11) SetGeneralizedSpeed( x', y', wx, wy, wz )
       (12) %----------------------------------------------------------
       (13) B.SetAngularVelocity( N,  wx*Nx> + wy*Ny> + wz*Nz> )
    -> (14) w_B_N> = wx*Nx> + wy*Ny> + wz*Nz>

       (15) Bcm.SetPositionVelocity( No,  x*Nx> + y*Ny> + R*Nz> )
    -> (16) p_No_Bcm> = x*Nx> + y*Ny> + R*Nz>
    -> (17) v_Bcm_N> = x'*Nx> + y'*Ny>

       (18) %----------------------------------------------------------
       (19) % Example: Partial angular velocities and velocities.
       (20) wBNPartials = B.GetPartialAngularVelocity( N )
    -> (21) wBNPartials = [0>;  0>;  Nx>;  Ny>;  Nz>]

       (22) vBcmNPartials = Bcm.GetPartialVelocity( N )
    -> (23) vBcmNPartials = [Nx>;  Ny>;  0>;  0>;  0>]

       (24) %----------------------------------------------------------
       (25) % Example: Generic partial velocities.
       (26) genericPartialA = GetPartialVelocity( cos(t)*x'*Nx> + sin(t)*y'*Ny> )
    -> (27) genericPartialA = [cos(t)*Nx>;  sin(t)*Ny>;  0>;  0>;  0>]

       (28) genericPartialB = GetPartialVelocity( R*(wx + wy) + 3*x' + 4*y' )
    -> (29) genericPartialB = [3;  4;  R;  R;  0]

       (30) genericPartialC = GetPartialVelocity( [w_B_N>;  v_Bcm_N>],  x' )
    -> (31) genericPartialC = [0>;  Nx>]

       (32) genericPartialD = GetPartialVelocity(  w_B_N>,             [x'; y'; wx] )
    -> (33) genericPartialD = [0>;  0>;  Nx>]

       (34) genericPartialE = GetPartialVelocity( [w_B_N>,  v_Bcm_N>], [x'; y'; wx] )
    -> (35) genericPartialE = [0>, Nx>;  0>, Ny>;  Nx>, 0>]

       (36) genericPartialF = GetPartialVelocity( [w_B_N>;  v_Bcm_N>], [x'; y'; wx] )
    -> (37) genericPartialF = [0>, 0>, Nx>;  Nx>, Ny>, 0>]

#### Dyadic

    Dyadic

     Purpose:  Constructs a dyadic.

    Syntax 1:  Dyadic( A,  xx, yy, zz )
    Syntax 2:  Dyadic( A,  xx,xy,xz, yx,yy,yz, zx,zy,zz )
    Syntax 3:  Dyadic( A,  threeElementMatrix )
    Syntax 4:  Dyadic( A,  nineElementMatrix )
    Syntax 5:  Dyadic( A,  dyadic>>   )

       Input:  A -- the name of a RigidFrame or RigidBody
               xx, xy, xz, ..., zz -- scalar expressions
               threeElementMatrix -- 3x1  or  1x3 matrix of scalars
               nineElementMatrix --  9x1  or  1x9  or  3x3 matrix

    Output 1:   xx*Ax>*Ax> + yy*Ay>*Ay> + zz*Az>*Az>

    Output 2:   xx*Ax>*Ax> + xy*Ax>*Ay> + xz*Ax>*Az>
              + yx*Ay>*Ax> + yy*Ay>*Ay> + yz*Ay>*Az>
              + zx*Az>*Ax> + zy*Az>*Ay> + zz*Az>*Az>

    Output 3:  3x3  matrix whose elements are the Ai>*Aj>
               (i,j = x,y,z) measures of dyadic>>

    Output 3:  Similar to Output 1.
    Output 4:  Similar to Output 2.

     Related:  >  >>  >>>  0> 0>> 1>>  Vector  Dyadic  Matrix  Express

       (1) %--------------------------------------------------------------------
       (2) % Example 1:  Dyadic( A,  xx, yy, zz )
       (3) %--------------------------------------------------------------------
       (4) RigidFrame A, B
       (5) Constant   xx, yy, zz
       (6) dyadic1>> = Dyadic( A,  xx, yy, zz )
    -> (7) dyadic1>> = xx*Ax>*Ax> + yy*Ay>*Ay> + zz*Az>*Az>

       (8) %--------------------------------------------------------------------
       (9) % Example 2:  Dyadic( A,  xx,xy,xz, yx,yy,yz,  zx,zy,zz )
       (10) %--------------------------------------------------------------------
       (11) Constant   xy, xz, yx, yz, zx, zy
       (12) dyadic2>> = Dyadic( A,  xx,xy,xz,  yx,yy,yz,  zx,zy,zz )
    -> (13) dyadic2>> = xx*Ax>*Ax> + xy*Ax>*Ay> + xz*Ax>*Az> + yx*Ay>*Ax> + yy*Ay>*Ay>
            + yz*Ay>*Az> + zx*Az>*Ax> + zy*Az>*Ay> + zz*Az>*Az>

       (14) %--------------------------------------------------------------------
       (15) % Example 3:  Dyadic( A,  threeElementMatrix )
       (16) %--------------------------------------------------------------------
       (17) dyadic3>> = Dyadic( A,  [xx; yy; zz] )
    -> (18) dyadic3>> = xx*Ax>*Ax> + yy*Ay>*Ay> + zz*Az>*Az>

       (19) %--------------------------------------------------------------------
       (20) % Example 4:  Dyadic( nineElementMatrix )
       (21) %--------------------------------------------------------------------
       (22) dyadic4>> = Dyadic( A,  [1, 2, 3;  4, 5, 6;  7, 8, 9] )
    -> (23) dyadic4>> = Ax>*Ax> + 2*Ax>*Ay> + 3*Ax>*Az> + 4*Ay>*Ax> + 5*Ay>*Ay>
            + 6*Ay>*Az> + 7*Az>*Ax> + 8*Az>*Ay> + 9*Az>*Az>

       (24) %--------------------------------------------------------------------
       (25) % Example 5:  Dyadic( A,  dyadic>> )
       (26) %--------------------------------------------------------------------
       (27) B.SetRotationMatrixZ( A, t )
    -> (28) B_A = [cos(t), sin(t), 0;  -sin(t), cos(t), 0;  0, 0, 1]

       (29) matrix1 = Dyadic( A,  2*Ax>*Ax> + 3*Ay>*Ay> + 4*Ax>*Ay> + 5*Ay>*Ax> )
    -> (30) matrix1 = [2, 4, 0;  5, 3, 0;  0, 0, 0]

       (31) matrix2 = Dyadic( B,  Ax>*Bz> + 2*Ay>*Bz> + 3*Az>*Bx> + 4*Bz>*Bz> )
    -> (32) matrix2 = [0, 0, cos(t) + 2*sin(t);  0, 0, 2*cos(t) - sin(t);  3, 0, 4]

#### Echo

    Echo

     Purpose:  Display messages on the screen.

      Syntax:  ECHO( MSG )

       Input:  MSG -- A string of characters that may include special
               character sequences which have a special effect, i.e.,

               SEQUENCE         EFFECT
               ------------------------------------------------------
               \a               Audible beep
               \p               Pauses program using the SetPause setting
               \p=n             Pauses n milliseconds (n = 0, 200, 3000, ...)
               \k               Stop reading from file (switch to keyboard input)
               \0               Terminates printing of MSG
               \n               Prints a newline character
               \e               Puts a newline character, indents 7 spaces
               \w               Puts a newline character, indents 9 spaces
               \#               Prints the # character
               \"               Prints the " character
               \\               Prints the \ character
               #CMSymbol#       Prints the name assigned to CMSymbol.
               #NewtonianFrame# If  a  NewtonianFrame has been declared,
                                prints  the  name of that frame,
                                otherwise #NewtonianFrame# is printed.

      Output:  MSG is printed to the screen

      Remark:  To prevent the removal of extra spaces, put the message in
               quotes, e.g., Echo( "Hello World!" ).   The ECHO command is
               helpful when creating external commands (.a and .r files).

      Related: SetBeepSoundOnError

     Example:

       (1) Echo( Renee says 1 + 1 = 2 )
    Renee says 1+1=2

       (1) Echo("Renee says 1 + 1 = 2" )
    Renee says 1 + 1 = 2

       (1) Echo(" Renee says \"Hello world!\" \n and also says 2 + 2 = 4" )
     Renee says "Hello world!"
     and also says 2 + 2 = 4

       (1) Echo(\k\a"Error: Wrong arguments to the myFunction command" )
    Error: Wrong arguments to the myFunction command

#### Encode

    ConstantEncode  SpecifiedEncode  OutputEncode

     Purpose:  Instructs MATLAB(R), C, and Fortran programs to incorporate
               additional inputs, outputs, or calculations that may
               not otherwise appear because of code-optimization.

    Syntax 1:  ConstantEncode  -- type  HELP CONSTANT   for information.
    Syntax 2:  SpecifiedEncode -- type  HELP SPECIFIED  for information.
    Syntax 3:  OutputEncode    -- type  HELP OUTPUT     for information.

      Remark:  Type  ConstantEncode to list the quantities previously
               named in a ConstantEncode declaration.
               Similarly type  SpecifiedEncode  or  OutputEncode.

     Related:  ODE  Solve  Input  Output  OutputPlot  Plot  Animate
               ConvertUnits  GetUnitSystem  SetUnitSystem  SetDigits
               Constant  Specified  Output

       (1) %--------------------------------------------------------------------
       (2) % Example 1: ConstantEncode
       (3) %--------------------------------------------------------------------
       (4) % ConstantEncode  a, b, c
       (5) %
       (6) %--------------------------------------------------------------------
       (7) % Example 2: SpecifiedEncode
       (8) %--------------------------------------------------------------------
       (9) % SpecifiedEncode  slipStickTest, Fx, vx, theta''
       (10) %
       (11) %--------------------------------------------------------------------
       (12) % Example 3: OutputEncode
       (13) %--------------------------------------------------------------------
       (14) Variables  x'' = cos(t)
    -> (15) x'' = cos(t)

       (16) SetUnitSystem( kg, m, sec )
       (17) Input  x = 3 miles,  x' = 0 ft/sec,  tFinal = 10 sec
       (18) OutputEncode  t seconds, x inches, x ft,  2*x km,  sin(x) noUnits
       (19) ODE()  EncodeExample.m

#### Epsilon

    Epsilon

     Purpose:  Rounds numbers that are suitably close to an integer.

    Syntax 1:  Epsilon( mathExpression, absEpsilon )
    Syntax 2:  Epsilon( mathExpression, absEpsilon, relEpsilon )

       Input:  mathExpression -- A scalar, vector, dyadic, or matrix expression.
               absEpsilon a real number r such that:   0  <=  r  < 0.5
               relEpsilon a real number r such that:   0  <=  r  < 0.5

    Output 1:  In mathExpression, rounds any number that is within absEpsilon of
               an integer to that integer.  For a number of the form  x.y,  no
               rounding occurs if  absEpsilon <  abs(0.y)  < 1 - absEpsilon

    Output 2:  Rounds any number d within abs( d * relEpsilon) of an integer
               to that integer.  Also does the rounding described by Output 1.

     Remark:   If  SetAutoEpsilon( d )  has also been employed,
               absEpsilon should be greater than or equal to d.

     Remark:   Also see RoundDigits.

     Related:  Epsilon  Evaluate  Expand  Explicit
               Factor  FactorLinear  FactorQuadratic  ReplaceString  RoundDigits
               SetAutoEpsilon  SetDigits

       (1) %--------------------------------------------------------------------
       (2) % Example 1:  Epsilon  (scalar expression)
       (3) %--------------------------------------------------------------------
       (4) SetDigits 16
       (5) s = 2E-11 + 1.00007*t + (9876 + 5E-8)*sin(t)
    -> (6) s = 2E-11 + 1.00007*t + 9876.00000005*sin(t)

       (7) s1 = Epsilon( s,  1.0E-10 )     % Absolute = 1.0E-10, Relative = 0
    -> (8) s1 = 1.00007*t + 9876.00000005*sin(t)

       (9) s2 = Epsilon( s,  0.0001  )     % Absolute = 1.0E-4,  Relative = 0
    -> (10) s2 = t + 9876*sin(t)

       (11) s3 = Epsilon( s,  0,   1E-7  )  % Absolute = 0,       Relative = 1E-7
    -> (12) s3 = 2E-11 + 1.00007*t + 9876*sin(t)

       (13) s4 = Epsilon( s,  0,   0.0001)  % Absolute = 0,       Relative = 1E-4
    -> (14) s4 = 2E-11 + t + 9876*sin(t)

       (15) %--------------------------------------------------------------------
       (16) % Example 2:  Epsilon  (vector expression)
       (17) %--------------------------------------------------------------------
       (18) RigidFrame  N
       (19) v> = Vector( N,  2E-11, 1.00007*t, (9876 + 5E-8)*sin(t) )
    -> (20) v> = 2E-11*Nx> + 1.00007*t*Ny> + 9876.00000005*sin(t)*Nz>

       (21) v1> = Epsilon( v>,  1.0E-10  )   % Absolute = 1.0E-10, Relative = 0
    -> (22) v1> = 1.00007*t*Ny> + 9876.00000005*sin(t)*Nz>

       (23) v2> = Epsilon( v>,  0,   1E-4 )  % Absolute = 0,       Relative = 1E-4
    -> (24) v2> = 2E-11*Nx> + t*Ny> + 9876*sin(t)*Nz>

       (25) %--------------------------------------------------------------------
       (26) % Example 3:  Epsilon  (matrix expression)
       (27) %--------------------------------------------------------------------
       (28) m = [s; v>]
    -> (29) m = [s;  2E-11*Nx> + 1.00007*t*Ny> + 9876.00000005*sin(t)*Nz>]

       (30) m1 = Epsilon( m,  1.0E-10  )     % Absolute = 1.0E-10, Relative = 0
    -> (31) m1 = [s;  1.00007*t*Ny> + 9876.00000005*sin(t)*Nz>]

       (32) m2 = Epsilon( m,  0,   1E-4 )    % Absolute = 0,       Relative = 1E-4
    -> (33) m2 = [s;  2E-11*Nx> + t*Ny> + 9876*sin(t)*Nz>]

#### Euler

    Euler -- one of the greatest engineer / mathematician of all time.

     Related:  AngularMomentum  GetEigen  Inertia  Lagrange  Optimize  Quaternion

#### Gibbs

    Gibbs -- one of the greatest engineer / mathematician of all time.

     Related:  Vectors  Dyadics

#### Evaluate

    Evaluate,  EvaluateAtInput,  EvaluateToNumber

     Purpose:  Evaluates an expression by replacing designated symbols.

    Syntax 1:  Evaluate( mathExpression, name1=rhs1, name2=rhs2, ... )
    Syntax 2:  EvaluateAtInput( mathExpression )
               EvaluateAtInput( mathExpression, name1=rhs1, name2=rhs2, ... )
    Syntax 3:  EvaluateToNumber( mathExpression )
               EvaluateToNumber( mathExpression, name1=rhs1, name2=rhs2, ... )

       Input:  mathExpression -- A scalar, vector, matrix, ... expression.
               namei -- The name of a symbol (e.g., a constant or variable).
               rhsi -- An expression to substitute for namei. (i=1,2,...),
                       with optional units (e.g., x = 3 deg).

    Output 1:  Returns mathExpression evaluated with rhsi substituted
               for namei wherever namei appears in mathExpression.

    Output 2:  In addition to making substitutions described in Output 1 (above),
               evaluates an expression using values assigned in Input statements.
               When a previous Input statement has been issued of the form:

               Input x=xValue, y=yValue deg, z=zValue km/hour

               returns mathExpression evaluated with xValue substituted for x,
               yValue * ConvertUnits(deg,rad)               substituted for y,
               zValue * ConvertUnits(km/hr, GetUnitSystem)  substituted for z.

    Output 3:  In addition to evaluating as described in Output 1 and 2,
               uses any assignment in the workspace of the form
               x = someNumber    (e.g., x = 2.3).

     Remark:   The units conversion factor used for arguments of the form
               x = 3 km/hour   depends on the current UnitSystem.

     Related:  Epsilon  Evaluate  EvaluateAtInput  Explicit  GetRhs
               Input  ReplaceString  RoundDigits  SetAutoRhs  SetUnitSystem

       (1) %--------------------------------------------------------------------
       (2) % Example 1: Evaluate   (scalar expression)
       (3) %--------------------------------------------------------------------
       (4) Variable  x, y
       (5) z = x^2*cos(y) - sin(t)
    -> (6) z = x^2*cos(y) - sin(t)

       (7) zEvaluated1 = Evaluate( z,  x=2, y=60 deg, t=30 deg )
    -> (8) zEvaluated1 = 1.5

       (9) zEvaluated2 = Evaluate( z,  x=t, y=t^3 )
    -> (10) zEvaluated2 = t^2*cos(t^3) - sin(t)

       (11) %--------------------------------------------------------------------
       (12) % Example 2: Evaluate   (vector expression)
       (13) %--------------------------------------------------------------------
       (14) RigidBody   B
       (15) v> = Vector( B, x, y, z )
    -> (16) v> = x*Bx> + y*By> + z*Bz>

       (17) vEvaluated1> = Evaluate( v>,  x=1 km, y=2 m, z=3 cm )
    -> (18) vEvaluated1> = 1000*Bx> + 2*By> + 0.03*Bz>

       (19) vEvaluated2> = Evaluate( v>,  x=t km, y=t^3 m )
    -> (20) vEvaluated2> = 1000*t*Bx> + t^3*By> + (1000000*t^2*cos(t^3)-sin(t))*Bz>

       (21) %--------------------------------------------------------------------
       (22) % Example 3: Evaluate   (matrix expression)
       (23) %--------------------------------------------------------------------
       (24) matrix[1] = v>
    -> (25) matrix[1] = x*Bx> + y*By> + z*Bz>

       (26) matrix[2] = z
    -> (27) matrix[2] = z

       (28) matrix[3] = x + y + z
    -> (29) matrix[3] = x + y + z

       (30) matrixEvaluated1 = Evaluate( matrix,  x=1 km, y=2, z=3 cm )
    -> (31) matrixEvaluated1 = [1000*Bx> + 2*By> + 0.03*Bz>;  0.03;  1002.03]

       (32) matrixEvaluated2 = Evaluate( matrix,  x=t, y=t^3 )
    -> (33) matrixEvaluated2[1] = t*Bx> + t^3*By> + (t^2*cos(t^3)-sin(t))*Bz>
    -> (34) matrixEvaluated2[2] = t^2*cos(t^3) - sin(t)
    -> (35) matrixEvaluated2[3] = t + t^3 + t^2*cos(t^3) - sin(t)

       (36) %--------------------------------------------------------------------
       (37) % Example 4: EvaluateAtInput
       (38) %--------------------------------------------------------------------
       (39) s = sin(y) + cos(t)*x^2
    -> (40) s = sin(y) + cos(t)*x^2

       (41) Input x=4, y=150 deg
       (42) sEvaluated2 = EvaluateAtInput( s )
    -> (43) sEvaluated2 = 0.5 + 16*cos(t)

       (44) sEvaluated3 = EvaluateAtInput( s,  x=t^2 )
    -> (45) sEvaluated3 = 0.5 + t^4*cos(t)

       (46) sEvaluated4 = EvaluateAtInput( s,  x=t^2, y=t deg )
    -> (47) sEvaluated4 = sin(0.01745329*t) + t^4*cos(t)

       (48) %--------------------------------------------------------------------
       (49) % Example 5: EvaluateToNumber
       (50) %--------------------------------------------------------------------
       (51) t = 2
    -> (52) t = 2

       (53) sEvaluatedToNumber = EvaluateToNumber( s,  y = log(2)*GetImaginaryNumber() )
    -> (54) sEvaluatedToNumber = -6.658349 + 0.75*imaginary

#### exp

    exp

     Purpose:  Returns the exponential function of a scalar expression.

      Syntax:  exp( scalarExpression )

       Input:  scalarExpression -- a real or complex scalar expression.

      Output:  Exponential function of scalarExpression, i.e., the number
               e (2.71828...) raised to the power scalarExpression.

     Related:  ImaginaryNumber  MathFunctions

       (1) %--------------------------------------------------------------------
       (2) % Example 1: exp   (real scalar expressions)
       (3) %--------------------------------------------------------------------
       (4) A = exp( 2 )
    -> (5) A = 7.389056

       (6) B = exp(2*t)
    -> (7) B = exp(2*t)

       (8) C = exp(0.5+2*t)
    -> (9) C = 1.648721*exp(2*t)

       (10) %--------------------------------------------------------------------
       (11) % Example 2: exp   (complex scalar expressions)
       (12) %--------------------------------------------------------------------
       (13) D = exp( 2 + 3*GetImaginaryNumber() )
    -> (14) D = -7.31511 + 1.042744*imaginary

       (15) E = exp( 3*GetImaginaryNumber() + t )
    -> (16) E = exp(3*imaginary+t)

#### Expand

    Expand or ExpandDeep

     Purpose:  Produces an expression that is mathematically equivalent to the
               given expression but usually containing fewer parentheses.

    Syntax 1:  Expand( mathExpression )
    Syntax 2:  Expand( mathExpression,  n   )
    Syntax 3:  Expand( mathExpression,  n:m )
    Syntax 4:  Expand( mathExpression,  X   )
    Syntax 5:  Expand( mathExpression,  n,   X )
    Syntax 6:  Expand( mathExpression,  n:m, X )
    Syntax x:  ExpandDeep( mathExpression, ... )        is the same as
               Expand( Explicit(mathExpression, ...) )  Hence
               ExpandDeep( mathExpression, 1:2, X) )    is the same as
               Expand( Explict(mathExpression, X),  1:2, X )

       Input:  mathExpression -- A scalar, vector, matrix, ... expression.

               n -- a positive integer
               m -- a positive integer

               X -- The name of a scalar symbol (e.g., a constant or variable)
                    or a comma-separated list of names of scalars
                    or a matrix of scalar names.

    Output 1:  Expands parentheses enclosing terms raised to the power 1.
    Output 2:  Expands parentheses enclosing terms raised to the power n.
    Output 3:  Expands parentheses enclosing terms raised to powers n:m.
    Output 4:  Expands parentheses enclosing terms raised to the power 1
               that also enclose one or more names contained in X.
    Output 5:  Expands parentheses enclosing terms raised to the power n
               that also enclose one or more names contained in X.
    Output 6:  Expands parentheses enclosing terms raised to powers n:m
               that also enclose one or more names contained in X.

      Remark:  Expand is a dual function.
               Expand( expression )     does not re-factor the expression.
               y = Expand( expression )     may  re-factor the expression.

     Related:  Epsilon  Evaluate  Expand  Explicit
               Factor  FactorLinear  FactorQuadratic  ReplaceString  RoundDigits

       (1) %--------------------------------------------------------------------
       (2) % Example 1: Expand  (scalar expressions with certain powers)
       (3) %--------------------------------------------------------------------
       (4) Constant  a, b, c, x
       (5) y = (a+b)^2 + a*(x+c^2) + b*(c+a*b)
    -> (6) y = (a+b)^2 + a*(x+c^2) + b*(c+a*b)

       (7) y1 = Expand( y )
    -> (8) y1 = a*x + b*c + a*b^2 + a*c^2 + (a+b)^2

       (9) y2 = Expand( y,  2 )
    -> (10) y2 = a^2 + b^2 + 2*a*b + a*(x+c^2) + b*(c+a*b)

       (11) y3 = Expand( y,  1:2 )
    -> (12) y3 = a*x + a^2 + b*c + b^2 + 2*a*b + a*b^2 + a*c^2

       (13) %--------------------------------------------------------------------
       (14) % Example 2: Expand  (scalar expressions containing certain symbols)
       (15) %--------------------------------------------------------------------
       (16) y4 = Expand( y,  a )
    -> (17) y4 = b*c + a*b^2 + (a+b)^2 + a*(x+c^2)

       (18) y5 = Expand( y,  x )
    -> (19) y5 = a*x + a*c^2 + (a+b)^2 + b*(c+a*b)

       (20) y6 = Expand( y,  [a,x] )
    -> (21) y6 = a*x + b*c + a*b^2 + a*c^2 + (a+b)^2

       (22) %--------------------------------------------------------------------
       (23) % Example 3: Expand  (scalar expressions with certain powers/symbols)
       (24) %--------------------------------------------------------------------
       (25) y7 = Expand( y,  2,  a )
    -> (26) y7 = a^2 + b^2 + 2*a*b + a*(x+c^2) + b*(c+a*b)

       (27) y8 = Expand( y,  2,  [a,x] )
    -> (28) y8 = a^2 + b^2 + 2*a*b + a*(x+c^2) + b*(c+a*b)

       (29) %--------------------------------------------------------------------
       (30) % Example 4: Expand  (Expand is a dual command so it can overwrite y)
       (31) %--------------------------------------------------------------------
       (32) Expand( y,  1:2 )
    -> (33) y = a*x + a^2 + b*c + b^2 + 2*a*b + a*b^2 + a*c^2

       (34) %--------------------------------------------------------------------
       (35) % Example 5: ExpandDeep -- same as Expand( Explicit(...) )
       (36) %--------------------------------------------------------------------
       (37) fred = b + x + sin(t)
    -> (38) fred = b + x + sin(t)

       (39) w = (a+x)^2 + fred^2
    -> (40) w = (a+x)^2 + fred^2

       (41) w1 = ExpandDeep( w )
    -> (42) w1 = (a+x)^2 + (b+x+sin(t))^2

       (43) w2 = ExpandDeep( w,  1:2 )
    -> (44) w2 = a^2 + b^2 + 2*a*x + 2*b*x + 2*x^2 + sin(t)^2 + 2*b*sin(t) + 2*x*sin(t)

       (45) w3 = ExpandDeep( w,  1:2, a )
    -> (46) w3 = a^2 + x^2 + 2*a*x + fred^2

       (47) w4 = ExpandDeep( w,  1:2, b )
    -> (48) w4 = b^2 + x^2 + (a+x)^2 + sin(t)^2 + 2*x*sin(t) + 2*b*(x+sin(t))

       (49) %--------------------------------------------------------------------
       (50) % Example 5: Expand  (vector expressions with certain powers)
       (51) %--------------------------------------------------------------------
       (52) RigidFrame  N
       (53) v> = Vector( N, (a+b)^2, (a+b)^3, (a+b)^4 )
    -> (54) v> = (a+b)^2*Nx> + (a+b)^3*Ny> + (a+b)^4*Nz>

       (55) Expand( v>,  2:3 )
    -> (56) v> = (a^2+b^2+2*a*b)*Nx> + (a^3+b^3+3*a*b^2+3*b*a^2)*Ny> + (a+b)^4*Nz>

       (57) %--------------------------------------------------------------------
       (58) % Example 6: Expand  (matrix expressions with certain power)
       (59) %--------------------------------------------------------------------
       (60) mat = [(a+b)^2;  Vector( N, (a+b)^2, (a+b)^3, (a+b)^4 )]
    -> (61) mat = [(a+b)^2;  (a+b)^2*Nx> + (a+b)^3*Ny> + (a+b)^4*Nz>]

       (62) Expand( mat,  2 )
    -> (63) mat[1] = a^2 + b^2 + 2*a*b
    -> (64) mat[2] = (a^2+b^2+2*a*b)*Nx> + (a+b)^3*Ny> + (a+b)^4*Nz>

#### Explicit

    Explicit

     Purpose:  Substitutes the right-hand-side of all names in an expressions,
               repeating this process until no names that have a
               right-hand-side remain the expression.

    Syntax 1:  Explicit( mathExpression )
    Syntax 2:  Explicit( mathExpression, X )

       Input:  mathExpression -- A scalar, vector, matrix, ... expression.

               X -- The name of a scalar symbol (e.g., a constant or variable)
                    or a comma-separated list of names of scalars
                    or a matrix of scalar names.

    Output 1:  Alternate representation of mathExpression that is explicit
               in names that do not have right-hand sides.

    Output 2:  Alternate representation of mathExpression that is explicit in X.

      Remark:  Explicit is a dual function.
               SetNoZeeSymbol helps ensure certain symbols remain explicit.

      Remark:  See also ExpandDeep() which is equivalent to
               Expand( Explicit(mathExpression), ... )

     Related:  Evaluate  Expand  Explicit
               Factor  FactorLinear  FactorQuadratic  ReplaceString
               GetRhs  SetAutoRhs  SetNoZeeSymbol

       (1) %--------------------------------------------------------------------
       (2) % Example 1: Explicit  (scalar expressions)
       (3) %--------------------------------------------------------------------
       (4) Constant  a, b, c
       (5) w = a + 2*b
    -> (6) w = a + 2*b

       (7) x = b + 5*c + w
    -> (8) x = b + 5*c + w

       (9) y = sin(x) + cos(t)
    -> (10) y = sin(x) + cos(t)

       (11) y1 = Explicit( y )
    -> (12) y1 = sin(a+3*b+5*c) + cos(t)

       (13) %--------------------------------------------------------------------
       (14) % Example 2: Explicit  (scalar expressions containing certain symbols)
       (15) %--------------------------------------------------------------------
       (16) y2 = Explicit( y,  c )
    -> (17) y2 = sin(b+5*c+w) + cos(t)

       (18) %--------------------------------------------------------------------
       (19) % Example 3: Explicit  (Explicit is a dual command so it can overwrite y)
       (20) %--------------------------------------------------------------------
       (21) Explicit( y )
    -> (22) y = sin(a+3*b+5*c) + cos(t)

       (23) %--------------------------------------------------------------------
       (24) % Example 4: Explicit  (vector expressions with certain powers)
       (25) %--------------------------------------------------------------------
       (26) RigidFrame  N
       (27) v> = Vector( N, w, x, y )
    -> (28) v> = w*Nx> + x*Ny> + y*Nz>

       (29) Explicit( v>,  [b,x] )
    -> (30) v> = (a+2*b)*Nx> + x*Ny> + (sin(a+3*b+5*c)+cos(t))*Nz>

       (31) %--------------------------------------------------------------------
       (32) % Example 5: Explicit  (matrix expressions with certain power)
       (33) %--------------------------------------------------------------------
       (34) m = [ y, v> ]
    -> (35) m = [y, (a+2*b)*Nx> + x*Ny> + (sin(a+3*b+5*c)+cos(t))*Nz>]

       (36) Explicit( m )
    -> (37) m[1,1] = sin(a+3*b+5*c) + cos(t)
    -> (38) m[1,2] = (a+2*b)*Nx> + (a+3*b+5*c)*Ny> + (sin(a+3*b+5*c)+cos(t))*Nz>

#### Express

    Express

     Purpose:  Expresses a vector, dyadic, or other tensor in terms of
               basis vectors fixed in RigidFrame or RigidBody.

      Syntax:  Express( v, RefFrame )

       Input:  v -- a vector, dyadic, triadic or tensor expression or
                    a matrix of such expressions.

               RefFrame -- name of a RigidFrame or RigidBody.

      Output:  v expressed in terms of the right-handed orthogonal unit vectors
               fixed in RefFrame, e.g., RefFramex>, RefFramey>, RefFramez>.

      Remark:  Express is a dual function.

       (1) %--------------------------------------------------------------------
       (2) % Example 1: Express   (vector expression)
       (3) %--------------------------------------------------------------------
       (4) RigidBody  A, B
       (5) Variable   q
       (6) B.RotateZ( A, q )
    -> (7) B_A = [cos(q), sin(q), 0;  -sin(q), cos(q), 0;  0, 0, 1]

       (8) vA> = Vector( A, 2, 3, 4 )
    -> (9) vA> = 2*Ax> + 3*Ay> + 4*Az>

       (10) vB> = Express( vA>, B )
    -> (11) vB> = (2*cos(q)+3*sin(q))*Bx> + (3*cos(q)-2*sin(q))*By> + 4*Bz>

       (12) %--------------------------------------------------------------------
       (13) % Example 2: Express   (dyadic expression)
       (14) %--------------------------------------------------------------------
       (15) dA>> = Dyadic( A, 2, 3, 4 )
    -> (16) dA>> = 2*Ax>*Ax> + 3*Ay>*Ay> + 4*Az>*Az>

       (17) dB>> = Express( dA>>, B )
    -> (18) dB>> = (2+sin(q)^2)*Bx>*Bx> + sin(q)*cos(q)*Bx>*By> + sin(q)*cos(q)*By>*Bx>
            + (3-sin(q)^2)*By>*By> + 4*Bz>*Bz>

       (19) %--------------------------------------------------------------------
       (20) % Example 3: Express   (matrix expression)
       (21) %--------------------------------------------------------------------
       (22) m[1] = vA>
    -> (23) m[1] = 2*Ax> + 3*Ay> + 4*Az>

       (24) m[2] = Vector( A, t, t^2, t^3 )
    -> (25) m[2] = t*Ax> + t^2*Ay> + t^3*Az>

       (26) Express( m, B )
    -> (27) m[1] = (2*cos(q)+3*sin(q))*Bx> + (3*cos(q)-2*sin(q))*By> + 4*Bz>
    -> (28) m[2] = t*(cos(q)+t*sin(q))*Bx> - t*(sin(q)-t*cos(q))*By> + t^3*Bz>

#### Factor

    Factor     (see also FactorLinear and FactorQuadratic)

     Purpose:  Useful to simplify results or compare results with another analyst.
               Rearranges expression by regrouping on certain factors.

      Syntax:  Factor( mathExpression, X )

       Input:  mathExpression -- A scalar, vector, matrix, ... expression.

               X -- A factor (e.g., a constant, variable, x^2, x+2, sin(x+y), etc.)
                    or a comma-separated list of names of factors
                    or a matrix of factors.

      Output:  mathExpression factored on X.

      Remark:  Factor is a dual function.

     Related:  Evaluate  Expand  Explicit
               Factor  FactorLinear  FactorQuadratic  ReplaceString
               FactorLinearShallow   FactorQuadraticShallow
               SetAutoFactor

       (1) %--------------------------------------------------------------------
       (2) % Example 1: Factor  (scalar expressions factored on one factor)
       (3) %--------------------------------------------------------------------
       (4) Constant  a, b, c
       (5) Variable  x
       (6) y = a + a*x + a*b*x + c*x^2 + c*x^3 + a*x^(2+b)
    -> (7) y = a + a*x + a*b*x + c*x^2 + c*x^3 + a*x^(2+b)

       (8) y1 = Factor( y,  x )
    -> (9) y1 = a + x*(a+a*b+c*x+c*x^2+a*x^(1+b))

       (10) y2 = Factor( y,  a )
    -> (11) y2 = c*x^2 + c*x^3 + a*(1+x+b*x+x^(2+b))

       (12) %--------------------------------------------------------------------
       (13) % Example 2: Factor  (scalar expression factored on multiple factors)
       (14) %--------------------------------------------------------------------
       (15) y3 = Factor( y,  a, c )
    -> (16) y3 = c*x^2*(1+x) + a*(1+x+b*x+x^(2+b))

       (17) %--------------------------------------------------------------------
       (18) % Example 3: Factor  (Factor is a dual command so it can overwrite y)
       (19) %--------------------------------------------------------------------
       (20) Factor( y,  x )
    -> (21) y = a + x*(a+a*b+c*x+c*x^2+a*x^(1+b))

       (22) %--------------------------------------------------------------------
       (23) % Example 4: Factor  (matrix expressions factored on one factor)
       (24) %--------------------------------------------------------------------
       (25) m = [a + a*x + b*x; c + a*x^2 + a*x^(2+b)]
    -> (26) m = [a + a*x + b*x;  c + a*x^2 + a*x^(2+b)]

       (27) Factor( m,  x )
    -> (28) m = [a + (a+b)*x;  c + a*x^2*(1+x^b)]

#### FactorLinear

    FactorLinear      FactorLinearShallow      (see also Factor)
    FactorQuadratic   FactorQuadraticShallow

     Purpose:  Useful to simplify results or compare results with another analyst.
               Rearranges expression by regrouping terms in designated names.
               FactorLinear    rearranges terms in groups of degree 1.
               FactorQuadratic rearranges terms in groups of degree 1 and 2.

    Syntax 1:  FactorLinear(           mathExpression, X )
               FactorQuadratic(        mathExpression, X )
    Syntax 2:  FactorLinearShallow(    mathExpression, X )
               FactorQuadraticShallow( mathExpression, X )

       Input:  mathExpression -- A scalar, vector, matrix, ... expression.

               X -- The name of a scalar symbol (e.g., a constant or variable)
                    or a comma-separated list of names of scalars
                    or a matrix of scalar names.

    Output 1:  Makes mathExpression explicit in X, then returns mathExpression:
               (a) grouped in terms of degree  1       in  X  for FactorLinear
               (b) grouped in terms of degree  1 or 2  in  X  for FactorQuadratic.

    Output 2:  Does NOT  Explicit(mathExpression, X),  but returns mathExpression:
               (a) grouped in degree  1       in  X  for FactorLinearShallow
               (b) grouped in degree  1 or 2  in  X  for FactorQuadraticShallow.

      Remark:  With SetAutoZee(ON), mathExpression is returned with Zees for its:
               (a) coefficients of terms of degree 1       in X  (FactorLinear)
               (b) coefficients of terms of degree 1 and 2 in X  (FactorQuadratic).

      Remark:  All these functions are dual functions.

     Related:  Evaluate  Expand  Explicit
               Factor  FactorLinear  FactorQuadratic  ReplaceString
               GetQuadraticRoots  SolveQuadraticPositiveRoot

       (1) %--------------------------------------------------------------------
       (2) % Example 1: FactorLinear  (scalar expressions)
       (3) %--------------------------------------------------------------------
       (4) Constant  a, b, c, x
       (5) y = 7 + a*c + a*x + b*(11+c+x*t)
    -> (6) y = 7 + a*c + a*x + b*(11+c+x*t)

       (7) y1 = FactorLinear( y,  a )
    -> (8) y1 = 7 + a*(c+x) + b*(11+c+x*t)

       (9) y2 = FactorLinear( y,  x, c )
    -> (10) y2 = 7 + 11*b + c*(a+b) + x*(a+b*t)

       (11) %--------------------------------------------------------------------
       (12) % Example 2: FactorLinear  (is a dual command so it overwrites y)
       (13) %--------------------------------------------------------------------
       (14) FactorLinear( y,  [x,c] )
    -> (15) y = 7 + 11*b + c*(a+b) + x*(a+b*t)

       (16) %--------------------------------------------------------------------
       (17) % Example 3: FactorQuadratic  (scalar expressions)
       (18) %--------------------------------------------------------------------
       (19) y3 = FactorQuadratic( y,  a )
    -> (20) y3 = 7 + 11*b + b*c + a*(c+x) + b*x*t

       (21) y4 = FactorQuadratic( y,  b )
    -> (22) y4 = 7 + a*c + a*x + b*(11+c+x*t)

       (23) y5 = FactorQuadratic( y,  b, c )
    -> (24) y5 = 7 + a*c + a*x + b*c + b*(11+x*t)

       (25) %--------------------------------------------------------------------
       (26) % Example 4: FactorQuadratic  (is a dual command so it overwrites y)
       (27) %--------------------------------------------------------------------
       (28) FactorQuadratic( y,  [b, c] )
    -> (29) y = 7 + a*c + a*x + b*c + b*(11+x*t)

#### factorial

    factorial

     Purpose:  Returns the factorial of a non-negative integer.

      Syntax:  factorial( intExpression )

       Input:  intExpression -- a non-negative integer expression, i.e.,
               non-negative integer or a scalar expression which,
               when evaluated, produces a non-negative integer.

      Output:  1 * 2 * 3 *  ...  *  (intExpression-1)  *  intExpression

     Related:  ceil  floor  int  max  min  round  RoundDigits  sign  MathFunctions

       (1) %--------------------------------------------------------------------
       (2) % Example: Factorial
       (3) %--------------------------------------------------------------------
       (4) A = Factorial( 4 )
    -> (5) A = 24

       (6) B = Factorial(2+t^2)
    -> (7) B = factorial(2+t^2)

       (8) C = Factorial( Evaluate(2+t^2,t=1) )
    -> (9) C = 6

#### Exclude

    Exclude    ExcludeV    ExcludeA

     Purpose:  Forms the portion of an expression that remains when
               terms containing designated names are excluded.

    Syntax 1:  Exclude(  ExpressionY, X )
    Syntax 2:  ExcludeV( ExpressionY )
    Syntax 3:  ExcludeA( ExpressionY )

       Input:  ExpressionY -- a scalar, vector, or dyadic expression or
               a matrix of scalars, vectors, and/or dyadics.

               X -- The name of a symbol (e.g., constant, variable, or unit vector)
                    or a comma-separated list of names of symbols
                    or a matrix of names of symbols.

    Output 1:  All terms in ExpressionY that do not contain X.

    Output 2:  All terms in ExpressionY that do not contain independent generalized
               speeds (generalized speeds are named in the SetGeneralizedSpeed command).

    Output 3:  All terms in ExpressionY that do not contain 1st-time-derivatives of
               independent generalized speeds.

      Remark:  To be Autolev compatible, use:
               ExcludeV( ExpressionY )  instead of  Exclude( ExpressionY, U  ),
               ExcludeA( ExpressionY )  instead of  Exclude( ExpressionY, U' ).

     Related:  D  Include  Exclude  GetCoefficient
               Evaluate  Expand  Explicit
               Factor  FactorLinear  FactorQuadratic

       (1) %--------------------------------------------------------------------
       (2) % Example 1: Exclude  (scalar expressions)
       (3) %--------------------------------------------------------------------
       (4) Constant  a, b, c, x
       (5) y = 7 + a*x + a*c^2 + b*(11+c+a*b)
    -> (6) y = 7 + a*x + a*c^2 + b*(11+c+a*b)

       (7) y1 = Exclude( y,  a )
    -> (8) y1 = 7 + b*(11+c)

       (9) y2 = Exclude( y,  b )
    -> (10) y2 = 7 + a*x + a*c^2

       (11) y3 = Exclude( y,  c, x )
    -> (12) y3 = 7 + b*(11+a*b)

       (13) %--------------------------------------------------------------------
       (14) % Example 2: Exclude  (vector expressions)
       (15) %--------------------------------------------------------------------
       (16) RigidFrame N
       (17) v> = Vector( N, a*sin(b), cos(b*c), x )
    -> (18) v> = a*sin(b)*Nx> + cos(b*c)*Ny> + x*Nz>

       (19) v1> = Exclude( v>,  a )
    -> (20) v1> = cos(b*c)*Ny> + x*Nz>

       (21) v2> = Exclude( v>,  b )
    -> (22) v2> = x*Nz>

       (23) v3> = Exclude( v>,  [c,x] )
    -> (24) v3> = a*sin(b)*Nx>

       (25) %--------------------------------------------------------------------
       (26) % Example 3: Exclude  (matrix expressions)
       (27) %--------------------------------------------------------------------
       (28) Constant  b1, b2, b3
       (29) Variable  x1, x2, x3
       (30) Zero[1] = 2*x1 + 3*x2 + 4*x3 - b1
    -> (31) Zero[1] = 2*x1 + 3*x2 + 4*x3 - b1

       (32) Zero[2] = 3*x1 + 4*x2 + 5*x3 - b2
    -> (33) Zero[2] = 3*x1 + 4*x2 + 5*x3 - b2

       (34) Zero[3] = 6*x1 + 7*x2 + 9*x3 - b3
    -> (35) Zero[3] = 6*x1 + 7*x2 + 9*x3 - b3

       (36) CoefficientMatrix = GetCoefficientMatrix( Zero,  [x1, x2, x3] )
    -> (37) CoefficientMatrix = [2, 3, 4;  3, 4, 5;  6, 7, 9]

       (38) RemainderMatrix = Exclude( Zero,  [x1, x2, x3] )
    -> (39) RemainderMatrix = [-b1;  -b2;  -b3]

#### Include

    Include    IncludeV    IncludeA

     Purpose:  Forms the portion of an expression that contains designated names

    Syntax 1:  Include(  ExpressionY, X )
    Syntax 2:  IncludeV( ExpressionY )
    Syntax 3:  IncludeA( ExpressionY )

       Input:  ExpressionY -- a scalar, vector, or dyadic expression or
               a matrix of scalars, vectors, and/or dyadics.

               X -- The name of a symbol (e.g., constant, variable, or unit vector)
                    or a comma-separated list of names of symbols,
                    or a matrix of names of symbols,
                    that appear linearly in ExpressionY.

    Output 1:  All terms in ExpressionY that contain X.

    Output 2:  All terms in ExpressionY that contain independent generalized
               speeds (generalized speeds are named in the SetGeneralizedSpeed command).

    Output 3:  All terms in ExpressionY that contain 1st-time-derivatives of
               independent generalized speeds.

      Remark:  To be Autolev compatible, use:
               IncludeV( ExpressionY )  instead of  Include( ExpressionY, U  ),
               IncludeA( ExpressionY )  instead of  Include( ExpressionY, U' ).

     Related:  D  Include  Exclude  GetCoefficient
               Evaluate  Expand  Explicit
               Factor  FactorLinear  FactorQuadratic

       (1) %--------------------------------------------------------------------
       (2) % Example 1: Include  (scalar expressions)
       (3) %--------------------------------------------------------------------
       (4) Constant  a, b, c, x
       (5) y = 7 + a*x + a*c^2 + (11+c+b*c)*t
    -> (6) y = 7 + a*x + a*c^2 + (11+c+b*c)*t

       (7) y1 = Include( y,  a )
    -> (8) y1 = a*(x+c^2)

       (9) y2 = Include( y,  b )
    -> (10) y2 = b*c*t

       (11) y3 = Include( y,  a, t )
    -> (12) y3 = a*x + a*c^2 + (11+c+b*c)*t

       (13) y4 = Include( y,  [a, t] )
    -> (14) y4 = a*x + a*c^2 + (11+c+b*c)*t

       (15) %--------------------------------------------------------------------
       (16) % Example 2: Include  (vector expressions)
       (17) %--------------------------------------------------------------------
       (18) RigidFrame N
       (19) v> = Vector( N, a*sin(b), cos(b)*(a+c), x )
    -> (20) v> = a*sin(b)*Nx> + cos(b)*(a+c)*Ny> + x*Nz>

       (21) v1> = Include( v>,  a )
    -> (22) v1> = a*sin(b)*Nx> + a*cos(b)*Ny>

       (23) v2> = Include( v>,  c )
    -> (24) v2> = c*cos(b)*Ny>

       (25) v3> = Include( v>,  [c, x] )
    -> (26) v3> = c*cos(b)*Ny> + x*Nz>

       (27) %--------------------------------------------------------------------
       (28) % Example 3: Include  (matrix expressions)
       (29) %--------------------------------------------------------------------
       (30) Constant  b1, b2, b3
       (31) Variable  x1, x2, x3
       (32) Zero[1] = 2*x1 + 3*x2 + 4*x3 - b1
    -> (33) Zero[1] = 2*x1 + 3*x2 + 4*x3 - b1

       (34) Zero[2] = 3*x1 + 4*x2 + 5*x3 - b2
    -> (35) Zero[2] = 3*x1 + 4*x2 + 5*x3 - b2

       (36) Zero[3] = 6*x1 + 7*x2 + 9*x3 - b3
    -> (37) Zero[3] = 6*x1 + 7*x2 + 9*x3 - b3

       (38) x12PartOfMatrix = Include( Zero,  x1, x2 )
    -> (39) x12PartOfMatrix = [2*x1 + 3*x2;  3*x1 + 4*x2;  6*x1 + 7*x2]

#### GetAcceleration

    GetAcceleration  or  GetRelativeAcceleration

     Purpose:  Gets a point's acceleration in a reference frame or gets a point's
               acceleration relative to another point in a reference frame.

    Syntax 1:  Q.GetAcceleration( refFrame )
    Syntax 2:  Q.GetAccelerationRelative( P, refFrame )
               Q.GetRelativeAcceleration( P, refFrame )

       Input:  Q, P -- names of points (e.g., Point or Particle).
               refFrame -- name of a RigidFrame or RigidBody..

    Output 1:  Returns Q's acceleration in refFrame.
    Output 2:  Returns Q's acceleration relative to P in refFrame, defined as
               Q.GetAcceleration(refFrame) - P.GetAcceleration(refFrame) or as
               DtDt( Q.GetPosition(P), refFrame ).

     Related:  Translate        SetPositionVelocity        SetVelocityAcceleration
               SetPosition      GetPosition   GetDistance  GetElongation
               SetVelocity      GetVelocity   GetSpeed     GetRelativeVelocity
               SetAcceleration  GetAcceleration            GetRelativeAcceleration

       (1) %--------------------------------------------------------------------
       (2) % Example: GetAcceleration
       (3) %--------------------------------------------------------------------
       (4) RigidFrame N
       (5) Point      Q
       (6) Variable   vx', vy'
       (7) Q.SetAcceleration( N, vx'*Nx> + vy'*Ny> )
    -> (8) a_Q_N> = vx'*Nx> + vy'*Ny>

       (9) QAccelerationInN> = Q.GetAcceleration( N )
    -> (10) QAccelerationInN> = vx'*Nx> + vy'*Ny>

       (11) %--------------------------------------------------------------------
       (12) % Example: GetRelativeAcceleration
       (13) %--------------------------------------------------------------------
       (14) Point       P
       (15) Variable    x'', y''
       (16) P.SetAcceleration( N,  x''*Nx> + y''*Ny> )
    -> (17) a_P_N> = x''*Nx> + y''*Ny>

       (18) aQRelativeToP> = Q.GetRelativeAcceleration( P, N )
    -> (19) aQRelativeToP> = (vx'-x'')*Nx> + (vy'-y'')*Ny>

       (20) %--------------------------------------------------------------------
       (21) % Example: GetRelativeAcceleration  (via differentiation).
       (22) %--------------------------------------------------------------------
       (23) Point       S
       (24) S.SetPosition( P,  t^2*Nx> + t^3*Ny> )
    -> (25) p_P_S> = t^2*Nx> + t^3*Ny>

       (26) aSRelativeToP> = S.GetRelativeAcceleration( P, N )
    -> (27) aSRelativeToP> = 2*Nx> + 6*t*Ny>

#### GetAngleBetweenVectors

    GetAngleBetweenVectors   GetAngleBetweenUnitVectors

     Purpose:  Forms the angle between two vectors.

    Syntax 1:  GetAngleBetweenVectors(        v>, w>  )
               GetAngleBetweenVectorsDegrees( v>, w>  )
    Syntax 2:  GetAngleBetweenVectors(        v>, w>, senseVector>  )
               GetAngleBetweenVectorsDegrees( v>, w>, senseVector>  )
    Syntax 3:  GetAngleBetweenUnitVectors(        uvec1>, uvec2>  )
               GetAngleBetweenUnitVectorsDegrees( uvec1>, uvec2>  )
    Syntax 4:  GetAngleBetweenUnitVectors(        uvec1>, uvec2>, senseVector> )
               GetAngleBetweenUnitVectorsDegrees( uvec1>, uvec2>, senseVector> )

      Inputs:  v>,  w> -- vectors.
               uvec1>,  uvec2> -- unit vectors.
               senseVector>  -- a vector providing a positive sense.

    Output 1:  Angle between  v>  and  w>          with range   0  <= Angle <= pi.
    Output 2:  Angle from     v>  to   w>          with range  -pi <  Angle <= pi.
    Output 3:  Angle between  uvec1>  and  uvec2>  with range   0  <= Angle <= pi.
    Output 4:  Angle from     uvec1>  to   uvec2>  with range  -pi <  Angle <= pi.

      Remark:  "Degrees" variant of commands multiply return values by 180/pi.
               Use return value with caution as the default units for angles
               are in radians for this program and C, MATLAB, FORTRAN, ...

      Remark:  A negative angle can result if a senseVector> is provided and
               the cross-product of v> and w> has a negative projection onto
               senseVector>, otherwise it is 0 or positive.

     Related:  GetMagnitude           GetMagnitudeSquared
               GetDistance            GetDistanceSquared
               GetSpeed               GetSpeedSquared
               GetAngularSpeed        GetAngularSpeedSquared
               GetAngleBetweenVectors GetAngleBetweenUnitVectors   ConvertUnits
               GetUnitVector          Vector   Dot   Rotate

       (1) %--------------------------------------------------------------------
       (2) % Example 1: GetAngleBetweenVectors
       (3) %--------------------------------------------------------------------
       (4) RigidFrame A
       (5) v> = 2*Ax> + 3*Ay> + 4*Az>
    -> (6) v> = 2*Ax> + 3*Ay> + 4*Az>

       (7) w> = 7*Ax> + 5*Ay> + 3*Az>
    -> (8) w> = 7*Ax> + 5*Ay> + 3*Az>

       (9) thetaRadians = GetAngleBetweenVectors( v>, w> )
    -> (10) thetaRadians = 0.5814062

       (11) thetaDegrees = GetAngleBetweenVectorsDegrees( v>, w> )
    -> (12) thetaDegrees = 33.31212

       (13) thetaNegative = GetAngleBetweenVectors( v>, w>, Ax> )
    -> (14) thetaNegative = -0.5814062

       (15) %--------------------------------------------------------------------
       (16) % Example 2: GetAngleBetweenVectors  (with sense)
       (17) %--------------------------------------------------------------------
       (18) f> = Ax> + 2*Ay>
    -> (19) f> = Ax> + 2*Ay>

       (20) g> = Ax> + t*Ay>
    -> (21) g> = Ax> + t*Ay>

       (22) theta = GetAngleBetweenVectors( f>, g> )
    -> (23) theta = acos(0.4472136*(1+2*t)/sqrt(1+t^2))

       (24) thetaWithSense = GetAngleBetweenVectors( f>, g>, Az> )
    -> (25) thetaWithSense = sign0IsPositive1(-2+t)*acos(0.4472136*(1+2*t)/sqrt(1+t^2))

       (26) %--------------------------------------------------------------------
       (27) % Example 3: GetAngleBetweenUnitVectors
       (28) %--------------------------------------------------------------------
       (29) unitVector1> = Vector( A, 0.6, 0.8, 0 )
    -> (30) unitVector1> = 0.6*Ax> + 0.8*Ay>

       (31) unitVector2> = Vector( A, 0,   0.6, 0.8 )
    -> (32) unitVector2> = 0.6*Ay> + 0.8*Az>

       (33) angleRadians = GetAngleBetweenUnitVectors( unitVector1>, unitVector2> )
    -> (34) angleRadians = 1.070142

       (35) angleDegrees = GetAngleBetweenUnitVectorsDegrees( unitVector1>, unitVector2> )
    -> (36) angleDegrees = 61.3146

       (37) %--------------------------------------------------------------------
       (38) % Example 4: GetAngleBetweenUnitVectors  (with sense)
       (39) %--------------------------------------------------------------------
       (40) RigidFrame B
       (41) B.SetRotationMatrixZ( A, t )
    -> (42) B_A = [cos(t), sin(t), 0;  -sin(t), cos(t), 0;  0, 0, 1]

       (43) angleWithSense = GetAngleBetweenUnitVectors( Bx>, unitVector2>, Az> )
    -> (44) angleWithSense = sign0IsPositive1(0.6*cos(t))*acos(0.6*sin(t))

#### GetAngularAcceleration

    GetAngularAcceleration

     Purpose:  Gets a rigid frame/body's angular acceleration in a reference frame.

      Syntax:  B.GetAngularAcceleration( A )

       Input:  B, A -- names of a RigidFrame or RigidBody.

      Output:  Returns B's angular acceleration in A.

     Related:  GetAngularAcceleration  GetAngularVelocity  GetRotationMatrix
               SetAngularAcceleration  SetAngularVelocity  SetRotationMatrix

       (1) %--------------------------------------------------------------------
       (2) % Example: GetAngularAcceleration
       (3) %--------------------------------------------------------------------
       (4) RigidFrame N
       (5) RigidBody  B
       (6) Variable   wx', wy', wz'
       (7) B.SetAngularAcceleration( N, wx'*Bx> + wy'*By> + wz'*Bz> )
    -> (8) alf_B_N> = wx'*Bx> + wy'*By> + wz'*Bz>

       (9) BAngularAccelerationInN> = B.GetAngularAcceleration( N )
    -> (10) BAngularAccelerationInN> = wx'*Bx> + wy'*By> + wz'*Bz>

#### GetAngularMomentum

    GetAngularMomentum

     Purpose:  Calculates an object's angular momentum about a point.

    Syntax 1:  Object.GetAngularMomentum( aboutPoint )
    Syntax 2:  Object.GetAngularMomentum( aboutPoint, refFrame )

       Input:  Object -- name of a Particle, RigidBody, or System.
               aboutPoint -- name of a point.
               refFrame -- name of a RigidFrame or RigidBody.

    Output 1:  Object's angular momentum abointPoint in the NewtonianFrame.
    Output 2:  Object's angular momentum abointPoint in refFrame.

      Remark:  A particle Q's angular momentum aboutPoint P in refFrame is defined
               Cross( Q.GetPosition(P), Q.GetTranslationalMomentum(refFrame) )

     Related:  GetAngularMomentum  GetTranslationalMomentum  GetGeneralizedMomentum
               GetKineticEnergy    GetMomentOfForces  GetResultantForce
               GetStatics   GetStaticsKane   GetStaticsLagrange
               GetDynamics  GetDynamicsKane  GetDynamicsLagrange

       (1) %--------------------------------------------------------------------
       (2) % Example 1: GetAngularMomentum  (point moving in a plane)
       (3) %--------------------------------------------------------------------
       (4) NewtonianFrame N
       (5) Particle       Q
       (6) Q.SetMass( mQ )
       (7) Variable       x'', y''
       (8) Q.Translate( No, x*Nx> + y*Ny> )
    -> (9) p_No_Q> = x*Nx> + y*Ny>
    -> (10) v_Q_N> = x'*Nx> + y'*Ny>
    -> (11) a_Q_N> = x''*Nx> + y''*Ny>

       (12) QAngularMomentumAboutNo> = Q.GetAngularMomentum( No )
    -> (13) QAngularMomentumAboutNo> = mQ*(x*y'-y*x')*Nz>

       (14) %--------------------------------------------------------------------
       (15) % Example 2: GetAngularMomentum  (rotating rigid body)
       (16) %--------------------------------------------------------------------
       (17) RigidBody  B
       (18) B.SetMass( mB )
       (19) B.SetInertia( Bcm, Ixx, Iyy, Izz )
       (20) Variable   theta''
       (21) B.RotateZ( N, theta )
    -> (22) B_N = [cos(theta), sin(theta), 0;  -sin(theta), cos(theta), 0;  0, 0, 1]
    -> (23) w_B_N> = theta'*Bz>
    -> (24) alf_B_N> = theta''*Bz>

       (25) BAngularMomentumAboutBcm> = B.GetAngularMomentum( Bcm )
    -> (26) BAngularMomentumAboutBcm> = Izz*theta'*Bz>

       (27) %--------------------------------------------------------------------
       (28) % Example 3: GetAngularMomentum  (rotating/translating rigid body)
       (29) %--------------------------------------------------------------------
       (30) Bcm.Translate( No, x*Nx> + y*Ny> )
    -> (31) p_No_Bcm> = x*Nx> + y*Ny>
    -> (32) v_Bcm_N> = x'*Nx> + y'*Ny>
    -> (33) a_Bcm_N> = x''*Nx> + y''*Ny>

       (34) BAngularMomentumAboutNo> = B.GetAngularMomentum( No )
    -> (35) BAngularMomentumAboutNo> = (Izz*theta'+mB*(x*y'-y*x'))*Bz>

#### GetAngularSpeed

    GetAngularSpeed  and   GetAngularSpeedSquared

     Purpose:  Gets a rigid frame/body's angular speed in a reference frame.

    Syntax 1:  B.GetAngularSpeed( A )
    Syntax 2:  B.GetAngularSpeedSquared( A )

       Input:  B, A -- names of a RigidFrame or RigidBody.

    Output 1:  Magnitude of B's angular velocity in A.
    Output 2:  Square of the magnitude of B's angular velocity in A.

     Related:  GetMagnitude           GetMagnitudeSquared
               GetDistance            GetDistanceSquared
               GetSpeed               GetSpeedSquared
               GetAngularSpeed        GetAngularSpeedSquared
               GetAngleBetweenVectors GetAngleBetweenUnitVectors
               GetAngularVelocity     SetAngularVelocity       Rotate
               GetUnitVector          Vector   Dot

       (1) %--------------------------------------------------------------------
       (2) % Example: GetAngularSpeed  and  GetAngularSpeedSquared
       (3) %--------------------------------------------------------------------
       (4) RigidFrame A, B
       (5) Variable   wx, wy
       (6) B.SetAngularVelocity( A, wx*Ax> + wy*Ay> )
    -> (7) w_B_A> = wx*Ax> + wy*Ay>

       (8) angularSpeed = B.GetAngularSpeed( A )
    -> (9) angularSpeed = sqrt(wx^2+wy^2)

       (10) angularSpeedSquared = B.GetAngularSpeedSquared( A )
    -> (11) angularSpeedSquared = wx^2 + wy^2

#### GetAngularVelocity

    GetAngularVelocity

     Purpose:  Gets a rigid frame/body's angular velocity in a reference frame.

      Syntax:  B.GetAngularVelocity( A )

       Input:  B, A -- names of a RigidFrame or RigidBody.

      Output:  Returns B's angular velocity in A.

     Related:  GetAngularAcceleration  GetAngularVelocity  GetRotationMatrix
               SetAngularAcceleration  SetAngularVelocity  SetRotationMatrix

       (1) %--------------------------------------------------------------------
       (2) % Example: GetAngularVelocity
       (3) %--------------------------------------------------------------------
       (4) RigidFrame N
       (5) RigidBody  A, B
       (6) Variable   wx, wy, wz,  w1, w2, w3
       (7) A.SetAngularVelocity( N, wx*Ax> + wy*Ay> + wz*Az> )
    -> (8) w_A_N> = wx*Ax> + wy*Ay> + wz*Az>

       (9) B.SetAngularVelocity( A, w1*Ax> + w2*Ay> + w3*Az> )
    -> (10) w_B_A> = w1*Ax> + w2*Ay> + w3*Az>

       (11) BAngularVelocityInN> = B.GetAngularVelocity( N )
    -> (12) BAngularVelocityInN> = (w1+wx)*Ax> + (w2+wy)*Ay> + (w3+wz)*Az>

       (13) %--------------------------------------------------------------------
       (14) % Example: GetAngularVelocity (via RigidFrame C fixed to RigidBody B).
       (15) %--------------------------------------------------------------------
       (16) RigidFrame C( B )
       (17) CAngularVelocityInB> = C.GetAngularVelocity( B )
    -> (18) CAngularVelocityInB> = 0>

       (19) CAngularVelocityInA> = C.GetAngularVelocity( A )
    -> (20) CAngularVelocityInA> = w1*Ax> + w2*Ay> + w3*Az>

       (21) CAngularVelocityInN> = C.GetAngularVelocity( N )
    -> (22) CAngularVelocityInN> = (w1+wx)*Ax> + (w2+wy)*Ay> + (w3+wz)*Az>

#### GetBasisVector

    GetBasisVector

     Purpose:  Returns a unit vector that was created when a RigidBody
               RigidFrame, or NewtonianFrame declaration was issued

      Syntax:  GetBasisVector( frameName, int123 )

       Input:  frameName -- name of a RigidFrame or RigidBody.
               int123 -- the number 1 or 2 or 3.

      Remark:  GetBasisVector is mostly used in .r and .a files.

     Related:  GetBasisVector  GetDefaults  SetBasisSubscripts

       (1) %--------------------------------------------------------------------
       (2) % Example 1:  GetBasisVector (default basis subscripts)
       (3) %--------------------------------------------------------------------
       (4) RigidBody A
       (5) AfirstBasisVector> := GetBasisVector( A, 1 )
    -> (6) AfirstBasisVector> = Ax>

       (7) AthirdBasisVector> := GetBasisVector( A, 3 )
    -> (8) AthirdBasisVector> = Az>

       (9) %--------------------------------------------------------------------
       (10) % Example 2:  GetBasisVector (vary basis subscripts)
       (11) %--------------------------------------------------------------------
       (12) SetBasisSubscripts( 1,2,3 )
       (13) AfirstBasisVector> := GetBasisVector( A, 1 )
    -> (14) AfirstBasisVector> = A1>

       (15) AthirdBasisVector> := GetBasisVector( A, 3 )
    -> (16) AthirdBasisVector> = A3>

       (17) %--------------------------------------------------------------------
       (18) % Example 3:  GetBasisVector (vary basis subscripts again)
       (19) %--------------------------------------------------------------------
       (20) SetBasisSubscripts( i,j,k )
       (21) AfirstBasisVector> := GetBasisVector( A, 1 )
    -> (22) AfirstBasisVector> = Ai>

       (23) AthirdBasisVector> := GetBasisVector( A, 3 )
    -> (24) AthirdBasisVector> = Ak>

#### GetCharge

    GetCharge

     Purpose:  Gets the charge on an object.

      Syntax:  Object.GetCharge()

       Input:  Object -- The name of a point or particle.

      Output:  Returns the charge on Object.

     Related:  GetCharge  GetMass  SetCharge  SetMass
               AddForceElectrostatic

       (1) %--------------------------------------------------------------------
       (2) % Example: GetCharge
       (3) %--------------------------------------------------------------------
       (4) Point   P, Q
       (5) P.SetCharge( 17 )
       (6) Q.SetCharge( cQ )
       (7) chargeOnPAndQ = P.GetCharge() + Q.GetCharge()
    -> (8) chargeOnPAndQ = 17 + cQ

#### GetCMAcceleration

    GetCMAcceleration  (also see GetCMPosition, GetCMVelocity)

     Purpose:  Gets a system's center of mass acceleration in a reference frame.

      Syntax:  S.GetCMAcceleration( refFrame )

       Input:  S -- the name of a System (which may be a RigidBody or Particle).
               refFrame -- the name of a RigidFrame or RigidBody.
               If the refFrame argument is missing, the NewtonianFrame is assumed.

      Output:  The acceleration of S's center of mass in refFrame.

     Related:  SetMass          GetMass         SetInertia
               GetCMPosition    GetCMVelocity   GetCMAcceleration
               Translate        SetPositionVelocity   SetVelocityAcceleration
               SetPosition      GetPosition     GetDistance
               SetVelocity      GetVelocity     GetSpeed   GetElongation
               SetAcceleration  GetAcceleration

       (1) %--------------------------------------------------------------------
       (2) % Example 1: GetCmAcceleration  (center of mass of rigid body)
       (3) %--------------------------------------------------------------------
       (4) NewtonianFrame N
       (5) RigidBody  B
       (6) B.SetMass( mB )
       (7) Variable   xB'', yB''
       (8) Bcm.Translate( No, xB*Nx> + yB*Ny> )
    -> (9) p_No_Bcm> = xB*Nx> + yB*Ny>
    -> (10) v_Bcm_N> = xB'*Nx> + yB'*Ny>
    -> (11) a_Bcm_N> = xB''*Nx> + yB''*Ny>

       (12) BCmAccelerationInN> = B.GetCmAcceleration( N )
    -> (13) BCmAccelerationInN> = xB''*Nx> + yB''*Ny>

       (14) %--------------------------------------------------------------------
       (15) % Example 2: GetCmAcceleration  (center of mass of system)
       (16) %--------------------------------------------------------------------
       (17) Particle   P
       (18) P.SetMass( mP )
       (19) Variable   xP'', yP''
       (20) P.Translate( No, xP*Nx> + yP*Ny> )
    -> (21) p_No_P> = xP*Nx> + yP*Ny>
    -> (22) v_P_N> = xP'*Nx> + yP'*Ny>
    -> (23) a_P_N> = xP''*Nx> + yP''*Ny>

       (24) SystemCmAccelerationInN> = System.GetCmAcceleration( N )
    -> (25) SystemCmAccelerationInN> = (mB*xB''+mP*xP'')/(mB+mP)*Nx> + (mB*yB''+mP*
            yP'')/(mB+mP)*Ny>

#### GetCMPosition

    GetCMPosition  (also see GetCMVelocity, GetCMAcceleration)

     Purpose:  Gets a system's center of mass position from another point.

      Syntax:  S.GetCMPosition( fromPoint )

       Input:  S -- the name of a System (which may be a RigidBody or Particle).
               fromPoint -- name of a point.

      Output:  The position vector of S's center of mass from fromPoint.

     Remark:   The following are used for the GetCMPosition command:
               (a) the mass of each relevant particle and/or body
               (b) the position vector fromPoint to each particle
               (c) the position vector fromPoint to the mass center of each body.

     Related:  SetMass          GetMass         SetInertia
               GetCMPosition    GetCMVelocity   GetCMAcceleration
               Translate        SetPositionVelocity   SetVelocityAcceleration
               SetPosition      GetPosition   GetDistance
               SetVelocity      GetVelocity   GetSpeed   GetElongation
               SetAcceleration  GetAcceleration

       (1) %--------------------------------------------------------------------
       (2) % Example 1: GetCmPosition  (center of mass of rigid body)
       (3) %--------------------------------------------------------------------
       (4) NewtonianFrame N
       (5) RigidBody  B
       (6) B.SetMass( mB )
       (7) Variable   xB, yB
       (8) Bcm.SetPosition( No, xB*Nx> + yB*Ny> )
    -> (9) p_No_Bcm> = xB*Nx> + yB*Ny>

       (10) BCmPositionFromNo> = B.GetCmPosition( No )
    -> (11) BCmPositionFromNo> = xB*Nx> + yB*Ny>

       (12) %--------------------------------------------------------------------
       (13) % Example 2: GetCmPosition  (center of mass of system)
       (14) %--------------------------------------------------------------------
       (15) Particle   P
       (16) P.SetMass( mP )
       (17) Variable   xP, yP
       (18) P.SetPosition( No, xP*Nx> + yP*Ny> )
    -> (19) p_No_P> = xP*Nx> + yP*Ny>

       (20) SystemCmPositionFromNo> = System.GetCmPosition( No )
    -> (21) SystemCmPositionFromNo> = (mB*xB+mP*xP)/(mB+mP)*Nx> + (mB*yB+mP*yP)/(
            mB+mP)*Ny>

#### GetCMVelocity

    GetCMVelocity  (also see GetCMPosition, GetCMAcceleration)

     Purpose:  Gets a system's center of mass velocity in a reference frame.

      Syntax:  S.GetCMVelocity( refFrame )

       Input:  S -- the name of a System (which may be a RigidBody or Particle).
               refFrame -- the name of a RigidFrame or RigidBody.
               If the refFrame argument is missing, the NewtonianFrame is assumed.

      Output:  The velocity of S's center of mass in refFrame.

     Related:  SetMass          GetMass         SetInertia
               GetCMPosition    GetCMVelocity   GetCMAcceleration
               Translate        SetPositionVelocity   SetVelocityAcceleration
               SetPosition      GetPosition   GetDistance
               SetVelocity      GetVelocity   GetSpeed   GetElongation
               SetAcceleration  GetAcceleration

       (1) %--------------------------------------------------------------------
       (2) % Example 1: GetCmVelocity  (center of mass of rigid body)
       (3) %--------------------------------------------------------------------
       (4) NewtonianFrame N
       (5) RigidBody  B
       (6) B.SetMass( mB )
       (7) Variable   xB', yB'
       (8) Bcm.SetVelocity( N, xB'*Nx> + yB'*Ny> )
    -> (9) v_Bcm_N> = xB'*Nx> + yB'*Ny>

       (10) BCmVelocityInN> = B.GetCmVelocity( N )
    -> (11) BCmVelocityInN> = xB'*Nx> + yB'*Ny>

       (12) %--------------------------------------------------------------------
       (13) % Example 2: GetCmVelocity  (center of mass of system)
       (14) %--------------------------------------------------------------------
       (15) Particle   P
       (16) P.SetMass( mP )
       (17) Variable   xP', yP'
       (18) P.SetVelocity( N, xP'*Nx> + yP'*Ny> )
    -> (19) v_P_N> = xP'*Nx> + yP'*Ny>

       (20) SystemCmVelocityInN> = System.GetCmVelocity( N )
    -> (21) SystemCmVelocityInN> = (mB*xB'+mP*xP')/(mB+mP)*Nx> + (mB*yB'+mP*yP')/(
            mB+mP)*Ny>

#### GetCoefficient

    GetCoefficient    GetCoefficientShallow

     Purpose:  Gets the coefficient of a name or names in an expression.

    Syntax 1:  GetCoefficient(        ExpressionY, X )
    Syntax 2:  GetCoefficientShallow( ExpressionY, X )

       Input:  ExpressionY -- an expression or matrix of expressions.

               X -- a name that appears linearly in ExpressionY or a
               one-dimensional (row/column) matrix of names that
               appear linearly in ExpressionY.

    Output 1:  Does a deep recursive examination of ExpressionY, searching for
               any  X  that appears directly or indirectly in  ExpressionY.

    Output 2:  GetCoefficientShallow  does a shallow non-recursive search for
               any  X  that appears directly in  ExpressionY.
               Does not examine the right-hand-side of any symbol appearing
               in ExpressionY to see if it may contain X, i.e., ignores
               assignments made to symbols appearing in ExpressionY.

      Remark:  GetCoefficientShallow is Autolev compatible.
               With SetDefaults( AUTOLEV ), the command  Coef  is interpreted as
               GetCoefficientShallow, otherwise it is interpreted GetCoefficient.

      Remark:  Returns an expression or matrix of expressions (depends on whether
               ExpressionY and X are expressions or matrices of expressions).

     Related:  D  Include  Exclude  GetCoefficient GetCoefficientShallow

       (1) %--------------------------------------------------------------------
       (2) % Example 1: GetCoefficient  (Scalar expression, scalar name)
       (3) %--------------------------------------------------------------------
       (4) Variable  x, y
       (5) Expression = 2*x + t*y - sin(t)
    -> (6) Expression = 2*x + t*y - sin(t)

       (7) coefX = GetCoefficient( Expression,  x )
    -> (8) coefX = 2

       (9) coefY = GetCoefficient( Expression,  y )
    -> (10) coefY = t

       (11) %--------------------------------------------------------------------
       (12) % Example 2: GetCoefficientShallow  (Scalar expression, scalar name)
       (13) %--------------------------------------------------------------------
       (14) shallowCoefX1 = GetCoefficientShallow(        Expression,   x )
    -> (15) shallowCoefX1 = 0

       (16) shallowCoefX2 = GetCoefficientShallow( GetRhs(Expression),  x )
    -> (17) shallowCoefX2 = 2

       (18) shallowCoefX3 = GetCoefficientShallow(      x*Expression,   x )
    -> (19) shallowCoefX3 = Expression

       (20) shallowCoefY1 = GetCoefficientShallow(        Expression,   y )
    -> (21) shallowCoefY1 = 0

       (22) shallowCoefY2 = GetCoefficientShallow( GetRhs(Expression),  y )
    -> (23) shallowCoefY2 = t

       (24) %--------------------------------------------------------------------
       (25) % Example 3: GetCoefficient  (Scalar expression, matrix of names)
       (26) %--------------------------------------------------------------------
       (27) coefXY = GetCoefficient( Expression,  [x;y] )
    -> (28) coefXY = [2;  t]

       (29) %--------------------------------------------------------------------
       (30) % Example 4: GetCoefficient  (Matrix expression, scalar name)
       (31) %--------------------------------------------------------------------
       (32) Zero[1] = sin(t)*x + cos(t)*y - exp(t)
    -> (33) Zero[1] = sin(t)*x + cos(t)*y - exp(t)

       (34) Zero[2] = cos(t)*x + 3*t^2*y - tan(t)
    -> (35) Zero[2] = cos(t)*x + 3*t^2*y - tan(t)

       (36) Fred = GetCoefficient( Zero,  x )
    -> (37) Fred = [sin(t);  cos(t)]

       (38) Joe  = GetCoefficient( Zero,  y )
    -> (39) Joe = [cos(t);  3*t^2]

       (40) %--------------------------------------------------------------------
       (41) % Example 5: GetCoefficient  (Matrix expression, matrix of names)
       (42) %--------------------------------------------------------------------
       (43) Sally = GetCoefficient( Zero,  x, y )
    -> (44) Sally = [sin(t), cos(t);  cos(t), 3*t^2]

       (45) Susan = GetCoefficient( Zero,  [x,y] )
    -> (46) Susan = [sin(t), cos(t);  cos(t), 3*t^2]

       (47) remainder = Exclude( Zero, [x,y] )
    -> (48) remainder = [-exp(t);  -tan(t)]

#### GetColumns

    GetRows    or    GetColumns

     Purpose:  Reports the number of rows or columns of a matrix.
               Creates a matrix from designated rows or columns of a matrix.

    Syntax 1:     GetRows( mat )
    Syntax 2:  GetColumns( mat )
    Syntax 3:     GetRows( mat,  i, j, k,  n:m,  ... )
    Syntax 4:  GetColumns( mat,  i, j, k,  n:m,  ... )

       Input:  mat     -- a matrix or matrix expression.
               i, j, k -- positive integers.
               n:m     -- A range of positive integers from n to m.

      Remark:  i, j, k, n, m must be positive integers that are less than or
               equal to the number of rows (or columns) in the matrix mat.
               n may be larger, smaller, or equal to m.

    Output 1:  Number of rows    in mat.
    Output 2:  Number of columns in mat.
    Output 3:  Matrix whose rows    are the i, j, n:m rows    of mat.
    Output 4:  Matrix whose columns are the i, j, n:m columns of mat.

      Remark:  To select one element of mat, use e.g., mat[ 2, 3 ].
               For a submatrix, use mat[ 2:3, 1:5 ].  See HELP [].

     Related:  GetColumns     GetDeterminant  GetDiagonalMatrix  GetEigen
               GetElement []  GetInverse      GetIdentityMatrix  GetNorm  GetRows
               GetTrace       GetTranspose    GetZeroMatrix      Solve

       (1) %--------------------------------------------------------------------
       (2) % Example 1: GetRows  or  GetColumns  (number of rows or columns in a matrix)
       (3) %--------------------------------------------------------------------
       (4) M = [1, 2, 3, 4;  5, 6, 7, 8;  9, 10, 11, 12]
    -> (5) M = [1, 2, 3, 4;  5, 6, 7, 8;  9, 10, 11, 12]

       (6) numberOfRows = GetRows( M )
    -> (7) numberOfRows = 3

       (8) numberOfColumns = GetColumns( M )
    -> (9) numberOfColumns = 4

       (10) %--------------------------------------------------------------------
       (11) % Example 2: GetRows  or  GetColumns  (designated rows or columns in a matrix)
       (12) %--------------------------------------------------------------------
       (13) Rows3And1OfM = GetRows( M,  3,1 )
    -> (14) Rows3And1OfM = [9, 10, 11, 12;  1, 2, 3, 4]

       (15) Columns3And1OfM = GetColumns( M,  4,1 )
    -> (16) Columns3And1OfM = [4, 1;  8, 5;  12, 9]

       (17) %--------------------------------------------------------------------
       (18) % Example 3: GetRows  or  GetColumns  (range of rows or columns in a matrix)
       (19) %--------------------------------------------------------------------
       (20) RangeOfRowsOfM = GetRows( M,  1:2 )
    -> (21) RangeOfRowsOfM = [1, 2, 3, 4;  5, 6, 7, 8]

       (22) RangeOfColumnsOfM = GetColumns( M,  2:3, 3:2 )
    -> (23) RangeOfColumnsOfM = [2, 3, 3, 2;  6, 7, 7, 6;  10, 11, 11, 10]

       (24) %--------------------------------------------------------------------
       (25) % Example 4: GetRows  or  GetColumns  (submatrix)
       (26) %--------------------------------------------------------------------
       (27) Submatrix1 = M[ 1:2, 1:2 ]
    -> (28) Submatrix1 = [1, 2;  5, 6]

       (29) Submatrix2 = M[ 3 : GetRow(M),  2 : GetColumn(M) ]
    -> (30) Submatrix2 = [10, 11, 12]

#### GetDefaults

    GetDefaults  and  SetDefaults

    Syntax 1:  GetDefaults
    Syntax 2:  SetDefaults( AUTOLEV )         // Type HELP AUTOLEV for more info.
    Syntax 3:  SetDefaults( MotionGenesis )   // This is the default setting.

    Output 1:  Displays the settings of default preferences.

    Output 2:  Sets program defaults to be compatible with Autolev, e.g.,
               SetBasisSubscripts( 1, 2, 3 )
               SetCMSymbol( o )
               Restricts how AUTOZ symbols are introduced (backward compatible).

    Output 3:  Sets program defaults to be compatible with MotionGenesis, e.g.,
               SetBasisSubscripts( x, y, z )
               SetCMSymbol( cm )
               SetOriginSymbol( o )
               Allows more efficient computation with AUTOZ symbols.

      Remark:  To change a default setting, issue the corresponding command.
               Use HELP for more information, e.g., HELP SetDigits.

      Remark:  Some defaults can be set in the MGDefaultPreferences.txt
               file that resides in the program's MGToolbox folder, e.g.,
               SetScratchDirectory  and  SetWorkingDirectory.

     Related:  AUTOLEV  SetPauseOnWarning

#### AUTOLEV

    AUTOLEV

     Purpose:  Sets defaults to be compatible with older versions of the program.

    Syntax 1:  SetDefaults( AUTOLEV )
    Syntax 2:  SetDefaults( MotionGenesis )   // This is the default setting.

    Output 1:  Sets program defaults to be compatible with Autolev, e.g.,
               SetBasisSubscripts( 1, 2, 3 )
               SetCMSymbol( o )
               Restricts how AUTOZ symbols are introduced (backward compatible).

    Output 2:  Sets program defaults to be compatible with MotionGenesis, e.g.,
               SetBasisSubscripts( x, y, z )
               SetCMSymbol( cm )
               SetOriginSymbol( o )
               Allows more efficient computation with AUTOZ symbols.

      Remark:  To be AUTOLEV compatible when the program starts, edit the file
               MGDefaultPreferences.txt file  (in the MGToolbox folder).
               Un-comment the line (remove the percent sign) in front of:
               % SetDefaults  AUTOLEV

      Remark:  The following AUTOLEV commands are available, albeit superseded.

           1.  CODE      superseded by   ODE and Solve
           2.  SIMPROT   superseded by   Rotate and SetRotationMatrix
           3.  V1PT      superseded by   SetVelocity
           4.  V2PTS     superseded by   SetVelocity
           5.  A1PT      superseded by   SetAcceleration
           6.  A2PTS     superseded by   SetAcceleration
           7.  KE        superseded by   GetKineticEnergy
           8.  FR        superseded by   GetGeneralizedForce
           9.  FRSTAR    superseded by  -GetGeneralizedEffectiveForce
          10.  TSTAR     superseded by  -GetMomentOfEffectiveForce
          11.  GYROSTAT  may be superseded in future versions

      Remark:  The following commands are only available when
               SetDefaults( AUTOLEV ) has been issued.

           1.  ARRANGE         replaced by   FactorLinear and FactorQuadratic
           2.  CM              replaced by   GetCMPosition
           3.  CODE DYNAMICS   replaced by   ODE
           4.  COEF( s, [x,y]  replaced by   GetCoefficientShallow( s, [x,y] )
                               superseded by GetCoefficient( s, [x,y] )
           5.  DEGREES         replaced by   ConvertUnits, Input, and Output
           6.  DIRCOS          replaced by   Rotate and SetRotationMatrix
           7.  EIG(M,A,B)      replaced by   GetEigen
           8.  INERTIA         replaced by   SetInertia and GetInertia
           9.  KANE            replaced by   GetDynamicsKane, GetStaticsKane, Solve
          10.  MASS            replaced by   SetMass and GetMass
          11.  MOMENTUM        replaced by   GetTranslationalMomentum,
                               and           GetAngularMomentum,
                               and           GetGeneralizedMomentum.
          12.  MotionVariable  replaced by   Variable and SetGeneralizedSpeed
          13.  MotionVariable' replaced by   Variable and SetGeneralizedSpeed
          14.  NiCheck         replaced by   GetEnergyCheckKane
          15.  REPRESENT       replaced by   Matrix, Vector, and Dyadic
          16.  UNITS           replaced by   ConvertUnits, Input, and Output

      Remark:  The following old AUTOLEV commands are incompatible
               with this program -- regardless of SetDefaults( AUTOLEV ).

           1.  Force( Q,   Vec> )   replaced by  Q.AddForce( Vec> )
               Force( P/Q, Vec> )   replaced by  Q.AddForce( P, Vec> )

           2.  Torque( B,   Vec> )  replaced by  B.AddTorque( Vec> )
               Torque( A/B, Vec> )  replaced by  B.AddTorque( A, Vec> )

           3.  NiCheck( SIGMA )     replaced by  GetEnergyCheckSigmaR
           4.  Fr( listOfObject )   removed because theoretically unsound

     Related:  AUTOLEV  GetDefaults  SetDefaults

#### GetCofactor

    GetCofactor   GetMinor

     Purpose:  Calculates the minor or cofactor of a matrix.

    Syntax 1:  GetMinor(    squareMatrix, i, j )
    Syntax 2:  GetCofactor( squareMatrix, i, j )

       Input:  squareMatrix -- a  square matrix
               i -- an integer designating a row in squareMatrix.
               j -- an integer designating a column in squareMatrix.

    Output 1:  Mij, the determinant of the submatrix formed by eliminating the
               ith row and jth column of squareMatrix.
    Output 2:  (-1)^(i+j) * Mij

     Related:  GetColumns     GetDeterminant  GetDiagonalMatrix  GetEigen
               GetElement []  GetInverse      GetIdentityMatrix  GetNorm  GetRows
               GetTrace       GetTranspose    GetZeroMatrix      Solve

       (1) %--------------------------------------------------------------------
       (2) % Example 1: GetMinor
       (3) %--------------------------------------------------------------------
       (4) Constant a{1:3, 1:3}
       (5) M = [a11, a12, a13;  a21, a22, a23;  a31, a32, a33]
    -> (6) M = [a11, a12, a13;  a21, a22, a23;  a31, a32, a33]

       (7) minor11 = GetMinor( M, 1, 1 )
    -> (8) minor11 = a22*a33 - a23*a32

       (9) minor12 = GetMinor( M, 1, 2 )
    -> (10) minor12 = a21*a33 - a23*a31

       (11) %--------------------------------------------------------------------
       (12) % Example 2: GetCofactor
       (13) %--------------------------------------------------------------------
       (14) cofactor11 = GetCofactor( M, 1, 1 )
    -> (15) cofactor11 = a22*a33 - a23*a32

       (16) cofactor12 = GetCofactor( M, 1, 2 )
    -> (17) cofactor12 = a23*a31 - a21*a33

#### GetDeterminant

    GetDeterminant

     Purpose:  Forms the determinant of a matrix.

    Syntax 1:  GetDeterminant( squareMatrix )
    Syntax 2:  GetDeterminant( Option, squareMatrix )

       Input:  squareMatrix -- a  square matrix
               Option -- MINORS or GAUSS

      Output:  Determinant of squareMatrix

      Remark:  The determinant is calculated by one of two methods.
               MINORS is advantageous for relatively small matrices
               whereas GAUSS may be better for relatively large ones.
               If neither MINORS or GAUSS is specified, a method is
               chosen based on the size and number of non-numerical
               elements in squareMatrix.

     Related:  GetColumns     GetDeterminant  GetDiagonalMatrix  GetEigen
               GetElement []  GetInverse      GetIdentityMatrix  GetNorm  GetRows
               GetTrace       GetTranspose    GetZeroMatrix      Solve

       (1) %--------------------------------------------------------------------
       (2) % Example: GetDeterminant
       (3) %--------------------------------------------------------------------
       (4) Constant a, b, c,  d, e, f,  g, h, i
       (5) M = [a, b, c;  d, e, f;  g, h, i]
    -> (6) M = [a, b, c;  d, e, f;  g, h, i]

       (7) determinant = GetDeterminant( M )
    -> (8) determinant = g*(b*f-c*e) + i*(a*e-b*d) - h*(a*f-c*d)

       (9) detWithMinors = GetDeterminant( MINORS, M )
    -> (10) detWithMinors = g*(b*f-c*e) + i*(a*e-b*d) - h*(a*f-c*d)

       (11) detWithGauss  = GetDeterminant( GAUSS,  M )
    -> (12) detWithGauss = (a*e-b*d)*(i-c*g/a-(f-c*d/a)*(h-b*g/a)/(e-b*d/a))

#### GetDiagonalMatrix

    GetDiagonalMatrix

     Purpose:  Forms diagonal matrices.
               Forms a column matrix from diagonal elements of a matrix.

    Syntax 1:  GetDiagonalMatrix( m, X )
    Syntax 2:  GetDiagonalMatrix( numberOfRows, numberOfColumns, X )
    Syntax 3:  GetDiagonalMatrix( oneDimensionalMatrix )
    Syntax 4:  GetDiagonalMatrix( twoDimensionalMatrix )

       Input:  m -- positive integer
               numberOfRows -- positive integer
               numberOfColumns -- positive integer
               X -- an expression
               oneDimensionalMatrix -- a row or column matrix
               twoDimensionalMatrix -- a rectangular matrix

     Output 1: The m x m square matrix having X as every element on
               the diagonal and 0 elsewhere.

     Output 2: The numberOfRows x numberOfColumns matrix such that
               every i,i element is X while remaining elements are 0.
               (i is smaller than numberOfRows and numberOfCols).

     Output 3: The diagonal matrix whose diagonal elements are the
               elements of oneDimensionalMatrix.

     Output 4: The column matrix whose elements are the elements of
               twoDimensionalmatrix with equal row and column indices.

     Related:  GetColumns     GetDeterminant  GetDiagonalMatrix  GetEigen
               GetElement []  GetInverse      GetIdentityMatrix  GetNorm  GetRows
               GetTrace       GetTranspose    GetZeroMatrix      Solve

       (1) %--------------------------------------------------------------------
       (2) % Example 1: GetDiagonalMatrix  (3x3 matrix with 15 on the diagonal)
       (3) %--------------------------------------------------------------------
       (4) M1 = GetDiagonalMatrix( 3,  15 )
    -> (5) M1 = [15, 0, 0;  0, 15, 0;  0, 0, 15]

       (6) %--------------------------------------------------------------------
       (7) % Example 2: GetDiagonalMatrix  (2x3 matrix with 17 on the diagonal)
       (8) %--------------------------------------------------------------------
       (9) M2 = GetDiagonalMatrix( 2,3,  17 )
    -> (10) M2 = [17, 0, 0;  0, 17, 0]

       (11) %--------------------------------------------------------------------
       (12) % Example 3: GetDiagonalMatrix  (3x3 matrix with 18,19,20 on diagonal)
       (13) M3 = GetDiagonalMatrix( [18,19,20] )
    -> (14) M3 = [18, 0, 0;  0, 19, 0;  0, 0, 20]

       (15) %--------------------------------------------------------------------
       (16) % Example 4: GetDiagonalMatrix  (get diagonal elements of matrix)
       (17) %--------------------------------------------------------------------
       (18) Constant  A{1:3,1:4}
       (19) M4 = GetDiagonalMatrix( [A11,A12,A13,A14;A21,A22,A23,A24;A31,A32,A33,A34] )
    -> (20) M4 = [A11;  A22;  A33]

#### GetDistance

    GetDistance  GetLength   GetDistanceSquared  GetLengthSquared

     Purpose:  Gets the distance (or its square) between two points.

    Syntax 1:  Q.GetDistance( P )
               Q.GetLength( P )
    Syntax 2:  Q.GetDistanceSquared( P )
               Q.GetLengthSquared( P )

       Input:  Q -- The name of a point.
               P -- The name of another point.

    Output 1:  Distance between Q and P.
    Output 2:  Square of the distance between Q and P.

     Related:  GetMagnitude           GetMagnitudeSquared
               GetDistance            GetDistanceSquared
               GetSpeed               GetSpeedSquared
               GetAngularSpeed        GetAngularSpeedSquared
               GetAngleBetweenVectors GetAngleBetweenUnitVectors
               GetPosition            SetPosition       Translate
               GetVelocity            SetVelocity       SetPositionVelocity
               GetAcceleration        SetAcceleration   SetVelocityAcceleration
               GetUnitVector          GetElongation     Vector   Dot

       (1) %--------------------------------------------------------------------
       (2) % Example 1: GetDistance  GetDistanceSquared
       (3) %--------------------------------------------------------------------
       (4) RigidFrame  N
       (5) Particle    P, Q
       (6) Variable    xQ
       (7) Q.SetPosition( P, xQ*Nx> )
    -> (8) p_P_Q> = xQ*Nx>

       (9) distanceBetweenQAndP = Q.GetDistance( P )
    -> (10) distanceBetweenQAndP = abs(xQ)

       (11) distanceSquaredQAndP = Q.GetDistanceSquared( P )
    -> (12) distanceSquaredQAndP = xQ^2

       (13) %--------------------------------------------------------------------
       (14) % Example 2: GetDistance  GetDistanceSquared  GetLength  GetLengthSquared
       (15) %--------------------------------------------------------------------
       (16) Variable    x, y, z
       (17) P.SetPosition( No,  x*Nx> + y*Ny> + z*Nz> )
    -> (18) p_No_P> = x*Nx> + y*Ny> + z*Nz>

       (19) distanceBetweenPAndNo = P.GetDistance( No )
    -> (20) distanceBetweenPAndNo = sqrt(x^2+y^2+z^2)

       (21) distanceBetweenQAndNo = Q.GetDistance( No )    % Same as Q.GetLength( No )
    -> (22) distanceBetweenQAndNo = sqrt(y^2+z^2+(x+xQ)^2)

       (23) distanceSquaredPAndNo = Q.GetLengthSquared( No )
    -> (24) distanceSquaredPAndNo = y^2 + z^2 + (x+xQ)^2

#### GetDynamics

    GetDynamics   GetDynamicsKane    GetDynamicsLagrange

     Purpose:  Gets equations of motion (dynamics).

    Syntax 1:  Object.GetDynamics()
    Syntax 2:  Object.GetDynamics( aboutPoint )
    Syntax 3:  System.GetDynamicsKane()
    Syntax 4:  System.GetDynamicsLagrange()

       Input:  Object -- The name of a Particle, RigidBody, or System.
               aboutPoint -- The name of a point.

    Output 1:  Newton's   equation of motion for Object (i.e., m*a - F).
    Output 2:  Euler's    equation of motion for Object about aboutPoint.
    Output 3:  Kane's     equation for dynamics for the entire System.
    Output 4:  Lagrange's equation for dynamics for the entire System.

      Remark:  If Q is a point of a RigidFrame or RigidBody B, declare it as
               Point Q(B).  This helps with subsequent velocity/acceleration
               and force/moment calculations.

      Remark:  For Newton/Euler equations, type  Help Statics  or  Help Dynamics
               For Kane's       equations, type  Help Kane
               For Lagrange's   equations, type  Help Lagrange

     Related:  AddForce  AddTorque  SetMass  SetInertia  Rotate  Translate
               NewtonianFrame  Point  Particle  RigidFrame  RigidBody
               GetStatics   GetStaticsKane   GetStaticsLagrange
               GetDynamics  GetDynamicsKane  GetDynamicsLagrange
               SetGeneralizedCoordinate   SetGeneralizedSpeed

       (1) %--------------------------------------------------------------------
       (2) % Example 1: GetDynamics   (dynamics of a particle in free-fall)
       (3) %--------------------------------------------------------------------
       (4) NewtonianFrame N
       (5) Particle       Q
       (6) Q.SetMass( mQ )
       (7) Variable  y''
       (8) Q.Translate( No, y*Ny> )
    -> (9) p_No_Q> = y*Ny>
    -> (10) v_Q_N> = y'*Ny>
    -> (11) a_Q_N> = y''*Ny>

       (12) Constant  g
       (13) Q.AddForceGravity( -g*Ny> )
    -> (14) Force_Q> = -mQ*g*Ny>

       (15) NewtonsVectorEqnForQ> = Q.GetDynamics()
    -> (16) NewtonsVectorEqnForQ> = mQ*(g+y'')*Ny>

       (17) NewtonsScalarEqnForQ = Dot( NewtonsVectorEqnForQ>, Ny> )
    -> (18) NewtonsScalarEqnForQ = mQ*(g+y'')

       (19) Solve(  NewtonsScalarEqnForQ,  y'' )
    -> (20) y'' = -g

       (21) %--------------------------------------------------------------------
       (22) % Example 2: GetDynamics  (rigid-body pendulum with applied torque)
       (23) %--------------------------------------------------------------------
       (24) RigidBody      B
       (25) Constant       L                 % Distance to B's center of mass
       (26) Variable       q''               % Pendulum angle
       (27) Variable       Tz                % Torque is applied to B
       (28) B.SetMass( m )
       (29) B.SetInertia( Bcm, Ixx, Iyy, Izz )
       (30) B.RotateZ( N, q )
    -> (31) B_N = [cos(q), sin(q), 0;  -sin(q), cos(q), 0;  0, 0, 1]
    -> (32) w_B_N> = q'*Bz>
    -> (33) alf_B_N> = q''*Bz>

       (34) Bcm.Translate( No, -L*By> )
    -> (35) p_No_Bcm> = -L*By>
    -> (36) v_Bcm_N> = L*q'*Bx>
    -> (37) a_Bcm_N> = L*q''*Bx> + L*q'^2*By>

       (38) B.AddForceGravity( -g*Ny> )
    -> (39) Force_Bcm> = -m*g*Ny>

       (40) B.AddTorque( Tz*Bz> )
    -> (41) Torque_B> = Tz*Bz>

       (42) EulersVectorEqnForBAboutNo> = B.GetDynamics( No )
    -> (43) EulersVectorEqnForBAboutNo> = (m*g*L*sin(q)+Izz*q''+m*L^2*q''-Tz)*Bz>

       (44) EulersScalarEqnForBAboutNo = Dot( EulersVectorEqnForBAboutNo>, Nz> )
    -> (45) EulersScalarEqnForBAboutNo = m*g*L*sin(q) + Izz*q'' + m*L^2*q'' - Tz

       (46) Solve( EulersScalarEqnForBAboutNo, q'' )
    -> (47) q'' = (Tz-m*g*L*sin(q))/(Izz+m*L^2)

#### GetEffectiveForce

    GetEffectiveForce    GetInertiaForce

     Purpose:  Gets effective force in the NewtonianFrame (or a designated frame).

    Syntax 1:  Object.GetEffectiveForce()
    Syntax 2:  Object.GetEffectiveForce( refFrame )

       Input:  Object -- The name of a Particle, RigidBody, or System.
               refFrame -- The name of a RigidFrame or RigidBody

    Output 1:  Effective force of Object in the NewtonianFrame.
    Output 2:  Effective force of Object in refFrame.

      Remark:  A particle Q's effective force in refFrame is defined
               Q.GetMass() * Q.GetAcceleration(refFrame)

      Remark:  To form inertia force, simply use a command like
               inertiaForce = -1 * Object.GetEffectiveForce()

     Related:  GetAngularMomentum  GetTranslationalMomentum  GetGeneralizedMomentum
               GetKineticEnergy    GetMomentOfForces  GetResultantForce
               GetEffectiveForce  GetMomentOfEffectiveForce
               GetStatics   GetStaticsKane   GetStaticsLagrange
               GetDynamics  GetDynamicsKane  GetDynamicsLagrange

       (1) %--------------------------------------------------------------------
       (2) % Example 1: GetEffectiveForce  (particle moving in a plane)
       (3) %--------------------------------------------------------------------
       (4) NewtonianFrame N
       (5) Particle       Q
       (6) Q.SetMass( mQ )
       (7) Variable       x'', y'', z''
       (8) Q.SetAcceleration( N, x''*Nx> + y''*Ny> + z''*Nz> )
    -> (9) a_Q_N> = x''*Nx> + y''*Ny> + z''*Nz>

       (10) QEffectiveForce> = Q.GetEffectiveForce()
    -> (11) QEffectiveForce> = mQ*x''*Nx> + mQ*y''*Ny> + mQ*z''*Nz>

       (12) %--------------------------------------------------------------------
       (13) % Example 2: GetEffectiveForce  (rigid body moving in a plane)
       (14) %--------------------------------------------------------------------
       (15) RigidBody  B
       (16) B.SetMass( mB )
       (17) Variable   vx', vy', vz'
       (18) Bcm.SetAcceleration( N, vx'*Nx> + vy'*Ny> + vz'*Nz> )
    -> (19) a_Bcm_N> = vx'*Nx> + vy'*Ny> + vz'*Nz>

       (20) BEffectiveForce> = B.GetEffectiveForce()
    -> (21) BEffectiveForce> = mB*vx'*Nx> + mB*vy'*Ny> + mB*vz'*Nz>

       (22) %--------------------------------------------------------------------
       (23) % Example 3: GetEffectiveForce  (linear momentum of a system)
       (24) %--------------------------------------------------------------------
       (25) SEffectiveForce> = System.GetEffectiveForce()
    -> (26) SEffectiveForce> = (mB*vx'+mQ*x'')*Nx> + (mB*vy'+mQ*y'')*Ny> + (mB*vz'+
            mQ*z'')*Nz>

#### GetEigen

    GetEigen

     Purpose:  Calculates the eigenvalues or the eigenvalues and eigenvectors of
               a real square matrix or a dyadic whose measures are real numbers.

    Syntax 1:  GetEigen( M )
    Syntax 2:  GetEigen( M, eigVectorMatrixName )
    Syntax 3:  GetEigen( dyadic>> )
    Syntax 4:  GetEigen( dyadic>>, eigVectorMatrixName )

       Input:  M -- a square matrix whose elements are real numbers.
               dyadic>> -- a dyadic whose measures are real numbers.

               eigVectorMatrixName -- the name of a square matrix whose
                    columns are to be the eigenvectors of M

    Output 1:  Returns the eigenvalues of M.
    Output 2:  Returns the eigenvalues of M.  Assigns eigVectorMatrixName.
    Output 3:  Returns the eigenvalues of dyadic>>.
    Output 3:  Returns the eigenvalues of dyadic>>.  Assigns eigVectorMatrixName.

      Remark:  The COLUMNS of eigVectorMatrixName are the eigenvectors of M.

     Related:  GetColumns     GetDeterminant  GetDiagonalMatrix  GetEigen
               GetElement []  GetInverse      GetIdentityMatrix  GetNorm  GetRows
               GetTrace       GetTranspose    GetZeroMatrix      Solve

       (1) %--------------------------------------------------------------------
       (2) % Example 1: GetEigen   (eigenvalues of a matrix)
       (3) %--------------------------------------------------------------------
       (4) Amatrix = [1, 2, 3;  4, 5, 6;  5, 3, 7]
    -> (5) Amatrix = [1, 2, 3;  4, 5, 6;  5, 3, 7]

       (6) eigenValuesA = GetEigen( Amatrix )
    -> (7) eigenValuesA = [-0.9412871;  1.542281;  12.39901]

       (8) %--------------------------------------------------------------------
       (9) % Example 2: GetEigen   (eigenvalues and eigenvectors of a matrix)
       (10) %--------------------------------------------------------------------
       (11) Bmatrix = [1, 2;  3, 4]
    -> (12) Bmatrix = [1, 2;  3, 4]

       (13) eigValuesB = GetEigen( Bmatrix, eigVectorsB )
    -> (14) eigVectorsB = [-0.8245648, -0.4159736;  0.5657675, -0.9093767]
    -> (15) eigValuesB = [-0.3722813;  5.372281]

       (16) eigVector1 = GetColumn( eigVectorsB, 1 )
    -> (17) eigVector1 = [-0.8245648;  0.5657675]

       (18) eigVector2 = GetColumn( eigVectorsB, 2 )
    -> (19) eigVector2 = [-0.4159736;  -0.9093767]

       (20) %--------------------------------------------------------------------
       (21) % Example 3: GetEigen   (eigenvalues of a dyadic)
       (22) %--------------------------------------------------------------------
       (23) RigidFrame  F
       (24) dyadic>> = Dyadic( F, Amatrix )
    -> (25) dyadic>> = Fx>*Fx> + 2*Fx>*Fy> + 3*Fx>*Fz> + 4*Fy>*Fx> + 5*Fy>*Fy>
            + 6*Fy>*Fz> + 5*Fz>*Fx> + 3*Fz>*Fy> + 7*Fz>*Fz>

       (26) eigValuesD = GetEigen( dyadic>> )
    -> (27) eigValuesD = [-0.9412871;  1.542281;  12.39901]

       (28) %--------------------------------------------------------------------
       (29) % Example 4: GetEigen   (eigenvalues and eigenvectors of a dyadic)
       (30) %--------------------------------------------------------------------
       (31) eigValuesD := GetEigen( dyadic>>, eigVectorsD )
    -> (32) eigVectorsD = [0.8537881*Fx> - 0.05164451*Fy> - 0.5180529*Fz>,
            -0.08917212*Fx> - 0.8360999*Fy> + 0.5412811*Fz>, 0.2947511*Fx> + 0.6929328*Fy> + 0.6580015*Fz>]

    -> (33) eigValuesD = [-0.9412871;  1.542281;  12.39901]

       (34) eigVector1> = eigVectorsD[ 1 ]
    -> (35) eigVector1> = 0.8537881*Fx> - 0.05164451*Fy> - 0.5180529*Fz>

       (36) eigVector2> = eigVectorsD[ 2 ]
    -> (37) eigVector2> = -0.08917212*Fx> - 0.8360999*Fy> + 0.5412811*Fz>

       (38) eigVector3> = eigVectorsD[ 3 ]
    -> (39) eigVector3> = 0.2947511*Fx> + 0.6929328*Fy> + 0.6580015*Fz>

#### []

    []

     Purpose:  Assigns or returns one or more elements of a matrix.
               Use  GetElement  to return elements for an unnamed matrix.

    Syntax 1:  mat1D[ index ]
    Syntax 2:  mat1D[ indexStart : indexStop ]
    Syntax 3:  mat2D[ i, j ]
    Syntax 4:  mat2D[ iStart : iStop,  jStart : jStop ]

       Input:  mat1D -- 1D (one-dimensional) matrix (row or column matrix).
               mat2D -- 2D (two-dimensional) matrix.
               index  -- integer identifying ith element of a 1D matrix.
               indexStart : indexStop -- integer range for elements in a 1D matrix.
               i -- integer identifying a row    in a 2D matrix.
               j -- integer identifying a column in a 2D matrix.
               iStart : iStop -- integers identifying rows in a 2D matrix.
               jStart : jStop -- integers identifying columns in a 2D matrix.

    Output 1:  The element of mat1D located at index.
    Output 2:  A sub-matrix whose elements are chosen by  indexStart : indexStop.
    Output 3:  Element in the ith row and jth column of mat2D.
    Output 4:  A sub-matrix with rows iStart : iStop  and columns  jStart : jStop.

      Remark:  Alternatively, select rows or columns with GetRows or GetColumns.
               Use GetElement to select elements from an unnamed matrix expression.

     Related:  GetColumns     GetDeterminant  GetDiagonalMatrix  GetEigen
               GetElement []  GetInverse      GetIdentityMatrix  GetNorm  GetRows
               GetTrace       GetTranspose    GetZeroMatrix      Solve

#### GetElement

    GetElement

     Purpose:  Returns one or more elements from an unnamed matrix expression.
               Type  Help []  for simpler syntax for a named matrix.

    Syntax 1:  GetElement( mat1DExpression,  index )
    Syntax 2:  GetElement( mat1DExpression,  indexStart : indexStop )
    Syntax 3:  GetElement( mat2DExpression,  i, j )
    Syntax 4:  GetElement( mat2DExpression,  iStart : iStop,  jStart : jStop )

       Input:  mat1DExpression -- 1D (one-dimensional) matrix or matrix expression.
               mat2DExpression -- 2D (two-dimensional) matrix or matrix expression.
               index  -- integer identifying ith element of a 1D matrix.
               indexStart : indexStop -- integer range for elements in a 1D matrix.
               i -- integer identifying a row    in a 2D matrix.
               j -- integer identifying a column in a 2D matrix.
               iStart : iStop -- integers identifying rows in a 2D matrix.
               jStart : jStop -- integers identifying columns in a 2D matrix.

    Output 1:  The element of mat1DExpression located at index.
    Output 2:  A sub-matrix whose elements are chosen by  indexStart : indexStop.
    Output 3:  Element in the ith row and jth column of mat2D or mat2DExpression.
    Output 4:  A sub-matrix with rows iStart : iStop  and columns  jStart : jStop.

      Remark:  Alternatively, select rows or columns with GetRows or GetColumns.
               Use [] to select elements from a named matrix.

     Related:  GetColumns     GetDeterminant  GetDiagonalMatrix  GetEigen
               GetElement []  GetInverse      GetIdentityMatrix  GetNorm  GetRows
               GetTrace       GetTranspose    GetZeroMatrix      Solve

       (1) %--------------------------------------------------------------------
       (2) % Example 1: GetElement of two-dimensional matrix -- uses [] syntax.
       (3) %--------------------------------------------------------------------
       (4) A = [1, 2, 3;  4,  5, 6; 7, 8, 9]
    -> (5) A = [1, 2, 3;  4, 5, 6;  7, 8, 9]

       (6) A12 = A[ 1, 2 ]
    -> (7) A12 = 2

       (8) Asubmatrix22 = A[ 1:2, 1:2 ]
    -> (9) Asubmatrix22 = [1, 2;  4, 5]

       (10) Asubmatrix23 = A[ 1:2, 1:cols(A) ]
    -> (11) Asubmatrix23 = [1, 2, 3;  4, 5, 6]

       (12) %--------------------------------------------------------------------
       (13) % Example 2: GetElement (unnamed two-dimensional matrix)
       (14) %--------------------------------------------------------------------
       (15) AA12 = GetElement( A * A,  1, 2 )
    -> (16) AA12 = 36

       (17) AAsubmatrix = GetElements( A * A,  1:2, 2:3 )
    -> (18) AAsubmatrix = [36, 42;  81, 96]

       (19) %--------------------------------------------------------------------
       (20) % Example 3: GetElement of one-dimensional matrix -- uses [] syntax.
       (21) %--------------------------------------------------------------------
       (22) B = [t^2, sin(t), cos(t), tan(t)]
    -> (23) B = [t^2, sin(t), cos(t), tan(t)]

       (24) B2 = B[ 2 ]
    -> (25) B2 = sin(t)

       (26) Bsubmatrix = B[ 2:4 ]
    -> (27) Bsubmatrix = [sin(t), cos(t), tan(t)]

       (28) %--------------------------------------------------------------------
       (29) % Example 4: GetElement (unnamed one-dimensional matrix)
       (30) %--------------------------------------------------------------------
       (31) BB2 = GetElement( B + B,  2 )
    -> (32) BB2 = 2*sin(t)

       (33) BBsubmatrix = GetElement( B + B,  2:4 )
    -> (34) BBsubmatrix = [2*sin(t), 2*cos(t), 2*tan(t)]

#### GetElongation

    GetElongation

     Purpose:  Gets the time-derivative of the distance between two points.

      Syntax:  Q.GetElongation( P )

       Input:  Q -- The name of a point.
               P -- The name of another point.

      Output:  Time-derivative of the distance between Q and P.

     Related:  Translate        SetPositionVelocity   SetVelocityAcceleration
               SetPosition      GetPosition   GetDistance  GetDistanceSquared
               SetVelocity      GetVelocity   GetSpeed     GetElongation
               SetAcceleration  GetAcceleration

       (1) %--------------------------------------------------------------------
       (2) % Example 1: GetElongation
       (3) %--------------------------------------------------------------------
       (4) RigidFrame N
       (5) Point      P, Q
       (6) Variable   xP', xQ', yQ'
       (7) P.SetPosition( No, xP*Nx> )
    -> (8) p_No_P> = xP*Nx>

       (9) ElongationBetweenPAndNo = P.GetElongation( No )
    -> (10) ElongationBetweenPAndNo = xP*xP'/abs(xP)

       (11) %--------------------------------------------------------------------
       (12) % Example 2: GetElongation
       (13) %--------------------------------------------------------------------
       (14) Q.SetPosition( P,  xQ*Nx> + yQ*Ny> )
    -> (15) p_P_Q> = xQ*Nx> + yQ*Ny>

       (16) ElongationBetweenQAndP = Q.GetElongation( P )
    -> (17) ElongationBetweenQAndP = (xQ*xQ'+yQ*yQ')/sqrt(xQ^2+yQ^2)

#### GetEnergyCheckKane

    GetEnergyCheckKane  and  GetEnergyCheckSigmaR

     Purpose:  Returns an energy checking function associated with Kane's
               dynamical equations, which theoretically remains constant
               throughout numerical integration of equations of motion.

    Syntax 1:  System.GetEnergyCheckKane()
    Syntax 2:  System.GetEnergyCheckKane( WF )
    Syntax 3:  Object.GetEnergyCheckSigmaR()
    Syntax 4:  Object.GetEnergyCheckSigmaR( refFrame )

       Input:  WF -- an expression for the System's work function.

       Input:  Object -- The name of a Particle, RigidBody, or System.

    Output 1:  Writes a differential equation of the form WChecki' = fi.
               Returns the associated energy checking function.

    Output 2:  Same as Output 1.

    Output 3:  Returns Object's SigmaR in the NewtonianFrame,
               a quantity defined by Mitiguy and Banerjee (see below)
               to construct the energy checking function.

    Output 4:  Returns Object's SigmaR in refFrame.

      Remark:  Due to round-off and truncation errors and numerical
               integration inaccuracies, the value of a checking function
               tends to vary slightly during numerical integration; but,
               usually (depending on machine accuracy) the variations in
               the value of a checking function become ever smaller when
               appropriate changes are made in error bounds, integration
               stepsize, etc.  When such changes fail to lead to ever
               smaller variations in checking function values, integration
               results must be regarded as suspect or incorrect.

      Remark:  GetEnergyCheckKane uses the following quantities:
               (a) Mass of particles and bodies
               (b) Inertia scalars for rigid bodies
               (c) Velocities of particles or mass center of rigid bodies
               (d) Angular velocities of rigid bodies

      Remark:  The syntax NiCheck(SIGMA) was replaced by GetEnergyCheckSigmaR
               due to algorithm changes (see below).

      Remark:  The algorithm for GetEnergyCheckKane is more efficient than
               the older NiCheck algorithm for programs before Autolev 4.1.
               The newer Mitiguy/Banerjee numerical integration energy checking
               was in: Mitiguy, Paul, "Advanced Dynamics & Motion Simulation".

       (1) %--------------------------------------------------------------------
       (2) % Example 1: GetEnergyCheckKane
       (3) %--------------------------------------------------------------------
       (4) NewtonianFrame  N
       (5) Particle        A          % Cart moving horizontally on N.
       (6) RigidBody       B          % Inverted pendulum on cart.
       (7) %------------------
       (8) Constant   L = 1 m         % Length of uniform rod B.
       (9) Constant   g = 9.8 m/s^2   % Earth's gravitational acceleration.
       (10) Variable   x''             % Measure of A's horizontal position on N.
       (11) Specified  phi''           % B's angle with Earth's local vertical.
       (12) SetGeneralizedSpeed( x' )
       (13) SetDt( phi = 3*sin(2*t) )
    -> (14) phi = 3*sin(2*t)
    -> (15) phi' = 6*cos(2*t)
    -> (16) phi'' = -12*sin(2*t)

       (17) A.SetMass( mA = 1 kg )
       (18) B.SetMassInertia( mB = 1 kg,  IB = mB*L^2/12, 0, IB )
    -> (19) IB = 0.08333333*mB*L^2

       (20) B.RotateZ( N, phi )
    -> (21) B_N = [cos(phi), sin(phi), 0;  -sin(phi), cos(phi), 0;  0, 0, 1]
    -> (22) w_B_N> = phi'*Bz>
    -> (23) alf_B_N> = phi''*Bz>

       (24) A.Translate( No, x*Nx> )
    -> (25) p_No_A> = x*Nx>
    -> (26) v_A_N> = x'*Nx>
    -> (27) a_A_N> = x''*Nx>

       (28) Bcm.Translate( A, 0.5*L*By> )
    -> (29) p_A_Bcm> = 0.5*L*By>
    -> (30) v_Bcm_N> = -0.5*L*phi'*Bx> + x'*Nx>
    -> (31) a_Bcm_N> = -0.5*L*phi''*Bx> - 0.5*L*phi'^2*By> + x''*Nx>

       (32) System.AddForceGravity( -g*Ny> )
    -> (33) Force_A> = -mA*g*Ny>
    -> (34) Force_Bcm> = -mB*g*Ny>

       (35) Dynamics = System.GetDynamicsKane()
    -> (36) Dynamics = [0.5*mB*L*(sin(phi)*phi'^2-cos(phi)*phi'') + (mA+mB)*x'']

       (37) EnergyCheck = System.GetEnergyCheckKane()
    -> (38) WCheck1' = 0.5*mB*L*(sin(phi)*phi'^2-cos(phi)*phi'')*x'
    -> (39) EnergyCheck = WCheck1 + 0.5*(mA+mB)*x'^2

       (40) Input  x = 0,  x' = 0
       (41) Input  tFinal = 10 s, tStep = 0.1, absError = 1.0E-9, relError = 1.0E-9
       (42) Output t sec,  EnergyCheck Joules,  x m,  phi degrees
       (43) ODE( Dynamics = 0,  x'' ) GetEnergyCheckKane

       (44) sigmaB = B.GetEnergyCheckSigmaR()
    -> (45) sigmaB = 0.5*mB*L*(sin(phi)*phi'^2-cos(phi)*phi'')*x'

       (46) isVerifySigmaB = IsSimplifyEqual( sigmaB, WCheck1' )
    -> (47) isVerifySigmaB = true

#### GetEnvironmentValue

    GetEnvironmentValue

     Purpose:  Displays the value of an operating system environment variable.

      Syntax:  GetEnvironmentValue( envName )

       Input:  envName -- the name of an operating system environment variable.

      Output:  Displays the value assigned to the operating system environment
               variable envName.  For example, on Microsoft Windows PCs,
               GetEnvironmentValue( COMPUTERNAME )
               displays the operating system value assigned to COMPUTERNAME.

      Remark:  If an environment variable, e.g., COMPUTERNAME is not set
               or is set improperly, it may be set as follows:

      Windows 2000 and XP:

               Click on Start, Settings, Control Panel, System, Advanced,
               Environment  Variables.  Under System Variables, click New ...
               Enter the Variable Name COMPUTERNAME and enter a Variable Value
               e.g., yourComputerName.  Click OK to exit each open dialogue box.

      Windows 95/98/Millenium:

               Add the following line to the file Autoexec.bat, which
               resides on the C:\ drive:

                   SET COMPUTERNAME=yourComputerName

      Windows NT:

               Click on Start, Settings, Control Panel, System.
               Click on the Environment tab.  Enter the Variable COMPUTERNAME
               and a Value, e.g., yourComputerName. Click OK to exit.

      Unix and Macintosh OSX:

               To set the  HOSTNAME  environment variable, edit the
               file .cshrc and add the following line:

                    setenv HOSTNAME yourComputerName

     Related:  GetDefaults  GetWorkingDirectory  SetWorkingDirectory
               GetEnvironmentValue   SetScratchDirectory

    --------------------------------------------------------------------
     Example:

       (1) GetEnvironmentValue( ComputerName )

     The value JPComputer is assigned to the environment variable ComputerName

#### GetForceElectrostaticPotentialEnergy

    GetForceElectrostaticPotentialEnergy

     Purpose:  Calculates a potential energy for an electrostatic force.

      Syntax:  Q.GetForceElectrostaticPotentialEnergy( P, k )

       Input:  Q -- the name of a point or particle.
               P -- the name of a point or particle.
               k -- scalar representing the electrostatic proportionality
                    constant, approximately 8.9875518E+09 N*m^2/Coulomb^2.

      Output:  Potential energy for an inverse square law electrostatic force
               between P and Q.

      Remark:  Ensure charges are assigned to Q and P with the commands:
               Q.SetCharge(...)  and  P.SetCharge(...).

      Remark:  Q's position vector from P must be available.

      Remark:  The NIST approximation for k is 8.9875518E+09 N*m^2/Coulomb^2.

     Related:  AddForce  AddForceDamper  AddForceElectrostatic  AddForceGravity
               AddForceInverseSquare  AddForceLinearActuator  AddForceSpring
               AddTorque  AddTorqueDamper
               GetMomentOfForces  GetResultantForce  GetResultantTorque
               GetForceGravityPotentialEnergy  GetForceSpringPotentialEnergy
               GetForceElectrostaticPotentialEnergy  GetCharge  SetCharge
               GetForceInverseSquarePotentialEnergy
               GetStatics   GetStaticsKane   GetStaticsLagrange
               GetDynamics  GetDynamicsKane  GetDynamicsLagrange

       (1) %--------------------------------------------------------------------
       (2) % Example 1: GetForceElectrostaticPotentialEnergy  (horizontal 1D)
       (3) %--------------------------------------------------------------------
       (4) NewtonianFrame N
       (5) Particle  A
       (6) Variable  xA
       (7) Constant  k
       (8) No.SetCharge( chargeN )
       (9) A.SetCharge(  chargeA )
       (10) A.SetPosition( No, xA*Nx> )
    -> (11) p_No_A> = xA*Nx>

       (12) potentialEnergy1 = A.GetForceElectrostaticPotentialEnergy( No, k )
    -> (13) potentialEnergy1 = chargeA*chargeN*k/abs(xA)

       (14) %--------------------------------------------------------------------
       (15) % Example 2: GetForceElectrostaticPotentialEnergy  (planar 2D)
       (16) %--------------------------------------------------------------------
       (17) Particle  P, Q
       (18) Variable  x, y
       (19) P.SetCharge( 10 )
       (20) Q.SetCharge( 20 )
       (21) Q.SetPosition( P, x*Nx> + y*Ny> )
    -> (22) p_P_Q> = x*Nx> + y*Ny>

       (23) potentialEnergy2 = Q.GetForceElectrostaticPotentialEnergy( P, k )
    -> (24) potentialEnergy2 = 200*k/sqrt(x^2+y^2)

#### GetForceInverseSquarePotentialEnergy

    GetForceInverseSquarePotentialEnergy

     Purpose:  Calculates a potential energy for an inverse-square force.

      Syntax:  Q.GetForceInverseSquarePotentialEnergy( P, coef )

       Input:  Q -- the name of a point or particle.
               P -- the name of a point or particle.
               coef -- a scalar expression

      Output:  Potential energy for an inverse square law force between P and Q.

      Remark:  Potential energy is calculated as:  coef / Q.GetDistance(P)
               Note: Q's position vector from P must be available.

      Remark:  A positive coef corresponds to a repulsive force (pushes Q away
               from P), whereas a negative coef corresponds to an attractive
               force (pulls Q towards P).

     Related:  AddForce  AddForceDamper  AddForceElectrostatic  AddForceGravity
               AddForceInverseSquare  AddForceLinearActuator  AddForceSpring
               AddTorque  AddTorqueDamper
               GetMomentOfForces  GetResultantForce  GetResultantTorque
               GetForceGravityPotentialEnergy  GetForceSpringPotentialEnergy
               GetForceElectrostaticPotentialEnergy
               GetForceInverseSquarePotentialEnergy
               GetStatics   GetStaticsKane   GetStaticsLagrange
               GetDynamics  GetDynamicsKane  GetDynamicsLagrange

       (1) %--------------------------------------------------------------------
       (2) % Example: GetForceInverseSquarePotentialEnergy
       (3) %--------------------------------------------------------------------
       (4) NewtonianFrame N
       (5) Particle   P, Q
       (6) Variable   x, y
       (7) Constant   coef
       (8) Q.SetPosition( P, x*Nx> + y*Ny> )
    -> (9) p_P_Q> = x*Nx> + y*Ny>

       (10) PotentialEnergy = Q.GetForceInverseSquarePotentialEnergy( P, coef )
    -> (11) PotentialEnergy = coef/sqrt(x^2+y^2)

#### GetForceGravityPotentialEnergy

    GetForceGravityPotentialEnergy

     Purpose:  Calculates a potential energy for uniform gravity forces.

    Syntax 1:  Object.GetForceGravityPotentialEnergy( gVector, refPoint )
    Syntax 2:  Q.GetForceGravityPotentialEnergy( P, G )

       Input:  Object -- The name of a Particle, RigidBody, or System.
               gVector -- A vector directed locally downward and whose magnitude
                          is the local gravitational acceleration constant.
               refPoint -- A point fixed on the attracting object (e.g., Earth).
                           Above this point, potential energy is positive whereas
                           below this point, potential energy is negative.

               Q -- the name of a Particle
               P -- the name of a Particle
               G -- a scalar representing the universal gravitational
                    constant, approximately 6.6732E-11 N*m^2/kg^2.

    Output 1:  Object's uniform gravitational potential energy for a given
               reference point, due to a uniform local gravitational force.

    Output 2:  A potential energy for an inverse square law gravitational
               force between P and Q.
               Note: Q's position vector from P must be available.

      Remark:  Ensure mass is assigned to appropriate particles and bodies
               before issuing an GetForceGravityPotentialEnergy command.

               NIST defines Earth's gravity acceleration as 9.80665 m/sec^2.
               The NIST approximation for G is 6.6732E-11 N*m^2/kg^2.
               The mass of the Earth is approximately 5.97E24 kg.
               The mass of the Moon  is approximately 7.34E22 kg.
               Earth's equatorial radius is approximately 6356 km (3949.4 miles).

     Related:  AddForce  AddForceDamper  AddForceElectrostatic  AddForceGravity
               AddForceInverseSquare  AddForceLinearActuator  AddForceSpring
               AddTorque  AddTorqueDamper
               GetMomentOfForces  GetResultantForce  GetResultantTorque
               GetForceGravityPotentialEnergy  GetForceSpringPotentialEnergy
               GetStatics   GetStaticsKane   GetStaticsLagrange
               GetDynamics  GetDynamicsKane  GetDynamicsLagrange

       (1) %--------------------------------------------------------------------
       (2) % Example 1: GetForceGravityPotentialEnergy  (local gravity on a particle)
       (3) %--------------------------------------------------------------------
       (4) NewtonianFrame N   % Nx> is horizontally-right and Ny> is vertically-upward.
       (5) Particle   Q
       (6) Q.SetMass( mQ )
       (7) Constant   g
       (8) Variable   x, y
       (9) Q.SetPosition( No, x*Nx> + y*Ny> )
    -> (10) p_No_Q> = x*Nx> + y*Ny>

       (11) PEQ = Q.GetForceGravityPotentialEnergy( -g*Ny>, No )
    -> (12) PEQ = mQ*g*y

       (13) %--------------------------------------------------------------------
       (14) % Example 2: GetForceGravityPotentialEnergy  (local gravity on pendulum)
       (15) %--------------------------------------------------------------------
       (16) RigidBody  B
       (17) B.SetMassInertia( mB, Ixx, Iyy, Izz )
       (18) Constant   L                           % Distance from No to Bcm.
       (19) Variable   theta
       (20) B.RotateZ( N, theta )
    -> (21) B_N = [cos(theta), sin(theta), 0;  -sin(theta), cos(theta), 0;  0, 0, 1]

       (22) Bcm.SetPosition( No, -L*By> )
    -> (23) p_No_Bcm> = -L*By>

       (24) PEB = B.GetPotentialEnergyGravity( -g*Ny>, No )
    -> (25) PEB = -mB*g*L*cos(theta)

       (26) %--------------------------------------------------------------------
       (27) % Example 3: GetForceGravityPotentialEnergy  (local gravity on system B, Q)
       (28) %--------------------------------------------------------------------
       (29) PE = System.GetForceGravityPotentialEnergy( -g*Ny>, No )
    -> (30) PE = g*(mQ*y-mB*L*cos(theta))

       (31) Input  x = 0 m,  y = 0 m,  theta = 0 degrees
       (32) PEInitial = EvaluateAtInput( PE )
    -> (33) PEInitial = -mB*g*L

       (34) DeltaPE = PE - PEInitial
    -> (35) DeltaPE = PE - PEInitial

       (36) %--------------------------------------------------------------------
       (37) % Example 4: GetPotentialEnergyGravity  (universal gravity)
       (38) %--------------------------------------------------------------------
       (39) Constant   bigG    % Universal gravitational constant
       (40) Particle   P
       (41) P.SetMass( mP )
       (42) Q.SetPosition( P, x*Nx> + y*Ny> )
    -> (43) p_P_Q> = x*Nx> + y*Ny>

       (44) InverseSquareLawPotentialEnergy = Q.GetForceGravityPotentialEnergy( P, bigG )
    -> (45) InverseSquareLawPotentialEnergy = -mP*mQ*bigG/sqrt(x^2+y^2)

#### GetForceSpringPotentialEnergy

    GetForceSpringPotentialEnergy

     Purpose:  Calculates a potential energy for a spring force.

    Syntax 1:  Q.GetForceSpringPotentialEnergy( P, k, Ln )
    Syntax 2:  Q.GetForceSpringPotentialEnergy( P, k, Ln, stretchExponent )

       Input:  Q -- the name of a point or particle.
               P -- the name of a point or particle.
               k -- the spring constant (scalar)
               Ln -- the spring's natural length (scalar)
               stretchExponent -- the exponent on the spring's stretch (scalar)

    Output 1:  Potential energy for a spring force on Q from P whose magnitude is
               k * stretch, where stretch = L - Ln (L is distance between Q and P).

    Output 2:  Potential energy for a spring force on Q from P whose magnitude is
               k * stretch^stretchExponent, where stretch = L - Ln.

      Remark:  Q's position vector from P must be available.

     Related:  AddForce  AddForceDamper  AddForceElectrostatic  AddForceGravity
               AddForceInverseSquare  AddForceLinearActuator  AddForceSpring
               AddTorque  AddTorqueDamper
               GetMomentOfForces  GetResultantForce  GetResultantTorque
               GetForceGravityPotentialEnergy  GetForceSpringPotentialEnergy
               GetStatics   GetStaticsKane   GetStaticsLagrange
               GetDynamics  GetDynamicsKane  GetDynamicsLagrange

       (1) %--------------------------------------------------------------------
       (2) % Example 1: GetForceSpringPotentialEnergy  (natural length is 0)
       (3) %--------------------------------------------------------------------
       (4) NewtonianFrame N
       (5) Particle  P1, Q1
       (6) Variable  x, y
       (7) Constant  k, Ln
       (8) Q1.SetPosition( P1, x*Nx> )
    -> (9) p_P1_Q1> = x*Nx>

       (10) PE1 = Q1.GetForceSpringPotentialEnergy( P1, k, 0 )
    -> (11) PE1 = 0.5*k*x^2

       (12) %--------------------------------------------------------------------
       (13) % Example 2: GetForceSpringPotentialEnergy  (natural length is Ln)
       (14) %--------------------------------------------------------------------
       (15) Particle  P2, Q2
       (16) Q2.SetPosition( P2, x*Nx> )
    -> (17) p_P2_Q2> = x*Nx>

       (18) PE2 = Q2.GetForceSpringPotentialEnergy( P2, k, Ln )
    -> (19) PE2 = 0.5*k*(Ln-abs(x))^2

       (20) %--------------------------------------------------------------------
       (21) % Example 3: GetForceSpringPotentialEnergy (natural length is Ln; exponent 3)
       (22) %--------------------------------------------------------------------
       (23) Particle  P3, Q3
       (24) Q3.SetPosition( P3, x*Nx> )
    -> (25) p_P3_Q3> = x*Nx>

       (26) PE3 = Q3.GetForceSpringPotentialEnergy( P3, k, Ln, 3 )
    -> (27) PE3 = 0.25*k*(Ln-abs(x))^4

       (28) %--------------------------------------------------------------------
       (29) % Example 4: GetForceSpringPotentialEnergy  (natural length is Ln; exponent -1)
       (30) %--------------------------------------------------------------------
       (31) Particle  P4, Q4
       (32) Q4.SetPosition( P4, x*Nx> + y*Ny> )
    -> (33) p_P4_Q4> = x*Nx> + y*Ny>

       (34) PE4 = Q4.GetForceSpringPotentialEnergy( P4, k, Ln, -1 )
    -> (35) PE4 = k*log(sqrt(x^2+y^2)-Ln)

#### GetGeneralizedEffectiveForce

    GetGeneralizedEffectiveForce    GetGeneralizedInertiaForce

     Purpose:  Forms expressions for generalized effective forces or
               contributions to generalized effective forces.

      Syntax:  Object.GetGeneralizedEffectiveForce()

       Input:  Object -- The name of a Particle, RigidBody, or System.

      Output:  Column matrix, each element of which is the contribution of
               Object to a generalized effective force in the NewtonianFrame.

      Remark:  To form generalized inertia forces, simply use a command like
               genInertiaForces = -1 * Object.GetGeneralizedEffectiveForce()

      Remark:  If using the old/deprecated command  SetDefaults( AUTOLEV ),
               the results produced by this command depend on whether
               the command precedes or follows a CONSTRAIN command.

     Related:  GetGeneralizedEffectiveForce  GetGeneralizedForce
               GetMomentOfEffectiveForce   GetEffectiveForce
               GetAngularMomentum  GetTranslationalMomentum  GetGeneralizedMomentum
               GetKineticEnergy    GetMomentOfForces  GetResultantForce
               Gyrostat  SetGeneralizedCoordinate  SetGeneralizedSpeed
               SetMass  SetInertia  Rotate  Translate
               GetStatics   GetStaticsKane   GetStaticsLagrange
               GetDynamics  GetDynamicsKane  GetDynamicsLagrange

       (1) %--------------------------------------------------------------------
       (2) % Example 1: GetGeneralizedEffectiveForce
       (3) %--------------------------------------------------------------------
       (4) NewtonianFrame N
       (5) Particle  A
       (6) RigidBody B
       (7) A.SetMass( mA )
       (8) B.SetMass( mB )
       (9) B.SetInertia( Bcm, Ixx, Iyy, Izz )
       (10) Variable  w{1:3}', vA'
       (11) SetGeneralizedSpeed( w{1:3}, vA )
       (12) A.SetVelocity( N, vA*Nx> )
    -> (13) v_A_N> = vA*Nx>

       (14) B.SetAngularVelocity( N, w1*Bx> + w2*By> + w3*Bz> )
    -> (15) w_B_N> = w1*Bx> + w2*By> + w3*Bz>

       (16) Bcm.SetVelocity( N, 0> )
    -> (17) v_Bcm_N> = 0>

       (18) FrEffectiveA = A.GetGeneralizedEffectiveForce()
    -> (19) FrEffectiveA = [0;  0;  0;  mA*vA']

       (20) FrEffectiveB = B.GetGeneralizedEffectiveForce()
    -> (21) FrEffectiveB[1] = Ixx*w1' - (Iyy-Izz)*w2*w3
    -> (22) FrEffectiveB[2] = (Ixx-Izz)*w1*w3 + Iyy*w2'
    -> (23) FrEffectiveB[3] = Izz*w3' - (Ixx-Iyy)*w1*w2
    -> (24) FrEffectiveB[4] = 0

       (25) FrEffectiveS = System.GetGeneralizedEffectiveForce()
    -> (26) FrEffectiveS[1] = Ixx*w1' - (Iyy-Izz)*w2*w3
    -> (27) FrEffectiveS[2] = (Ixx-Izz)*w1*w3 + Iyy*w2'
    -> (28) FrEffectiveS[3] = Izz*w3' - (Ixx-Iyy)*w1*w2
    -> (29) FrEffectiveS[4] = mA*vA'

#### GetGeneralizedForce

    GetGeneralizedForce

     Purpose:  Gets generalized forces associated with various forces and torques.

    Syntax 1a: Q.GetGeneralizedForce( P )
           1b: Q.GetGeneralizedResultantForce( P )

    Syntax 2a: Q.GetGeneralizedExternalForce()
           2b: Q.GetGeneralizedResultantForce()

    Syntax 3a: B.GetGeneralizedTorque( A )
           3b: B.GetGeneralizedResultantTorque( A )

    Syntax 4a: B.GetGeneralizedExternalTorque()
           4b: B.GetGeneralizedResultantTorque()

    Syntax 5:  System.GetGeneralizedForce()

       Input:  Q, P -- names of points (e.g., Point or Particle).
               B, A -- name of a RigidFrame or RigidBody.

    Output 1a: Generalized force for Force_Q_P> (action/reaction force on Q from P)
           1b  Generalized force for Force_Q_P> and Force_P_Q>.

    Output 2a: Generalized force for Force_Q>   (Force_Q> is "external" force on Q)
           2b: Generalized force for all forces on Q, i.e., for external force
               Force_Q> and all action/reaction forces on Q.

    Output 3a: Generalized torque for Torque_B_A> (action/reaction torque on B from A).
           3b  Generalized torque for Torque_B_A> and Torque_A_B>.

    Output 4a: Generalized torque for Torque_B> ("external" torque on B).
           4b: Generalized torque for all torques on B, i.e., for external torque
               Torque_B> and all action/reaction torques on B.

    Output 5:  Generalized force for all forces and torques in the system.

      Remark:  Outputs a column matrix, with each element being the contribution of
               forces and torques to one generalized force in the NewtonianFrame.

      Remark:  If using the old/deprecated command  SetDefaults( AUTOLEV ),
               the results produced by this command depend on whether
               the command precedes or follows a CONSTRAIN command.

     Related:  AddForce  AddForceDamper  AddForceElectrostatic  AddForceGravity
               AddForceInverseSquare  AddForceLinearActuator  AddForceSpring
               AddTorque  AddTorqueDamper
               GetGeneralizedEffectiveForce  GetGeneralizedForce
               GetGeneralizedMomentum  GetTranslationalMomentum  GetAngularMomentum
               SetGeneralizedCoordinate  SetGeneralizedSpeed
               SetMass  SetInertia  Rotate  Translate
               GetStatics   GetStaticsKane   GetStaticsLagrange
               GetDynamics  GetDynamicsKane  GetDynamicsLagrange

       (1) %----------------------------------------------------------------------
       (2) % Example 1: GetGeneralizedForce (for a force on point Bo from point Ao)
       (3) %----------------------------------------------------------------------
       (4) NewtonianFrame  N
       (5) RigidBody       A, B
       (6) Specified       FBA
       (7) Variable        ux, uy, vx, vy
       (8) SetGeneralizedSpeed( ux, uy, vx, vy )
       (9) Ao.SetVelocity( N,  vx*Nx> + vy*Ny> )
    -> (10) v_Ao_N> = vx*Nx> + vy*Ny>

       (11) Bo.SetVelocity( N,  ux*Nx> + uy*Ny> )
    -> (12) v_Bo_N> = ux*Nx> + uy*Ny>

       (13) Bo.AddForce( Ao,  FBA*Nx> )
    -> (14) Force_Bo_Ao> = FBA*Nx>

       (15) GeneralizedForceOnBoFromAo = Bo.GetGeneralizedForce( Ao )
    -> (16) GeneralizedForceOnBoFromAo = [FBA;  0;  -FBA;  0]

       (17) %----------------------------------------------------------------------
       (18) % Example 2: GetGeneralizedExternalForce   (for Force_Bo> )
       (19) %            GetGeneralizedResultantForce  (for all forces on point Bo)
       (20) %----------------------------------------------------------------------
       (21) Specified       FBx, FBy
       (22) Bo.AddForce( FBx*Nx> + FBy*Ny> )     % "External" force on Bo.
    -> (23) Force_Bo> = FBx*Nx> + FBy*Ny>

       (24) GeneralizedExternalForceOnBo = Bo.GetGeneralizedExternalForce()
    -> (25) GeneralizedExternalForceOnBo = [FBx;  FBy;  0;  0]

       (26) GeneralizedResultantForceOnBo = Bo.GetGeneralizedResultantForce()
    -> (27) GeneralizedResultantForceOnBo = [FBA + FBx;  FBy;  0;  0]

       (28) %----------------------------------------------------------------------
       (29) % Example 3: GetGeneralizedTorque  (for torque on body B from body A)
       (30) %----------------------------------------------------------------------
       (31) Specified       TBA
       (32) Variable        wA, wB
       (33) A.SetAngularVelocity( N, wA*Nz> )
    -> (34) w_A_N> = wA*Nz>

       (35) B.SetAngularVelocity( N, wB*Nz> )
    -> (36) w_B_N> = wB*Nz>

       (37) B.AddTorque( A,  TBA*Nz> )
    -> (38) Torque_B_A> = TBA*Nz>

       (39) genSpeed = ResetGeneralizedSpeed( GetGeneralizedSpeed(), wA, wB )
    -> (40) genSpeed = [ux;  uy;  vx;  vy;  wA;  wB]

       (41) GeneralizedTorqueOnBFromA = B.GetGeneralizedTorque( A )
    -> (42) GeneralizedTorqueOnBFromA = [0;  0;  0;  0;  -TBA;  TBA]

       (43) %----------------------------------------------------------------------
       (44) % Example 4: GetGeneralizedExternalTorque   (for Torque_B> )
       (45) %            GetGeneralizedResultantTorque  (for  all torques on body B)
       (46) %----------------------------------------------------------------------
       (47) Specified       TBz
       (48) B.AddTorque( TBz*Nz> )     % "External" torque on B.
    -> (49) Torque_B> = TBz*Nz>

       (50) GeneralizedExternalTorqueOnB = B.GetGeneralizedExternalTorque()
    -> (51) GeneralizedExternalTorqueOnB = [0;  0;  0;  0;  0;  TBz]

       (52) GeneralizedResultantTorqueOnB = B.GetGeneralizedResultantTorque()
    -> (53) GeneralizedResultantTorqueOnB = [0;  0;  0;  0;  0;  TBA + TBz]

       (54) %----------------------------------------------------------------------
       (55) % Example 5: GetGeneralizedForce  (for all forces and torques on the system)
       (56) %----------------------------------------------------------------------
       (57) systemGeneralizedForce = System.GetGeneralizedForce()
    -> (58) systemGeneralizedForce = [FBA + FBx;  FBy;  -FBA;  0;  -TBA;  TBA + TBz]

#### GetGeneralizedMomentum

    GetGeneralizedMomentum

     Purpose:  Forms expressions for generalized momenta or
               contributions to generalized momenta.

      Syntax:  Object.GetGeneralizedMomentum()

       Input:  Object -- The name of a Particle, RigidBody, or System.

      Output:  Column matrix, each element of which is the contribution of
               Object to a generalized momenta in the NewtonianFrame.

      Remark:  If using the old/deprecated command  SetDefaults( AUTOLEV ),
               the results produced by this command depend on whether
               the command precedes or follows a CONSTRAIN command.

     Related:  GetAngularMomentum  GetTranslationalMomentum  GetGeneralizedMomentum
               GetKineticEnergy    GetMomentOfForces  GetResultantForce
               Gyrostat  SetGeneralizedCoordinate  SetGeneralizedSpeed
               SetMass  SetInertia  Rotate  Translate
               GetStatics   GetStaticsKane   GetStaticsLagrange
               GetDynamics  GetDynamicsKane  GetDynamicsLagrange

       (1) %--------------------------------------------------------------------
       (2) % Example 1: GetGeneralizedMomentum
       (3) %--------------------------------------------------------------------
       (4) NewtonianFrame N
       (5) Particle  A
       (6) RigidBody B
       (7) A.SetMass( mA )
       (8) B.SetMass( mB )
       (9) B.SetInertia( Bcm, Ixx, Iyy, Izz )
       (10) Variable  w{1:3}', vA'
       (11) SetGeneralizedSpeed( w{1:3}, vA )
       (12) A.SetVelocity( N, vA*Nx> )
    -> (13) v_A_N> = vA*Nx>

       (14) B.SetAngularVelocity( N, w1*Bx> + w2*By> + w3*Bz> )
    -> (15) w_B_N> = w1*Bx> + w2*By> + w3*Bz>

       (16) Bcm.SetVelocity( N, 0> )
    -> (17) v_Bcm_N> = 0>

       (18) generalizedMomentaA = A.GetGeneralizedMomentum()
    -> (19) generalizedMomentaA = [0;  0;  0;  mA*vA]

       (20) generalizedMomentaB = B.GetGeneralizedMomentum()
    -> (21) generalizedMomentaB = [Ixx*w1;  Iyy*w2;  Izz*w3;  0]

       (22) generalizedMomentaS = System.GetGeneralizedMomentum()
    -> (23) generalizedMomentaS = [Ixx*w1;  Iyy*w2;  Izz*w3;  mA*vA]

#### GetIdentityMatrix

    GetZeroMatrix     or    GetIdentityMatrix

     Purpose:  Forms a square or rectangular zero or identity matrix.

    Syntax 1:  GetZeroMatrix( m )
    Syntax 2:  GetZeroMatrix( m, n )
    Syntax 3:  GetIdentityMatrix( m )
    Syntax 4:  GetIdentityMatrix( m, n )

       Input:  m, n -- positive integers (m rows, n columns).

    Output 1:  m x m  matrix with 0 as every element.
    Output 2:  m x n  matrix with 0 as every element.

    Output 3:  m x m diagonal matrix with the number 1 on each diagonal
                     element and 0 on every off-diagonal element.

    Output 4:  m x n matrix with the number 1 for elements whose row and column
               indices are equal and the number 0 for the remaining elements.

     Related:  GetColumns     GetDeterminant  GetDiagonalMatrix  GetEigen
               GetElement []  GetInverse      GetIdentityMatrix  GetNorm  GetRows
               GetTrace       GetTranspose    GetZeroMatrix      Solve

       (1) %--------------------------------------------------------------------
       (2) % Example: GetIdentityMatrix
       (3) %--------------------------------------------------------------------
       (4) Ia = GetIdentityMatrix( 3 )
    -> (5) Ia = [1, 0, 0;  0, 1, 0;  0, 0, 1]

       (6) Ib = GetIdentityMatrix( 3, 4 )
    -> (7) Ib = [1, 0, 0, 0;  0, 1, 0, 0;  0, 0, 1, 0]

       (8) Ic = GetIdentityMatrix( 4, 3 )
    -> (9) Ic = [1, 0, 0;  0, 1, 0;  0, 0, 1;  0, 0, 0]

       (10) %--------------------------------------------------------------------
       (11) % Example: GetZeroMatrix
       (12) %--------------------------------------------------------------------
       (13) Za = GetZeroMatrix( 3 )
    -> (14) Za = [0, 0, 0;  0, 0, 0;  0, 0, 0]

       (15) Zb = GetZeroMatrix( 2, 3 )
    -> (16) Zb = [0, 0, 0;  0, 0, 0]

       (17) Zc = GetZeroMatrix( 3, 1 )
    -> (18) Zc = [0;  0;  0]

#### GetInertiaDyadic

    GetInertiaDyadic

     Purpose:  Gets an object's inertia dyadic about a point.

    Syntax 1:  Object.GetInertiaDyadic( aboutPoint )
    Syntax 2:  Object.GetInertiaDyadic( aboutPoint, expressBasis )

       Input:  Object       -- name of a Particle, RigidBody, or System.
               aboutPoint   -- name of a point or particle.
               expressBasis -- name of a RigidFrame or RigidBody.

    Output 1:  Object's inertia dyadic about aboutPoint.
    Output 2:  Object's inertia dyadic about aboutPoint expressed in expressBasis.

      Remark:  Products of inertia adhere to the "negative sign convention".
               Example: For a 1 kg particle whose position from a point P is
               2*Nx> + 3*Ny>, the product of inertia Ixy = -m*x*y = -6 kg*m^2.

     Related:  SetMass          GetMass         SetInertia
               GetCMPosition    GetCMVelocity   GetCMAcceleration
               GetInertiaDyadic  GetInertiaMatrix  GetMomentOfInertia
               GetProductOfInertia  GetRadiusOfGyration  GetInertiaVector

       (1) %--------------------------------------------------------------------
       (2) % Example 1: GetInertiaDyadic  (inertia dyadic of a rigid body)
       (3) %--------------------------------------------------------------------
       (4) RigidBody  B
       (5) B.SetInertia( Bcm, Ixx, Iyy, Izz )
       (6) BInertiaDyadicAboutBcm>> = B.GetInertiaDyadic( Bcm )
    -> (7) BInertiaDyadicAboutBcm>> = Ixx*Bx>*Bx> + Iyy*By>*By> + Izz*Bz>*Bz>

       (8) %--------------------------------------------------------------------
       (9) % Example 2: GetInertiaDyadic  (inertia dyadic in designated basis)
       (10) %--------------------------------------------------------------------
       (11) RigidFrame A
       (12) Variable  theta
       (13) B.SetRotationMatrixZ( A, theta )
    -> (14) B_A = [cos(theta), sin(theta), 0;  -sin(theta), cos(theta), 0;  0, 0, 1]

       (15) BInertiaDyadicAboutBcmExpressedInA>> = B.GetInertiaDyadic( Bcm, A )
    -> (16) BInertiaDyadicAboutBcmExpressedInA>> = (Ixx*cos(theta)^2+Iyy*sin(theta)^2)
            *Ax>*Ax> + (Ixx-Iyy)*sin(theta)*cos(theta)*Ax>*Ay> + (Ixx-Iyy)*sin(the
            ta)*cos(theta)*Ay>*Ax> + (Iyy+(Ixx-Iyy)*sin(theta)^2)*Ay>*Ay> + Izz*Az>*Az>

       (17) %--------------------------------------------------------------------
       (18) % Example 3: GetInertiaDyadic  (inertia dyadic of a particle)
       (19) %--------------------------------------------------------------------
       (20) Particle   Q
       (21) Q.SetMass( mQ )
       (22) Variable   x, y, z
       (23) Q.SetPosition( Bo, x*Bx> + y*By> + z*Bz> )
    -> (24) p_Bo_Q> = x*Bx> + y*By> + z*Bz>

       (25) QInertiaDyadicAboutBoExpressedInB>> = Q.GetInertiaDyadic( Bo, B )
    -> (26) QInertiaDyadicAboutBoExpressedInB>> = mQ*(y^2+z^2)*Bx>*Bx> - mQ*x*y*Bx>*By>
            - mQ*x*z*Bx>*Bz> - mQ*x*y*By>*Bx> + mQ*(x^2+z^2)*By>*By> - mQ*y*z*By>*Bz>
            - mQ*x*z*Bz>*Bx> - mQ*y*z*Bz>*By> + mQ*(x^2+y^2)*Bz>*Bz>

       (27) %--------------------------------------------------------------------
       (28) % Example 4: GetInertiaDyadic  (inertia dyadic of a system)
       (29) %--------------------------------------------------------------------
       (30) B.SetMass( mB )
       (31) Bcm.SetPosition( Bo, 2*Bx> + 3*By> + 4*Bz> )
    -> (32) p_Bo_Bcm> = 2*Bx> + 3*By> + 4*Bz>

       (33) SystemInertiaDyadicAboutBoExpressedInB>> = System.GetInertiaDyadic( Bo, B )
    -> (34) SystemInertiaDyadicAboutBoExpressedInB>> = (Ixx+25*mB+mQ*(y^2+z^2))*Bx>*Bx>
            + (-6*mB-mQ*x*y)*Bx>*By> + (-8*mB-mQ*x*z)*Bx>*Bz> + (-6*mB-mQ*x*y)*By>*Bx>
            + (Iyy+20*mB+mQ*(x^2+z^2))*By>*By> + (-12*mB-mQ*y*z)*By>*Bz> + (-8*mB-
            mQ*x*z)*Bz>*Bx> + (-12*mB-mQ*y*z)*Bz>*By> + (Izz+13*mB+mQ*(x^2+y^2))*
            Bz>*Bz>

#### GetInertiaMatrix

    GetInertiaMatrix

     Purpose:  Gets an object's inertia matrix about a point.

      Syntax:  Object.GetInertiaMatrix( aboutPoint, expressBasis )

       Input:  Object       -- name of a Particle, RigidBody, or System.
               aboutPoint   -- name of a Point or Particle.
               expressBasis -- name of a RigidFrame or RigidBody.

      Output:  Object's inertia matrix about aboutPoint expressed in expressBasis.

      Remark:  Products of inertia adhere to the "negative sign convention".
               Example: For a 1 kg particle whose position from a point P is
               2*Nx> + 3*Ny>, the product of inertia Ixy = -m*x*y = -6 kg*m^2.

     Related:  SetMass          GetMass         SetInertia
               GetCMPosition    GetCMVelocity   GetCMAcceleration
               GetInertiaDyadic  GetInertiaMatrix  GetMomentOfInertia
               GetProductOfInertia  GetRadiusOfGyration  GetInertiaVector

       (1) %--------------------------------------------------------------------
       (2) % Example 1: GetInertiaMatrix  (inertia matrix of a rigid body)
       (3) %--------------------------------------------------------------------
       (4) RigidBody  B
       (5) B.SetInertia( Bcm, Ixx, Iyy, Izz )
       (6) BInertiaMatrixAboutBcmInB = B.GetInertiaMatrix( Bcm, B )
    -> (7) BInertiaMatrixAboutBcmInB = [Ixx, 0, 0;  0, Iyy, 0;  0, 0, Izz]

       (8) %--------------------------------------------------------------------
       (9) % Example 2: GetInertiaMatrix  (inertia matrix in another basis)
       (10) %--------------------------------------------------------------------
       (11) RigidFrame A
       (12) Variable  theta
       (13) B.SetRotationMatrixZ( A, theta )
    -> (14) B_A = [cos(theta), sin(theta), 0;  -sin(theta), cos(theta), 0;  0, 0, 1]

       (15) BInertiaMatrixAboutBcmInA = B.GetInertiaMatrix( Bcm, A )
    -> (16) BInertiaMatrixAboutBcmInA[1,1] = Ixx*cos(theta)^2 + Iyy*sin(theta)^2
    -> (17) BInertiaMatrixAboutBcmInA[1,2] = (Ixx-Iyy)*sin(theta)*cos(theta)
    -> (18) BInertiaMatrixAboutBcmInA[1,3] = 0
    -> (19) BInertiaMatrixAboutBcmInA[2,1] = (Ixx-Iyy)*sin(theta)*cos(theta)
    -> (20) BInertiaMatrixAboutBcmInA[2,2] = Iyy + (Ixx-Iyy)*sin(theta)^2
    -> (21) BInertiaMatrixAboutBcmInA[2,3] = 0
    -> (22) BInertiaMatrixAboutBcmInA[3,1] = 0
    -> (23) BInertiaMatrixAboutBcmInA[3,2] = 0
    -> (24) BInertiaMatrixAboutBcmInA[3,3] = Izz

       (25) %--------------------------------------------------------------------
       (26) % Example 3: GetInertiaMatrix  (inertia matrix of a particle)
       (27) %--------------------------------------------------------------------
       (28) Particle   Q
       (29) Q.SetMass( mQ )
       (30) Variable   x, y, z
       (31) Q.SetPosition( Bo, x*Bx> + y*By> + z*Bz> )
    -> (32) p_Bo_Q> = x*Bx> + y*By> + z*Bz>

       (33) QInertiaMatrixAboutBoInB = Q.GetInertiaMatrix( Bo, B )
    -> (34) QInertiaMatrixAboutBoInB[1,1] = mQ*(y^2+z^2)
    -> (35) QInertiaMatrixAboutBoInB[1,2] = -mQ*x*y
    -> (36) QInertiaMatrixAboutBoInB[1,3] = -mQ*x*z
    -> (37) QInertiaMatrixAboutBoInB[2,1] = -mQ*x*y
    -> (38) QInertiaMatrixAboutBoInB[2,2] = mQ*(x^2+z^2)
    -> (39) QInertiaMatrixAboutBoInB[2,3] = -mQ*y*z
    -> (40) QInertiaMatrixAboutBoInB[3,1] = -mQ*x*z
    -> (41) QInertiaMatrixAboutBoInB[3,2] = -mQ*y*z
    -> (42) QInertiaMatrixAboutBoInB[3,3] = mQ*(x^2+y^2)

       (43) %--------------------------------------------------------------------
       (44) % Example 4: GetInertiaDyadic  (inertia matrix of a system)
       (45) %--------------------------------------------------------------------
       (46) B.SetMass( mB )
       (47) Bcm.SetPosition( Bo, 2*Bx> + 3*By> + 4*Bz> )
    -> (48) p_Bo_Bcm> = 2*Bx> + 3*By> + 4*Bz>

       (49) SystemInertiaMatrixAboutBoInB = System.GetInertiaMatrix( Bo, B )
    -> (50) SystemInertiaMatrixAboutBoInB[1,1] = Ixx + 25*mB + mQ*(y^2+z^2)
    -> (51) SystemInertiaMatrixAboutBoInB[1,2] = -6*mB - mQ*x*y
    -> (52) SystemInertiaMatrixAboutBoInB[1,3] = -8*mB - mQ*x*z
    -> (53) SystemInertiaMatrixAboutBoInB[2,1] = -6*mB - mQ*x*y
    -> (54) SystemInertiaMatrixAboutBoInB[2,2] = Iyy + 20*mB + mQ*(x^2+z^2)
    -> (55) SystemInertiaMatrixAboutBoInB[2,3] = -12*mB - mQ*y*z
    -> (56) SystemInertiaMatrixAboutBoInB[3,1] = -8*mB - mQ*x*z
    -> (57) SystemInertiaMatrixAboutBoInB[3,2] = -12*mB - mQ*y*z
    -> (58) SystemInertiaMatrixAboutBoInB[3,3] = Izz + 13*mB + mQ*(x^2+y^2)

#### GetInertiaScalar

    GetInertiaScalar

     Purpose:  Gets an object's inertia scalar about a point for
               two unit vectors.

      Syntax:  Object.GetInertiaScalar( aboutPoint, unitVectorA, unitVectorB )

       Input:  Object -- The name of a Particle, RigidBody, or System.
               aboutPoint -- The name of a point or particle.
               unitVectorA -- Unit vector or expression for a unit vector.
               unitVectorB -- Unit vector or expression for a unit vector.

      Output:  Object's inertia scalar about aboutPoint for the
               unit vectors unitVectorA and unitVectorB.

      Remark:  Products of inertia adhere to the "negative sign convention".
               Example: For a 1 kg particle whose position from a point P is
               2*Nx> + 3*Ny>, the product of inertia Ixy = -m*x*y = -6 kg*m^2.

     Related:  SetMass          GetMass         SetInertia   SetMassInertia
               GetCMPosition    GetCMVelocity   GetCMAcceleration
               GetInertiaDyadic  GetInertiaMatrix  GetMomentOfInertia
               GetProductOfInertia  GetRadiusOfGyration  GetInertiaVector

       (1) %--------------------------------------------------------------------
       (2) % Example 1: GetInertiaScalar  (inertia scalar of a rigid body)
       (3) %--------------------------------------------------------------------
       (4) RigidBody  B
       (5) B.SetInertia( Bcm, Ixx, Iyy, Izz )
       (6) BInertiaScalarAboutBcmForBxBx = B.GetInertiaScalar( Bcm, Bx>, Bx> )
    -> (7) BInertiaScalarAboutBcmForBxBx = Ixx

       (8) %--------------------------------------------------------------------
       (9) % Example 2: GetInertiaScalar  (inertia scalar in another basis)
       (10) %--------------------------------------------------------------------
       (11) RigidFrame A
       (12) Variable  theta
       (13) B.SetRotationMatrixZ( A, theta )
    -> (14) B_A = [cos(theta), sin(theta), 0;  -sin(theta), cos(theta), 0;  0, 0, 1]

       (15) BInertiaScalarAboutBcmForAxAx = B.GetInertiaScalar( Bcm, Ax>, Ay> )
    -> (16) BInertiaScalarAboutBcmForAxAx = (Ixx-Iyy)*sin(theta)*cos(theta)

       (17) %--------------------------------------------------------------------
       (18) % Example 3: GetInertiaScalar  (inertia scalar of a particle)
       (19) %--------------------------------------------------------------------
       (20) Particle   Q
       (21) Q.SetMass( mQ )
       (22) Variable   x, y, z
       (23) Q.SetPosition( Bo, x*Bx> + y*By> + z*Bz> )
    -> (24) p_Bo_Q> = x*Bx> + y*By> + z*Bz>

       (25) QInertiaScalarAboutBoForBxBx = Q.GetInertiaScalar( Bo, Bx>, Bx> )
    -> (26) QInertiaScalarAboutBoForBxBx = mQ*(y^2+z^2)

       (27) QInertiaScalarAboutBoForByBz = Q.GetInertiaScalar( Bo, By>, Bz> )
    -> (28) QInertiaScalarAboutBoForByBz = -mQ*y*z

       (29) %--------------------------------------------------------------------
       (30) % Example 4: GetInertiaScalar  (inertia scalar of a system)
       (31) %--------------------------------------------------------------------
       (32) B.SetMass( mB )
       (33) Bcm.SetPosition( Bo, 2*Bx> + 3*By> + 4*Bz> )
    -> (34) p_Bo_Bcm> = 2*Bx> + 3*By> + 4*Bz>

       (35) SystemInertiaScalarAboutBoForByBy = System.GetInertiaScalar( Bo, By>, By> )
    -> (36) SystemInertiaScalarAboutBoForByBy = Iyy + 20*mB + mQ*(x^2+z^2)

       (37) SystemInertiaScalarAboutBoForAyAy = System.GetInertiaScalar( Bo, Ay>, Ay> )
    -> (38) SystemInertiaScalarAboutBoForAyAy = Iyy + 20*mB + mQ*(x^2+z^2) - sin(
            theta)*(Iyy*sin(theta)+12*mB*cos(theta)+mQ*x^2*sin(theta)+2*mQ*x*y*cos(
            theta)-5*mB*sin(theta)-Ixx*sin(theta)-mQ*y^2*sin(theta))

#### GetInertiaVector

    GetInertiaVector

     Purpose:  Gets an object's inertia vector for a unit vector.

      Syntax:  Object.GetInertiaVector( aboutPoint, unitVector )

       Input:  Object -- The name of a Particle, RigidBody, or System.
               aboutPoint -- The name of a point or Particle.
               unitVector -- Unit vector or expression for a unit vector.

      Output:  Object's inertia vector aboutPoint for unitVector.

      Remark:  Products of inertia adhere to the "negative sign convention".
               Example: For a 1 kg particle whose position from a point P is
               2*Nx> + 3*Ny>, the product of inertia Ixy = -m*x*y = -6 kg*m^2.

     Related:  SetMass          GetMass         SetInertia   SetMassInertia
               GetCMPosition    GetCMVelocity   GetCMAcceleration
               GetInertiaDyadic  GetInertiaMatrix  GetMomentOfInertia
               GetProductOfInertia  GetRadiusOfGyration  GetInertiaVector

       (1) %--------------------------------------------------------------------
       (2) % Example 1: GetInertiaVector  (inertia vector of a rigid body)
       (3) %--------------------------------------------------------------------
       (4) RigidBody  B
       (5) B.SetInertia( Bcm, Ixx, Iyy, Izz )
       (6) BInertiaVectorAboutBcmForBx> = B.GetInertiaVector( Bcm, Bx> )
    -> (7) BInertiaVectorAboutBcmForBx> = Ixx*Bx>

       (8) %--------------------------------------------------------------------
       (9) % Example 2: GetInertiaVector  (inertia vector for Ax>)
       (10) %--------------------------------------------------------------------
       (11) RigidFrame A
       (12) Variable  theta
       (13) B.SetRotationMatrixZ( A, theta )
    -> (14) B_A = [cos(theta), sin(theta), 0;  -sin(theta), cos(theta), 0;  0, 0, 1]

       (15) BInertiaVectorAboutBcmForAx> = B.GetInertiaVector( Bcm, Ax> )
    -> (16) BInertiaVectorAboutBcmForAx> = Ixx*cos(theta)*Bx> - Iyy*sin(theta)*By>

       (17) %--------------------------------------------------------------------
       (18) % Example 3: GetInertiaVector  (inertia vector of a particle)
       (19) %--------------------------------------------------------------------
       (20) Particle   Q
       (21) Q.SetMass( mQ )
       (22) Variable   x, y, z
       (23) Q.SetPosition( Bo, x*Bx> + y*By> + z*Bz> )
    -> (24) p_Bo_Q> = x*Bx> + y*By> + z*Bz>

       (25) QInertiaVectorAboutBoForBx> = Q.GetInertiaVector( Bo, Bx> )
    -> (26) QInertiaVectorAboutBoForBx> = mQ*(y^2+z^2)*Bx> - mQ*x*y*By> - mQ*x*z*Bz>

       (27) %--------------------------------------------------------------------
       (28) % Example 4: GetInertiaVector  (inertia vector of a system)
       (29) %--------------------------------------------------------------------
       (30) B.SetMass( mB )
       (31) Bcm.SetPosition( Bo, 2*Bx> + 3*By> + 4*Bz> )
    -> (32) p_Bo_Bcm> = 2*Bx> + 3*By> + 4*Bz>

       (33) SInertiaVectorAboutBoForBx> = System.GetInertiaVector( Bo, Bx> )
    -> (34) SInertiaVectorAboutBoForBx> = (Ixx+25*mB+mQ*(y^2+z^2))*Bx> + (-6*mB-mQ*
            x*y)*By> + (-8*mB-mQ*x*z)*Bz>

#### GetInverse

    GetInverse

     Purpose:  Forms the inverse of a matrix or a dyadic.

    Syntax 1:  GetInverse( squareMatrixOrDyadic )
    Syntax 2:  GetDeterminant( Option, squareMatrixOrDyadic )

       Input:  squareMatrixOrDyadic -- a  square matrix or a dyadic
               Option -- MINORS or GAUSS

      Output:  Inverse of squareMatrixOrDyadic

      Remark:  Matrix inversion is calculated by one of two methods.
               MINORS is advantageous for relatively small matrices
               whereas GAUSS may be better for relatively large ones.
               If neither MINORS or GAUSS is specified, a method is
               chosen based on the size and number of non-numerical
               elements in the squareMatrixOfDyadic.

     Related:  GetColumns     GetDeterminant  GetDiagonalMatrix  GetEigen
               GetElement []  GetInverse      GetIdentityMatrix  GetNorm  GetRows
               GetTrace       GetTranspose    GetZeroMatrix      Solve

       (1) %--------------------------------------------------------------------
       (2) % Example 1: GetInverse  (inverse of a matrix)
       (3) %--------------------------------------------------------------------
       (4) Constant  a, b, c, d
       (5) M = [a, b;  c, d]
    -> (6) M = [a, b;  c, d]

       (7) inverse = GetInverse( M )
    -> (8) inverse[1,1] = d/(a*d-b*c)
    -> (9) inverse[1,2] = -b/(a*d-b*c)
    -> (10) inverse[2,1] = -c/(a*d-b*c)
    -> (11) inverse[2,2] = a/(a*d-b*c)

       (12) inverseWithMinors = GetInverse( MINORS, M )
    -> (13) inverseWithMinors[1,1] = d/(a*d-b*c)
    -> (14) inverseWithMinors[1,2] = -b/(a*d-b*c)
    -> (15) inverseWithMinors[2,1] = -c/(a*d-b*c)
    -> (16) inverseWithMinors[2,2] = a/(a*d-b*c)

       (17) inverseWithGauss  = GetInverse( GAUSS,  M )
    -> (18) inverseWithGauss[1,1] = (1+b*c/(a*d-b*c))/a
    -> (19) inverseWithGauss[1,2] = -b/(a*d-b*c)
    -> (20) inverseWithGauss[2,1] = -c/(a*d-b*c)
    -> (21) inverseWithGauss[2,2] = 1/(d-b*c/a)

       (22) %--------------------------------------------------------------------
       (23) % Example 2: GetInverse  (inverse of a dyadic)
       (24) %--------------------------------------------------------------------
       (25) RigidFrame F
       (26) D>> = 2*Fx>*Fy> - 3*Fy>*Fz> + Fz>*Fx>
    -> (27) D>> = 2*Fx>*Fy> - 3*Fy>*Fz> + Fz>*Fx>

       (28) dyadicInverse>> = GetInverse( D>> )
    -> (29) dyadicInverse>> = Fx>*Fz> + 0.5*Fy>*Fx> - 0.3333333*Fz>*Fy>

#### GetTranslationalMomentum

    GetTranslationalMomentum  or  GetLinearMomentum

     Purpose:  Gets translational (linear) momentum in a reference frame.

    Syntax 1:  Object.GetTranslationalMomentum()
    Syntax 2:  Object.GetTranslationalMomentum( refFrame )

       Input:  Object -- The name of a Particle, RigidBody, or System.
               refFrame -- The name of a RigidFrame or RigidBody

    Output 1:  Object's translational (linear) momentum in the NewtonianFrame.
    Output 2:  Object's translational (linear) momentum in refFrame.

      Remark:  A particle Q's translational momentum in refFrame is defined
               Q.GetMass() * Q.GetVelocity(refFrame)

     Related:  GetAngularMomentum  GetTranslationalMomentum  GetGeneralizedMomentum
               GetKineticEnergy    GetMomentOfForces  GetResultantForce
               Gyrostat  SetGeneralizedCoordinate  SetGeneralizedSpeed
               SetMass  SetInertia  Rotate  Translate
               GetStatics   GetStaticsKane   GetStaticsLagrange
               GetDynamics  GetDynamicsKane  GetDynamicsLagrange

#### GetKineticEnergy

    GetKineticEnergy  or  GetKineticEnergyi (i = 0, 1, 2)

     Purpose:  Gets kinetic energy in the NewtonianFrame (or a designated frame).

    Syntax 1:  Object.GetKineticEnergy()  or Object.GetKineticEnergy(  refFrame )
    Syntax 2:  Object.GetKineticEnergy0() or Object.GetKineticEnergy0( refFrame )
    Syntax 3:  Object.GetKineticEnergy1() or Object.GetKineticEnergy1( refFrame )
    Syntax 4:  Object.GetKineticEnergy2() or Object.GetKineticEnergy2( refFrame )

       Input:  Object -- The name of a Particle, RigidBody, or System.
               refFrame -- The name of a RigidFrame or RigidBody

    Output 1:  Object's kinetic energy in the NewtonianFrame (or refFrame).

    Output 2:  Object's homogeneous kinetic energy function of degree n = 0 in
               quantities declared by SetGeneralizedSpeeds.

    Output 3:  Same as Output 2 except n = 1.
    Output 4:  Same as Output 2 except n = 2.

     Related:  GetAngularMomentum  GetTranslationalMomentum  GetGeneralizedMomentum
               GetKineticEnergy    GetMomentOfForces  GetResultantForce
               Gyrostat  SetGeneralizedCoordinate  SetGeneralizedSpeed
               SetMass  SetInertia  Rotate  Translate   GetPower
               GetStatics   GetStaticsKane   GetStaticsLagrange
               GetDynamics  GetDynamicsKane  GetDynamicsLagrange

       (1) %--------------------------------------------------------------------
       (2) % Example 1: GetKineticEnergy  (Kinetic energy of a particle)
       (3) %--------------------------------------------------------------------
       (4) NewtonianFrame N
       (5) Particle       Q
       (6) Specified      v1
       (7) Variable       v2
       (8) Q.SetMass( mQ )
       (9) Q.SetVelocity( N, (v1+v2)*Nx> )
    -> (10) v_Q_N> = (v1+v2)*Nx>

       (11) QKineticEnergy = Q.GetKineticEnergy()
    -> (12) QKineticEnergy = 0.5*mQ*(v1+v2)^2

       (13) %------------------------
       (14) SetGeneralizedSpeed( v2 )
       (15) QKineticEnergy0 = Q.GetKineticEnergy0()
    -> (16) QKineticEnergy0 = 0.5*mQ*v1^2

       (17) QKineticEnergy1 = Q.GetKineticEnergy1()
    -> (18) QKineticEnergy1 = mQ*v1*v2

       (19) QKineticEnergy2 = Q.GetKineticEnergy2()
    -> (20) QKineticEnergy2 = 0.5*mQ*v2^2

       (21) %--------------------------------------------------------------------
       (22) % Example 2: GetKineticEnergy  (Kinetic energy of a rigid body)
       (23) %--------------------------------------------------------------------
       (24) RigidBody    B
       (25) B.SetMass( mB )
       (26) B.SetInertia( Bcm, Ixx, Iyy, Izz )
       (27) Variable     vx, vy, wz
       (28) B.SetAngularVelocity( N, wz*Bz> )
    -> (29) w_B_N> = wz*Bz>

       (30) Bcm.SetVelocity( N, vx*Nx> + vy*Ny> )
    -> (31) v_Bcm_N> = vx*Nx> + vy*Ny>

       (32) BKineticEnergy = B.GetKineticEnergy()
    -> (33) BKineticEnergy = 0.5*Izz*wz^2 + 0.5*mB*(vx^2+vy^2)

       (34) %--------------------------------------------------------------------
       (35) % Example 3: GetKineticEnergy  (Kinetic energy of a system)
       (36) %--------------------------------------------------------------------
       (37) SKineticEnergy = System.GetKineticEnergy( N )
    -> (38) SKineticEnergy = 0.5*Izz*wz^2 + 0.5*mB*(vx^2+vy^2) + 0.5*mQ*(v1+v2)^2

       (39) SKineticEnergy0 = System.GetKineticEnergy0()
    -> (40) SKineticEnergy0 = 0.5*mQ*v1^2 + 0.5*Izz*wz^2 + 0.5*mB*(vx^2+vy^2)

       (41) SKineticEnergy1 = System.GetKineticEnergy1()
    -> (42) SKineticEnergy1 = mQ*v1*v2

       (43) SKineticEnergy2 = System.GetKineticEnergy2()
    -> (44) SKineticEnergy2 = 0.5*mQ*v2^2

#### GetMagnitude

    GetMagnitude  and  GetMagnitudeSquared

     Purpose:  Calculates the magnitude of a vector or its magnitude squared.

    Syntax 1:  GetMagnitude( vector> )
    Syntax 2:  GetMagnitudeSquared( vector> )

       Input:  vector> -- a vector

    Output 1:  Magnitude of vector>
    Output 2:  Square of the magnitude of vector>

      Remark:  Use  abs           for absolute value of a real or complex scalar.
               Use  GetMagnitude  for the magnitude of a vector.
               Use  GetNorm       for the 2-norm of a real row or column matrix.

     Related:  GetMagnitude           GetMagnitudeSquared     abs     GetNorm
               GetDistance            GetDistanceSquared
               GetSpeed               GetSpeedSquared
               GetAngularSpeed        GetAngularSpeedSquared
               GetAngleBetweenVectors GetAngleBetweenUnitVectors
               GetPosition            SetPosition       Translate
               GetVelocity            SetVelocity       SetPositionVelocity
               GetAcceleration        SetAcceleration   SetVelocityAcceleration
               GetUnitVector          GetElongation     Vector   Dot

       (1) %--------------------------------------------------------------------
       (2) %Example: GetMagnitude and GetMagnitudeSquared
       (3) %--------------------------------------------------------------------
       (4) RigidFrame A
       (5) Constant x, y, z
       (6) v> = Vector( A, x, y, z )
    -> (7) v> = x*Ax> + y*Ay> + z*Az>

       (8) mag = GetMagnitude( v> )
    -> (9) mag = sqrt(x^2+y^2+z^2)

       (10) magSquared = GetMagnitudeSquared( v> )
    -> (11) magSquared = x^2 + y^2 + z^2

#### GetMass

    GetMass

     Purpose:  Gets an object's mass.

      Syntax:  Object.GetMass()

       Input:  Object -- The name of a Particle, RigidBody or System.

      Output:  Returns Object's mass.

     Related:  SetMass          GetMass         SetInertia   SetMassInertia
               GetCMPosition    GetCMVelocity   GetCMAcceleration
               GetInertiaDyadic  GetInertiaMatrix  GetMomentOfInertia
               GetProductOfInertia  GetRadiusOfGyration  GetInertiaVector

       (1) %--------------------------------------------------------------------
       (2) % Example 1: GetMass   (mass of particles)
       (3) %--------------------------------------------------------------------
       (4) Particle   P, Q, R, S
       (5) Variable   mS'
       (6) P.SetMass( 17 )
       (7) Q.SetMass( mQ )         % Declares mQ as a non-negative constant
       (8) R.SetMass( mR = 3 kg )  % Declares mR and sets its INPUT value to 3 kg
       (9) S.SetMass( mS )         % mS may be governed by an ODE
       (10) massOfP = P.GetMass()
    -> (11) massOfP = 17

       (12) massOfPAndQ = P.GetMass() + Q.GetMass()
    -> (13) massOfPAndQ = 17 + mQ

       (14) massOfPQRS = System.GetMass()
    -> (15) massOfPQRS = 17 + mQ + mR + mS

       (16) %--------------------------------------------------------------------
       (17) % Example 2: GetMass   (mass of rigid body)
       (18) %--------------------------------------------------------------------
       (19) RigidBody  B
       (20) B.SetMass( mB )    % Declares mB as a non-negative constant
       (21) massOfB = B.GetMass()
    -> (22) massOfB = mB

       (23) %--------------------------------------------------------------------
       (24) % Example 3: GetMass   (mass of system of particles and rigid body)
       (25) %--------------------------------------------------------------------
       (26) massOfSystem = System.GetMass()
    -> (27) massOfSystem = 17 + mB + mQ + mR + mS

#### GetMassUnit

    GetMassUnit  GetLengthUnit  GetTimeUnit  GetAngleUnit

     Purpose:  Displays the mass, length, time, or angle unit.
               Stands for the unit of mass, length, or time
               set by the SetUnitSystem command.

    Syntax 1:  GetMassUnit()
    Syntax 2:  GetLengthUnit()
    Syntax 3:  GetTimeUnit()
    Syntax 4:  GetAngleUnit()

    Output 1:  Displays the current mass   unit to the screen.
    Output 2:  Displays the current length unit to the screen.
    Output 3:  Displays the current time   unit to the screen.
    Output 4:  Displays "radian"  to the screen.

     Related:  ODE  Solve  Input  Output  OutputPlot  Plot  Animate
               ConvertUnits  GetUnitSystem  SetUnitSystem
               GetMassUnit   GetLengthUnit   GetTimeUnit  GetAngleUnit

    --------------------------------------------------------------------
     Examples:
    --------------------------------------------------------------------
       (1) GetMassUnit()
     kilogram
       (1) GetLengthUnit()
     meter
       (1) GetTimeUnit()
     second
       (1) GetAngleUnit()
     radian

       (1) %--------------------------------------------------------------------
       (2) %Example 1: GetMassUnit, GetLengthUnit, GetTimeUnit, GetAngleUnit
       (3) %--------------------------------------------------------------------
       (4) SetUnitSystem( kg, m, sec )
       (5) kilogramsPerGram = ConvertUnits( GetMassUnit, gram )
    -> (6) kilogramsPerGram = 1000

       (7) inchesPerMeter = ConvertUnits( inch, GetLengthUnit )
    -> (8) inchesPerMeter = 0.0254

       (9) secondSquaredPerMilliSecSquared = ConvertUnits( GetTimeUnit^2, milliSec^2 )
    -> (10) secondSquaredPerMilliSecSquared = 1000000

       (11) radianSecPerDegreeSecond = ConvertUnits( GetAngleUnit*sec, deg*sec )
    -> (12) radianSecPerDegreeSecond = 57.29578

       (13) %--------------------------------------------------------------------
       (14) %Example 2: GetMassUnit, GetLengthUnit, GetTimeUnit, GetAngleUnit
       (15) %--------------------------------------------------------------------
       (16) Variable  x' = sin(t)
    -> (17) x' = sin(t)

       (18) Input  x = 2 GetLengthUnit,  tFinal = 10 seconds
       (19) Output t GetTimeUnit, x GetLengthUnit, x' GetLengthUnit/sec
       (20) ODE() GetUnitExample

#### GetMemory

    GetMemory

     Purpose:  Reports amount of dynamically allocated program memory.

      Syntax:  GetMemory()

      Output:  Number of bytes of dynamically allocated memory.

     Example:

       (1) x = 5
    -> (2) x = 5
       (3) GetMemory()

     25247 BYTES OF MEMORY USED.

       (3) y = 7
    -> (4) y = 7
       (5) GetMemory()

     25260 BYTES OF MEMORY USED.

#### GetMomentOfEffectiveForce

    GetMomentOfEffectiveForce    GetMomentOfInertiaForce (inertia torque)

     Purpose:  Calculates an object's moment of effective force about a point.

    Syntax 1:  Object.GetMomentOfEffectiveForce( aboutPoint )
    Syntax 2:  Object.GetMomentOfEffectiveForce( aboutPoint, refFrame )

       Input:  Object     -- name of a Particle, RigidBody, or System.
               aboutPoint -- name of a Point.
               refFrame   -- name of a RigidFrame or RigidBody.

    Output 1:  Object's moment of effective force abointPoint in the NewtonianFrame.
    Output 2:  Object's moment of effective force abointPoint in refFrame.

      Remark:  Particle Q's moment of effective force aboutPoint in refFrame is:
               Cross( Q.GetPosition(aboutPoint), Q.GetEffectiveForce(refFrame) )

      Remark:  To form moment of inertia force, simply use a command like
               inertiaTorque = -1 * Object.GetMomentOfEffectiveForce( aboutPoint )

     Related:  GetTranslationalMomentum  GetAngularMomentum  GetEffectiveForce
               GetMomentOfForces  GetResultantForce  GetMomentOfEffectiveForce
               GetStatics   GetStaticsKane   GetStaticsLagrange
               GetDynamics  GetDynamicsKane  GetDynamicsLagrange

       (1) %--------------------------------------------------------------------
       (2) % Example 1: GetMomentOfEffectiveForce  (point moving in a plane)
       (3) %--------------------------------------------------------------------
       (4) NewtonianFrame N
       (5) Particle       Q
       (6) Q.SetMass( mQ )
       (7) Variable       x'', y''
       (8) Q.Translate( No, x*Nx> + y*Ny> )
    -> (9) p_No_Q> = x*Nx> + y*Ny>
    -> (10) v_Q_N> = x'*Nx> + y'*Ny>
    -> (11) a_Q_N> = x''*Nx> + y''*Ny>

       (12) QMomentOfEffectiveForceAboutNo> = Q.GetMomentOfEffectiveForce( No )
    -> (13) QMomentOfEffectiveForceAboutNo> = mQ*(x*y''-y*x'')*Nz>

       (14) %--------------------------------------------------------------------
       (15) % Example 2: GetMomentOfEffectiveForce  (rotating rigid body)
       (16) %--------------------------------------------------------------------
       (17) RigidBody  B
       (18) B.SetMass( mB )
       (19) B.SetInertia( Bcm, Ixx, Iyy, Izz )
       (20) Variable   theta''
       (21) B.RotateZ( N, theta )
    -> (22) B_N = [cos(theta), sin(theta), 0;  -sin(theta), cos(theta), 0;  0, 0, 1]
    -> (23) w_B_N> = theta'*Bz>
    -> (24) alf_B_N> = theta''*Bz>

       (25) BMomentOfEffectiveForceAboutBcm> = B.GetMomentOfEffectiveForce( Bcm )
    -> (26) BMomentOfEffectiveForceAboutBcm> = Izz*theta''*Bz>

       (27) %--------------------------------------------------------------------
       (28) % Example 3: GetMomentOfEffectiveForce  (rotating/translating rigid body)
       (29) %--------------------------------------------------------------------
       (30) Bcm.Translate( No, x*Nx> + y*Ny> )
    -> (31) p_No_Bcm> = x*Nx> + y*Ny>
    -> (32) v_Bcm_N> = x'*Nx> + y'*Ny>
    -> (33) a_Bcm_N> = x''*Nx> + y''*Ny>

       (34) BMomentOfEffectiveForceAboutNo> = B.GetMomentOfEffectiveForce( No )
    -> (35) BMomentOfEffectiveForceAboutNo> = (Izz*theta''+mB*(x*y''-y*x''))*Bz>

#### GetMomentOfForces

    GetMomentOfForces

     Purpose:  Sums the moments of all forces applied to an object.

      Syntax:  Object.GetMomentOfForces( aboutPoint )

       Input:  Object -- name of Point, Particle, RigidFrame, RigidBody, or System.
               aboutPoint -- the name of a point or Particle.

      Output:  Moment of all forces on Object about aboutPoint.

      Remark:  System depends on whether a NewtonianFrame was declared.
               Type HELP SYSTEM for more information.

      Remark:  If Q is a point of a RigidFrame or RigidBody B, declare it as
               Point Q(B).  This helps with subsequent velocity/acceleration
               and force/moment calculations.

     Related:  AddForce  AddForceDamper  AddForceElectrostatic  AddForceGravity
               AddForceInverseSquare  AddForceLinearActuator  AddForceSpring
               AddTorque  AddTorqueDamper
               GetMomentOfForces  GetResultantForce  GetResultantTorque
               GetForceGravityPotentialEnergy  GetForceSpringPotentialEnergy
               GetStatics   GetStaticsKane   GetStaticsLagrange
               GetDynamics  GetDynamicsKane  GetDynamicsLagrange

       (1) %--------------------------------------------------------------------
       (2) % Example 1: GetMomentOfForces  (moment of forces on Ao about No)
       (3) %--------------------------------------------------------------------
       (4) RigidFrame N
       (5) RigidBody  A
       (6) Variable   x, y
       (7) Ao.SetPosition( No, x*Nx> )
    -> (8) p_No_Ao> = x*Nx>

       (9) Ao.AddForce( 2*Nx> + 3*Ny> )
    -> (10) Force_Ao> = 2*Nx> + 3*Ny>

       (11) MomentOfForcesOnAoAboutNo> = Ao.GetMomentOfForces( No )
    -> (12) MomentOfForcesOnAoAboutNo> = 3*x*Nz>

       (13) %--------------------------------------------------------------------
       (14) % Example 2: GetMomentOfForces  (moment of forces on A about various points)
       (15) %--------------------------------------------------------------------
       (16) Acm.SetPosition( No, y*Ny> )
    -> (17) p_No_Acm> = y*Ny>

       (18) Acm.AddForce( 4*Nx> + 5*Ny> )
    -> (19) Force_Acm> = 4*Nx> + 5*Ny>

       (20) MomentOfForcesOnAAboutAcm> = A.GetMomentOfForces( Acm )
    -> (21) MomentOfForcesOnAAboutAcm> = (2*y+3*x)*Nz>

       (22) MomentOfForcesOnAAboutAo> = A.GetMomentOfForces( Ao )
    -> (23) MomentOfForcesOnAAboutAo> = (-5*x-4*y)*Nz>

       (24) MomentOfForcesOnAAboutNo> = A.GetMomentOfForces( No )
    -> (25) MomentOfForcesOnAAboutNo> = (3*x-4*y)*Nz>

       (26) %--------------------------------------------------------------------
       (27) % Example 3: GetMomentOfForces (action/reaction)
       (28) %--------------------------------------------------------------------
       (29) RigidBody  B
       (30) Variable   Fx, Fy
       (31) Ao.SetPosition( Bo, 2*x*Nx> )
    -> (32) p_Bo_Ao> = 2*x*Nx>

       (33) Ao.AddForce( Bo, Fx*Nx> )
    -> (34) Force_Ao_Bo> = Fx*Nx>

       (35) MomentOfForcesOnAAboutAo> := A.GetMomentOfForces( Ao )
    -> (36) MomentOfForcesOnAAboutAo> = (-5*x-4*y)*Nz>

       (37) MomentOfForcesOnBAboutAo> := B.GetMomentOfForces( Ao )
    -> (38) MomentOfForcesOnBAboutAo> = 0>

       (39) %--------------------------------------------------------------------
       (40) % Example 4: GetMomentOfForces (action/reaction with RigidFrame N)
       (41) %--------------------------------------------------------------------
       (42) No.AddForce( Acm, Fy*Ny> )
    -> (43) Force_No_Acm> = Fy*Ny>

       (44) MomentOfForcesOnSystemAboutNo> := System.GetMomentOfForces( Ao )
    -> (45) MomentOfForcesOnSystemAboutNo> = (-5*x-4*y)*Nz>

       (46) %--------------------------------------------------------------------
       (47) % Example 5: GetMomentOfForces (NewtonianFrame is external to system)
       (48) %--------------------------------------------------------------------
       (49) NewtonianFrame  N
       (50) MomentOfForcesOnSystemAboutNo> := System.GetMomentOfForces( Ao )
    -> (51) MomentOfForcesOnSystemAboutNo> = (Fy*x-5*x-4*y)*Nz>

#### GetMomentOfInertia

    GetMomentOfInertia

     Purpose:  Gets an object's moment of inertia about a line.

      Syntax:  Object.GetMomentOfInertia( aboutPoint, unitVector )

       Input:  Object -- The name of a Particle, RigidBody, or System.
               aboutPoint -- The name of a point or Particle.
               unitVector -- Unit vector or expression for a unit vector.

      Output:  Returns Object's moment of inertia for the line that passes
               through aboutPoint and that is parallel to unitVector.

     Related:  SetMass          GetMass         SetInertia   SetMassInertia
               GetCMPosition    GetCMVelocity   GetCMAcceleration
               GetInertiaDyadic  GetInertiaMatrix  GetMomentOfInertia
               GetProductOfInertia  GetRadiusOfGyration  GetInertiaVector

       (1) %--------------------------------------------------------------------
       (2) % Example 1: GetMomentOfInertia  (moment of inertia of a rigid body)
       (3) %--------------------------------------------------------------------
       (4) RigidBody  B
       (5) B.SetInertia( Bcm, Ixx, Iyy, Izz )
       (6) BMomentOfInertiaAboutBcmForBx = B.GetMomentOfInertia( Bcm, Bx> )
    -> (7) BMomentOfInertiaAboutBcmForBx = Ixx

       (8) %--------------------------------------------------------------------
       (9) % Example 2: GetMomentOfInertia  (moment of inertia in another basis)
       (10) %--------------------------------------------------------------------
       (11) RigidFrame A
       (12) Variable  theta
       (13) B.SetRotationMatrixZ( A, theta )
    -> (14) B_A = [cos(theta), sin(theta), 0;  -sin(theta), cos(theta), 0;  0, 0, 1]

       (15) BMomentOfInertiaAboutBcmForAx = B.GetMomentOfInertia( Bcm, Ax> )
    -> (16) BMomentOfInertiaAboutBcmForAx = Ixx*cos(theta)^2 + Iyy*sin(theta)^2

       (17) %--------------------------------------------------------------------
       (18) % Example 3: GetMomentOfInertia  (moment of inertia of a particle)
       (19) %--------------------------------------------------------------------
       (20) Particle   Q
       (21) Q.SetMass( mQ )
       (22) Variable   x, y, z
       (23) Q.SetPosition( Bo, x*Bx> + y*By> + z*Bz> )
    -> (24) p_Bo_Q> = x*Bx> + y*By> + z*Bz>

       (25) QMomentOfInertiaAboutBoForBx = Q.GetMomentOfInertia( Bo, Bx> )
    -> (26) QMomentOfInertiaAboutBoForBx = mQ*(y^2+z^2)

       (27) %--------------------------------------------------------------------
       (28) % Example 4: GetMomentOfInertia  (moment of inertia of a system)
       (29) %--------------------------------------------------------------------
       (30) B.SetMass( mB )
       (31) Bcm.SetPosition( Bo, 2*Bx> + 3*By> + 4*Bz> )
    -> (32) p_Bo_Bcm> = 2*Bx> + 3*By> + 4*Bz>

       (33) SMomentOfInertiaAboutBoForBx = System.GetMomentOfInertia( Bo, Bx> )
    -> (34) SMomentOfInertiaAboutBoForBx = Ixx + 25*mB + mQ*(y^2+z^2)

       (35) SMomentOfInertiaAboutBoForAx = System.GetMomentOfInertia( Bo, Ax> )
    -> (36) SMomentOfInertiaAboutBoForAx = Ixx + 25*mB + mQ*(y^2+z^2) + sin(theta)*
            (Iyy*sin(theta)+12*mB*cos(theta)+mQ*x^2*sin(theta)+2*mQ*x*y*cos(theta)-
            5*mB*sin(theta)-Ixx*sin(theta)-mQ*y^2*sin(theta))

#### GetPolynomialRoots

    GetPolynomialRoots GetQuadraticRoots       GetCubicRoots       ...
    GetPolynomial      GetQuadraticPolynomial  GetCubicPolynomial  ...

     Purpose:  GetPolynomialRoots  gets the roots of a polynomial of degree
     Purpose:  GetPolynomial       creates a polynomial function from a matrix
               of coefficients or determines the coefficients of the leading
               terms of the Taylor-series expansion of a function about 0.

    Syntax 1:  GetPolynomialRoots(       M  )       % M  is row or column matrix.
               GetLinearRoots(           M2 )       % M2 is 2-element matrix.
               GetQuadraticRoots(        M3 )       % M3 is 3-element matrix.
               GetCubicRoots(            M4 )       % M4 is 4-element matrix.
               GetQuarticRoots(          M5 )       % M5 is 5-element matrix.
               GetQuinticRoots(          M6 )       % M6 is 6-element matrix.
               GetQuadraticPositiveRoot( M2 )
               GetQuadraticNegativeRoot( M2 )
    Syntax 2:  GetPolynomialRoots(       expression = 0,  x, p )
               GetLinearRoots(           expression = 0,  x )
               GetQuadraticRoots(        expression = 0,  x )
               GetCubicRoots(            expression = 0,  x )
               GetQuarticRoots(          expression = 0,  x )
               GetQuinticRoots(          expression = 0,  x )
               GetQuadraticPositiveRoot( expression = 0,  x )
               GetQuadraticNegativeRoot( expression = 0,  x )
    Syntax 3:  GetPolynomial(          M,  x )      % M  is row or column matrix.
               GetLinearPolynomial(    M2, x )      % M2 is 2-element matrix.
               GetQuadraticPolynomial( M3, x )      % M3 is 3-element matrix.
               GetCubicPolynomial(     M4, x )      % M4 is 4-element matrix.
               GetQuarticPolynomial(   M5, x )      % M5 is 5-element matrix.
               GetQuinticPolynomial(   M6, x )      % M6 is 6-element matrix.
    Syntax 4:  GetPolynomial(          expression, x, p )
               GetLinearPolynomial(    expression, x )
               GetQuadraticPolynomial( expression, x )
               GetCubicPolynomial(     expression, x )
               GetQuarticPolynomial(   expression, x )
               GetQuinticPolynomial(   expression, x )

       Input:  M -- row or column matrix with scalar elements.  For example,
               M = [2, 5, 7, 9]  may represent  2*x^3 + 5*x^2 + 7*x + 9.

               p   -- positive integer.
               x   -- scalar name (variable, constant, specified, ...)
               expression -- scalar expression that is a function of x.  A polynomial
               is created from a Taylor series expansion of expression about x = 0.

    Output 1:  Row or column matrix whose elements are the roots of the
               polynomial represented by M.

               For special case of quadratic formula:  a*x^2 + b*x + c = 0,
               GetQuadraticPositiveRoot  returns (-b + sqrt(b^2 - 4*a*c)) / 2*a
               GetQuadraticNegativeRoot  returns (-b - sqrt(b^2 - 4*a*c)) / 2*a

               Note: To also assign results to x, use
               SolveQuadraticPositiveRoot  or  SolveQuadraticNegativeRoot.

    Output 2:  Column matrix whose elements are the roots of the polynomial
               formed by the p+1 leading terms of the Taylor series expansion
               of expression about x = 0.  For example,

               taylorSeriesRoots = GetPolynomialRoots( exp(x),  x,  3 )

               returns the roots of the polynomial generated by doing a Taylor
               series expansion of exp(x) about x=0, i.e., it returns the roots
               of the polynomial  1 + x + x^2/2 + x^3/factorial(3).

    Output 3:  Polynomial of degree p-1 in x equal to:
               M[1]*x^(p-1) + M[2]*x^(p-2) + ... M[p-1]*x + M[p].

    Output 4:  Column matrix having p+1 elements whose ith element is the
               coefficient of the term of degree  p+1-i  in x  in the
               Taylor series expansion of expression about x = 0.

     Related:  GetPolynomial  GetPolynomialRoots  GetQuadraticRoots  ...
               SolveQuadraticPositiveRoot  SolveQuadraticPositiveRootDt  ...
               Solve  SolveDt  SolveSetInput
               Spline (Line, Cubic, Bell, Pulse, Step, Transition, Polynomial, ...)
               FactorLinear  FactorQuadratic

       (1) %--------------------------------------------------------------------
       (2) % Example 1: GetLinearRoots     (roots of linear equation).
       (3) %--------------------------------------------------------------------
       (4) Variable x
       (5) Constant a, b, c
       (6) root1A = GetLinearRoot( a*x = b,  x )
    -> (7) root1A = b/a

       (8) root1B = GetLinearRoot( [a; -b] )
    -> (9) root1B = b/a

       (10) %--------------------------------------------------------------------
       (11) % Example 2: GetQuadraticRoots  (roots of quadratic equation).
       (12) %--------------------------------------------------------------------
       (13) root2A = GetQuadraticRoots( a*x^2 + b*x + c = 0,  x )
    -> (14) root2A[1] = -0.5*(b+sqrt(b^2-4*a*c))/a
    -> (15) root2A[2] = -0.5*(b-sqrt(b^2-4*a*c))/a

       (16) positiveRootA = GetQuadraticPositiveRoot( a*x^2 + b*x + c = 0,  x )
    -> (17) positiveRootA = -0.5*(b-sqrt(b^2-4*a*c))/a

       (18) negativeRootA = GetQuadraticNegativeRoot( a*x^2 + b*x + c = 0,  x )
    -> (19) negativeRootA = -0.5*(b+sqrt(b^2-4*a*c))/a

       (20) root2B = GetQuadraticRoots( [a; b; c] )
    -> (21) root2B[1] = -0.5*(b+sqrt(b^2-4*a*c))/a
    -> (22) root2B[2] = -0.5*(b-sqrt(b^2-4*a*c))/a

       (23) %--------------------------------------------------------------------
       (24) % Example 3: GetCubicRoots      (roots of 3rd-order polynomial).
       (25) %--------------------------------------------------------------------
       (26) SetImaginaryNumber( i )
       (27) Variable  p
       (28) root3A = GetCubicRoots( 3*p^3 + 5*p^2 + 9*p + 17 = 0,   p )
    -> (29) root3A = [-1.775053;  0.05419336 - 1.785905*i;  0.05419336 + 1.785905*i]

       (30) root3B = GetCubicRoots( [3, 5, 9, 17] )
    -> (31) root3B = [-1.775053, 0.05419336 - 1.785905*i, 0.05419336 + 1.785905*i]

       (32) %--------------------------------------------------------------------
       (33) % Example 4: GetQuarticRoots    (roots of 4th-order polynomial).
       (34) %--------------------------------------------------------------------
       (35) root4A = GetQuarticRoots( 2*p^4 + 3*p^3 + 5*p^2 + 9*p + 17 = 0,   p )
    -> (36) root4A = [-1.361636 - 1.014663*i;  -1.361636 + 1.014663*i;  0.6116363
            - 1.604248*i;  0.6116363 + 1.604248*i]

       (37) root4B = GetQuarticRoots( [2, 3, 5, 9, 17] )
    -> (38) root4B = [-1.361636 - 1.014663*i, -1.361636 + 1.014663*i, 0.6116363 - 1.604248*i, 0.6116363 + 1.604248*i]

       (39) %--------------------------------------------------------------------
       (40) % Example 5: GetQuinticRoots    (roots of 5th-order polynomial).
       (41) %--------------------------------------------------------------------
       (42) root5A = GetQuinticRoots( p^5 + 2*p^4 + 3*p^3 + 5*p^2 + 9*p + 17 = 0,  p )
    -> (43) root5A = [-1.857621;  -0.9475112 - 1.507048*i;  -0.9475112 + 1.507048*i;
            0.8763218 - 1.455989*i;  0.8763218 + 1.455989*i]

       (44) root5B = GetQuinticRoots( [1, 2, 3, 5, 9, 17] )
    -> (45) root5B = [-1.857621, -0.9475112 - 1.507048*i, -0.9475112 + 1.507048*i, 0.8763218 - 1.455989*i, 0.8763218 + 1.455989*i]

       (46) %--------------------------------------------------------------------
       (47) % Example 6: GetPolynomialRoots  (roots of nth-order polynomial).
       (48) %--------------------------------------------------------------------
       (49) root7A = GetPolynomialRoots( p^7 + 2*p^3 + 13 = 0,   p, 7 )
    -> (50) root7A = [-1.348251;  -0.9844658 - 1.16944*i;  -0.9844658 + 1.16944*i;
            0.3798201 - 1.331288*i;  0.3798201 + 1.331288*i;  1.278771 - 0.7194889*i;  1.278771 + 0.7194889*i]

       (51) root7B = GetPolynomialRoots( [1, 0, 0, 0, 2, 0, 0, 13] )
    -> (52) root7B = [-1.348251, -0.9844658 - 1.16944*i, -0.9844658 + 1.16944*i,
            0.3798201 - 1.331288*i, 0.3798201 + 1.331288*i, 1.278771 - 0.7194889*i, 1.278771 + 0.7194889*i]

       (53) %--------------------------------------------------------------------
       (54) % Example 7: GetPolynomial
       (55) %--------------------------------------------------------------------
       (56) quadraticFunctionA = GetPolynomial(  [t, 5, 3],  x )
    -> (57) quadraticFunctionA = 3 + 5*x + t*x^2

       (58) approximateAsCubic = GetCubicPolynomial( sin(x),  x )
    -> (59) approximateAsCubic = [-0.1666667;  0;  1;  0]

       (60) approximateAs5thOrder = GetPolynomial( cos(x),  x, 5 )
    -> (61) approximateAs5thOrder = [0;  0.04166667;  0;  -0.5;  0;  1]

#### GetEulerParameterMatrix44

    GetEulerParameterMatrix44

     Purpose:  Gets the 4x4 Euler parameter matrix that multiplies a 4x1 Euler-
               parameter matrix to produce the 4 Euler parameters associated
               with concatenating two rotation matrices.

      Syntax:  GetEulerParameterMatrix44( e0, e1, e2, e3 )

       Input:  e0, e1, e2, e3 -- expressions for Euler parameters (quaternion)

      Output:  4x4 Euler parameter matrix, equal to:
               [ e0,  -e1,  -e2,  -e3;
                 e1,   e0,  -e3,   e2;
                 e2,   e3,   e0,  -e1;
                 e3,  -e2,   e1,   e0   ]

      Remark:  Definitions of Euler parameters (quaternion) etc., are in
               Kane, Likins, Levinson: Spacecraft Dynamics, McGraw-Hill, Ch. 1, and
               Mitiguy, Paul: "Advanced Dynamics & Motion Simulation".

     Related:  Rotate  RotateX  RotateY  RotateZ
               RotateNegativeX  RotateNegativeY  RotateNegativeZ
               SetRotationMatrixX  SetRotationMatrixY  SetRotationMatrixZ
               SetRotationMatrixNegativeX  SetRotationMatrixNegativeY  ...
               SetRotationMatrix  SetAngularVelocity  SetAngularAcceleration
               GetRotationMatrix  GetAngularVelocity  GetAngularAcceleration
               SetRotationMatrixODE   SetRigidTransform

       (1) %--------------------------------------------------------------------
       (2) % Example: GetEulerParameterMatrix44.al
       (3) %--------------------------------------------------------------------
       (4) Variable  e0, e1, e2, e3
       (5) E = GetEulerParameterMatrix44( e0, e1, e2, e3 )
    -> (6) E = [e0, -e1, -e2, -e3;  e1, e0, -e3, e2;  e2, e3, e0, -e1;  e3, -e2, e1, e0]

#### GetPosition

    GetPosition

     Purpose:  Gets the position of a point from another point.

      Syntax:  Q.GetPosition( fromPoint )

       Input:  Q, fromPoint -- names of points (e.g., Point or Particle).

      Output:  Q's position vector from fromPoint.

     Related:  Translate        SetPositionVelocity   SetVelocityAcceleration
               SetPosition      GetPosition   GetDistance  GetDistanceSquared
               SetVelocity      GetVelocity   GetSpeed     GetElongation
               SetAcceleration  GetAcceleration

       (1) %--------------------------------------------------------------------
       (2) % Example: GetPosition
       (3) %--------------------------------------------------------------------
       (4) RigidFrame N
       (5) Point      P
       (6) Particle   Q
       (7) Variable   xP, yP, zP
       (8) Variable   xQ, yQ, zQ
       (9) P.SetPosition( No, xP*Nx> + yP*Ny> + zP*Nz> )
    -> (10) p_No_P> = xP*Nx> + yP*Ny> + zP*Nz>

       (11) Q.SetPosition( P,  xQ*Nx> + yQ*Ny> + zQ*Nz> )
    -> (12) p_P_Q> = xQ*Nx> + yQ*Ny> + zQ*Nz>

       (13) QPositionVectorFromNo> = Q.GetPosition( No )
    -> (14) QPositionVectorFromNo> = (xP+xQ)*Nx> + (yP+yQ)*Ny> + (zP+zQ)*Nz>

#### GetPotentialEnergy

    GetPotentialEnergy

     Purpose:  Help with potential energy associated with various forces.

               For help with  gravity  potential energy, type
               Help  GetForceGravityPotentialEnergy

               For help with  spring  potential energy, type
               Help  GetForceSpringPotentialEnergy

               For help with  electrostatic  potential energy, type
               Help  GetForceElectrostaticPotentialEnergy

               For help with other inverse-square forces' potential energy, type
               Help  GetForceInverseSquarePotentialEnergy

#### GetPower

    GetPower

     Purpose:  Gets the power associated with various forces and torques.

    Syntax 1a: Q.GetPowerForce( P )
           1b: Q.GetPowerResultantForce( P )

    Syntax 2a: Q.GetPowerExternalForce()
           2b: Q.GetPowerResultantForce()

    Syntax 3a: B.GetPowerTorque( A )
           3b: B.GetPowerResultantTorque( A )

    Syntax 4a: B.GetPowerExternalTorque()
           4b: B.GetPowerResultantTorque()

    Syntax 5:  System.GetPower()

       Input:  Q, P -- names of a Point or Particle.
               B, A -- name of a RigidFrame or RigidBody.

    Output 1a: Power of Force_Q_P>    (Force_Q_P> is action/reaction on Q from P)
           1b  Power of Force_Q_P> and Force_P_Q>.

    Output 2a: Power of Force_Q>      (Force_Q> is the "external" force on Q).
           2b: Power of all forces on Q, i.e., power of external force
               Force_Q> and all action/reaction forces on Q.

    Output 3a: Power of Torque_B_A>   (Torque_B_A> is action/reaction on B from A).
           3b  Power of Torque_B_A> and Torque_A_B>.

    Output 4a: Power of Torque_B>     (Torque_B> is the "external" torque on B).
           4b: Power of all torques on B, i.e., power of external torque
               Torque_B> and all action/reaction torques on B.

    Output 5:  Power of all forces and torques in the system.

      Remark:  Power is calculated in the NewtonianFrame.  To calculate in a
               different reference frame, temporarily reassign NewtonianFrame.

     Related:  AddForce  AddForceDamper  AddForceElectrostatic  AddForceGravity
               AddForceInverseSquare  AddForceLinearActuator  AddForceSpring
               AddTorque  AddTorqueDamper
               GetMomentOfForces  GetResultantForce  GetResultantTorque
               GetForceGravityPotentialEnergy  GetForceSpringPotentialEnergy
               GetStatics   GetStaticsKane   GetStaticsLagrange   SetWorkODE
               GetDynamics  GetDynamicsKane  GetDynamicsLagrange  GetKineticEnergy

       (1) %----------------------------------------------------------------------
       (2) % Example 1: GetPowerForce  (for a force on point Bo from point Ao)
       (3) %----------------------------------------------------------------------
       (4) NewtonianFrame  N
       (5) RigidBody       A, B
       (6) Specified       FBA
       (7) Variable        vx, vy, ux, uy
       (8) Ao.SetVelocity( N,  vx*Nx> + vy*Ny> )
    -> (9) v_Ao_N> = vx*Nx> + vy*Ny>

       (10) Bo.SetVelocity( N,  ux*Nx> + uy*Ny> )
    -> (11) v_Bo_N> = ux*Nx> + uy*Ny>

       (12) Bo.AddForce( Ao,  FBA*Nx> )
    -> (13) Force_Bo_Ao> = FBA*Nx>

       (14) PowerOfForceOnBoFromAo = Bo.GetPowerForce( Ao )
    -> (15) PowerOfForceOnBoFromAo = FBA*(ux-vx)

       (16) %----------------------------------------------------------------------
       (17) % Example 2: GetPowerExternalForce   (for Force_Bo> )
       (18) %            GetPowerResultantForce  (for all forces on point Bo)
       (19) %----------------------------------------------------------------------
       (20) Specified       FBx, FBy
       (21) Bo.AddForce( FBx*Nx> + FBy*Ny> )     % "External" force on Bo.
    -> (22) Force_Bo> = FBx*Nx> + FBy*Ny>

       (23) PowerOfExternalForceOnBo = Bo.GetPowerExternalForce()
    -> (24) PowerOfExternalForceOnBo = FBx*ux + FBy*uy

       (25) PowerOfResultantForceOnBo = Bo.GetPowerResultantForce()
    -> (26) PowerOfResultantForceOnBo = FBy*uy + (FBA+FBx)*ux

       (27) %----------------------------------------------------------------------
       (28) % Example 3: GetPowerTorque  (for torque on body B from body A)
       (29) %----------------------------------------------------------------------
       (30) Specified       TBA
       (31) Variable        wA, wB
       (32) A.SetAngularVelocity( N, wA*Nz> )
    -> (33) w_A_N> = wA*Nz>

       (34) B.SetAngularVelocity( N, wB*Nz> )
    -> (35) w_B_N> = wB*Nz>

       (36) B.AddTorque( A,  TBA*Nz> )
    -> (37) Torque_B_A> = TBA*Nz>

       (38) PowerOfTorqueOnBFromA = B.GetPowerTorque( A )
    -> (39) PowerOfTorqueOnBFromA = -TBA*(wA-wB)

       (40) %----------------------------------------------------------------------
       (41) % Example 4: GetPowerExternalTorque   (for Torque_B> )
       (42) %            GetPowerResultantTorque  (for all torques on body B)
       (43) %----------------------------------------------------------------------
       (44) Specified       TBz
       (45) B.AddTorque( TBz*Nz> )     % "External" torque on B.
    -> (46) Torque_B> = TBz*Nz>

       (47) PowerOfExternalTorqueOnB = B.GetPowerExternalTorque()
    -> (48) PowerOfExternalTorqueOnB = TBz*wB

       (49) PowerOfResultantTorqueOnB = B.GetPowerResultantTorque()
    -> (50) PowerOfResultantTorqueOnB = (TBA+TBz)*wB

       (51) %----------------------------------------------------------------------
       (52) % Example 5: GetPower  (for all forces and torques on the system)
       (53) %----------------------------------------------------------------------
       (54) systemPower = System.GetPower()
    -> (55) systemPower = FBx*ux + FBy*uy + TBz*wB + FBA*(ux-vx) - TBA*(wA-wB)

#### GetProductOfInertia

    GetProductOfInertia

     Purpose:  Gets an object's product of inertia about a point for
               two orthogonal unit vectors.

      Syntax:  Object.GetProductOfInertia( aboutPoint, unitVectorA, unitVectorB )

       Input:  Object -- The name of a Particle, RigidBody, or System.
               aboutPoint -- The name of a point or Particle.
               unitVectorA -- Unit vector or expression for a unit vector.
               unitVectorB -- Unit vector or expression for a unit vector.

      Output:  Object's product of inertia about aboutPoint for
               the unit vectors unitVectorA and unitVectorB.

      Remark:  Products of inertia adhere to the "negative sign convention".
               Example: For a 1 kg particle whose position from a point P is
               2*Nx> + 3*Ny>, the product of inertia Ixy = -m*x*y = -6 kg*m^2.

     Related:  SetMass          GetMass         SetInertia   SetMassInertia
               GetCMPosition    GetCMVelocity   GetCMAcceleration
               GetInertiaDyadic  GetInertiaMatrix  GetMomentOfInertia
               GetProductOfInertia  GetRadiusOfGyration  GetInertiaVector

       (1) %--------------------------------------------------------------------
       (2) % Example 1: GetProductOfInertia  (product of inertia of a rigid body)
       (3) %--------------------------------------------------------------------
       (4) RigidBody  B
       (5) B.SetInertia( Bcm, Ixx, Iyy, Izz )
       (6) BProductOfInertiaAboutBcmForBxBy = B.GetProductOfInertia( Bcm, Bx>, By> )
    -> (7) BProductOfInertiaAboutBcmForBxBy = 0

       (8) %--------------------------------------------------------------------
       (9) % Example 2: GetProductOfInertia  (product of inertia in another basis)
       (10) %--------------------------------------------------------------------
       (11) RigidFrame A
       (12) Variable  theta
       (13) B.SetRotationMatrixZ( A, theta )
    -> (14) B_A = [cos(theta), sin(theta), 0;  -sin(theta), cos(theta), 0;  0, 0, 1]

       (15) BProductOfInertiaAboutBcmForAxAy = B.GetProductOfInertia( Bcm, Ax>, Ay> )
    -> (16) BProductOfInertiaAboutBcmForAxAy = (Ixx-Iyy)*sin(theta)*cos(theta)

       (17) %--------------------------------------------------------------------
       (18) % Example 3: GetProductOfInertia  (product of inertia of a particle)
       (19) %--------------------------------------------------------------------
       (20) Particle   Q
       (21) Q.SetMass( mQ )
       (22) Variable   x, y, z
       (23) Q.SetPosition( Bo, x*Bx> + y*By> + z*Bz> )
    -> (24) p_Bo_Q> = x*Bx> + y*By> + z*Bz>

       (25) QProductOfInertiaAboutBoForBxBy = Q.GetProductOfInertia( Bo, Bx>, By> )
    -> (26) QProductOfInertiaAboutBoForBxBy = -mQ*x*y

       (27) %--------------------------------------------------------------------
       (28) % Example 4: GetProductOfInertia  (product of inertia of a system)
       (29) %--------------------------------------------------------------------
       (30) B.SetMass( mB )
       (31) Bcm.SetPosition( Bo, 2*Bx> + 3*By> + 4*Bz> )
    -> (32) p_Bo_Bcm> = 2*Bx> + 3*By> + 4*Bz>

       (33) SProductOfInertiaAboutBoForBxBy = System.GetProductOfInertia( Bo, Bx>, By> )
    -> (34) SProductOfInertiaAboutBoForBxBy = -6*mB - mQ*x*y

       (35) SProductOfInertiaAboutBoForAxBy = System.GetProductOfInertia( Bo, Ax>, Ay> )
    -> (36) SProductOfInertiaAboutBoForAxBy = -6*mB - mQ*x*y - sin(theta)*(Iyy*cos(
            theta)+mQ*x^2*cos(theta)-12*mB*sin(theta)-5*mB*cos(theta)-Ixx*cos(theta)
            -2*mQ*x*y*sin(theta)-mQ*y^2*cos(theta))

#### GetRadiusOfGyration

    GetRadiusOfGyration

     Purpose:  Gets an object's radius of gyration about a line.

      Syntax:  Object.GetRadiusOfGyration( aboutPoint, unitVector )

       Input:  Object -- The name of a Particle, RigidBody, or System.
               aboutPoint -- The name of a point or Particle.
               unitVector -- Unit vector or expression for a unit vector.

      Output:  Object's radius of gyration for the line that passes
               through aboutPoint and that is parallel to unitVector.

     Related:  SetMass          GetMass         SetInertia   SetMassInertia
               GetCMPosition    GetCMVelocity   GetCMAcceleration
               GetInertiaDyadic  GetInertiaMatrix  GetMomentOfInertia
               GetProductOfInertia  GetRadiusOfGyration  GetInertiaVector

       (1) %--------------------------------------------------------------------
       (2) % Example 1: GetRadiusOfGyration  (radius of gyration of a rigid body)
       (3) %--------------------------------------------------------------------
       (4) RigidBody  B
       (5) B.SetMass( mB )
       (6) B.SetInertia( Bcm, Ixx, Iyy, Izz )
       (7) BRadiusOfGyrationAboutBcmForBx = B.GetRadiusOfGyration( Bcm, Bx> )
    -> (8) BRadiusOfGyrationAboutBcmForBx = sqrt(Ixx)/sqrt(mB)

       (9) %--------------------------------------------------------------------
       (10) % Example 2: GetRadiusOfGyration  (radius of gyration in another basis)
       (11) %--------------------------------------------------------------------
       (12) RigidFrame A
       (13) Variable  theta
       (14) B.SetRotationMatrixZ( A, theta )
    -> (15) B_A = [cos(theta), sin(theta), 0;  -sin(theta), cos(theta), 0;  0, 0, 1]

       (16) BRadiusOfGyrationAboutBcmForAx = B.GetRadiusOfGyration( Bcm, Ax> )
    -> (17) BRadiusOfGyrationAboutBcmForAx = sqrt(Ixx*cos(theta)^2+Iyy*sin(theta)^2)
            /sqrt(mB)

       (18) %--------------------------------------------------------------------
       (19) % Example 3: GetRadiusOfGyration  (radius of gyration of a particle)
       (20) %--------------------------------------------------------------------
       (21) Particle   Q
       (22) Q.SetMass( mQ )
       (23) Variable   x, y, z
       (24) Q.SetPosition( Bo, x*Bx> + y*By> + z*Bz> )
    -> (25) p_Bo_Q> = x*Bx> + y*By> + z*Bz>

       (26) QRadiusOfGyrationAboutBoForBx = Q.GetRadiusOfGyration( Bo, Bx> )
    -> (27) QRadiusOfGyrationAboutBoForBx = sqrt(y^2+z^2)

       (28) %--------------------------------------------------------------------
       (29) % Example 4: GetRadiusOfGyration  (radius of gyration of a system)
       (30) %--------------------------------------------------------------------
       (31) Bcm.SetPosition( Bo, 2*Bx> + 3*By> + 4*Bz> )
    -> (32) p_Bo_Bcm> = 2*Bx> + 3*By> + 4*Bz>

       (33) SRadiusOfGyrationAboutBoForBx = System.GetRadiusOfGyration( Bo, Bx> )
    -> (34) SRadiusOfGyrationAboutBoForBx = sqrt((Ixx+25*mB+mQ*(y^2+z^2))/(mB+mQ))

       (35) SRadiusOfGyrationAboutBoForAx = System.GetRadiusOfGyration( Bo, Ax> )
    -> (36) SRadiusOfGyrationAboutBoForAx = sqrt((Ixx+25*mB+mQ*(y^2+z^2)+sin(theta)
            *(Iyy*sin(theta)+12*mB*cos(theta)+mQ*x^2*sin(theta)+2*mQ*x*y*cos(theta)
            -5*mB*sin(theta)-Ixx*sin(theta)-mQ*y^2*sin(theta)))/(mB+mQ))

#### GetResultantForce

    GetResultantForce  GetNetForce  (synonymous)

     Purpose:  Returns the sum of forces applied to an object.

    Syntax 1:  Object.GetResultantForce()
    Syntax 2:  Q.GetResultantForce( P )

       Input:  Object -- a Point, Particle, RigidBody, RigidFrame, or System
               Q, P -- names of points (e.g., Point or Particle).

    Output 1:  Sum of all forces applied to Object.
    Output 2:  Sum of all forces applied to Q by P.

      Remark:  If Q is a point of a RigidFrame or RigidBody B, declare it as
               Point Q(B).  This helps with subsequent velocity/acceleration
               and force/moment calculations.

      Remark:  Force_Q>  denotes the inherently "external" forces on Q whereas
               Q.GetResultantForce() also accounts for all action/reaction
               forces applied to Q from all other points in the system.

               Force_Q_P>  denotes the action/reaction force on Q from P whereas
               Q.GetResultantForce(P)  returns  Force_Q_P> - Force_P_Q>.

      Remark:  Q.GetForce(P) is deprecated for Q.GetResultantForce(P).

      Remark:  The NewtonianFrame is not part of the "System" for the command
               System.GetResultantForce().  Type HELP SYSTEM for more information.

     Related:  AddForce  AddForceDamper  AddForceElectrostatic  AddForceGravity
               AddForceInverseSquare  AddForceLinearActuator  AddForceSpring
               AddTorque  AddTorqueDamper
               GetMomentOfForces  GetResultantForce  GetResultantTorque
               GetForceGravityPotentialEnergy  GetForceSpringPotentialEnergy
               GetStatics   GetStaticsKane   GetStaticsLagrange
               GetDynamics  GetDynamicsKane  GetDynamicsLagrange

       (1) %--------------------------------------------------------------------
       (2) % Example: GetResultantForce  or  GetNetForce (synonymns).
       (3) %--------------------------------------------------------------------
       (4) RigidBody  A, B
       (5) Point      Bp( B )                          % Bp is a point of body B.
       (6) Specified  Fx, Fy, FBA
       (7) Bp.AddForce( Fx*Ax> )                       % Add external force on Bp.
    -> (8) Force_Bp> = Fx*Ax>

       (9) Bp.AddForce( Ao,  FBA*Ax> )                 % Add action/reaction force on Bp from Ao.
    -> (10) Force_Bp_Ao> = FBA*Ax>

       (11) Ao.AddForce( Bp,  2*Ay> )                   % Add action/reaction force on Ao from Bp.
    -> (12) Force_Ao_Bp> = 2*Ay>

       (13) NetForceOnBpFromAo> = Bp.GetNetForce( Ao )  % Net action/reaction force on Bp from Ao.
    -> (14) NetForceOnBpFromAo> = FBA*Ax> - 2*Ay>

       (15) NetForceOnAoFromBp> = Ao.GetNetForce( Bp )  % Net action/reaction force on Ao from Bp.
    -> (16) NetForceOnAoFromBp> = -FBA*Ax> + 2*Ay>

       (17) NetForceOnBp> = Bp.GetResultantForce()      % Resultant (net) force on point Bp.
    -> (18) NetForceOnBp> = (FBA+Fx)*Ax> - 2*Ay>

       (19) NetForceOnB> = B.GetResultantForce()        % Resultant (net) force on body B.
    -> (20) NetForceOnB> = (FBA+Fx)*Ax> - 2*Ay>

       (21) NetForceOnA> = A.GetResultantForce()        % Resultant (net) force on body A.
    -> (22) NetForceOnA> = -FBA*Ax> + 2*Ay>

       (23) NetForceOnS> = System.GetResultantForce()   % Resultant (net) force on all objects.
    -> (24) NetForceOnS> = Fx*Ax>

#### GetResultantTorque

    GetResultantTorque  GetNetTorque  (synonymous)

     Purpose:  Returns the sum of torques applied to a rigid object.

    Syntax 1:  Object.GetResultantTorque()
    Syntax 2:  B.GetResultantTorque( A )

       Input:  Object -- a RigidBody, RigidFrame, or System
               B -- the name of a RigidBody or RigidFrame.
               A -- the name of a RigidBody or RigidFrame.

    Output 1:  Sum of all torques applied to Object.
    Output 2:  Sum of all torques applied to B by A.

      Remark:  Torque_B>  denotes the inherently "external" torque on B whereas
               B.GetResultantTorque() also accounts for all action/reaction
               torques applied to B from all other objects in the system.

               Torque_B_A>  denotes the torque on B from A whereas
               B.GetResultantTorque(A)  returns  Torque_B_A> - Torque_A_B>.

      Remark:  B.GetTorque(A) is deprecated for B.GetResultantTorque(A).

      Remark:  The NewtonianFrame is not part of the "System" for the command
               System.GetResultantTorque().  Type HELP SYSTEM for more information.

     Related:  AddForce  AddForceDamper  AddForceElectrostatic  AddForceGravity
               AddForceInverseSquare  AddForceLinearActuator  AddForceSpring
               AddTorque  AddTorqueDamper
               GetMomentOfForces  GetResultantForce  GetResultantTorque
               GetForceGravityPotentialEnergy  GetForceSpringPotentialEnergy
               GetStatics   GetStaticsKane   GetStaticsLagrange
               GetDynamics  GetDynamicsKane  GetDynamicsLagrange

       (1) %--------------------------------------------------------------------
       (2) % Example 1:  GetResultantTorque  or  GetNetTorque
       (3) %--------------------------------------------------------------------
       (4) RigidBody  A, B
       (5) Specified  Tx, TBAx, TBAy
       (6) B.AddTorque( Tx*Ax> )                     % Add external torque on B.
    -> (7) Torque_B> = Tx*Ax>

       (8) B.AddTorque( A,  TBAx*Ax> )               % Add action/reaction torque on B from A.
    -> (9) Torque_B_A> = TBAx*Ax>

       (10) NetTorqueOnBFromA> = B.GetNetTorque( A )  % Net action/reaction torque on B from A.
    -> (11) NetTorqueOnBFromA> = TBAx*Ax>

       (12) NetTorqueOnAFromB> = A.GetNetTorque( B )  % Net action/reaction torque on A from B.
    -> (13) NetTorqueOnAFromB> = -TBAx*Ax>

       (14) NetTorqueOnB> = B.GetResultantTorque()    % Resultant (net) torque on body B.
    -> (15) NetTorqueOnB> = (TBAx+Tx)*Ax>

       (16) NetTorqueOnA> = A.GetResultantTorque()    % Resultant (net) torque on body A.
    -> (17) NetTorqueOnA> = -TBAx*Ax>

       (18) NetTorqueOnS> = System.GetNetTorque()     % Resultant (net) torque on System(A, B).
    -> (19) NetTorqueOnS> = Tx*Ax>

       (20) %--------------------------------------------------------------------
       (21) % Example 2:  GetResultantTorque  or  GetNetTorque
       (22) %--------------------------------------------------------------------
       (23) B.AddTorque( A,  TBAy*Ay> )               % Add action/reaction torque on B from A.
    -> (24) Torque_B_A> = TBAx*Ax> + TBAy*Ay>

       (25) A.AddTorque( B,     9*Ay> )               % Add action/reaction torque on A from B.
    -> (26) Torque_A_B> = 9*Ay>

       (27) NetTorqueOnBFromA> := B.GetNetTorque( A ) % Net action/reaction torque on B from A.
    -> (28) NetTorqueOnBFromA> = TBAx*Ax> + (-9+TBAy)*Ay>

       (29) NetTorqueOnB> := B.GetResultantTorque()   % Resultant (net) torque on body B.
    -> (30) NetTorqueOnB> = (TBAx+Tx)*Ax> + (-9+TBAy)*Ay>

       (31) NetTorqueOnA> := A.GetResultantTorque()   % Resultant (net) torque on body A.
    -> (32) NetTorqueOnA> = -TBAx*Ax> + (9-TBAy)*Ay>

       (33) NetTorqueOnS> := System.GetNetTorque()    % Resultant (net) torque on System(A, B).
    -> (34) NetTorqueOnS> = Tx*Ax>

#### GetRhs

    GetRhs

     Purpose:  Returns the expression that is assigned to a name.
               For example, if  y = 3*sin(t),  GetRhs(y)  returns 3*sin(t).

    Syntax 1:  GetRhs( scalarName )
    Syntax 2:  GetRhs( mathExpression )

     Input 1:  scalarName -- the name of a scalar quantity (e.g., y).
     Input 2:  mathExpression -- a scalar, vector, dyadic, or matrix expression.

    Output 1:  The expression assigned to scalarName.  If scalarName does
               not have a right-hand-side, then scalarName is returned.
    Output 2:  The expression that results when each scalarName appearing in
               mathExpression is replaced with its assigned right-hand-side.

      Remark:  Use the Explicit command to produce an expression that is solely in
               terms of scalar quantities that do not have a right-hand-side
               (e.g., names appearing in Constant or Variable declarations).

      Remark:  The GetRhs command is usually unnecessary for names of
               matrices, vectors, or dyadics.  Usually, these names are
               automatically replaced with their right-hand-sides.

     Related:  Evaluate  Explicit  GetRhs  ReplaceString  SetAutoRhs

       (1) %--------------------------------------------------------------------
       (2) % Example:  GetRhs
       (3) %--------------------------------------------------------------------
       (4) a = sin(t)
    -> (5) a = sin(t)

       (6) b = cos(t)
    -> (7) b = cos(t)

       (8) c = a + b
    -> (9) c = a + b

       (10) r1 = GetRhs( a )
    -> (11) r1 = sin(t)

       (12) r2 = GetRhs( a + b )
    -> (13) r2 = sin(t) + cos(t)

       (14) r3 = GetRhs( a + b + c )
    -> (15) r3 = sin(t) + cos(t) + a + b

       (16) r4 = GetRhs( [a;  b;  c] )
    -> (17) r4 = [sin(t);  cos(t);  a + b]

#### GetRotationMatrix

    GetRotationMatrix

     Purpose:  Gets the rotation matrix relating two sets of bases vectors.

      Syntax:  B.GetRotationMatrix( N )

       Input:  B, N -- name of a RigidFrame or RigidBody.

      Output:  Rotation matrix B_N that relates Bx>, By>, Bz>  to  Nx>, Ny>, Nz>.

     Remark:   Each syntax of the command SetRotationMatrix() has
               a corresponding syntax for GetRotationMatrix().  Example:
               B.GetRotationMatrix( A, BodyXY, q1, q2 )   forms the same matrix as
               B.SetRotationMatrix( A, BodyXY, q1, q2 ).  Example:
               B.GetRotationMatrixZ( theta )   calculates  the same matrix as
               B.SetRotationMatrixZ( theta ).
               "Set" methods calculate and store rotation matrices whereas
               "Get" methods just calculate rotation matrices (no storage).

     Related:  GetAngularAcceleration  GetAngularVelocity  GetRotationMatrix
               SetAngularAcceleration  SetAngularVelocity  SetRotationMatrix
               GetRotationMatrixDyadic

       (1) %--------------------------------------------------------------------
       (2) % Example: GetRotationMatrix
       (3) %--------------------------------------------------------------------
       (4) RigidFrame N
       (5) RigidBody  A, B
       (6) Variable   qA, qB
       (7) A.SetRotationMatrixX( N, qA )
    -> (8) A_N = [1, 0, 0;  0, cos(qA), sin(qA);  0, -sin(qA), cos(qA)]

       (9) B.SetRotationMatrixY( A, qB )
    -> (10) B_A = [cos(qB), 0, -sin(qB);  0, 1, 0;  sin(qB), 0, cos(qB)]

       (11) B_N_RotationMatrix = B.GetRotationMatrix( N )
    -> (12) B_N_RotationMatrix[1,1] = cos(qB)
    -> (13) B_N_RotationMatrix[1,2] = sin(qA)*sin(qB)
    -> (14) B_N_RotationMatrix[1,3] = -sin(qB)*cos(qA)
    -> (15) B_N_RotationMatrix[2,1] = 0
    -> (16) B_N_RotationMatrix[2,2] = cos(qA)
    -> (17) B_N_RotationMatrix[2,3] = sin(qA)
    -> (18) B_N_RotationMatrix[3,1] = sin(qB)
    -> (19) B_N_RotationMatrix[3,2] = -sin(qA)*cos(qB)
    -> (20) B_N_RotationMatrix[3,3] = cos(qA)*cos(qB)

#### GetRotationMatrixDyadic

    GetRotationMatrixDyadic

     Purpose:  Gets the rotation matrix dyadic relating two sets of bases vectors.

      Syntax:  B.GetRotationMatrixDyadic( A )

       Input:  B, A -- name of a RigidFrame or RigidBody.

      Output:  Rotation dyadic B_A>> that relates Bx>, By>, Bz>  to  Ax>, Ay>, Az>.

     Related:  GetAngularAcceleration  GetAngularVelocity  GetRotationMatrix
               SetAngularAcceleration  SetAngularVelocity  SetRotationMatrix

       (1) %--------------------------------------------------------------------
       (2) % Example 1: GetRotationMatrixDyadic (form a rotation matrix dyadic)
       (3) %--------------------------------------------------------------------
       (4) RigidFrame A, B
       (5) Variable   q
       (6) B.SetRotationMatrixZ( A, q )
    -> (7) B_A = [cos(q), sin(q), 0;  -sin(q), cos(q), 0;  0, 0, 1]

       (8) B_A>> = B.GetRotationMatrixDyadic( A )
    -> (9) B_A>> = cos(q)*Bx>*Ax> + sin(q)*Bx>*Ay> - sin(q)*By>*Ax> + cos(q)*By>*Ay> + Bz>*Az>

       (10) A_B>> = A.GetRotationMatrixDyadic( B )
    -> (11) A_B>> = cos(q)*Ax>*Bx> - sin(q)*Ax>*By> + sin(q)*Ay>*Bx> + cos(q)*Ay>*By> + Az>*Bz>

       (12) %--------------------------------------------------------------------
       (13) % Example 2: Use A_B>> to express a vector in another frame.
       (14) %--------------------------------------------------------------------
       (15) Variable  x, y, z
       (16) vA> = x*Ax> + y*Ay> + z*Az>    % Vector v expressed in frame A.
    -> (17) vA> = x*Ax> + y*Ay> + z*Az>

       (18) vB> := Dot(   vA>,  A_B>> )    % Vector v expressed in frame B.
    -> (19) vB> = (x*cos(q)+y*sin(q))*Bx> + (y*cos(q)-x*sin(q))*By> + z*Bz>

       (20) vB> := Dot( B_A>>,   vA>  )    % Vector v expressed in frame B.
    -> (21) vB> = (x*cos(q)+y*sin(q))*Bx> + (y*cos(q)-x*sin(q))*By> + z*Bz>

       (22) vB> := Express( vA>,   B  )    % Vector v expressed in frame B.
    -> (23) vB> = (x*cos(q)+y*sin(q))*Bx> + (y*cos(q)-x*sin(q))*By> + z*Bz>

       (24) vA> := Dot(   vB>,  B_A>> )    % Vector v expressed in frame A.
    -> (25) vA> = x*Ax> + y*Ay> + z*Az>

       (26) vA> := Dot( A_B>>,   vB>  )    % Vector v expressed in frame A.
    -> (27) vA> = x*Ax> + y*Ay> + z*Az>

       (28) vA> := Express( vB>,  A   )    % Vector v expressed in frame A.
    -> (29) vA> = x*Ax> + y*Ay> + z*Az>

#### GetState

    GetState  and  GetDtState   (EXPERIMENTAL COMMAND, NOT RECOMMEND FOR USE).

     Purpose:  Creates an array of all names that are currently regarded as state.

    Syntax 1:  GetState()
    Syntax 2:  GetDtState()

    Output 1:  Creates an array of all names that are currently regarded as state.
               These names are usually named in a Variable or Specified declaration.
    Output 2:  The time-derivative of the matrix returned by State().

     Related:  Constant  ImaginaryNumber  Specified  Variable
               SetGeneralizedCoordinate  SetGeneralizedSpeed
               GetGeneralizedCoordinate  GetGeneralizedSpeed
               SetDt  SolveDt  SetAutoDifferentiate

       (1) %--------------------------------------------------------------------
       (2) % Example 1: GetState and GetDtState
       (3) %--------------------------------------------------------------------
       (4) Variable   x, x', x''
       (5) State = GetState()
    -> (6) State = [x;  x']

       (7) DtState = GetDtState()
    -> (8) DtState = [x';  x'']

       (9) %--------------------------------------------------------------------
       (10) % Example 2: GetState and GetDtState
       (11) %--------------------------------------------------------------------
       (12) Specified  y'
       (13) State := GetState()
    -> (14) State = [x;  x';  y]

       (15) DtState := GetDtState()
    -> (16) DtState = [x';  x'';  y']

#### GetSpeed

    GetSpeed  and  GetSpeedSquared

     Purpose:  Gets a point's speed in a reference frame.

    Syntax 1:  Q.GetSpeed( refFrame )
    Syntax 2:  Q.GetSpeedSquared( refFrame )

       Input:  Q -- name of a point.
               refFrame -- name of a RigidFrame or RigidBody.

    Output 1:  Magnitude of Q's velocity in refFrame.
    Output 2:  Square of the magnitude of Q's velocity in refFrame.

      Remark:  To set generalized speeds for Kane's method, use:
               SetGeneralizedSpeed

     Related:  GetMagnitude           GetMagnitudeSquared
               GetDistance            GetDistanceSquared
               GetSpeed               GetSpeedSquared
               GetAngularSpeed        GetAngularSpeedSquared
               GetAngleBetweenVectors GetAngleBetweenUnitVectors
               GetPosition            SetPosition       Translate
               GetVelocity            SetVelocity       SetPositionVelocity
               GetAcceleration        SetAcceleration   SetVelocityAcceleration
               GetUnitVector          GetElongation     Vector   Dot

       (1) %--------------------------------------------------------------------
       (2) % Example: GetSpeed  and  GetSpeedSquared
       (3) %--------------------------------------------------------------------
       (4) RigidFrame N
       (5) Point      Q
       (6) Variable   vx, vy
       (7) Q.SetVelocity( N, vx*Nx> + vy*Ny> )
    -> (8) v_Q_N> = vx*Nx> + vy*Ny>

       (9) speed = Q.GetSpeed( N )
    -> (10) speed = sqrt(vx^2+vy^2)

       (11) speedSquared = Q.GetSpeedSquared( N )
    -> (12) speedSquared = vx^2 + vy^2

#### GetStatics

    GetStatics    GetStaticsKane    GetStaticsLagrange

     Purpose:  Gets equations governing static equilibrium.

    Syntax 1:  Object.GetStatics()
    Syntax 2:  Object.GetStatics( aboutPoint )
    Syntax 3:  System.GetStaticsKane()
    Syntax 4:  System.GetStaticsLagrange()  IN DEVELOPMENT.  SEE SYNTAX.

       Input:  Object -- Point, Particle, RigidFrame, RigidBody, or System.
               aboutPoint -- The name of a point.

    Output 1:  Resultant of all forces on Object.
    Output 2:  Resultant of all moments on Object about aboutPoint.
    Output 3:  Kane's     equation for statics for the entire System.
    Output 4:  Lagrange's equation for statics for the entire System.

      Remark:  If Q is a point of a RigidFrame or RigidBody B, declare it as
               Point Q(B).  This helps with subsequent velocity/acceleration
               and force/moment calculations.

      Remark:  For Newton/Euler equations, type  Help Statics  or  Help Dynamics
               For Kane's       equations, type  Help Kane
               For Lagrange's   equations, type  Help Lagrange

     Related:  AddForce  AddForceDamper  AddForceElectrostatic  AddForceGravity
               AddForceInverseSquare  AddForceLinearActuator  AddForceSpring
               AddTorque  AddTorqueDamper
               GetMomentOfForces  GetResultantForce  GetResultantTorque
               GetForceGravityPotentialEnergy  GetForceSpringPotentialEnergy
               SetMass  SetPosition  SetRotationMatrix  Rotate
               NewtonianFrame  Point  Particle  RigidFrame  RigidBody
               GetStatics   GetStaticsKane   GetStaticsLagrange
               GetDynamics  GetDynamicsKane  GetDynamicsLagrange
               SetGeneralizedCoordinate  SetGeneralizedSpeed

       (1) %--------------------------------------------------------------------
       (2) % Example: GetStatics
       (3) %--------------------------------------------------------------------
       (4) NewtonianFrame N
       (5) RigidBody      B           % Rigid pendulum
       (6) Constant       g           % Local gravitational constant
       (7) Constant       L           % Length of pendulum
       (8) Variable       theta       % Pendulum angle
       (9) Variable       Tz          % Torque applied to B from N
       (10) Variable       Fx, Fy      % Support force on Bo from No
       (11) B.SetMass( m )
       (12) B.SetRotationMatrixZ( N, theta )
    -> (13) B_N = [cos(theta), sin(theta), 0;  -sin(theta), cos(theta), 0;  0, 0, 1]

       (14) Bcm.SetPosition( Bo, -L*By> )
    -> (15) p_Bo_Bcm> = -L*By>

       (16) Bo.AddForce( No, Fx*Nx> + Fy*Ny> )
    -> (17) Force_Bo_No> = Fx*Nx> + Fy*Ny>

       (18) Bcm.AddForce( -m*g*Ny> )
    -> (19) Force_Bcm> = -m*g*Ny>

       (20) B.AddTorque( Tz*Bz> )
    -> (21) Torque_B> = Tz*Bz>

       (22) % Resultant of all forces on B
       (23) BStaticForces> = B.GetStatics()
    -> (24) BStaticForces> = Fx*Nx> + (Fy-m*g)*Ny>

       (25) % Resultant of the moments of all forces on B about Bo
       (26) BStaticMoments> = B.GetStatics( Bo )
    -> (27) BStaticMoments> = Tz*Bz> - m*g*L*sin(theta)*Nz>

       (28) % Solve scalar equations for Fx, Fy, and Tz
       (29) BStatics[1] = Dot( BStaticForces>,  Nx> )
    -> (30) BStatics[1] = Fx

       (31) BStatics[2] = Dot( BStaticForces>,  Ny> )
    -> (32) BStatics[2] = Fy - m*g

       (33) BStatics[3] = Dot( BStaticMoments>, Nz> )
    -> (34) BStatics[3] = Tz - m*g*L*sin(theta)

       (35) Solve( BStatics, Fx, Fy, Tz )
    -> (36) Fx = 0
    -> (37) Fy = m*g
    -> (38) Tz = m*g*L*sin(theta)

#### SVD

    SVD        Experimental command, not recommended for use!

     Purpose:  Calculates the singular values (and possibly singular vectors)
               of a real matrix.

    Syntax 1:  SVD( M )
    Syntax 2:  SVD( M, nameU, nameV )

       Input:  M -- a matrix whose elements are real numbers.

               nameU -- the name to be assigned to the matrix whose columns
               are the singular vectors of M * Transpose(M).

               nameV -- the name to be assigned to the matrix whose columns
               are the singular vectors of Transpose(M) * M.

    Output 1:  Returns a column matrix Scol with M's singular values ordered
               from lowest to highest (subject to change).
    Output 2:  Returns the column matrix Scol and assigns M's singular vectors
               to the columns of nameU and the columns of nameV.

      Remark:  M = U * S * Transpose(V), where U and V are orthonormal matrices
               and S is a diagonal matrix with M's singular values on the diagonal.

     Related:  GetColumns     GetDeterminant  GetDiagonalMatrix  GetEigen
               GetElement []  GetInverse      GetIdentityMatrix  GetNorm  GetRows
               GetTrace       GetTranspose    GetZeroMatrix      Solve

       (1) %--------------------------------------------------------------------
       (2) % Example 1: SVD   (singularValues of a full-rank matrix)
       (3) %--------------------------------------------------------------------
       (4) A = [1, 2, 3;  4, 5, 6;  5, 3, 7]
    -> (5) A = [1, 2, 3;  4, 5, 6;  5, 3, 7]

       (6) SingularValuesOfA = SVD( A )
    -> (7) SingularValuesOfA = [0.7659489;  1.801498;  13.04484]

       (8) %--------------------------------------------------------------------
       (9) % Example 2: SVD   (singularValues of a singular matrix)
       (10) %--------------------------------------------------------------------
       (11) B = [1, 2, 3;  4, 5, 6;  2, 4, 6]
    -> (12) B = [1, 2, 3;  4, 5, 6;  2, 4, 6]

       (13) SingularValuesOfB = SVD( B )
    -> (14) SingularValuesOfB = [6.82857E-08;  1.363919;  12.04739]

       (15) %--------------------------------------------------------------------
       (16) % Example 3: SVD   (singularValues of a non-square matrix)
       (17) %--------------------------------------------------------------------
       (18) C = [1, 2, 3;  4, 5, 6]
    -> (19) C = [1, 2, 3;  4, 5, 6]

       (20) SingularValuesOfC = SVD( C )
    -> (21) SingularValuesOfC = [0.7728696;  9.508032]

       (22) %--------------------------------------------------------------------
       (23) % Example 4: SVD   (singularValues and singularVectors of a matrix)
       (24) %--------------------------------------------------------------------
       (25) D = [1, 2;  3, 4]
    -> (26) D = [1, 2;  3, 4]

       (27) SingularValuesOfD := SVD( D, SingularVectorU, SingularVectorV )
    -> (28) SingularVectorU = [-0.9145143, -0.4045536;  0.4045536, -0.9145143]
    -> (29) SingularVectorV = [-0.8174156, -0.5760484;  0.5760484, -0.8174156]
    -> (30) SingularValuesOfD = [0.3659662;  5.464986]

#### GetTaylorSeries

    GetTaylorSeries

     Purpose:  Expands functions in Taylor series.
               Use Linearize  for a Taylor series with the 0th and 1st terms.
               Use Linearize1 for a Taylor series with just the 1st term.

      Syntax:  GetTaylorSeries( F, Range, arg1, arg2, ... )

       Input:  F -- a  scalar, vector, dyadic, or matrix expression.

               Range -- n  or  n:m,  where n and m are positive
                        integers such that n < m.

               argi -- the scalar name Ci (e.g., a constant or variable) or
                       the equation Ci = D (D is a scalar expression); or
                       the equation Ci = D:P, where P is a scalar name.

      Output:  The following table describes output associated with F.

               Range|    argi    |              Output
               -----|------------|-----------------------------------
                 n  |  Ci        |  nth term of the Taylor series
                    |            |  expansion of F about Ci = 0.
                    |            |
                 n  |  Ci = D    |  nth term of the Taylor series
                    |            |  expansion of F about Ci = D.
                    |            |
                 n  |  Ci = D:P  |  nth term of the Taylor series
                    |            |  expansion of F about Ci = D,
                    |            |  with P in place of Ci - D.
                    |            |
                n:m |  Ci        |  nth  through  mth  terms of Taylor
                    |            |  expansion of F about Ci = 0.
                    |            |
                n:m |  Ci = D    |  nth  through  mth  terms of Taylor
                    |            |  expansion of F about Ci = D.
                    |            |
                n:m |  Ci = D:P  |  nth  through  mth  terms of Taylor
                    |            |  expansion of F about Ei = D,
                    |            |  with P in place of Ci - D.

      Remark:  Certain numerical inaccuracies in Taylor series expansions
               may make it advantageous to issue a command such as
               SetAutoEpsilon( 1.0E-13 ).

     Related:  GetTaylorSeries  Linearize  SetAutoLinearize  SetAutoTaylorSeries

       (1) %--------------------------------------------------------------------
       (2) % Example 1:  GetTaylorSeries   (one function with one variable)
       (3) %--------------------------------------------------------------------
       (4) Variable x, dx
       (5) TaylorCosAbout0 = GetTaylorSeries( cos(x), 0:4, x )
    -> (6) TaylorCosAbout0 = 1 + 0.04166667*x^4 - 0.5*x^2

       (7) TaylorCosAbout1 = GetTaylorSeries( cos(x), 0:3, x=1 )
    -> (8) TaylorCosAbout1 = 1.381773 + 0.1402452*(-1+x)^3 - 0.841471*x - 0.2701512
           *(-1+x)^2

       (9) TaylorCosAbout1Dx = GetTaylorSeries( cos(x), 0:3, x=1:dx )
    -> (10) TaylorCosAbout1Dx = 0.5403023 + 0.1402452*dx^3 - 0.841471*dx - 0.2701512
            *dx^2

       (11) %--------------------------------------------------------------------
       (12) % Example 2:  GetTaylorSeries   (one function with two variables)
       (13) %--------------------------------------------------------------------
       (14) Variable y, dy
       (15) TaylorExpXYAbout0 = GetTaylorSeries( exp(x+y), 0:1, x, y )
    -> (16) TaylorExpXYAbout0 = 1 + x + y

       (17) TaylorExpXYAbout2 = GetTaylorSeries( exp(x+y), 0:1, x=2, y=2 )
    -> (18) TaylorExpXYAbout2 = -163.7945 + 54.59815*x + 54.59815*y

       (19) TaylorExpXYAbout2Dxy = GetTaylorSeries( exp(x+y), 0:1, x=2:dx, y=2:dy )
    -> (20) TaylorExpXYAbout2Dxy = 54.59815 + 54.59815*dx + 54.59815*dy

       (21) %--------------------------------------------------------------------
       (22) % Example 3:  GetTaylorSeries   (matrix of functions with one variable)
       (23) %--------------------------------------------------------------------
       (24) matrix = [sin(x); cos(x); exp(x)]
    -> (25) matrix = [sin(x);  cos(x);  exp(x)]

       (26) matrixExpanded = GetTaylorSeries( matrix, 0:4, x=0 )
    -> (27) matrixExpanded[1] = -0.1666667*x*(-6+x^2)
    -> (28) matrixExpanded[2] = 1 + 0.04166667*x^4 - 0.5*x^2
    -> (29) matrixExpanded[3] = 1 + x + 0.04166667*x^4 + 0.1666667*x^3 + 0.5*x^2

       (30) %--------------------------------------------------------------------
       (31) % Example 4:  GetTaylorSeries   (vector function of two variable)
       (32) %--------------------------------------------------------------------
       (33) z = sin(x) + cos(y)
    -> (34) z = sin(x) + cos(y)

       (35) RigidFrame  N
       (36) vector> = sin(x)*Nx> + cos(y)*Ny> + z*Nz>
    -> (37) vector> = sin(x)*Nx> + cos(y)*Ny> + z*Nz>

       (38) vectorExpanded> = GetTaylorSeries( vector>, 0:1, x=1:dx, y=2:dy )
    -> (39) vectorExpanded> = (0.841471+0.5403023*dx)*Nx> + (-0.4161468-0.9092974*
            dy)*Ny> + (0.4253241+0.5403023*dx-0.9092974*dy)*Nz>

#### Linearize

    Linearize  Linearize0   Linearize1

     Purpose:  Returns the sum of the 0th and 1st term of a Taylor series
               or returns just the 0th or 1st terms of that Taylor series.

      Syntax:  Linearize(  F, arg1, arg2, ... )  --  0th and 1st terms.
               Linearize0( F, arg1, arg2, ... )  --  same as Evaluate.
               Linearize1( F, arg1, arg2, ... )  --  1st term of Taylor series.

       Input:  F -- a  scalar, vector, dyadic, or matrix expression.

               argi -- the scalar name Ci (e.g., a constant or variable) or
                       the equation Ci = D (D is a scalar expression); or
                       the equation Ci = D:P, where P is a scalar name.

      Output:  The following table describes output associated with F.

                   argi    |  Output is Taylor series expansion of F
               ------------|-----------------------------------
                 Ci        |  0th  and/or  1st  terms about Ci = 0.
                 Ci = D    |  0th  and/or  1st  terms about Ci = D.
                 Ci = D:P  |  0th  and/or  1st  terms about Ei = D,
                           |  with P in place of Ci - D.

      Remark:  Certain numerical inaccuracies in Taylor series expansions
               may make it advantageous to issue a command such as
               SetAutoEpsilon( 1.0E-13 ).

     Related:  GetDefaults  SetAutoZee
               GetTaylorSeries  Linearize  SetAutoLinearize  SetAutoTaylorSeries
               FactorLinear  FactorQuadratic

       (1) %--------------------------------------------------------------------
       (2) % Example 1:  Linearize   (one function with one variable)
       (3) %--------------------------------------------------------------------
       (4) Variable x, dx
       (5) linearizeCosAbout0 = Linearize( cos(x), x )
    -> (6) linearizeCosAbout0 = 1

       (7) linearizeCosAbout1 = Linearize( cos(x), x=1 )
    -> (8) linearizeCosAbout1 = 1.381773 - 0.841471*x

       (9) linearizeCosAbout1Dx = Linearize( cos(x), x=1:dx )
    -> (10) linearizeCosAbout1Dx = 0.5403023 - 0.841471*dx

       (11) %--------------------------------------------------------------------
       (12) % Example 2:  Linearize   (one function with two variables)
       (13) %--------------------------------------------------------------------
       (14) Variable y, dy
       (15) linearizeExpXYAbout0 = Linearize( exp(x+y), x, y )
    -> (16) linearizeExpXYAbout0 = 1 + x + y

       (17) linearizeExpXYAbout2 = Linearize( exp(x+y), x=2, y=2 )
    -> (18) linearizeExpXYAbout2 = -163.7945 + 54.59815*x + 54.59815*y

       (19) linearizeExpXYAbout2Dxy = Linearize( exp(x+y), x=2:dx, y=2:dy )
    -> (20) linearizeExpXYAbout2Dxy = 54.59815 + 54.59815*dx + 54.59815*dy

       (21) %--------------------------------------------------------------------
       (22) % Example 3:  Linearize   (matrix of functions with one variable)
       (23) %--------------------------------------------------------------------
       (24) matrix = [sin(x); cos(x); exp(x)]
    -> (25) matrix = [sin(x);  cos(x);  exp(x)]

       (26) linearizeMatrix  = Linearize(  matrix, x=0 )
    -> (27) linearizeMatrix = [x;  1;  1 + x]

       (28) linearizeMatrix0 = Linearize0( matrix, x=0 )
    -> (29) linearizeMatrix0 = [0;  1;  1]

       (30) linearizeMatrix1 = Linearize1( matrix, x=0 )
    -> (31) linearizeMatrix1 = [x;  0;  x]

       (32) %--------------------------------------------------------------------
       (33) % Example 4:  Linearize   (vector function of two variable)
       (34) %--------------------------------------------------------------------
       (35) z = sin(x) + cos(y)
    -> (36) z = sin(x) + cos(y)

       (37) RigidFrame  N
       (38) vector> = sin(x)*Nx> + cos(y)*Ny> + z*Nz>
    -> (39) vector> = sin(x)*Nx> + cos(y)*Ny> + z*Nz>

       (40) vectorExpanded> = Linearize( vector>, x=1:dx, y=2:dy )
    -> (41) vectorExpanded> = (0.841471+0.5403023*dx)*Nx> + (-0.4161468-0.9092974*
            dy)*Ny> + (0.4253241+0.5403023*dx-0.9092974*dy)*Nz>

#### GetNorm

    GetNorm

     Purpose:  Forms the 2-norm of a real one-dimensional (row or column) matrix.

      Syntax:  GetNorm( matrixExpression )

       Input:  matrixExpression -- row or column matrix.

      Output:  sqrt( matrixExpression * transpose(matrixExpression) )

      Remark:  Use  abs           for absolute value of a real or complex scalar.
               Use  GetMagnitude  for the magnitude of a vector.
               Use  GetNorm       for the 2-norm of a real row or column matrix.

     Related:  GetColumns     GetDeterminant  GetDiagonalMatrix  GetEigen
               GetElement []  GetInverse      GetIdentityMatrix  GetNorm  GetRows
               GetTrace       GetTranspose    GetZeroMatrix      Solve
               abs            GetMagnitude    GetMagnitudeSquared

       (1) %--------------------------------------------------------------------
       (2) % Example 1: GetNorm and GetNormSquared (row matrix)
       (3) %--------------------------------------------------------------------
       (4) A = [1, 2, -2]
    -> (5) A = [1, 2, -2]

       (6) Anorm = GetNorm( A )
    -> (7) Anorm = 3

       (8) AnormSquared = GetNormSquared( A )
    -> (9) AnormSquared = 9

       (10) %--------------------------------------------------------------------
       (11) % Example 2: GetNorm and GetNormSquared (column matrix)
       (12) %--------------------------------------------------------------------
       (13) B = [5;  12]
    -> (14) B = [5;  12]

       (15) Bnorm = GetNorm( B )
    -> (16) Bnorm = 13

       (17) BnormSquared = GetNormSquared( B )
    -> (18) BnormSquared = 169

       (19) %--------------------------------------------------------------------
       (20) % Example 3: GetNorm and GetNormSquared  (symbolic column matrix)
       (21) %--------------------------------------------------------------------
       (22) C = [sin(t);  cos(t);  3;  4;  exp(t)]
    -> (23) C = [sin(t);  cos(t);  3;  4;  exp(t)]

       (24) Cnorm = GetNorm( C )
    -> (25) Cnorm = sqrt(26+exp(2*t))

       (26) CnormSquared = GetNormSquared( C )
    -> (27) CnormSquared = 26 + exp(2*t)

#### GetTrace

    GetTrace

     Purpose:  Forms the trace of a matrix or dyadic.

      Syntax:  GetTrace( A )

       Input:  A -- a matrix or a dyadic.

      Output:  Trace of A.

     Related:  GetColumns     GetDeterminant  GetDiagonalMatrix  GetEigen
               GetElement []  GetInverse      GetIdentityMatrix  GetNorm  GetRows
               GetTrace       GetTranspose    GetZeroMatrix      Solve

       (1) %--------------------------------------------------------------------
       (2) % Example 1: GetTrace   ( trace of a matrix )
       (3) %--------------------------------------------------------------------
       (4) Constant a{1:3,1:3}
       (5) M = [a11, a12, a13; a21, a22, a23]
    -> (6) M = [a11, a12, a13;  a21, a22, a23]

       (7) traceOfMatrixM = GetTrace( M )
    -> (8) traceOfMatrixM = a11 + a22

       (9) %--------------------------------------------------------------------
       (10) % Example 2: GetTrace   ( trace of a dyadic )
       (11) %--------------------------------------------------------------------
       (12) RigidBody B
       (13) D>> = Dyadic( B,  a11, a12, 0,  0, 0, 0,  0, a23, a33  )
    -> (14) D>> = a11*Bx>*Bx> + a12*Bx>*By> + a23*Bz>*By> + a33*Bz>*Bz>

       (15) traceOfDyadicD = GetTrace( D>> )
    -> (16) traceOfDyadicD = a11 + a33

#### GetTranspose

    GetTranspose

     Purpose:  Forms the transpose of a matrix or dyadic.

      Syntax:  GetTranspose( A )

       Input:  A -- a matrix or a dyadic.

      Output:  Trace of A.

     Related:  GetColumns     GetDeterminant  GetDiagonalMatrix  GetEigen
               GetElement []  GetInverse      GetIdentityMatrix  GetNorm  GetRows
               GetTrace       GetTranspose    GetZeroMatrix      Solve

       (1) %--------------------------------------------------------------------
       (2) % Example 1: GetTranspose  ( transpose of a matrix )
       (3) %--------------------------------------------------------------------
       (4) Constant a, b
       (5) M = [a, b;  3, 4;  5, 6]
    -> (6) M = [a, b;  3, 4;  5, 6]

       (7) transposeM = GetTranspose( M )
    -> (8) transposeM = [a, 3, 5;  b, 4, 6]

       (9) %--------------------------------------------------------------------
       (10) % Example 2: GetTranspose  ( transpose of a dyadic )
       (11) %--------------------------------------------------------------------
       (12) RigidBody B
       (13) D>> = Dyadic( B,  a, a*b, 3,  4, b^2, 5,  6, 7, 8 )
    -> (14) D>> = a*Bx>*Bx> + a*b*Bx>*By> + 3*Bx>*Bz> + 4*By>*Bx> + b^2*By>*By>
            + 5*By>*Bz> + 6*Bz>*Bx> + 7*Bz>*By> + 8*Bz>*Bz>

       (15) tranposeD>> = GetTranspose( D>> )
    -> (16) tranposeD>> = a*Bx>*Bx> + 4*Bx>*By> + 6*Bx>*Bz> + a*b*By>*Bx> + b^2*By>*By>
            + 7*By>*Bz> + 3*Bz>*Bx> + 5*Bz>*By> + 8*Bz>*Bz>

#### GetUnitVector

    GetUnitVector

     Purpose:  Forms a unit vector in the same direction as a given vector.

    Syntax 1:  GetUnitVector( v> )
    Syntax 2:  GetUnitVector( v>, denominator )
    Syntax 3:  Q.GetUnitVector( fromPoint )
    Syntax 4:  Q.GetUnitVector( fromPoint, denominator )

       Input:  v> -- a vector
               Q -- The name of a point.
               fromPoint -- The name of another point.
               denominator -- A non-negative scalar expression equal to the
                              magnitude of v> -- or equal to the magnitude
                              of v> plus a small "epsilon", where epsilon's
                              purpose is to avoid divide-by-zero errors.

    Output 1:  v> divided by the magnitude of v>
    Output 2:  v> divided by denominator
    Output 3:  Unit vector directed to Q from fromPoint
    Output 4:  Q's position vector fromPoint divided by denominator

     Remark:   denominator is useful when a symbol already exists for the
               magnitude of v> - or when an "epsilon" is useful for avoiding
               divide-by-zero errors that otherwise may result when the
               magnitude of v> is zero.

     Related:  GetMagnitude           GetMagnitudeSquared
               GetDistance            GetDistanceSquared
               GetSpeed               GetSpeedSquared
               GetAngularSpeed        GetAngularSpeedSquared
               GetAngleBetweenVectors GetAngleBetweenUnitVectors   ConvertUnits
               GetUnitVector          Vector   Cross  Dot   Rotate

       (1) %--------------------------------------------------------------------
       (2) %Example 1: GetUnitVector   (Unit vector from vector)
       (3) %--------------------------------------------------------------------
       (4) RigidFrame N
       (5) v> = 3*Nx> + 4*Ny>
    -> (6) v> = 3*Nx> + 4*Ny>

       (7) unitVector> = GetUnitVector( v> )
    -> (8) unitVector> = 0.6*Nx> + 0.8*Ny>

       (9) %--------------------------------------------------------------------
       (10) %Example 2: GetUnitVector   (Unit vector from vector with denominator)
       (11) %--------------------------------------------------------------------
       (12) Constant  epsilon
       (13) unitVectorWithEpsilon> = GetUnitVector( t*Nx>, epsilon+t )
    -> (14) unitVectorWithEpsilon> = t/(epsilon+t)*Nx>

       (15) %--------------------------------------------------------------------
       (16) %Example 3: GetUnitVector   (Unit vector between points)
       (17) %--------------------------------------------------------------------
       (18) Point     P, Q
       (19) Variable  zQ
       (20) Q.SetPosition( P,  zQ*Nz> )
    -> (21) p_P_Q> = zQ*Nz>

       (22) UnitPositionVectorFromPToQ> = Q.GetUnitVector( P )
    -> (23) UnitPositionVectorFromPToQ> = zQ/abs(zQ)*Nz>

       (24) %--------------------------------------------------------------------
       (25) %Example 4: GetUnitVector   (Unit vector between points with denominator)
       (26) %--------------------------------------------------------------------
       (27) Variable  xP, yP
       (28) P.SetPosition( No, xP*Nx> + yP*Ny> )
    -> (29) p_No_P> = xP*Nx> + yP*Ny>

       (30) L = Q.GetDistance( No )
    -> (31) L = sqrt(xP^2+yP^2+zQ^2)

       (32) UnitPositionVectorFromNoToQ> = Q.GetUnitVector( No, L )
    -> (33) UnitPositionVectorFromNoToQ> = xP/L*Nx> + yP/L*Ny> + zQ/L*Nz>

#### GetUnitSystem

    GetUnitSystem

     Purpose:  Displays the dimensions of a quantity.
               Displays the names of all units recognized by the program.

    Syntax 1:  GetUnitSystem( unitExpression )
    Syntax 2:  GetUnitSystem()

       Input:  unitExpression -- an expression involving names of units and their
                                 products (*), quotients (/), and powers (^).

    Output 1:  The dimension of unitExpression.  For example, if unitExpression
               is  Newton*meter,  the response is  mass*length^2/time^2.

    Output 2:  Names of all units recognized by the program.

     Related:  ODE  Solve  Input  Output  OutputPlot  Plot  Animate
               ConvertUnits  GetUnitSystem  SetUnitSystem
               GetMassUnit   GetLengthUnit   GetTimeUnit   GetAngleUnit

    --------------------------------------------------------------------
     Example:  GetUnitSystem
    --------------------------------------------------------------------
       (1) GetUnitSystem( Newton * meter^2 )
    mass*length^3/time^2

#### GetVelocity

    GetVelocity  or  GetRelativeVelocity

     Purpose:  Gets a point's velocity in a reference frame or gets a point's
               velocity relative to another point in a reference frame.

    Syntax 1:  Q.GetVelocity( refFrame )
    Syntax 2:  Q.GetVelocityRelative( P, refFrame )
               Q.GetRelativeVelocity( P, refFrame )

       Input:  Q, P -- names of points (e.g., Point or Particle).
               refFrame -- name of a RigidFrame or RigidBody.

    Output 1:  Returns Q's velocity in refFrame.
    Output 2:  Returns Q's velocity relative to P in refFrame, defined as
               Q.GetVelocity(refFrame) - P.GetVelocity(refFrame) or as
               Dt( Q.GetPosition(P), refFrame ).

     Related:  Translate        SetPositionVelocity        SetVelocityAcceleration
               SetPosition      GetPosition   GetDistance  GetElongation
               SetVelocity      GetVelocity   GetSpeed     GetRelativeVelocity
               SetAcceleration  GetAcceleration            GetRelativeAcceleration

       (1) %--------------------------------------------------------------------
       (2) % Example: GetVelocity
       (3) %--------------------------------------------------------------------
       (4) RigidFrame  N
       (5) RigidBody   B
       (6) Variable    vx, vy, wz
       (7) Bo.SetVelocity( N,  vx*Nx> + vy*Ny> )
    -> (8) v_Bo_N> = vx*Nx> + vy*Ny>

       (9) BoVelocityInN> = Bo.GetVelocity( N )
    -> (10) BoVelocityInN> = vx*Nx> + vy*Ny>

       (11) %--------------------------------------------------------------------
       (12) % Example: GetRelativeVelocity  (also called GetVelocityRelative)
       (13) %--------------------------------------------------------------------
       (14) Point       P
       (15) Variable    x', y'
       (16) P.SetVelocity( N,  x'*Nx> + y'*Ny> )
    -> (17) v_P_N> = x'*Nx> + y'*Ny>

       (18) vQRelativeToBo> = P.GetRelativeVelocity( Bo, N )
    -> (19) vQRelativeToBo> = (x'-vx)*Nx> + (y'-vy)*Ny>

       (20) %--------------------------------------------------------------------
       (21) % Example: GetRelativeVelocity  (via differentiation).
       (22) %--------------------------------------------------------------------
       (23) Point       S
       (24) S.SetPosition( P,  t^2*Nx> + t^3*Ny> )
    -> (25) p_P_S> = t^2*Nx> + t^3*Ny>

       (26) vSRelativeToP> = S.GetRelativeVelocity( P, N )
    -> (27) vSRelativeToP> = 2*t*Nx> + 3*t^2*Ny>

       (28) %--------------------------------------------------------------------
       (29) % Example: GetVelocity (via two points fixed on RigidBody B).
       (30) %--------------------------------------------------------------------
       (31) Point       Q( B )
       (32) B.SetAngularVelocity( N, wz*Bz> )
    -> (33) w_B_N> = wz*Bz>

       (34) Q.SetPosition( Bo,  x*Bx> + y*By> )
    -> (35) p_Bo_Q> = x*Bx> + y*By>

       (36) QVelocityInN> = Q.GetVelocity( N )
    -> (37) QVelocityInN> = -wz*y*Bx> + wz*x*By> + vx*Nx> + vy*Ny>

#### GetVelocityRemainder

    GetVelocityRemainder  GetAngularVelocityRemainder

     Purpose:  Forms velocity and angular velocity remainder.

    Syntax 1:  Q.GetVelocityRemainder( refFrame )
    Syntax 2:  B.GetAngularVelocityRemainder( refFrame )
    Syntax 3:  GetVelocityRemainder( mathExpression )

       Input:  Q -- name of a Point or Particle.
               B -- name of a RigidFrame or RigidBody.
               refFrame -- name of a RigidFrame or  RigidBody.
               mathExpression -- A scalar, vector, matrix, ... expression.

    Output 1:  Portion of Q's velocity in refFrame that does NOT
               multiply an independent generalized speed.

    Output 2:  Portion of B's angular velocity in in refFrame that does NOT
               multiply an independent generalized speed.

    Output 3:  Portion of mathExpression that does NOT
               multiply an independent generalized speed.

      Remark:  If using the old/deprecated command  SetDefaults( AUTOLEV ),
               the returned quantity may depend on whether the command is
               issued before or after the CONSTRAIN command.

     Related:  GetPartialVelocity    GetPartialAngularVelocity
               GetVelocityRemainder  GetAngularVelocityRemainder
               Exclude

       (1) %--------------------------------------------------------------------
       (2) % Example: GetVelocityRemainder and GetAngularVelocityRemainder
       (3) %--------------------------------------------------------------------
       (4) NewtonianFrame N
       (5) RigidBody      B       % Sphere
       (6) Point          BN(B)   % Point of B in contact with N
       (7) %----------------------------------------------
       (8) Constant    R
       (9) Variable    x', y'
       (10) Variable    wz
       (11) Specified   wx,  wy
       (12) SetGeneralizedSpeed( x', y', wz )
       (13) %----------------------------------------------
       (14) %     Kinematics
       (15) B.SetAngularVelocity( N,  wx*Nx> + wy*Ny> + wz*Nz> )
    -> (16) w_B_N> = wx*Nx> + wy*Ny> + wz*Nz>

       (17) Bcm.SetPositionVelocity( No, x*Nx> + y*Ny> + R*Nz> )
    -> (18) p_No_Bcm> = x*Nx> + y*Ny> + R*Nz>
    -> (19) v_Bcm_N> = x'*Nx> + y'*Ny>

       (20) %----------------------------------------------
       (21) %     Angular velocity and velocity remainders
       (22) wBNRemainder> = B.GetAngularVelocityRemainder( N )
    -> (23) wBNRemainder> = wx*Nx> + wy*Ny>

       (24) vBcmNRemainder> = Bcm.GetVelocityRemainder( N )
    -> (25) vBcmNRemainder> = 0>

#### if

    if  else  elseif  (used for control flow in scripts, also see IsPositive, etc.)

     Purpose:  Controls whether or not certain lines are executed in a script
               depending on whether a logical expression evaluates to true.
               If true, statements contained within braces are executed.
               Otherwise, the statements are skipped.
               Note: if statements only work in a script -- not when entering
               commands interactively at the MotionGenesis line prompt.

    Syntax 1:  if( LogicalExpression )  { Statements }

    Syntax 2:  if( LogicalExpression )  { StatementsA }
               else                     { StatementsB }

    Syntax 3:  if(     LogicalExpressionA )  { StatementsA }
               elseif( LogicalExpressionB )  { StatementsB }

    Syntax 4:  if(     LogicalExpressionA )  { StatementsA }
               elseif( LogicalExpressionB )  { StatementsB }
               elseif( LogicalExpressionC )  { StatementsC }
               else                          { StatementsD }

       Input:  LogicalExpression -- an expression that evaluates to true or false
               and which involves at least one of the comparative operators which
               are evaluates using logic in the command IsSimplifyZero.

               ==   equal to
               !=   not equal to
               <=   less than or equal to
               <    less than
               >=   greater than or equal to  -- must be preceded by a blank space.
               >    greater than              -- must be preceded by a blank space.

               &&   Logical AND separates logical expressions.
               ||   Logical OR  separates logical expressions.

      Braces:  The left and right braces should appear on the same line or
               use the "Allman brace style" which means the
               opening brace { is on a line by itself and the
               closing brace } is on a line by itself, e.g., as
               if( a==2 && b==3 )
               {
                 Fred = 12 * 4
                 Jill = 20 * 3
               }

      Remark:  See: IsNegative,  IsNegativeOr0,  IsPositiveOr0,  IsPositive
               To implement   if t < 0,  Fx = sin(t),  else Fx = cos(t),  use:
               Fx = IsNegative(t) * sin(t)  +  IsPositiveOr0(t) * cos(t)

      Remark:  Alternatively, use MATLAB, C, or Fortran to control code flow.
               For example, the following shows how to make x = 0 when t >= pi.

               Specified sintOrZero = sin(t)
               Variable y' = sintOrZero               % Valid when t <= pi.
               Input   tFinal = 4,  y = 0             % Arbitrary input values.
               Output  t, y,  y'
               %% if( t > pi ) sintOrZero = 0;  end
               ODE()  simulateWithIfStatement.m       % Create MATLAB program.

               Edit simulateWithIfStatement.m and verify it contains the line
               %% if( t > pi ) sintOrZero = 0;  end
               Un-comment and move this line so the MATLAB code has

               sintOrZero = sin(t);
               if( t > pi ) sintOrZero = 0;  end

     Related:  !  %  &  Clear  Save  Run  Quit  if  else  elseif  ceil  floor  sign
               IsNegative  IsNegativeOr0  IsPositiveOr0  IsPositive
               IsSimplifyEqual  IsSimplifyZero  IsSimplifyTrue

    --------------------------------------------------------------------
    Example 1a: if                   % Results in x = 18.
    --------------------------------------------------------------------
     if( 5 != 4 )  { x = 6*3 }

    --------------------------------------------------------------------
    Example 1b: if                   % Results in x = 18   and  y = 24.
    --------------------------------------------------------------------
     if( (5 >= 6  ||  2*pi >= 6)  &&  8 < 9 )  { x = 6*3;  y=6*4 }

    --------------------------------------------------------------------
    Example 2: if  else              % Results in x = 3   and  y = 4.
    --------------------------------------------------------------------
     if( 5 >= 6 )  { x = 6*3;  y=6*4 }
     else          { x = 3;    y=4  }

    --------------------------------------------------------------------
    Example 3: if  elseif            % Results in x = 17.
    --------------------------------------------------------------------
     if( 5 >= 6  )           { x = 6*3;  y=6*4 }
     elseif( sqrt(5) > 2 )   { x = 17 }

    --------------------------------------------------------------------
    Example 4: if  elseif  else      % Results in x = 18  and  y = 24.
    --------------------------------------------------------------------
     if( 5 >= 6  )           { x = 6*3;  y=6*4 }
     elseif( sqrt(5) >  9 )  { x = 17 }
     elseif( sqrt(4) == 2 )  { x = 16 }
     else
     {
        x = 6 * 3
        y = 6 * 4
     }
    --------------------------------------------------------------------
    Example 5:  if t < 0,  Fx = sin(t),  else Fx = cos(t)
    --------------------------------------------------------------------
     Fx = IsNegative(t) * sin(t)  +  IsPositiveOr0(t) * cos(t)

    --------------------------------------------------------------------
    Example 6:  if 5 < t < 9,  Fy = exp(t),  else Fy = 0
    --------------------------------------------------------------------
     isTimeGreaterThan5 = IsPositive( t - 5 )
     isTimeLessThan9    = IsNegative( t - 9 )
     isTimeBetween5And9 = isTimeGreaterThan5 * isTimeLessThan9
     Fy = isTimeBetween5And9 * exp(t)

#### ImaginaryNumber

    ImaginaryNumber

     Purpose:  Declares the name assigned to the square root of -1.
               Returns  the name assigned to the square root of -1.

    Syntax 1:  SetImaginaryNumber( i )
    Syntax 2:  GetImaginaryNumber()

       Input:  i -- the name to be assigned to sqrt(-1).

    Output 2:  Name assigned to sqrt(-1).

      Remark:  The default name of the square root of -1 is imaginary.

     Related:  Constant  ImaginaryNumber  Specified  Variable
               MathFunctions  SetComplex

       (1) %--------------------------------------------------------------------
       (2) % Example: ImaginaryNumber
       (3) %--------------------------------------------------------------------
       (4) B = 3 + sqrt(-1)         % Default name of sqrt(-1) is imaginary
    -> (5) B = 3 + imaginary

       (6) SetImaginaryNumber( i )
       (7) C = 3 + sqrt(-1)
    -> (8) C = 3 + i

       (9) D = 4*sqrt(-1) + 3*GetImaginaryNumber()
    -> (10) D = 7*i

       (11) E = abs(3+i) + sin(i) + cosh(i)
    -> (12) E = 3.70258 + 1.175201*i

#### IndependentVariable

    IndependentVariable

     Purpose:  Declares the name assigned to the independent variable.
               Returns  the name assigned to the independent variable.

    Syntax 1:  SetIndependentVariable( t )
    Syntax 2:  GetIndependentVariable()

       Input:  t --  the name to be assigned as the independent variable.

    Output 2:  Name assigned to the independent variable.

      Remark:  The default name of the independent variable is t.

      Remark:  The prime symbol ' denotes implicit ordinary differentiation
               with respect to the independent variable.  For example, when
               the independent variable t denotes time, x' denotes dx/dt,
               the ordinary time-derivative of x.

     Related:  Constant  ImaginaryNumber  Specified  Variable
               SetGeneralizedCoordinate  SetGeneralizedSpeed

       (1) %--------------------------------------------------------------------
       (2) % Example 1:  IndependentVariable
       (3) %--------------------------------------------------------------------
       (4) Variable  y''
       (5) a = GetIndependentVariable() + y + dt(y)
    -> (6) a = t + y + y'

       (7) SetIndependentVariable( s )
       (8) b = GetIndependentVariable()^2
    -> (9) b = s^2

#### Input

    Input

     Purpose:  Assigns/reports numerical values (with optional units) to constants,
               initial values, and numerical integration parameters for use by the
               ODE, Solve, EvaluateAtInput, and EvaluateToNumber commands.

    Syntax 1:  Input a = v1 unitsA,  b = v2 unitsB,  c = v3,  d = v4 noUnits
    Syntax 2:  Input
    Syntax 3:  Input( a )                or  Input( a + 2*b + 3*c )
    Syntax 4:  InputNoConversion( a )    or  InputNoConversion( a + 2*b + 3*c )
    Syntax 5:  InputWithConversion( a )  or  InputWithConversion( a + 2*b + 3*c )
    Syntax 6:  ClearInput( a, b, c )

               a, b, c, d     -- names of scalars or a matrix of names of scalars.
               v1, v2, v3, v4 -- expressions that resolve to a real number.
               unitsA, unitsB -- units associated with a and b.

    Output 1:  Assigns input values (possibly with units) to  a, b, c, d.
    Output 2:  Lists quantities (values and units) assigned in Input statements.
    Output 3:  Returns the input value of  a   (no units conversion).
    Output 4:  Returns the input value of  a   (no units conversion).
               Same as Input( a, NoUnitSystem ).
    Output 5:  Returns the input value of  a   multiplied by the conversion factor
               from a's units to the current units in SetUnitSystem.
               Same as Input( a, GetUnitSystem ).
    Output 6:  Clears the input values and units assigned to  a, b, c.

      Remark:  Input values and units can also be assigned by declarations in:
               Constant, SetMass, SetInertia, and SetMassInertia

      Remark:  Input values can also be assigned to:  absError,  relError,
               tInitial,  tFinal,  tStep,  printIntScreen,  printIntFile.

      Remark:  Type GetUnitSystem for a list of units

     Related:  ODE  Solve  Input  Output  OutputPlot  Plot  Animate
               ConvertUnits  GetUnitSystem  SetUnitSystem  SetDigits
               t  tInitial  tFinal  tStep  absError  printIntScreen  printIntFile
               Solve  SolveDt  SolveSetInput  SolveSetInputDt  ...

       (1) %--------------------------------------------------------------------
       (2) % Example 1: Setting Input.
       (3) %--------------------------------------------------------------------
       (4) SetUnitSystem( kg, m, s )
       (5) Constant  a = 2 m,  b = 3 cm/s,  c
       (6) Variable  y'' = a*y + b*y' + c*sin(y)
    -> (7) y'' = a*y + c*sin(y) + b*y'

       (8) Input     y = 4 m,  y' = 0,  c = 5 + Input(a) meters
       (9) %
       (10) %--------------------------------------------------------------------
       (11) % Example 2: Getting input for scalars.
       (12) %--------------------------------------------------------------------
       (13) ac = Input( a + c )
    -> (14) ac = 9

       (15) b1 = InputNoConversion( b )
    -> (16) b1 = 3

       (17) b2 = InputWithConversion( b )
    -> (18) b2 = 0.03

       (19) %
       (20) %--------------------------------------------------------------------
       (21) % Example 3: Getting input for matrices.
       (22) %--------------------------------------------------------------------
       (23) mat = [a, c, y, y']
    -> (24) mat = [a, c, y, y']

       (25) mInput1 = Input( mat )
    -> (26) mInput1 = [2, 7, 4, 0]

       (27) mInput2 = InputWithConversion( [a; b; c] )
    -> (28) mInput2 = [2;  0.03;  7]

       (29) %
       (30) %--------------------------------------------------------------------
       (31) % Example 3: Type INPUT to display current input values, e.g.:
       (32) %--------------------------------------------------------------------
       (33) %  INPUT has been assigned as follows:
       (34) %   a                         2                       m
       (35) %   b                         3                       cm/s
       (36) %   c                         7                       meters
       (37) %   y                         4                       m
       (38) %   y'                        0
       (39) %--------------------------------------------------------------------
       (40) % Example 4: ClearInput
       (41) %--------------------------------------------------------------------
       (42) ClearInput( a, b, y' )

#### int

    int

     Purpose:  Returns the integer portion of a real scalar expression.

      Syntax:  int( realScalarExpression )

       Input:  realScalarExpression -- a real scalar expression.

      Output:  Integer portion of realScalarExpression.

     Related:  ceil  floor  int  max  min  round  RoundDigits  sign  MathFunctions

       (1) %--------------------------------------------------------------------
       (2) % Example: int
       (3) %--------------------------------------------------------------------
       (4) A = int( 2.991 )
    -> (5) A = 2

       (6) B = int( 3.001 )
    -> (7) B = 3

       (8) C = int( -2.991 )
    -> (9) C = -2

       (10) D = int( -3.001 )
    -> (11) D = -3

       (12) E = int( 2.9 + t )
    -> (13) E = int(2.9+t)

#### Integrate

    Integrate

     Purpose:  Integrates a scalar function or matrix of scalar functions.

      Syntax:  Integrate( scalarOrMatrixExpression,  x = xi : xf )

       Input:  scalarOrMatrixExpression -- a scalar or matrix of scalar
                                           expressions that depend on x.
               x  -- a scalar symbol
               xi -- the integral's lower limit for x
               xf -- the integral's upper limit for x

      Output:  Integral of (scalarOfMatrixExpression * dx) from x=xi to x=xf,
               where dx is the differential of x.

      Remark:  Integrate returns a number or matrix of numbers.
               Integrate may be nested to create double and triple integrals.

      Remark:  Do not use Integrate with time-integrals (x=t) which involve
               implicit-derivatives of time (e.g., the integrand or limits
               involve y and y' exists (or vice-versa).
               Good:     Integrate( t^2,  t=0:3 )
               Bad:      Variable x' = 3;  Input x = 0;  Integrate( x, t=0:3)

      Remark:  Integrate returns a numerical approximation to the integral.
               The accuracy of the solution tends to improve as the input
               value assigned to absError and/or relError gets smaller.
               The default value of absError (e.g., absError = 1.0E-7)
               can be changed via the Input command, e.g.,
               Input  absError = 1.0E-7

     Related:  D  Dt  DtDt  Integrate  MathFunctions  absError  relError

       (1) %--------------------------------------------------------------------
       (2) % Example 1:  Integrate( scalarExpression,  x=xi:xf )
       (3) %--------------------------------------------------------------------
       (4) Input absError = 1.0E-9
       (5) Variable  x
       (6) integral1 = Integrate( 2*x,  x=0:3 )
    -> (7) integral1 = 9

       (8) %--------------------------------------------------------------------
       (9) % Example 2:  Integrate( matrixExpression,  x=xi:xf )
       (10) %--------------------------------------------------------------------
       (11) matrix = [x^2;  3*sqrt(cos(x))*exp(2*x)]
    -> (12) matrix = [x^2;  3*sqrt(cos(x))*exp(2*x)]

       (13) integral2 = Integrate( matrix,  x = -pi/2 : pi/2 )
    -> (14) integral2 = [2.583856;  20.08743]

       (15) %--------------------------------------------------------------------
       (16) % Example 3:  Integrate( Integrate( ... ) )
       (17) %--------------------------------------------------------------------
       (18) Variable  y
       (19) areaRectangle = Integrate( Integrate( 1, x=0:3 ),  y=0:7 )
    -> (20) areaRectangle = 21

       (21) %--------------------------------------------------------------------
       (22) % Example 4:  Integrate( Integrate( ... ) )
       (23) %--------------------------------------------------------------------
       (24) Variable  r, theta
       (25) areaCircle = Integrate( Integrate( r, r=0:1 ),  theta=0:2*pi )
    -> (26) areaCircle = pi

       (27) %--------------------------------------------------------------------
       (28) % Example 5:  Integrate( Integrate( ... ) )
       (29) %--------------------------------------------------------------------
       (30) %  Equation of ellipse: x^2/a^2 + y^2/b^2 = 1             or
       (31) %  r^2*[cos(theta)^2/a^2 + sin(theta)^2/b^2] = 1          or
       (32) %  r^2*[cos(theta)^2*b^2 + sin(theta)^2*a^2] = a^2*b^2    or
       (33) %  r^2 = a^2*b^2 / [b^2*cos(theta)^2 + a^2*sin(theta)^2]
       (34) Constant a = 1 m, b = 2 m
       (35) rLimit = sqrt(a^2*b^2 / (b^2*cos(theta)^2 + a^2*sin(theta)^2) )
    -> (36) rLimit = abs(a*b)/sqrt(a^2*sin(theta)^2+b^2*cos(theta)^2)

       (37) areaEllipse = Integrate( Integrate( r, r=0:rLimit),  theta=0:2*pi )
    -> (38) areaEllipse = 6.283185

       (39) %--------------------------------------------------------------------
       (40) % Example 6:  Integrate( Integrate( ... ) )
       (41) %--------------------------------------------------------------------
       (42) integral6 = Integrate( exp(y) * Integrate( cos(x),  x=1:3 ),  y=0:2 )
    -> (43) integral6 = -4.474582

       (44) %--------------------------------------------------------------------
       (45) % Example 7:  Integrate( Integrate( ... ) )
       (46) %--------------------------------------------------------------------
       (47) integral7 = Integrate( Integrate( x*y,  x=0:y ),  y=2:0 )
    -> (48) integral7 = -2

       (49) integral8 = Integrate( Integrate( cos(x*y)*exp(y),  x=0:y ),  y=0:2 )
    -> (50) integral8 = 2.291264

#### Interface

    Interface with the Operating System:
     Issue a system command:             !
     Clear the workspace:                CLEAR
     Print a message on the screen:      ECHO
     List or change defaults:            GetDefaults
     Display the amount of memory used:  GetMemory
     Learn about the help system:        HELP
     List the input and responses:       LIST
     Pause the program:                  Pause
     Run/load a specific input file:     RUN
     Quit/exit the program:              QUIT
     Save input and responses:           SAVE

#### IsPositive

    IsNegative  IsNegativeOr0  IsPositiveOr0  IsPositive    (subject to change).

     Purpose:  Return a value that depends on the sign of a real scalar expression.

    Syntax 1:  IsNegative( x )       % Returns  true  if x <  0,  otherwise  false.
    Syntax 2:  IsNegativeOr0( x )    % Returns  true  if x <= 0,  otherwise  false.
               IsNonPositive( x )
    Syntax 3:  IsPositiveOr0( x )    % Returns  true  if x >- 0,  otherwise  false.
               IsNonNegative( x )
    Syntax 4:  IsPositive( x )       % Returns  true  if x >  0,  otherwise  false.

       Input:  x -- a real scalar expression.

      Remark:  The derivative of these functions can be assumed to be 0.

      Remark:  To implement  if t < 0, Fx = sin(t),  else Fx = cos(t), use:
               Fx = IsNegative(t) * sin(t)  +  IsPositiveOr0(t) * cos(t)

      Remark:  IsPositive can be used to implement a logical OR whereas the
               multiplication operator * can mimic a logical AND.
               IsPositive( false + false )   returns false
               IsPositive( false + true  )   returns true
               IsPositive( true  + false )   returns true
               IsPositive( true  + true  )   returns true
                           false * false     returns false
                           false * true      returns false
                           true  * false     returns false
                           true  * true      returns true

     Related:  ceil  floor  int  max  min  round  sign  MathFunctions
               IsNegative  IsNegativeOr0  IsPositiveOr0  IsPositive

       (1) %--------------------------------------------------------------------
       (2) % Example 1: IsPositive  and  IsPositiveOr0
       (3) %--------------------------------------------------------------------
       (4) a = IsPositive( 2.3 )
    -> (5) a = true

       (6) b = IsPositive( 0 )
    -> (7) b = false

       (8) c = IsPositiveOr0( 0 )
    -> (9) c = true

       (10) d = IsPositive(  2.3 ) + IsPositiveOr0(  2.3 ) + IsPositive(5+t)
    -> (11) d = 2 + IsPositive(5+t)

       (12) e = IsPositive( -2.3 ) + IsPositiveOr0( -2.3 ) + IsPositive(5+t)
    -> (13) e = IsPositive(5+t)

       (14) %--------------------------------------------------------------------
       (15) % Example 2: IsNegative  and  IsNegativeOr0
       (16) %--------------------------------------------------------------------
       (17) f = IsNegative( 2.3 )
    -> (18) f = false

       (19) g = IsNegative( 0 )
    -> (20) g = false

       (21) h = IsNegativeOr0( 0 )
    -> (22) h = true

       (23) i = IsNegative(  2.3 ) + IsNegativeOr0(  2.3 ) + IsNegative(5+t)
    -> (24) i = IsNegative(5+t)

       (25) j = IsNegative( -2.3 ) + IsNegativeOr0( -2.3 ) + IsNegative(5+t)
    -> (26) j = 2 + IsNegative(5+t)

       (27) %--------------------------------------------------------------------
       (28) % Example 3:  if t < 0,  Fx = sin(t),  else Fx = cos(t)
       (29) %--------------------------------------------------------------------
       (30) Fx = IsNegative(t) * sin(t)  +  IsPositiveOr0(t) * cos(t)
    -> (31) Fx = IsNegative(t)*sin(t) + IsPositiveOr0(t)*cos(t)

       (32) %--------------------------------------------------------------------
       (33) % Example 4:  if t <= 5,  Fy = sin(t),  else Fy = cos(t)
       (34) %--------------------------------------------------------------------
       (35) isTLessThanOrEqualTo5 = IsNegativeOr0(-5 + t)
    -> (36) isTLessThanOrEqualTo5 = IsNegativeOr0(-5+t)

       (37) isTGreaterThan5 = IsPositive(-5 + t)
    -> (38) isTGreaterThan5 = IsPositive(-5+t)

       (39) Fy = isTLessThanOrEqualTo5 * sin(t)  +  isTGreaterThan5 * cos(t)
    -> (40) Fy = sin(t)*isTLessThanOrEqualTo5 + cos(t)*isTGreaterThan5

       (41) %--------------------------------------------------------------------
       (42) % Example 5:  IsPositive used to implement a logical OR
       (43) %--------------------------------------------------------------------
       (44) orA = IsPositive( false + false )
    -> (45) orA = false

       (46) orB = IsPositive( false + true  )
    -> (47) orB = true

       (48) orC = IsPositive( true  + false )
    -> (49) orC = true

       (50) orD = IsPositive( true  + true  )
    -> (51) orD = true

       (52) %--------------------------------------------------------------------
       (53) % Example 6:  IsPositive used as "if" statement for calculations.
       (54) %--------------------------------------------------------------------
       (55) isTLessThanPi = isPositive(pi-t)      % true   if t < pi, otherwise 0 (false).
    -> (56) isTLessThanPi = IsPositive(pi-t)

       (57) sintOrZero = sin(t) * isTLessThanPi   % sin(t) if t < pi, otherwise 0 (false).
    -> (58) sintOrZero = sin(t)*isTLessThanPi

       (59) Variable y' = sintOrZero
    -> (60) y' = sintOrZero

       (61) Input  tFinal = 4,  y = 0             % Arbitrary input values.
       (62) Output  t,  y,  y'
       (63) ODE()  simulateWithIfStatement

#### IsContainSymbol

    IsContainSymbol   (semi-experimental command)

     Purpose:  Checks whether an expression contains a certain symbol.

      Syntax:  IsContainSymbol( expression, X )

       Input:  expression -- an expression or matrix of expressions.
               X -- the name of a scalar, unit vector, zero vector, zero dyadic,
               or unit dyadic or  or matrix of these -- e.g., a Variable.

       Output: True or false (or a matrix of true/false) depending on whether
               expression contains X.

     Related:  D  Dt  DtDt  Integrate  GetPartials  GetJacobian  MathFunctions

       (1) %--------------------------------------------------------------------
       (2) % Example 1:  IsContainSymbol( scalarExpression, name )
       (3) %--------------------------------------------------------------------
       (4) Variable x, y
       (5) s = 3*x + y^2
    -> (6) s = 3*x + y^2

       (7) sContainXYT = IsContainSymbol( s,  [x, y, t] )
    -> (8) sContainXYT = [true, true, false]

       (9) y = exp(t)
    -> (10) y = exp(t)

       (11) sContainXYT := IsContainSymbol( s,  [x, y, t] )
    -> (12) sContainXYT = [true, true, true]

       (13) %--------------------------------------------------------------------
       (14) % Example 2:  IsContainSymbol( matrixExpression, name )
       (15) %--------------------------------------------------------------------
       (16) matrix = [1, 2*t;  3*x, 4*y^2]
    -> (17) matrix = [1, 2*t;  3*x, 4*y^2]

       (18) mContainX = IsContainSymbol( matrix,  x )
    -> (19) mContainX = [false, false;  true, false]

       (20) mContainT = IsContainSymbol( matrix,  t )
    -> (21) mContainT = [false, true;  false, true]

       (22) %--------------------------------------------------------------------
       (23) % Example 3:  IsContainSymbol( vectorExpression, name )
       (24) %--------------------------------------------------------------------
       (25) RigidFrame A
       (26) v> = x*Ax> + y^2*Ay>
    -> (27) v> = x*Ax> + y^2*Ay>

       (28) vContains = IsContainSymbol( v>,   [x, y, t, Ax>, Ay>, Az>] )
    -> (29) vContains = [true, true, true, true, true, false]

       (30) d>> = 1>> + x*Ay>*Az>
    -> (31) d>> = 1>> + x*Ay>*Az>

       (32) dContains = IsContainSymbol( d>>,  [x, y, t, Ax>, Ay>, Az>, 0>, 1>>] )
    -> (33) dContains = [true, false, false, false, true, true, false, true]

#### IsSimplifyZero

    IsSimplifyZero     (semi-experimental command)

     Purpose:  Determines whether a mathematical expression simplifies to zero
               (or within a numerical tolerance of zero).

    Syntax 1:  IsSimplifyZero( expression )
    Syntax 2:  IsSimplifyZero( expression,  absEpsilon )
    Syntax 3:  IsSimplifyZero( expression,  absEpsilon, relEpsilon )

       Input:  expression -- a scalar, vector, tensor, or matrix expression.
               absEpsilon -- a real number r with   0  <=  r  < 0.5
               relEpsilon -- a real number r with   0  <=  r  < 0.5

    Output 1:  true if expression simplifies to zero, otherwise false.
    Output 2:  true if expression simplifies to zero after calling
               Epsilon( expression,  absEpsilon ).
    Output 3:  true if expression simplifies to zero after calling
               Epsilon( expression,  absEpsilon, relEpsilon ).

      Remark:  Output is false if current simplification algorithms cannot simplify
               to zero (future simplification algorithms may change result).
               If output seems to improperly resolve to false, try:
               IsSimplifyZero( Expand(expression, 0:2) ).
      Remark:  To debug IsSimplifyZero, view the output produced by:
                        Expand(expression, 0:2)   and/or
               Epsilon( Expand(expression, 0:2),  absEpsilon, relEpsilon ).
      Remark:  The Epsilon command describes absEpsilon and relEpsilon.

     Related:  IsSimplifyEqual  IsSimplifyZero  IsSimplifyTrue  Strcmp  Strcmpi
               IsNegative  IsNegativeOr0  IsPositiveOr0  IsPositive
               Epsilon  RoundDigits  Expand  Explicit

       (1) %--------------------------------------------------------------------
       (2) % Example 1:  IsSimplifyZero( scalarExpression )
       (3) %--------------------------------------------------------------------
       (4) isZeroA = IsSimplifyZero( 2 - 2 )
    -> (5) isZeroA = true

       (6) isZeroB = IsSimplifyZero( 2 + 2 )
    -> (7) isZeroB = false

       (8) isZeroC = IsSimplifyZero( 0.001,  0.002 )
    -> (9) isZeroC = true

       (10) isZeroD = IsSimplifyZero( 0.003,  0.002 )
    -> (11) isZeroD = false

       (12) isZeroE = IsSimplifyZero( sin(1.01*t) - sin(t),     0.02 )
    -> (13) isZeroE = true

       (14) isZeroF = IsSimplifyZero( sin(1.03*t) - sin(t),     0.02 )
    -> (15) isZeroF = false

       (16) isZeroG = IsSimplifyZero( sin(10.1*t) - sin(10*t),  0, 0.02 )
    -> (17) isZeroG = true

       (18) isZeroH = IsSimplifyZero( sin(10.3*t) - sin(10*t),  0, 0.02 )
    -> (19) isZeroH = false

       (20) isZeroI = IsSimplifyZero( t^7.33 - t^7.34,  0.02 )
    -> (21) isZeroI = true

       (22) isZeroJ = IsSimplifyZero( t^7.33 - t^7.36,  0.02 )
    -> (23) isZeroJ = false

       (24) isZeroK = IsSimplifyZero( t^10.1 - t^10,    0, 0.02 )
    -> (25) isZeroK = true

       (26) isZeroL = IsSimplifyZero( t^10.3 - t^10,    0, 0.02 )
    -> (27) isZeroL = false

       (28) isZeroM = IsSimplifyZero( t^10.3 - t^10.4,   0, 0.02 )
    -> (29) isZeroM = false

       (30) isZeroN = IsSimplifyZero( t^10.3 - t^10.4,   0.02, 0 )
    -> (31) isZeroN = false

       (32) %--------------------------------------------------------------------
       (33) % Example 2:  IsSimplifyZero( vectorExpression )
       (34) %--------------------------------------------------------------------
       (35) RigidBody  B
       (36) isZeroO = IsSimplifyZero( Bx> - Bx> )
    -> (37) isZeroO = true

       (38) isZeroP = IsSimplifyZero( Bx> - By> )
    -> (39) isZeroP = false

       (40) isZeroQ = IsSimplifyZero( Bx> - 1.01*Bx>,  0.02 )
    -> (41) isZeroQ = true

       (42) isZeroR = IsSimplifyZero( Bx> - 0.03*Bx>,  0.02 )
    -> (43) isZeroR = false

       (44) %--------------------------------------------------------------------
       (45) % Example 3:  IsSimplifyZero( matrixExpression )
       (46) %--------------------------------------------------------------------
       (47) isZeroS = IsSimplifyZero( [ 2-2,  Bx> - Bx>;  Bx>*By> - Bx>*By>,  0] )
    -> (48) isZeroS = true

#### IsSimplifyTrue

    IsSimplifyTrue     (semi-experimental command)

     Purpose:  Determines whether a mathematical expression simplifies to true
               (or within a numerical tolerance of zero).

    Syntax 1:  IsSimplifyTrue( expression )
    Syntax 2:  IsSimplifyTrue( expression,  absEpsilon )
    Syntax 3:  IsSimplifyTrue( expression,  absEpsilon, relEpsilon )

       Input:  expression -- a scalar, vector, tensor, or matrix expression.
               absEpsilon -- a real number r with   0  <=  r  < 0.5
               relEpsilon -- a real number r with   0  <=  r  < 0.5

    Output 1:  true if expression simplifies to true, otherwise false.
    Output 2:  true if expression simplifies to true after calling
               Epsilon( expression,  absEpsilon ).
    Output 3:  true if expression simplifies to zero after calling
               Epsilon( expression,  absEpsilon, relEpsilon ).

      Remark:  Output is false if current simplification algorithms cannot simplify
               to true (future simplification algorithms may change result).
      Remark:  The Epsilon command describes absEpsilon and relEpsilon.

     Related:  IsSimplifyEqual  IsSimplifyZero  IsSimplifyTrue  Strcmp  Strcmpi
               IsNegative  IsNegativeOr0  IsPositiveOr0  IsPositive
               Epsilon  RoundDigits  Expand  Explicit

       (1) %--------------------------------------------------------------------
       (2) % Example 1:  IsSimplifyTrue( scalarExpression )
       (3) %--------------------------------------------------------------------
       (4) trueOrFalse = IsSimplifyEqual( sin(t)/cos(t), tan(t) )
    -> (5) trueOrFalse = true

       (6) isTrueA = IsSimplifyTrue( trueOrFalse )
    -> (7) isTrueA = true

       (8) %--------------------------------------------------------------------
       (9) % Example 2:  IsSimplifyZero( matrixExpression )
       (10) %--------------------------------------------------------------------
       (11) trueFalse[1] = IsSimplifyEqual( 9, 9 )
    -> (12) trueFalse[1] = true

       (13) trueFalse[2] = IsSimplifyEqual( 1, sin(t)^2 + cos(t)^2 )
    -> (14) trueFalse[2] = true

       (15) trueFalse[3] = IsSimplifyEqual( t^3/t, t^2 )
    -> (16) trueFalse[3] = true

       (17) isTrueB = IsSimplifyTrue( trueFalse )
    -> (18) isTrueB = true

#### IsSimplifyEqual

    IsSimplifyEqual    (semi-experimental command)

     Purpose:  Determines whether two expressions simplify to the same result
               (or are within a numerical tolerance of the same result).

    Syntax 1:  IsSimplifyEqual( mathA, mathB )
    Syntax 2:  IsSimplfiyEqual( mathA, mathB,  absEpsilon )
    Syntax 3:  IsSimplifyEqual( mathA, mathB,  absEpsilon, relEpsilon )

       Input:  mathA -- a scalar, vector, tensor, or matrix expression.
               mathB -- a scalar, vector, tensor, or matrix expression.
               absEpsilon -- a real number r with   0  <=  r  < 0.5
               relEpsilon -- a real number r with   0  <=  r  < 0.5

    Output 1:  true if mathA == mathB  (with current simplification algorithms).
    Output 2:  true if mathA == mathB  with given absEpsilon and relEpsilon = 0.
    Output 3:  true if mathA == mathB  with given absEpsilon and relEpsilon.

      Remark:  IsSimplifyEqual( x, y ) is similar to IsSimplifyZero( x - y ).
               Read the help for IsSimplifyZero for useful debugging tips.

     Related:  IsSimplifyEqual  IsSimplifyZero  IsSimplifyTrue  Strcmp  Strcmpi
               IsNegative  IsNegativeOr0  IsPositiveOr0  IsPositive
               Epsilon  RoundDigits  Expand  Explicit

       (1) %--------------------------------------------------------------------
       (2) % Example 1:  IsSimplifyEqual( scalarA, scalarB )
       (3) %--------------------------------------------------------------------
       (4) isEqualA = IsSimplifyEqual( 5,  5 )
    -> (5) isEqualA = true

       (6) isEqualB = IsSimplifyEqual( 5, -5 )
    -> (7) isEqualB = false

       (8) isEqualC = IsSimplifyEqual( 5, 5.01,  0.02 )
    -> (9) isEqualC = true

       (10) isEqualD = IsSimplifyEqual( 5, 5.03,  0.02 )
    -> (11) isEqualD = false

       (12) isEqualE = IsSimplifyEqual( sin(1.01*t), sin(t),     0.02 )
    -> (13) isEqualE = true

       (14) isEqualF = IsSimplifyEqual( sin(1.03*t), sin(t),     0.02 )
    -> (15) isEqualF = false

       (16) isEqualG = IsSimplifyEqual( sin(10.1*t), sin(10*t),  0, 0.02 )
    -> (17) isEqualG = true

       (18) isEqualH = IsSimplifyEqual( sin(10.3*t), sin(10*t),  0, 0.02 )
    -> (19) isEqualH = false

       (20) isEqualI = IsSimplifyEqual( t^7.33,  t^7.34,  0.02 )
    -> (21) isEqualI = true

       (22) isEqualJ = IsSimplifyEqual( t^7.33,  t^7.36,  0.02 )
    -> (23) isEqualJ = false

       (24) isEqualK = IsSimplifyEqual( t^10.1,  t^10,    0, 0.02 )
    -> (25) isEqualK = true

       (26) isEqualL = IsSimplifyEqual( t^10.3,  t^10,    0, 0.02 )
    -> (27) isEqualL = false

       (28) isEqualM = IsSimplifyEqual( t^10.3,  t^10.4,  0, 0.02 )
    -> (29) isEqualM = false

       (30) isEqualN = IsSimplifyEqual( t^10.3,  t^10.4,  0.02, 0 )
    -> (31) isEqualN = false

       (32) %--------------------------------------------------------------------
       (33) % Example 2:  IsSimplifyEqual( vectorA, vectorB )
       (34) %--------------------------------------------------------------------
       (35) RigidBody  B
       (36) isEqualO = IsSimplifyEqual( Bx>,  Bx> )
    -> (37) isEqualO = true

       (38) isEqualP = IsSimplifyEqual( Bx>,  By> )
    -> (39) isEqualP = false

       (40) isEqualQ = IsSimplifyEqual( Bx>,  8   )
    -> (41) isEqualQ = false

       (42) isEqualR = IsSimplifyEqual( Bx>,  By>*Bz> )
    -> (43) isEqualR = false

       (44) isEqualS = IsSimplifyEqual( Bx>,  1.01*Bx>,  0.02 )
    -> (45) isEqualS = true

       (46) isEqualT = IsSimplifyEqual( Bx>,  0.03*Bx>,  0.02 )
    -> (47) isEqualT = false

       (48) %--------------------------------------------------------------------
       (49) % Example 3:  IsSimplifyEqual( matrixA, matrixB )
       (50) %--------------------------------------------------------------------
       (51) isEqualU = IsSimplifyEqual( [2, Bx>,  Bx>*By>],  [2, Bx>, Bx>*By>] )
    -> (52) isEqualU = true

#### Strcmp

    Strcmp  Strcmpi

     Purpose:  Compares two strings and returns:
               -1  if stringA  <  stringB
                0  if stringA  =  stringB  (strings are regarded as equal)
                1  if stringA  >  stringB

    Syntax 1:  Strcmp(  stringA, stringB )
    Syntax 2:  Strcmpi( stringA, stringB )

       Input:  stringA -- a string which may be enclosed within quotes.
               stringB -- a string which may be enclosed within quotes.

    Output 1:  -1, 0, or 1 from case sensitive comparison of stringA and stringB.
    Output 2:  -1, 0, or 1 from case insensitive comparison of stringA and stringB.

      Remark:  Strcmp  is a case   sensitive string comparison.
               Strcmpi is a case insensitive string comparison.
               A string within quotes differs from a string without quotes.
               For example, "abc" is not the same as abc.

     Related:  IsSimplifyEqual  IsSimplifyZero  IsSimplifyTrue  Strcmp  Strcmpi
               IsNegative  IsNegativeOr0  IsPositiveOr0  IsPositive
               Epsilon  RoundDigits  Expand  Explicit

       (1) %--------------------------------------------------------------------
       (2) % Example 1:  Strcmp
       (3) %--------------------------------------------------------------------
       (4) intA = Strcmp( "abc", "abc" )    % Identical.
    -> (5) intA = 0

       (6) intB = Strcmp( "abc", "def" )    % Different letters.
    -> (7) intB = -1

       (8) intC = Strcmp( "abc", "ABC" )    % Different (lower/upper) case.
    -> (9) intC = 1

       (10) intD = Strcmp( "abc", "abc ")    % Extra space at end.
    -> (11) intD = 1

       (12) intE = Strcmp( "abc",  abc  )    % Missing quotes "".
    -> (13) intE = -1

       (14) %--------------------------------------------------------------------
       (15) % Example 2:  Strcmpi
       (16) %--------------------------------------------------------------------
       (17) intF = Strcmpi( "abc", "abc" )   % Identical.
    -> (18) intF = 0

       (19) intG = Strcmpi( "abc", "def" )   % Different letters.
    -> (20) intG = -1

       (21) intH = Strcmpi( "abc", "ABC" )   % Different (lower/upper) case.
    -> (22) intH = 0

       (23) intI = Strcmpi( "abc", "abc ")   % Extra space at end.
    -> (24) intI = 1

       (25) intJ = Strcmpi( "abc",  abc  )   % Missing quotes "".
    -> (26) intJ = -1

       (27) %--------------------------------------------------------------------

#### Kane

    GetStaticsKane  GetDynamicsKane

     Purpose:  Gets Kane's equations for statics or dynamics .

    Syntax 1:  System.GetStaticsKane()
    Syntax 2:  System.GetDynamicsKane()

    Output 1:  Kane's statics  equations for the System.
    Output 2:  Kane's dynamics equations for the System.

      Remark:  For Newton/Euler equations, type  Help Statics or Help Dynamics
               For Kane's       equations, type  Help Kane
               For Lagrange's   equations, type  Help Lagrange

     Related:  AddForce  AddTorque  SetMass  SetInertia  Rotate  Translate
               NewtonianFrame  Point  Particle  RigidFrame  RigidBody
               GetStatics   GetStaticsKane   GetStaticsLagrange
               GetDynamics  GetDynamicsKane  GetDynamicsLagrange
               Constrain  SetGeneralizedCoordinate  SetGeneralizedSpeed

#### Lagrange

    GetStaticsLagrange  GetDynamicsLagrange

     Purpose:  Gets Lagrange's equations for statics or dynamics.

    Syntax 1:  System.GetStaticsLagrange(  SystemPotential = sysPotential )
               System.GetDynamicsLagrange( SystemPotential = sysPotential )
    ---------------------------------------------------------------------------
    Syntax 2*: System.GetStaticsLagrange(     AddPotential = addPotential ) **
               System.GetDynamicsLagrange(    AddPotential = addPotential ) **
    Syntax 3*: System.GetStaticsLagrange()  ** RESERVED SYNTAX, IN DEVELOPMENT.
               System.GetDynamicsLagrange() ** RESERVED SYNTAX, IN DEVELOPMENT.
    ---------------------------------------------------------------------------

       Input:  sysPotential -- system potential energy (all generalized forces).
               addPotential -- potential energy for forces not in the workspace.

    Output 1:  Lagrange's statics or dynamics equations for the entire System.
               All generalized forces have a corresponding potential function.
    Output 3:  Lagrange's statics or dynamics equations for the entire System.
               Generalized forces are formed via partial derivatives.

      Remark:  For Newton/Euler equations, type  Help Statics or Help Dynamics
               For Kane's       equations, type  Help Kane
               For Lagrange's   equations, type  Help Lagrange

     Related:  AddForce  AddTorque  SetMass  SetInertia  Rotate  Translate
               NewtonianFrame  Point  Particle  RigidFrame  RigidBody
               GetStatics   GetStaticsKane   GetStaticsLagrange
               GetDynamics  GetDynamicsKane  GetDynamicsLagrange
               SetGeneralizedCoordinate  SetGeneralizedSpeed

#### Newton

    GetStatics  GetDynamics

     Purpose:  Gets Newton/Euler statics or dynamics equations of motion.

    Syntax 1:  Object.GetStatics()
    Syntax 2:  Object.GetDynamics()

       Input:  Object -- Point, Particle, RigidBody, RigidFrame, or System.

    Output 1:  Newton/Euler statics  equations for Object.
    Output 2:  Newton/Euler dynamics equations for Object.

      Remark:  For Newton/Euler equations, type  Help Statics or Help Dynamics
               For Kane's       equations, type  Help Kane
               For Lagrange's   equations, type  Help Lagrange

     Related:  AddForce  AddTorque  SetMass  SetInertia  Rotate  Translate
               NewtonianFrame  Point  Particle  RigidFrame  RigidBody
               GetStatics   GetStaticsKane   GetStaticsLagrange
               GetDynamics  GetDynamicsKane  GetDynamicsLagrange
               SetGeneralizedCoordinate  SetGeneralizedSpeed

#### License

    License  LicenseNetwork  LicenseAgreement

    Syntax 1:  License
               Displays information about the program's license on your computer.
               Asks if you would like to generate a license.

    Syntax 2:  LicenseNetwork  or  LicenseServer
               Displays information about the program's license on your computer.
               Asks if you would like to generate a license for a network/server.

    Syntax 3:  LicenseAgreement
               Displays the program's license agreement.

    Remark:    End-user and/or computer/IT administrators are responsible for all
               computer security.  We recommend the software be installed on a
               computer/account with restricted privileges as all users who access
               the software may have privileges at least equal to the account under
               which the software is installed.  All users who access the software
               must have read/write privileges for the file MGLicense.txt.

    Optional:  Instructions relevant only for a server/network license (rare).
               All users who access the software must have read/write privileges
               for the file MGLicense.txt.  If you have a server/network version,
               you need to change read/write permissions for MGLicense.txt.
               For example, from a MacOSX terminal, cd to the MotionGenesis folder
               and type the Unix command:  chmod a+x MGLicense.txt
               For PC/Windows, do something like the following:
            1. Navigate to C:\MotionGenesis (the folder containing MGLicense.txt).
            2. Right-click on MGLicense.txt and select "Properties".
            3. Click on the "Security" tab.
            4. Click on "Users" from the "Group or user names" section
               (if needed, press the "Edit" button to open "Edit Permissions").
            5. Check the "Allow" checkbox under the "Full Control" option to
               enable all users read/write access to the file MGLicense.txt.
            6. Press "OK" to save the changes.

#### List

    List

     Purpose:  Displays workspace contents on the screen.

    Syntax 1:  List
    Syntax 2:  List( startLineNumber )
    Syntax 3:  List( startLineNumber:stopLineNumber )

       Input:  startLineNumber -- the first line number to be displayed.
               stopLineNumber  -- the  last line number to be displayed.

    Output 1:  Displays all lines in the workspace.
    Output 2:  Displays startLineNumber and all subsequent lines in the workspace.
    Output 2:  Displays startLineNumber to stopLineNumber.

     Related:  !  %  &  Clear  List  Pause  Quit  Run  Save  GetDefaults

    --------------------------------------------------------------------
     Example:  List
    --------------------------------------------------------------------
       (1) a = 2
    -> (2) a = 2

       (3) b = 3
    -> (4) b = 3

       (5) list 1:2

       (1) a = 2
    -> (2) a = 2

#### log

    log or log10

     Purpose:  Returns the natural (base e) logarithm of a scalar expression.
               Returns the base 10 logarithm of a scalar expression.

     Syntax 1: log( scalarExpression )
     Syntax 2: log10( scalarExpression )

       Input:  scalarExpression -- a real or complex scalar expression.

    Output 1:  Base e (2.71828...) logarithm of scalarExpression.
    Output 2:  Base 10 logarithm of scalarExpression.

      Remark:  Use  log(r)/log(b)  to calculate the logarithm of the real
               positive number r to the real positive base b.

     Related:  ImaginaryNumber  MathFunctions

       (1) %--------------------------------------------------------------------
       (2) % Example 1: log and log10   (real scalar expressions)
       (3) %--------------------------------------------------------------------
       (4) Ae = log( 2 )
    -> (5) Ae = 0.6931472

       (6) Be = log(2*t)
    -> (7) Be = 0.6931472 + log(t)

       (8) A10 = log10( 2 )
    -> (9) A10 = 0.30103

       (10) B10 = log10(2*t)
    -> (11) B10 = 0.30103 + log10(t)

       (12) C = log(1+2*t) + log10(1+2*t)
    -> (13) C = log(1+2*t) + log10(1+2*t)

       (14) %--------------------------------------------------------------------
       (15) % Example 2: log and log10   (complex scalar expressions)
       (16) %--------------------------------------------------------------------
       (17) Ye = log( 2 + 3*GetImaginaryNumber() )
    -> (18) Ye = 1.282475 + 0.9827937*imaginary

       (19) Y10 = log10( 2 + 3*GetImaginaryNumber() )
    -> (20) Y10 = 0.5569717 + 0.4268219*imaginary

       (21) Z = log( 3*GetImaginaryNumber() + t ) + log10( 3*GetImaginaryNumber() + t )
    -> (22) Z = log(3*imaginary+t) + log10(3*imaginary+t)

#### MathFunctions

    MathFunctions

     Absolute value:           abs
     Exponential,logarithmic:  exp, log, log10
     factorial:                factorial
     Hyperbolic:               cosh, sinh, tanh
     Integer functions:        ceil, floor, int, round, sign, RandomInteger
     Inverse trigonometric:    acos, asin, atan, atan2, acosDegrees, ...
     Maximum, minimum:         max, min
     Square, square-root:      squared, sqrt
     Trigonometric:            cos, sin, tan, cosDegrees, sinDegrees, ...
     Related:                  ImaginaryNumber

    Type HELP NAME for help with NAME; e.g., HELP abs

#### Matrix

    Matrix

     Purpose:  Constructs a matrix from a vector, dyadic, ...

    Syntax 1:  Matrix( A,  vector>    )  or  Vector( A,  vector>  )
    Syntax 2:  Matrix( A,  dyadic>>   )  or  Dyadic( A,  dyadic>> )
    Syntax 3:  Matrix( A,  triadic>>> )
    Syntax 4:  Matrix( A,  [ v1>, ...  vn> ]  )

       Input:  A -- the name of a RigidFrame or RigidBody
               vector>    -- a vector  expression
               dyadic>>   -- a dyadic  expression
               triadic>>> -- a triadic expression
               [v1> ...  vn>] -- one dimensional (row or column) matrix of vectors

    Output 1:  3 x 1 matrix whose elements are the Ax>, Ay>, Az>
               measures of vector>.

    Output 2:  3 x 3 matrix whose elements are the Ai>*Aj> (i,j = x,y,z)
               measures of dyadic>>.

    Output 3:  27 x 1 matrix whose elements are the Ai>*Aj>*Ak> (i,j,k = x,y,z)
               measures of triadic>>>.

    Output 4:  n x 3  or  3 x n  matrix whose elements are the Ax>, Ay>, Az>
               measures of v1> ... vn>

      Remark:  To select one element of the matrix m, use e.g., m[ 2, 3 ].
               For a submatrix, use m[ 2:3, 1:5 ].  See HELP [].

     Related:  Express        Vector          Dyadic             Matrix  SkewMatrix
               GetColumns     GetDeterminant  GetDiagonalMatrix  GetEigen
               GetElement []  GetInverse      GetIdentityMatrix  GetNorm  GetRows
               GetTrace       GetTranspose    GetZeroMatrix      Solve

       (1) %--------------------------------------------------------------------
       (2) % Example: Matrix  (with vector argument)
       (3) %--------------------------------------------------------------------
       (4) RigidFrame A, B
       (5) Constant   x, y, z
       (6) B.SetRotationMatrixZ( A, t )
    -> (7) B_A = [cos(t), sin(t), 0;  -sin(t), cos(t), 0;  0, 0, 1]

       (8) xyzA> = x*Ax> + y*Ay> + z*Az>
    -> (9) xyzA> = x*Ax> + y*Ay> + z*Az>

       (10) M1 = Matrix( A,  xyzA> )
    -> (11) M1 = [x;  y;  z]

       (12) M2 = Matrix( B,  xyzA> )
    -> (13) M2 = [x*cos(t) + y*sin(t);  y*cos(t) - x*sin(t);  z]

       (14) %--------------------------------------------------------------------
       (15) % Example: Matrix  (with dyadic argument)
       (16) %--------------------------------------------------------------------
       (17) M3 = Matrix( A,  x^2*Ax>*Ax> + y^2*Ay>*Ay> + x*y*Ax>*Ay> + x*y*Ay>*Ax> + z^2*Az>*Az> )
    -> (18) M3 = [x^2, x*y, 0;  x*y, y^2, 0;  0, 0, z^2]

       (19) %--------------------------------------------------------------------
       (20) % Example: Matrix  (with dyadic in mixed bases)
       (21) %--------------------------------------------------------------------
       (22) M4 = Matrix( B,  Ax>*Bz> + 2*Ay>*Bz> + 3*Az>*Bx> + 4*Bz>*Bz> )
    -> (23) M4 = [0, 0, cos(t) + 2*sin(t);  0, 0, 2*cos(t) - sin(t);  3, 0, 4]

       (24) %--------------------------------------------------------------------
       (25) % Example: Matrix  (1x2 row matrix of vectors produces 3x2 result)
       (26) %--------------------------------------------------------------------
       (27) M5 = Matrix( A,  [xyzA>,  7*Bx>] )
    -> (28) M5 = [x, 7*cos(t);  y, 7*sin(t);  z, 0]

       (29) %--------------------------------------------------------------------
       (30) % Example: Matrix  (4x1 column matrix of vectors produces 4x3 result)
       (31) %--------------------------------------------------------------------
       (32) M6 = Matrix( A,  [xyzA>;  7*Bx>;  8*Ay>;  9*Az>] )
    -> (33) M6 = [x, y, z;  7*cos(t), 7*sin(t), 0;  0, 8, 0;  0, 0, 9]

#### SkewMatrix

    SkewMatrix

     Purpose:  Constructs a skew-symmetric matrix from a vector.

    Syntax 1:  SkewMatrix( A, vector> )
    Syntax 2:  SkewMatrix( vector> )

       Input:  A -- the name of a RigidFrame or RigidBody.
               vector> -- a vector expression.

    Output 1:  3 x 3 skew-symmetric matrix whose off-diagonal elements are the
               Ax>, Ay>, Az> measures of vector>.  For example, if
               vector> = vx*Ax> + vy*Ay> + vz*Az>,  the output is
               [ 0,  -vz,   vy;
                vz,    0,  -vx;
               -vy,   vx,    0]

    Output 2:  Same as Output 1 when vector> is expressed in terms of only unit
               vectors expressed in terms of the same RigidFrame or RigidBody A.

      Remark:  The output skew-symmetric matrix helps represent cross products
               through matrix multiplication and matrices.  For example,
               SkewMatrix( A, v1> ) * Matrix( A, v2> ) is a 3 x 1 column matrix
               representation of Cross( v1>, v2> ) expressed with Ax>, Ay>, Az>.

      Remark:  In general, a skew-symmetric matrix S is a square matrix with the
               property  Transpose(S) = -S.  Matrix S has zeros along its diagonal.
               The off-diagonal elements of S have the property Sji = -Sij.

     Related:  Express        Vector          Dyadic             Matrix  SkewMatrix
               GetColumns     GetDeterminant  GetDiagonalMatrix  GetEigen
               GetElement []  GetInverse      GetIdentityMatrix  GetNorm  GetRows
               GetTrace       GetTranspose    GetZeroMatrix      Solve

       (1) %--------------------------------------------------------------------
       (2) % Example 1: SkewMatrix  (with 2 arguments).
       (3) %--------------------------------------------------------------------
       (4) RigidFrame A
       (5) Constant   vx, vy, vz
       (6) v> = vx*Ax> + vy*Ay> + vz*Az>
    -> (7) v> = vx*Ax> + vy*Ay> + vz*Az>

       (8) vSkewMatrixA = SkewMatrix( A,  v> )
    -> (9) vSkewMatrixA = [0, -vz, vy;  vz, 0, -vx;  -vy, vx, 0]

       (10) v234> = 2*Ax> + 3*Ay> + 4*Az>
    -> (11) v234> = 2*Ax> + 3*Ay> + 4*Az>

       (12) crossProductMatrixA = vSkewMatrixA * Matrix( A, v234> )
    -> (13) crossProductMatrixA = [4*vy - 3*vz;  2*vz - 4*vx;  3*vx - 2*vy]

       (14) crossProductVector> = Cross( v>, v234> )
    -> (15) crossProductVector> = (4*vy-3*vz)*Ax> + (2*vz-4*vx)*Ay> + (3*vx-2*vy)*Az>

       (16) isEqual[1] = IsSimplifyEqual( Vector(A, crossProductMatrixA),  crossProductVector> )
    -> (17) isEqual[1] = true

       (18) %--------------------------------------------------------------------
       (19) % Example 2: SkewMatrix  (with 1 argument since v> has a uniform basis).
       (20) %--------------------------------------------------------------------
       (21) vSkewMatrixA := SkewMatrix( v> )
    -> (22) vSkewMatrixA = [0, -vz, vy;  vz, 0, -vx;  -vy, vx, 0]

       (23) %--------------------------------------------------------------------
       (24) % Example 3: SkewMatrix  (with 2 arguments and a mixed-basis vector).
       (25) %--------------------------------------------------------------------
       (26) RigidBody  B
       (27) Constant   theta
       (28) B.SetRotationMatrixZ( A, theta )
    -> (29) B_A = [cos(theta), sin(theta), 0;  -sin(theta), cos(theta), 0;  0, 0, 1]

       (30) v> := vx*Ax> + vy*By> + vz*Bz>    % Mixed-basis vector v>.
    -> (31) v> = vx*Ax> + vy*By> + vz*Bz>

       (32) vSkewMatrixA := SkewMatrix( A,  v> )
    -> (33) vSkewMatrixA[1,1] = 0
    -> (34) vSkewMatrixA[1,2] = -vz
    -> (35) vSkewMatrixA[1,3] = vy*cos(theta)
    -> (36) vSkewMatrixA[2,1] = vz
    -> (37) vSkewMatrixA[2,2] = 0
    -> (38) vSkewMatrixA[2,3] = vy*sin(theta) - vx
    -> (39) vSkewMatrixA[3,1] = -vy*cos(theta)
    -> (40) vSkewMatrixA[3,2] = vx - vy*sin(theta)
    -> (41) vSkewMatrixA[3,3] = 0

       (42) vSkewMatrixB := SkewMatrix( B,  v> )
    -> (43) vSkewMatrixB[1,1] = 0
    -> (44) vSkewMatrixB[1,2] = -vz
    -> (45) vSkewMatrixB[1,3] = vy - vx*sin(theta)
    -> (46) vSkewMatrixB[2,1] = vz
    -> (47) vSkewMatrixB[2,2] = 0
    -> (48) vSkewMatrixB[2,3] = -vx*cos(theta)
    -> (49) vSkewMatrixB[3,1] = vx*sin(theta) - vy
    -> (50) vSkewMatrixB[3,2] = vx*cos(theta)
    -> (51) vSkewMatrixB[3,3] = 0

       (52) isEqual[2] = IsSimplifyEqual( A_B * vSkewMatrixB * B_A,  vSkewMatrixA )
    -> (53) isEqual[2] = true

       (54) isEqual[3] = IsSimplifyEqual( B_A * vSkewMatrixA * A_B,  vSkewMatrixB )
    -> (55) isEqual[3] = true

       (56) %--------------------------------------------------------------------
       (57) % Example 4: SkewMatrix  (related to matrices of unit vectors).
       (58) %--------------------------------------------------------------------
       (59) v> := vx*Ax> + vy*Ay> + vz*Az>
    -> (60) v> = vx*Ax> + vy*Ay> + vz*Az>

       (61) vSkewMatrixA := -Dot( v>,  Cross( [Ax>; Ay>; Az>], [Ax>, Ay>, Az>] ))
    -> (62) vSkewMatrixA = [0, -vz, vy;  vz, 0, -vx;  -vy, vx, 0]

       (63) %--------------------------------------------------------------------
       (64) % Example 5: SkewMatrix  (related to cross-product with unit dyadic).
       (65) %--------------------------------------------------------------------
       (66) v> := vx*Ax> + vy*Ay> + vz*Az>
    -> (67) v> = vx*Ax> + vy*Ay> + vz*Az>

       (68) vCrossUnitDyadic>> = Cross( v>,  1>> )
    -> (69) vCrossUnitDyadic>> = -vz*Ax>*Ay> + vy*Ax>*Az> + vz*Ay>*Ax> - vx*Ay>*Az>
            - vy*Az>*Ax> + vx*Az>*Ay>

       (70) unitDyadicCrossV>> = Cross( 1>>,  v> )
    -> (71) unitDyadicCrossV>> = -vz*Ax>*Ay> + vy*Ax>*Az> + vz*Ay>*Ax> - vx*Ay>*Az>
            - vy*Az>*Ax> + vx*Az>*Ay>

       (72) vCrossUnitDyadicSkewA = Matrix( A, vCrossUnitDyadic>> )
    -> (73) vCrossUnitDyadicSkewA = [0, -vz, vy;  vz, 0, -vx;  -vy, vx, 0]

       (74) unitDyadicCrossVSkewA = Matrix( A, unitDyadicCrossV>> )
    -> (75) unitDyadicCrossVSkewA = [0, -vz, vy;  vz, 0, -vx;  -vy, vx, 0]

       (76) vSkewMatrixA := SkewMatrix( A,  v> )
    -> (77) vSkewMatrixA = [0, -vz, vy;  vz, 0, -vx;  -vy, vx, 0]

       (78) isEqual[4] = IsSimplifyEqual( vCrossUnitDyadicSkewA, unitDyadicCrossVSkewA )
    -> (79) isEqual[4] = true

       (80) isEqual[5] = IsSimplifyEqual( vCrossUnitDyadicSkewA, vSkewMatrixA )
    -> (81) isEqual[5] = true

#### min

    min  or  max

     Purpose:  Returns the smaller or larger of two real numbers.

    Syntax 1:  min( x, y )
    Syntax 2:  max( x, y )

       Input:  x -- an expression that resolves to a real number.
               y -- an expression that resolves to a real number.

    Output 1:  Minimum of x and y.
    Output 2:  Maximum of x and y.

     Related:  ceil  floor  int  max  min  round  RoundDigits  sign  MathFunctions

       (1) %--------------------------------------------------------------------
       (2) % Example: min
       (3) %--------------------------------------------------------------------
       (4) A = min(  3,  5 )
    -> (5) A = 3

       (6) B = min( -3, -5 )
    -> (7) B = -5

       (8) C = 50
    -> (9) C = 50

       (10) D = min( 3, C )
    -> (11) D = 3

       (12) %--------------------------------------------------------------------
       (13) % Example: max
       (14) %--------------------------------------------------------------------
       (15) E = max(  3,  5 )
    -> (16) E = 5

       (17) F = max( -3, -5 )
    -> (18) F = -3

#### NewtonianFrame

    NewtonianFrame

     Purpose:  Declares a Newtonian (inertial) reference frame, which is
               a special RigidFrame in which  F = m*a  is valid.

    Syntax 1:  NewtonianFrame N      (creates a Newtonian reference frame N)
    Syntax 2:  NewtonianFrame        (displays the name of the NewtonianFrame)
    Syntax 3:  #NewtonianFrame#      (string substitution with the NewtonianFrame)

       Input:  N -- name that starts with a letter, followed by a reasonable number
                    of alphanumeric characters (e.g., less than 12 characters).

    Output 1:  NewtonianFrame N   creates a special  RigidFrame N  and creates
               right-handed orthogonal unit vectors Nx>, Ny>, Nz> fixed in N and
               creates a point No (called N's origin) fixed in N (welded to N).

      Remark:  The NewtonianFrame may be changed anytime or reassigned
               to the name of an existing RigidFrame or RigidBody.
               It cannot be welded to another frame.

     Related:  NewtonianFrame  Particle  Point  RigidBody  RigidFrame  System

       (1) %--------------------------------------------------------------------
       (2) % Example: NewtonianFrame
       (3) %--------------------------------------------------------------------
       (4) NewtonianFrame N
       (5) Particle  Q
       (6) Q.SetMass( m )
       (7) Q.SetVelocity( N,  2*Nx> + 4*Ny> )
    -> (8) v_Q_N> = 2*Nx> + 4*Ny>

       (9) KE = Q.GetKineticEnergy()
    -> (10) KE = 10*m

       (11) a_Q_#NewtonianFrame#> = Dt( Q.GetVelocity(#NewtonianFrame#), #NewtonianFrame# )
    -> (12) a_Q_N> = 0>

#### numerator

    numerator  or  denominator  (experimental command -- subject to change).

     Purpose:  Returns the numerator or a denominator of a fraction.

    Syntax 1:  numerator(   fractionExpression )
    Syntax 2:  denominator( fractionExpression )

       Input:  fractionExpression -- an expression that resolves to fraction.

    Output 1:  The numerator   of fractionExpression.
    Output 2:  The denominator of fractionExpression.

     Related:  MathFunctions

       (1) %--------------------------------------------------------------------
       (2) % Example: numerator or denominator
       (3) %--------------------------------------------------------------------
       (4) expression = 3*(2+t)/(5 + cos(t))
    -> (5) expression = 3*(2+t)/(5+cos(t))

       (6) num = numerator( expression )
    -> (7) num = 6 + 3*t

       (8) den = denominator( expression )
    -> (9) den = 5 + cos(t)

#### ODE

    ODE

     Purpose:  Executes or writes a MATLAB, C, or Fortran program to solve
               ordinary differential or coupled differential/algebraic equations.

    Syntax 1:  ODE()                             Filename.Ext
    Syntax 2:  ODE( EqnsToSolve, x1, x2, ... )   Filename.Ext
    Syntax 3:  ODE()                             Filename.Ext( Tx, Ty, Tz )
    Syntax 4:  ODE() [A = Astart, Astop, Astep]  Filename.Ext
    Note:      The various options in Syntax 1-4 can be used together.

       Input:  Filename -- a valid file name.  If no Filename is specified,
               the program solves the ODEs and puts results in the file ODE.i

               Ext -- nothing (immediate solution)
                   -- .m    (produces MATLAB  code)
                   -- .c    (produces C       code and input file Filename.in)
                   -- .f    (produces FORTRAN code and input file Filename.in)
                   -- .for  (same as .f except 72 character line length)

       Input:  EqnsToSolve -- matrix of (or single) scalar expressions that are
               LINEAR functions of x1, x2, ..., and regarded as equal to zero.
               Treated as:  EqnsToSolve[1] = 0,   EqnsToSolve[2] = 0, ...
               EqnsToSolve may have form EqnsToSolve = 0 or EqnsToSolve = Rhs.

               x1, x2 -- the names of scalars or a matrix of scalar names.

               Tx, Ty, Tz -- scalar names (maybe with units) that allow for
               passing command-line arguments to MATLAB or C programs.
               Example 1:  Filename.m( Tx N*m,  Ty N*cm,  Tz lbf*ft )
               Example 2:  Filename( Tx=2 N*m,  Ty=3 N*cm,  Tz = 5 )

               A = Astart, Astop, Astep -- A is the name (maybe with units) of a
               scalar quantity used as a loop index.  Astart, Astop, Astep are
               numerical values.  Example:  [A cm = 0, 100, 2]

    Output 1:  Produces a program that solves the ordinary differential
               equations in the workspace, output their numerical results, and
               output numerical values of quantities named in OUTPUT statements.

    Output 2:  Solves the set of simultaneous algebraic equations in EqnsToSolve
               for x1, x2, ...  at each time step while also solving the ODEs
               in the workspace and outputting relevant numerical results.

    Output 3:  To run Filename.m, type  Filename( 12, 56, 87 )  at MATLAB prompt.
               To run Filename.c, type  Filename 12 56 87       from OS shell.

    Output 4:  Incorporates Fortran DO-loops or C/MATLAB FOR-loops.
               To have multiple loops inside the program, use, e.g.,
               [ A = Astart, Astop, Astep;   B = Bstart, Bstop, Bstep; ... ]

      Remark:  Input values and units are named in INPUT statements.
               Output quantities and units are named in OUTPUT statements.

      Remark:  SetDigits sets the format of numbers output by programs created by
               the ODE command.  It does not affect calculation accuracy.

      Remark:  The solution is approximate and its accuracy tends to improve
               as the input value assigned to absError gets smaller.
               The default value of absError can be changed via the Input command:
               Input  absError = 1.0E-5 cm,  relError = 1.0E-7

      Remark:  Use the  .for  extension for FORTRAN whose line lengths cannot
               exceed 72 characters and which supports all line breaks.
               Use the  .f   extension for FORTRAN with lines less than 120
               characters and which cannot break lines in the middle of names.

     Related:  ODE  Solve  Input  Output  OutputPlot  Plot  Animate
               ConvertUnits  GetUnitSystem  SetUnitSystem  SetDigits  SetLineWidth
               t  tInitial  tFinal  tStep  absError  printIntScreen  printIntFile
               Solve  SolveDt  SolveSetInput  SolveSetInputDt  ...

       (1) %--------------------------------------------------------------------
       (2) % Example 1: ODE()      (1st-order ODE)
       (3) %--------------------------------------------------------------------
       (4) Variable x' = sin(t)
    -> (5) x' = sin(t)

       (6) Input  x = 1 m,  tFinal=10 sec,  tStep=0.02 sec,  absError=1.0E-07
       (7) Output  t seconds,  x m,  x' m/sec
       (8) ODE()  FirstOrderODE

       (9) %--------------------------------------------------------------------
       (10) % Example 2: ODE()      (2nd-order ODE)
       (11) %--------------------------------------------------------------------
       (12) Variable  q'' = cos(t) - sin(q)
    -> (13) q'' = cos(t) - sin(q)

       (14) Input  q = 0 deg,  q' = 2 rad/sec
       (15) Output  t seconds,  q  degrees,  q' deg/sec,  q'' rad/sec^2
       (16) ODE()  SecondOrderODE

       (17) %--------------------------------------------------------------------
       (18) % Example 3: ODE()      (Pass arguments b and k to .m function)
       (19) %--------------------------------------------------------------------
       (20) Constant m = 1 kg,  b,  k
       (21) Variable y'' = (-b*y' - k*y) / m
    -> (22) y'' = -(k*y+b*y')/m

       (23) Input  y = 1 m,  y' = 0 m/sec
       (24) ODE()  HarmonicOscillator.m(  b N*s/m,  k N/cm )

       (25) %--------------------------------------------------------------------
       (26) % Example 4: ODE(...)   (Coupled 2rd-order ODEs - with plotting)
       (27) %--------------------------------------------------------------------
       (28) Variable qA'', qB''
       (29) Eqn[1] = 10*sin(qA) + (21-sin(qB)^2)*qA'' - 2*sin(qB)*cos(qB)*qA'*qB'
    -> (30) Eqn[1] = 10*sin(qA) + (21-sin(qB)^2)*qA'' - 2*sin(qB)*cos(qB)*qA'*qB'

       (31) Eqn[2] = sin(qB)*cos(qB)*qA'^2 + qB''
    -> (32) Eqn[2] = sin(qB)*cos(qB)*qA'^2 + qB''

       (33) Input  qA = 90 deg,  qB = 1.0 deg,  qA' = 0 rad/sec,  qB' = 0 rad/sec
       (34) OutputPlot  t sec,  qA degrees,  qB degrees
       (35) ODE( Eqn = 0,  qA'',  qB'' )  CoupledSecondOrderODE.m

#### Optimize

    Optimize   EXPERIMENTAL METHOD (SUBJECT TO CHANGE).

     Purpose:  Forms a set of equations which when solved optimizes a function
               (e.g., finds a local minimum or maximum), with or without
               equality constraints.

    Syntax:    eqnsZero = Optimize( CostFunction,  Constraints = 0,  x1, x2, ... )
               eqnsZero = Optimize( CostFunction,                    x1, x2, ... )

       Input   CostFunction -- Single scalar expression that depends on x1, x2, ...

               Constraints -- a scalar expression or a matrix of scalar expressions
               that are functions of x1, x2, ..., and regarded as equal to zero.
               Constraints may be a combination of statics/dynamics equations,
               geometry constraints, motion constraints, etc.
               x1, x2, ... -- the names of scalars or a matrix of scalar names.

    Output:    Matrix of scalar expressions (herein arbitrary named eqnsZero) that
               are equal to zero and which generally are functions of x1, x2 ...
               If there are Constraints, eqnsZero depend on Lagrange multipliers
               e.g., lambda1, lambda2, ... which are auto-declared as Variables.
               eqnsZero can be subsequently solved (e.g., with one of the many
               variants of the Solve command) to determine x1, x2, ...
               If there are Constraints, also solve for lambda1, lambda2, ...

     Remark:   Depending on CostFunction and Constraints, the matrix of returned
               equations (herein eqnsZero) may be linear or nonlinear in x1, x2.
               For example, the quadratic cost function CostFunction = x1^2 + x2^2
               is associated with least-square optimization. Optimizing a quadratic
               cost function that has no associated constraints or has Constraints
               that also happen to be linear in  x1, x2, ... return a matrix of
               equations (herein eqnsZero) that are linear in x1, x2, ...
               Note: For convex optimization, e.g.,  CostFunction = x1^2 + x2^2
               or CostFunction = x1^4 + x2^4,  there is one optimal solution.
               For non-convex optimization, the returned equations(s)
               may be nonlinear and there may be multiple solutions.

     Related:  ODE  Solve  SolveDt  SolveSetInput  SolveSetInputDt  Optimize ...
               GetPolynomial  GetPolynomialRoots  GetQuadraticRoots  ...
               SolveQuadraticPositiveRoot  SolveQuadraticPositiveRootDt  ...
               SetAutoDifferentiate  SetAutoOverwrite
               SetDt  SetNoDt   =   :=   +=   *=   /=   ^=

       (1) %---------------------------------------------------------------------
       (2) % Example 1: Optimize (local minimum or maximum of a function of x).
       (3) %---------------------------------------------------------------------
       (4) Variable  x, y
       (5) costFunctionA = x^3/3 - sin(x)
    -> (6) costFunctionA = 0.3333333*x^3 - sin(x)

       (7) eqnsToSolveA = Optimize( CostFunctionA,  x )
    -> (8) eqnsToSolveA = [x^2 - cos(x)]

       (9) xOptimal1 = Solve( eqnsToSolveA = 0,  x = 1 )    % Local minimum or maximum
    -> (10) xOptimal1 = [0.8241323]

       (11) xOptimal2 = Solve( eqnsToSolveA = 0,  x = -2 )   % Local minimum or maximum
    -> (12) xOptimal2 = [-0.8241323]

       (13) %---------------------------------------------------------------------
       (14) % Example 2: Optimize (local minimum or maximum of a function of x and y).
       (15) %---------------------------------------------------------------------
       (16) costFunctionB = y^2 + 3*(2+x)^2 - 4*x*y
    -> (17) costFunctionB = y^2 + 3*(2+x)^2 - 4*x*y

       (18) eqnsToSolveB = Optimize( costFunctionB,  x, y )
    -> (19) eqnsToSolveB = [12 + 6*x - 4*y;  2*y - 4*x]

       (20) xyOptimal = Solve( eqnsToSolveB = 0,  x, y )     % Only one min/max.
    -> (21) xyOptimal = [6;  12]

       (22) %---------------------------------------------------------------------
       (23) % Example 3: Optimize subject to a constraint
       (24) %            (minimize sum of squares of muscle tensions).
       (25) %---------------------------------------------------------------------
       (26) Variable  TA,  TB  % Muscle tensions to keep a human arm in static equilibrium.
       (27) StaticConstraint = -34.6 + 0.05*TA + 0.02*TB
    -> (28) StaticConstraint = -34.6 + 0.02*TB + 0.05*TA

       (29) costFunctionC = TA^2 + TB^2
    -> (30) costFunctionC = TA^2 + TB^2

       (31) eqnsToSolveC = Optimize( costFunctionC,  StaticConstraint = 0,  TA, TB )
    -> (32) eqnsToSolveC = [0.05*lambda + 2*TA;  0.02*lambda + 2*TB;  -34.6 + 0.02*TB + 0.05*TA]

       (33) TATBLambdaOptimal = Solve( eqnsToSolveC = 0,  TA, TB, Lambda )
    -> (34) TATBLambdaOptimal = [596.5517;  238.6207;  -23862.07]

       (35) %---------------------------------------------------------------------
       (36) % Example 4: Optimize subject to a constraint
       (37) %            (minimize a measure of muscle metabolic energy).
       (38) %---------------------------------------------------------------------
       (39) Constant  AreaA = 4.6 cm^2   % Biceps     physiological cross-sectional area.
       (40) Constant  AreaB = 5.4 cm^2   % Brachialis physiological cross-sectional area.
       (41) CostFunctionD := TA^3/AreaA^3 + TB^3/AreaB^3
    -> (42) CostFunctionD = TA^3/AreaA^3 + TB^3/AreaB^3

       (43) eqnsToSolveD = Optimize( CostFunctionD,  StaticConstraint = 0,  TA, TB )
    -> (44) eqnsToSolveD = [0.05*bLambda + 3*TA^2/AreaA^3;  0.02*bLambda + 3*TB^2/AreaB^3;  -34.6 + 0.02*TB + 0.05*TA]

       (45) %  Solve() works well with relative error convergence since abs(bLambda) is huge.
       (46) TATBLambdaOptimal := Solve( relError = 1E-8,  eqnsToSolveD = 0,  TA = 500, TB = 500, bLambda = 0 )
    -> (47) TATBLambdaOptimal = [523.5409;  421.1478;  -1.689581E+17]

       (48) %  Alternatively, symbolically solve for bLambda, TA, TB.
       (49) Solve( eqnsToSolveD[2:3] = 0,  bLambda, TA )
    -> (50) bLambda = -150*TB^2/AreaB^3
    -> (51) TA = 692 - 0.4*TB

       (52) SolveQuadraticNegativeRoot( eqnsToSolveD[1], TB )
    -> (53) TB = 1730*(1/AreaA^3-3.952847/sqrt(AreaA^3*AreaB^3))/(1/AreaA^3-15.625/AreaB^3)

       (54) %  Verify previous numerical results for TA, TB, bLambda.
       (55) TATBLambdaOptimal := EvaluateToNumber( [TA; TB; bLambda] )
    -> (56) TATBLambdaOptimal = [523.5409;  421.1478;  -1.689581E+17]

       (57) %---------------------------------------------------------------------
       (58) % Example 5: Optimize (maximize) the Az> measure of a vector v> subject to the
       (59) %            constraint that v> is a unit vector perpendicular to a given vector w>.
       (60) %---------------------------------------------------------------------
       (61) RigidFrame  A
       (62) Variable    ux, uy, uz
       (63) v> = ux*Ax> + uy*Ay> + uz*Az>
    -> (64) v> = ux*Ax> + uy*Ay> + uz*Az>

       (65) w> = 4*Ax> + 3*Ay> + 2*Az>
    -> (66) w> = 4*Ax> + 3*Ay> + 2*Az>

       (67) CostFunctionE = uz
    -> (68) CostFunctionE = uz

       (69) Constraints[1] = Dot( v>, w> )                    % v> is perpendicular to w>.
    -> (70) Constraints[1] = 2*uz + 3*uy + 4*ux

       (71) Constraints[2] = GetMagnitudeSquared( v> ) - 1    % v> is a unit vector.
    -> (72) Constraints[2] = -1 + ux^2 + uy^2 + uz^2

       (73) eqnsToSolveE = Optimize( CostFunctionE,  Constraints = 0,  ux, uy, uz )
    -> (74) eqnsToSolveE[1] = 4*cLambda1 + 2*cLambda2*ux
    -> (75) eqnsToSolveE[2] = 3*cLambda1 + 2*cLambda2*uy
    -> (76) eqnsToSolveE[3] = 1 + 2*cLambda1 + 2*cLambda2*uz
    -> (77) eqnsToSolveE[4] = 2*uz + 3*uy + 4*ux
    -> (78) eqnsToSolveE[5] = -1 + ux^2 + uy^2 + uz^2

       (79) %  Solve nonlinear algebraic equations with guesses for the unknowns.
       (80) Solve( eqnsToSolveE = 0,  cLambda1 = 1, cLambda2 = 1, ux = 1, uy = 1, uz = 1 )
    -> (81) cLambda1 = -0.06896552
    -> (82) cLambda2 = -0.4642383
    -> (83) ux = -0.2971125
    -> (84) uy = -0.2228344
    -> (85) uz = 0.9284767

#### SolveOptimize

    SolveOptimize (RESERVED KEYWORD & SYNTAXES. IN-DEVELOPMENT)

     Purpose:  Forms a set of equations which when solved optimizes a function
               (e.g., finds a local minimum or maximum), with or without
               equality constraints (e.g., a combination of statics, dynamics,
               and/or geometry and motion constraints).

    Syntax 1:  SolveOptimize( CostFunction,  Constraints,  x1,  x2, ... )
               SolveOptimize( CostFunction,                x1,  x2, ... )
    Syntax 2:  SolveOptimize( CostFunction,  Constraints,  x1=Guess1,  x2=Guess2 )
               SolveOptimize( CostFunction,                x1=Guess1,  x2=Guess2 )
    Syntax 3:  answer = SolveOptimize( CostFunction, Constraints, x1=Guess1, x2=Guess2 )
               answer = SolveOptimize( CostFunction,              x1=Guess1, x2=Guess2 )

       Input   CostFunction -- Single scalar expression that depends on x1, x2, ...

               Constraints -- one or more scalar expressions (in a matrix) that
               are functions of x1, x2, ..., and regarded as equal to zero.
               Treated as:  Constraints[1] = 0,   Constraints[2] = 0,  ...

               x1, x2, ... -- the names of scalars or a matrix of scalar names.

               Guess1, Guess2 -- expressions that resolve to real numbers.

    Output 1:  Matrix of scalar expressions (herein arbitrary named eqnsZero) that
               are equal to zero and which generally are functions of x1, x2 ...
               If there are Constraints, eqnsZero depend on Lagrange multipliers
               lambda1, lambda2, ... which are auto-declared as Variables..
               eqnsZero can be subsequently solved (e.g., with one of the many
               variants of the Solve command) to determine x1, x2, ...
               (and if there are Constraints, lambda1, lambda2, ...).

    Output 2:  Convenience function to do the following
               eqnsEqualZero = Optimize( CostFunction,  Constraints,  x1,  x2, ... )
               Solve( eqnsEqualZero = 0,  x1,  x2, lambda1, lambda2, ... )
               eqnsEqualZero = Optimize( CostFunction,  x1,  x2, ... )
               Solve( eqnsEqualZero = 0,  x1,  x2, lambda1, lambda2, ... )
    Output 3:  Solutions (real numbers) are returned in a matrix.
               Solutions are NOT assigned to x1, x2, ...
    Output 2:  Solutions (real numbers) are assigned to x1, x2, ...
    Output 3:  Solutions (real numbers) are returned in a matrix.
               Solutions are NOT assigned to x1, x2, ...

     Remark:   Depending on the CostFunction and Constraints, the matrix of
               returned equations may be linear or nonlinear in the unknowns.

     Remark:   CostFunction is a single (one) scalar expression. A CostFunction
               of the form  CostFunction = x1^2 + x2^2  is associated with
               least-square optimization and if Constraints happen to be
               linear in x1, x2, the returned matrix of equation(s) (herein called
               eqnsEqualZero) are linear in x1, x2, ...
               Note: For convex optimization, e.g.,  CostFunction = x1^2 + x2^2
               or CostFunction = x1^4 + x2^4,  there is one optimal solution.
               For non-convex optimization, the returned equations(s)
               may be nonlinear and there may be multiple solutions.

     Remark:   Providing Guess1, Guess2, ..., instructs Optimize to subsequently
               call  Solve  to produce a NUMERICAL solution for x1, x2, ...
               Type  Help Solve  for more information.

     Related:  ODE  Solve  SolveDt  SolveSetInput  SolveSetInputDt  Optimize ...
               GetPolynomial  GetPolynomialRoots  GetQuadraticRoots  ...
               SolveQuadraticPositiveRoot  SolveQuadraticPositiveRootDt  ...
               SetAutoDifferentiate  SetAutoOverwrite
               SetDt  SetNoDt   =   :=   +=   *=   /=   ^=

#### Output

    Output  OutputPlot  OutputEncode

     Purpose:  Causes programs created by the ODE and CODE command to create
               output files containing designated quantities and units.
               Displays quantities listed in Output statements.

    Syntax 1:  Output       x1 optionalUnits1, x2 optionalUnits2, ...
               OutputPlot   x1 optionalUnits1, x2 optionalUnits2, ...
               OutputEncode x1 optionalUnits1, x2 optionalUnits2, ...

       Input:  x1, x2, ... -- the names of scalars or matrices
               optionalUnits1, optionalUnits2 -- units associated with x1, x2, ...

               The values of x1 and x2 are calculated when a program produced
               by the ODE or Solve command is executed.

               OutputPlot will include statements in .m files to generate plots
               when a .m file is run - or immediately generate plots when
               an ODE() command is run with a Windows/PC computer.

               OutputEncode instructs programs to calculate output without writing
               to data files or displaying them on-screen.

    Response:  Output statements are entered before an ODE or CODE command.

     Remark:   In the event that x1, x2, ... is a matrix, the associated programs
               calculate the matrix elements, but do not display their values.

               If no units are assigned to x1, x2, ... in an Output statement,
               the units assigned to x1, x2, ... in an Input command will
               automatically be assigned to x1, x2, ...

               If no units are assigned in Input or Output statements to:
               t, tInitial, tFinal, tStep,  then the time unit designated
               by SetUnitSystem is assigned to these quantities automatically.

               Type  GetUnitSystem  for a list of units
    --------------------------------------------------------------------
       Remark: To clear some or all of previously entered Output, OutputPlot,
               or OutputEncode statements, use:

    Syntax 2:  ClearOutput()       or ClearOutput(     startInteger : stopInteger)
               ClearOutputPlot()   or ClearOutputPlot( startInteger : stopInteger)
               ClearOutputEncode() or ClearOutputEncode(startInteger: stopInteger)

       Input:  startInteger -- the first output statement to be cleared.
               stopInteger  -- the last  output statement to be cleared.
    --------------------------------------------------------------------
    Syntax 3:  Output  or  OutputPlot  or  OutputEncode
               Displays a list of Output, OutputPlot, OutputEncode statements.
    --------------------------------------------------------------------

     Related:  ODE  Input  Output  OutputPlot  Plot  SetPlotInterface  Animate
               ConvertUnits  GetUnitSystem  SetUnitSystem  SetDigits
               t  tInitial  tFinal  tStep  absError  printIntScreen  printIntFile

       (1) %--------------------------------------------------------------------
       (2) % Example 1:  Output
       (3) %--------------------------------------------------------------------
       (4) Variable  y' = cos(t)*y
    -> (5) y' = cos(t)*y

       (6) mat = [t, y, y';  y^2, abs(y), cos(t)]
    -> (7) mat = [t, y, y';  y^2, abs(y), cos(t)]

       (8) Input  y = 22 cm,  tFinal = 5 sec,  tStep = 0.1 sec
       (9) Output        t sec,  y cm,  y inch,  y^2 m
       (10) OutputPlot    t sec,  y m,   y' m/s
       (11) OutputEncode  t sec,  mat noUnits
       (12) ODE() Test.m

       (13) %-------------------------------------------------------------------
       (14) % Running the MATLAB file Test.m produces: a plot, the data file Test.1
       (15) % and calculations for all the elements in the matrix mat.
       (16) %
       (17) % FILE: Test.1
       (18) %
       (19) %       t              y              y             y^2
       (20) %     (sec)          (cm)          (inch)           (m)
       (21) %
       (22) % 0.000000E+00   2.200000E+01   8.661417E+00   4.840000E-02
       (23) % 1.000000E-01   2.430971E+01   9.570752E+00   5.909620E-02
       (24) %      ...            ...           ...            ...
       (25) %
       (26) %--------------------------------------------------------------------
       (27) % Example 2: Typing OUTPUT causes the following to be displayed
       (28) %--------------------------------------------------------------------
       (29) % Output 1:  t sec, y cm, y inch, y^2 m

#### Particle

    Particle

     Purpose:  Declares particles.

    Syntax 1:  Particle Q1, Q2, ...          (creates particles Q1, Q2, ...)
    Syntax 2:  Particle                      (displays names of all Particles)

       Input:  Q1 -- name that starts with a letter, followed by a reasonable
                     number of alphanumeric characters (similarly for Q2).

      Remark:  Particle Q{1:4}       is same as:  Particle Q1, Q2, Q3, Q4
               Particle Q{1:3}Ed     is same as:  Particle Q1Ed, Q2Ed, Q3Ed
               Particle Q{1:2}{2:3}  is same as:  Particle QB12, Q13, Q22, Q23

     Related:  NewtonianFrame  Particle  Point  RigidBody  RigidFrame  System
               SetMass

       (1) %--------------------------------------------------------------------
       (2) % Example 1: Particle
       (3) %--------------------------------------------------------------------
       (4) Particle  Q
       (5) Particle  Q{1:4}
       (6) %--------------------------------------------------------------------
       (7) % Example 2: Particle  (typing PARTICLE displays the following)
       (8) %--------------------------------------------------------------------
       (9) % The following Particle have been declared:
       (10) %
       (11) % Q  Q1  Q2  Q3  Q4
       (12) %--------------------------------------------------------------------
       (13) % Example 3: Particle  (SetMass -- for a particle)
       (14) %--------------------------------------------------------------------
       (15) Q1.SetMass( m1 )
       (16) Q2.SetMass( m2 )
       (17) m12 = Q1.GetMass() + Q2.GetMass()
    -> (18) m12 = m1 + m2

#### PathToMotionGenesis

    PathToMotionGenesis  (Unnecessary for regular program use).

     Purpose:  Specifies the operating system path to the MotionGenesis folder.
               This is the top-level directory (folder) for the program.
               Its sub-directories contains files used by the program.

      Windows 10:

               To permanently set the operating system environment variable
               1. Open the Start Search (click on the Windows key).
               2. Type env
               3. Choose Edit the system environment variables
               4. Click the Environment Variables ... button.
               5. Under the user variables panel, click on the New button.
               6. Enter the variable name  as  PathToMotionGenesis
               7. Enter the variable value as  pathToProgram
                  where pathToProgram is something like C:\MotionGenesis

               To temporarily set this operating system environment variable
               1.  Open a operating system terminal window -- which can be done in
                   many ways, e.g., browse to the MotionGenesis folder and click on
                   the fileMotionGenesisTerminal.lnk.
               2.  At the terminal prompt, type the following where pathToProgram
                   is the path to the MotionGenesis folder, e.g., C:\MotionGenesis

                   SET PathToMotionGenesis=pathToProgram

      Unix and Macintosh OSX:

               To permanently set the environment variable, edit the file .cshrc
               and add the following line where pathToProgram is something like
               /applications/MotionGenesis

                    setenv PathToMotionGenesis pathToProgram

               After editing the .cshrc file, type source .cshrc at the Unix prompt
               (or logout and login again)

      Remark:  Even if this environment variable is not set or is set improperly,
               the program searches and usually finds its associated files.

      Remark:  Before March 2020, PathToMotionGenesis was named MOTIONGENESISPATH

     Related:  GetDefaults  GetWorkingDirectory  SetWorkingDirectory
               GetEnvironmentValue   SetScratchDirectory

#### Pause

    Pause  or  Stop

     Purpose:  Suspends execution when running an input file.

    Syntax 1:  Pause( )
    Syntax 2:  Pause( numberOfSeconds )
    Syntax 3:  Pause( WAIT )
    Syntax 4:  Pause( STOP )   or   STOP

       Input:  numberOfSeconds -- an integer between 0 and 60, equal to the
               desired duration, in seconds, to pause program execution.
               Note: No pause occurs when numberOfSeconds is 0.

    Output 1:  On-screen appearance of the following message:
               Press ENTER to resume execution.
               Press any other key to proceed interactively.

    Output 2:  Suspends program execution for numberOfSeconds.
    Output 3:  Suspends program execution until the user presses the ENTER key.
    Output 4:  Stops reading from input file and proceeds interactively.

      Remark:  If reading from an input file stops, you may type RUN
               to resume execution from the input file.

     Related:  !  %  &  Clear  List  Pause  Quit  Run  Save  SetPauseOnWarning

#### pi

    pi

     Purpose:  Name assigned to the following ratio associated with a circle:
               pi = CircumferenceOfCircle / DiameterOfCircle.

      Syntax:  pi

      Value:   3.14159265358979323846264338327950288419716939937510582 ...

     Related:  Constant  ImaginaryNumber  Specified  Variable  true false
               SetGeneralizedCoordinate  SetGeneralizedSpeed  t

       (1) %--------------------------------------------------------------------
       (2) % Example: pi
       (3) %--------------------------------------------------------------------
       (4) a = sin(pi*t)
    -> (5) a = sin(pi*t)

       (6) b = dt( a )
    -> (7) b = pi*cos(pi*t)

       (8) c = 1.234*dt(a)
    -> (9) c = 3.876725*cos(pi*t)

#### Plot

    Plot       For PC/Windows and with proper install of Java JDK on Macintosh OS/X

     Purpose:  Invokes plotting program

    Syntax 1:  Plot
    Syntax 2:  Plot dataFile1
    Syntax 3:  Plot dataFile1, dataFile2, dataFile3
    Syntax 4:  Plot dataFile1 [1,2,3,4]  dataFile2 [1,4,3]
    Syntax 5:  PlotTest

       Input:  dataFilei -- the name of a data file having columns of numbers.
               [1,2,3,4] -- designates the columns to be plotted, i.e.,
                            plots columns 2, 3, and 4 versus column 1.

    Output 1:  Starts the interactive plotting program (graphical user interface).
    Output 2:  Starts the plotting program and plots the data in dataFile1.
    Output 3:  Plots the data in dataFile1, dataFiel2, dataFile3.
    Output 4:  Plots columns 2 vs 1, 3 vs 1, 4 vs 1 in dataFile1.
               Plots columns 4 vs 1, 3 vs 1  in dataFile2.
    Output 5:  Tests the plotting program by displaying a sample plot.

      Remark:  Alternatively, you can invoke the plotting program from the
               OS (operating system) command line by typing, e.g.,
               MotionGenesis  Plot  dataFile1
               MotionGenesis  Plot  dataFile1, dataFile2, dataFile3
               MotionGenesis  Plot  dataFile1 [1,2,3,4]  dataFile2 [1,4,3]

      Remark:  There are many ways to plot (with or without a license).
               At the operating system prompt, type:  MotionGenesis dataFile1
               PC/Windows: Drag and drop one or more data files onto the icon for
               MotionGenesis  or  MotionGenesisStartHere
               See more HELP (and many other options) after starting the Plot tool.

     Related:  ODE  Solve  Input  Output  OutputPlot  Plot  Animate
               SetPlotInterface

       (1) %--------------------------------------------------------------------
       (2) % Example: Plot
       (3) % Plot A:  x, x^2, x' versus t.  Uses data from file OdeData.1
       (4) % Plot B:  x, y       versus t.  Uses files OdeData.1, OdeData.2
       (5) %--------------------------------------------------------------------
       (6) Variable x' = sin(t)
    -> (7) x' = sin(t)

       (8) Variable y' = cos(t)
    -> (9) y' = cos(t)

       (10) Input   x = 0,  y = 0,  tFinal = 10
       (11) Output  t, x, x^2, x'
       (12) Output  t, y, y'
       (13) ODE()  OdeData

       (14) Plot   OdeData.1 [1, 2,3,4]
       (15) Pause( 5 )
       (16) Plot   OdeData.1 [1,2]       OdeData.2 [1,2]

#### Point

    Point

     Purpose:  Declares points.  Welds a point to a RigidFrame or RigidBody.

    Syntax 1:  Point P1, P2, ...   (creates points P1, P2, ...)
    Syntax 2:  Point P()           (creates point P, not welded to an object)
    Syntax 3:  Point Q( B )        (creates point Q welded to B)
    Syntax 4:  Point               (displays names of all Points)

       Input:  P1 -- name that starts with a letter, followed by a reasonable
                     number of alphanumeric characters (similarly for P2, etc).

               B -- the name of a RigidFrame or RigidBody.

    Output 2:  Point P()  creates a point Q that is purposely not attached to a
               RigidBody or RigidFrame (suppressing related notes/warnings).

    Output 3:  Creates point Q of RigidFrame or RigidBody B  (welds Q to B).
               Sets Q's velocity and acceleration in B  to 0>.
               Propagates forces on Q to resultant forces and moments on B.

      Remark:  Point P{1:4}        is same as:   Point P1, P2, P3, P4
               Point P{1:3}Ed      is same as:   Point P1Ed, P2Ed, P3Ed
               Point P{1:2}{2:3}   is same as:   Point P12, P13, P22, P23

      Remark:  The declaration  RigidFrame A  or  RigidBody A  automatically
               creates a point Ao (called A's origin) that is fixed on A.

               The declaration  RigidBody B  automatically creates a
               point Bcm (B's center of mass) that is fixed on B.

     Related:  NewtonianFrame  Particle  Point  RigidBody  RigidFrame  System

       (1) %--------------------------------------------------------------------
       (2) % Example 1: Point
       (3) %--------------------------------------------------------------------
       (4) RigidBody  B
       (5) Point P
       (6) Point P{1:4}
       (7) Point Q(B)
       (8) %--------------------------------------------------------------------
       (9) % Example 2: Point  (typing POINT displays the following)
       (10) %--------------------------------------------------------------------
       (11) % The following Point have been declared:
       (12) %
       (13) % Bo  P  P1  P2  P3  P4  Q(B), Bcm

#### Quit

    Quit  or  QuitExit

     Purpose:  Quits (exits) the program.

    Syntax 1:  Quit
    Syntax 2:  QuitExit

      Remark:  Quit will prompt the user if information has not been saved.
               QuitExit will quit (exit) without prompting the user to save.

     Related:  !  %  &  Clear  List  Pause  Quit  Run  Save  GetDefaults

#### RandomInteger

    RandomInteger

     Purpose:  Returns a random positive integer.

      Syntax:  RandomInteger()

      Output:  Random integer that is greater than or equal to 0 and less
               than or equal to a machine specific number (e.g., 32767).

     Related:  ceil  floor  int  max  min  round  RoundDigits  sign  MathFunctions

       (1) %--------------------------------------------------------------------
       (2) % Example: RandomInteger
       (3) %--------------------------------------------------------------------
       (4) randomIntegerA = RandomInteger()
    -> (5) randomIntegerA = 9396

       (6) randomIntegerB = RandomInteger()
    -> (7) randomIntegerB = 9930

       (8) randomIntegerC = RandomInteger()
    -> (9) randomIntegerC = 20325

#### ReplaceString

    ReplaceString

     Purpose:  Replaces strings in an expression with new strings.
               Truncates numbers in an expression (possibly simplifying it) by
               using the number of significant digits determined by SetDigits.

    Syntax 1:  ReplaceString( mathExpression )
    Syntax 2:  ReplaceString( mathExpression, string1=rhs1, string2=rhs2, ... )
    Syntax 3:  QueryReplaceString( mathExpression, string1=rhs1, string2=rhs2 )

       Input:  mathExpression -- A scalar, vector, dyadic or matrix expression.
               stringi -- A string of characters appearing in mathExpression.
               rhsi -- An expression to substitute for stringi. (i=1, 2, ...)

    Output 1:  Returns mathExpression with numbers rounded to the number
               of digits used for display which is determined by SetDigits
               (generally, less precise numbers are displayed than stored).

    Output 2:  Returns mathExpression with stringi replaced by rhsi
               wherever stringi appears in mathExpression.
               Numbers are also truncated as described above.

    Output 3:  Similar to Output 2 except that for each occurrence of stringi
               in mathExpression, queries whether or not replacement should occur.

      Remark:  The  ReplaceString  command  uses a string replacement
               which ignores mathematical rules as shown in Example 1:

      Remark:  Also see RoundDigits.

     Related:  Epsilon  Evaluate  Expand  Explicit
               Factor  FactorLinear  FactorQuadratic  ReplaceString  RoundDigits
               GetRhs  SetAutoRhs  SetDigits

       (1) %--------------------------------------------------------------------
       (2) % Example 1: ReplaceString   (scalar expression)
       (3) %--------------------------------------------------------------------
       (4) Constant  a, x, y, z
       (5) s = x^2*cos(y) - sin(t)
    -> (6) s = x^2*cos(y) - sin(t)

       (7) s1 = ReplaceString( s,  2*cos(y) = z )
    -> (8) s1 = x^z - sin(t)

       (9) s2 = ReplaceString( s,  x^2*cos(y) = z )
    -> (10) s2 = z - sin(t)

       (11) se = ReplaceString( s,  x^2*cos(y) - sin(t) = 3*z )
    -> (12) se = 3*z

       (13) %--------------------------------------------------------------------
       (14) % Example 2: ReplaceString  (vector expression)
       (15) %--------------------------------------------------------------------
       (16) RigidBody   B
       (17) v> = Vector( B, (1.0000000000004)*x, (1.0000004)*x*y, (1.0004)*x*y*z )
    -> (18) v> = 1*x*Bx> + 1*x*y*By> + 1.0004*x*y*z*Bz>

       (19) v1> = ReplaceString( v> )
    -> (20) v1> = x*Bx> + x*y*By> + 1.0004*x*y*z*Bz>

       (21) v2> = ReplaceString( v>,  x*y = z )
    -> (22) v2> = x*Bx> + z*By> + 1.0004*z^2*Bz>

       (23) %--------------------------------------------------------------------
       (24) % Example 3: ReplaceString   (matrix expression)
       (25) %--------------------------------------------------------------------
       (26) matrixA = [ v>;   x*y - z ]
    -> (27) matrixA = [1*x*Bx> + 1*x*y*By> + 1.0004*x*y*z*Bz>;  x*y - z]

       (28) matrixB = ReplaceString( matrixA,  x*y - z = 5 )
    -> (29) matrixB = [x*Bx> + x*y*By> + 1.0004*x*y*z*Bz>;  5]

       (30) %--------------------------------------------------------------------
       (31) % Example 4: QueryReplaceString
       (32) %--------------------------------------------------------------------
       (33) q = QueryReplaceString( t + t^2 + sin(t) + cos(t),  t^2 = 9, cos(t) = exp(t) )
    -> (34) q = 9 + t + sin(t) + exp(t)

#### RigidBody

    RigidBody

     Purpose:  Declares rigid bodies.

    Syntax 1:  RigidBody  A, B, ...     (creates rigid bodies A, B, ...)
    Syntax 2:  RigidBody                (displays all names declared as RigidBody)

       Input:  A -- name that starts with a letter, followed by a reasonable
                    number of alphanumeric characters (similarly for B).

    Output 1:  The declaration  RigidBody B  automatically creates right-handed
               orthogonal unit vectors Bx>, By>, Bz>  fixed in B and creates a
               point Bcm (B's center of mass) that is fixed in B and creates a
               point Bo  (called B's origin)  that is fixed in B (welded to B).

      Remark:  RigidBody B{1:4}       is same as  RigidBody B1, B2, B3, B4
               RigidBody B{1:3}Ed     is same as  RigidBody B1Ed, B2Ed, B3Ed
               RigidBody B{1:2}{2:3}  is same as  RigidBody B12, B13, B22, B23

      Remark:  The declaration  Point P(B)       welds point P to rigid body B.
               The declaration  RigidFrame F(B)  welds F to rigid body B.

     Related:  NewtonianFrame  Particle  Point  RigidBody  RigidFrame  System
               SetMass         SetInertia   SetMassInertia

       (1) %--------------------------------------------------------------------
       (2) % Example: RigidBody
       (3) %--------------------------------------------------------------------
       (4) RigidBody A
       (5) RigidBody B, C
       (6) RigidBody F{3:5}Ed
       (7) %--------------------------------------------------------------------
       (8) % Example 2: RigidBody  (typing RigidBody displays the following)
       (9) %--------------------------------------------------------------------
       (10) % The following have been declared RigidBody:
       (11) %
       (12) % A  B  C  F3Ed  F4Ed  F5Ed
       (13) %--------------------------------------------------------------------
       (14) % Example 3: RigidBody  (SetMass and SetInertia -- for a RigidBody)
       (15) %--------------------------------------------------------------------
       (16) A.SetMass( mA )
       (17) B.SetMass( mB )
       (18) mAB = A.GetMass() + B.GetMass()
    -> (19) mAB = mA + mB

       (20) A.SetInertia( Ao,  IAxx, IAyy, IAzz )
       (21) B.SetInertia( Bcm, IBxx, IByy, IBzz, IBxy, IByz, IBzx )
       (22) C.SetMassInertia( mC, Ccm, ICxx, ICyy, ICzz )
       (23) IC = C.GetInertiaMatrix( CCm, C )
    -> (24) IC = [ICxx, 0, 0;  0, ICyy, 0;  0, 0, ICzz]

#### RigidFrame

    RigidFrame

     Purpose:  Declares a rigid frame (reference frame).
               Welds a rigid frame to a RigidBody or another RigidFrame.

    Syntax 1:  RigidFrame  A, B, ...    (creates rigid frames A, B, ...)
    Syntax 2:  RigidFrame  B( D )       (creates rigid frame B welded to D)
    Syntax 3:  RigidFrame               (displays names of all RigidFrames)

       Input:  A -- name that starts with a letter, followed by a reasonable
                    number of alphanumeric characters (similarly for B).

               D -- name of a RigidFrame or RigidBody.

    Output 1:  The declaration  RigidFrame A  automatically creates right-handed
               orthogonal unit vectors Ax>, Ay>, Az>  fixed in A and creates a
               point Ao  (called A's origin)  that is fixed in A (welded to A).

    Output 2:  Creates RigidFrame B and welds it to RigidBody or RigidFrame D.
               Sets  B's  angular velocity/acceleration in D to 0>.
               Sets  point Bo's  velocity/acceleration  in D to 0>.
               Propagates force/torques on B to resultant forces/moments on D.

               RigidFrame B{1:4}       is same as  RigidFrame B1, B2, B3, B4
               RigidFrame B{1:3}Ed     is same as  RigidFrame B1Ed, B2Ed, B3Ed
               RigidFrame B{1:2}{2:3}  is same as  RigidFrame B12, B13, B22, B23

      Remark:  The NewtonianFrame is a special RigidFrame.

      Remark:  The declaration  Point P(B)  welds point P to RigidFrame B.

     Related:  NewtonianFrame  Particle  Point  RigidBody  RigidFrame  System

       (1) %--------------------------------------------------------------------
       (2) % Example: RigidFrame
       (3) %--------------------------------------------------------------------
       (4) RigidFrame A, D
       (5) RigidFrame B( D )
       (6) RigidFrame G{3:5}Ed
       (7) %--------------------------------------------------------------------
       (8) % Example 2: RigidFrame  (typing RigidFrame displays the following)
       (9) %--------------------------------------------------------------------
       (10) % The following have been declared RigidFrame:
       (11) %
       (12) % A  B(D)  D  G3Ed  G4Ed  G5Ed

#### round

    round

     Purpose:  Returns the integer nearest to a real number.

      Syntax:  round( realScalarExpression )

       Input:  realScalarExpression -- a real scalar expression.

      Output:  Integer nearest to realScalarExpression.
               Positive numbers with a fractional part of 0.5 round up whereas
               negative numbers with a fractional part of -0.5 round down.

      Remark:  Also see RoundDigits.

     Related:  ceil  floor  int  max  min  round  RoundDigits  sign  MathFunctions

       (1) %--------------------------------------------------------------------
       (2) % Example: Round
       (3) %--------------------------------------------------------------------
       (4) A = Round( 2.991 )
    -> (5) A = 3

       (6) B = Round( 3.001 )
    -> (7) B = 3

       (8) C = Round( -2.991 )
    -> (9) C = -3

       (10) D = Round( -3.001 )
    -> (11) D = -3

       (12) E = Round( 2.9 + t )
    -> (13) E = round(2.9+t)

       (14) F = Round(  2.499999999 )
    -> (15) F = 2

       (16) G = Round( -2.499999999 )
    -> (17) G = -2

       (18) H = Round(  3.5 )
    -> (19) H = 4

       (20) I = Round( -3.5 )
    -> (21) I = -4

#### RoundDigits

    RoundDigits

     Purpose:  Truncates numbers in an expression to a number of significant digits.

      Syntax:  RoundDigits( expression, n )

       Input:  expression -- a scalar, vector, dyadic, or matrix expression.
               n -- a positive integer less than or equal to 16.

      Output:  An approximation of expression in which all its numbers are
               truncated to n significant digits.

      Remark:  Also see Epsilon and ReplaceString.

     Related:  Epsilon  Evaluate  Expand  Explicit
               Factor  FactorLinear  FactorQuadratic  ReplaceString  RoundDigits
               GetRhs  SetAutoRhs  SetDigits

       (1) %--------------------------------------------------------------------
       (2) % Example 1:  RoundDigits  (scalar expression)
       (3) %--------------------------------------------------------------------
       (4) s = 2E-11 + 1.00007*t + (9876 + 5E-8)*sin(t)
    -> (5) s = 2E-11 + 1.00007*t + 9876*sin(t)

       (6) s1 = RoundDigits( s,  1 )
    -> (7) s1 = 2E-11 + t + 10000*sin(t)

       (8) s2 = RoundDigits( s,  2 )
    -> (9) s2 = 2E-11 + t + 9900*sin(t)

       (10) s3 = RoundDigits( s,  3 )
    -> (11) s3 = 2E-11 + t + 9880*sin(t)

       (12) s4 = RoundDigits( s,  4 )
    -> (13) s4 = 2E-11 + t + 9876*sin(t)

       (14) %--------------------------------------------------------------------
       (15) % Example 2:  RoundDigits  (vector expression)
       (16) %--------------------------------------------------------------------
       (17) RigidFrame  N
       (18) v> = Vector( N,  2E-11, 1.00007*t, (9876 + 5E-8)*sin(t) )
    -> (19) v> = 2E-11*Nx> + 1.00007*t*Ny> + 9876*sin(t)*Nz>

       (20) v1> = RoundDigits( v>,  1 )
    -> (21) v1> = 2E-11*Nx> + t*Ny> + 10000*sin(t)*Nz>

       (22) v2> = RoundDigits( v>,  2 )
    -> (23) v2> = 2E-11*Nx> + t*Ny> + 9900*sin(t)*Nz>

       (24) %--------------------------------------------------------------------
       (25) % Example 3:  RoundDigits  (matrix expression)
       (26) %--------------------------------------------------------------------
       (27) m = [s; v>]
    -> (28) m = [s;  2E-11*Nx> + 1.00007*t*Ny> + 9876*sin(t)*Nz>]

       (29) m1 = RoundDigits( m,  3 )
    -> (30) m1 = [s;  2E-11*Nx> + t*Ny> + 9880*sin(t)*Nz>]

       (31) m2 = RoundDigits( m,  4 )
    -> (32) m2 = [s;  2E-11*Nx> + t*Ny> + 9876*sin(t)*Nz>]

#### Rotate

    Rotate

     Purpose:  Sets the rotation matrix (direction cosine matrix) associated
               with the right-handed rotation of a rigid basis (e.g., B) in
               another rigid basis (e.g., A).  Tries to form B's angular
               velocity/acceleration in A and in the NewtonianFrame.

    Syntax 1:  B.Rotate( A, matrix33 )
    Syntax 2:  B.Rotate( A, aboutUnitVector, theta )
    Syntax 3:  B.Rotate( A, SequenceIJK, q1, q2, q3 )
    Syntax 4:  B.Rotate( A, EulerParameters, e0, e1, e2, e3 )
               B.Rotate( A, Quaternion,      e0, e1, e2, e3 )
    Syntax 5:  B.Rotate( A, RodriguesParameters, rho1, rho2, rho3 )
    Syntax 6:  B.RotateX( A, theta )     B.RotateNegativeX( A, theta )
               B.RotateY( A, theta )     B.RotateNegativeY( A, theta )
               B.RotateZ( A, theta )     B.RotateNegativeZ( A, theta )
               Type  HELP RotateX  for examples.

       Input:  B, A -- names of a RigidFrame or RigidBody.

               matrix33 -- 3x3 rotation matrix (direction cosine matrix).

               theta, q1, q2, q3 -- angles (scalar expressions).

               e0, e1, e2, e3 -- expressions for Euler parameters (quaternion).

               rho1, rho2, rho3 -- expressions for Rodrigues parameters.

               aboutUnitVector -- unit vector that can be expressed in terms of
                                  either  Ax>, Ay>, Az>  or  Bx>, By>, Bz>.

               SequenceIJK -- BodyIJK or SpaceIJK, e.g., of the form:
                       BodyXYZ,  BodyYZX,  BodyZXY,  BodyXZY,  BodyYXZ,  BodyZYX
                       BodyXYX,  BodyXZX,  BodyYXY,  BodyYZY,  BodyZXZ,  BodyZYZ
                      SpaceXYZ, SpaceYZX, SpaceZXY, SpaceXZY, SpaceYXZ, SpaceZYX
                      SpaceXYX, SpaceXZX, SpaceYXY, SpaceYZY, SpaceZXZ, SpaceZYZ

      Output:  Sets and returns the rotation matrix B_A that is associated with
               right-handed rotations of B relative to A.  This rotation matrix
               relates unit vectors Bx>, By>, Bz>  to  Ax>, Ay>, Az>.

               B's angular velocity and angular acceleration in A are also
               formed if rotation matrix can be time-differentiated.

               B's angular velocity and angular acceleration in the
               NewtonianFrame are also formed if a NewtonianFrame was
               declared and the angular velocity and angular acceleration
               of A in the NewtonianFrame is in the workspace.

      Remark:  Definitions of orientation angles, Euler parameters (quaternion),
               Rodrigues parameters and direction cosines are in
               Kane, Likins, Levinson: Spacecraft Dynamics, McGraw-Hill, Ch. 1, and
               Mitiguy, Paul, "Advanced Dynamics & Motion Simulation".

      Remark:  The command SetRotationMatrixODE also forms ODEs for the
               associated variables, e.g., the angles, or quaternion or ...

     Related:  Rotate  RotateX  RotateY  RotateZ
               RotateNegativeX  RotateNegativeY  RotateNegativeZ
               SetRotationMatrixX  SetRotationMatrixY  SetRotationMatrixZ
               SetRotationMatrixNegativeX  SetRotationMatrixNegativeY  ...
               SetRotationMatrix  SetAngularVelocity  SetAngularAcceleration
               GetRotationMatrix  GetAngularVelocity  GetAngularAcceleration
               SetRotationMatrixODE

       (1) RigidFrame A, B, C, D, E, F, G
       (2) %--------------------------------------------------------------------
       (3) % Example 1: Rotate (from rotation matrix).
       (4) %--------------------------------------------------------------------
       (5) Variable  R{1:3}{1:3}
       (6) B.Rotate( A, [R11,R12,R13; R21,R22,R23; R31,R32,R33] )
    -> (7) B_A = [R11, R12, R13;  R21, R22, R23;  R31, R32, R33]

       (8) %--------------------------------------------------------------------
       (9) % Example 2: Rotate (simple rotation about a unit vector).
       (10) %--------------------------------------------------------------------
       (11) Variable   theta''
       (12) C.Rotate( B, GetUnitVector( Bx> + By> ),  theta )
    -> (13) C_B[1,1] = 0.5 + 0.5*cos(theta)
    -> (14) C_B[1,2] = 0.5 - 0.5*cos(theta)
    -> (15) C_B[1,3] = -0.7071068*sin(theta)
    -> (16) C_B[2,1] = 0.5 - 0.5*cos(theta)
    -> (17) C_B[2,2] = 0.5 + 0.5*cos(theta)
    -> (18) C_B[2,3] = 0.7071068*sin(theta)
    -> (19) C_B[3,1] = 0.7071068*sin(theta)
    -> (20) C_B[3,2] = -0.7071068*sin(theta)
    -> (21) C_B[3,3] = cos(theta)
    -> (22) w_C_B> = 0.7071068*theta'*Bx> + 0.7071068*theta'*By>
    -> (23) alf_C_B> = 0.7071068*theta''*Bx> + 0.7071068*theta''*By>

       (24) %--------------------------------------------------------------------
       (25) % Example 3: Rotate (successive Body-fixed rotations with 3 angles).
       (26) %--------------------------------------------------------------------
       (27) Variable   q1'', q2'', q3''
       (28) D.Rotate( C, BodyXYZ,   q1, q2, q3 )
    -> (29) D_C[1,1] = cos(q2)*cos(q3)
    -> (30) D_C[1,2] = sin(q3)*cos(q1) + sin(q1)*sin(q2)*cos(q3)
    -> (31) D_C[1,3] = sin(q1)*sin(q3) - sin(q2)*cos(q1)*cos(q3)
    -> (32) D_C[2,1] = -sin(q3)*cos(q2)
    -> (33) D_C[2,2] = cos(q1)*cos(q3) - sin(q1)*sin(q2)*sin(q3)
    -> (34) D_C[2,3] = sin(q1)*cos(q3) + sin(q2)*sin(q3)*cos(q1)
    -> (35) D_C[3,1] = sin(q2)
    -> (36) D_C[3,2] = -sin(q1)*cos(q2)
    -> (37) D_C[3,3] = cos(q1)*cos(q2)
    -> (38) w_D_C> = (sin(q3)*q2'+cos(q2)*cos(q3)*q1')*Dx> + (cos(q3)*q2'-sin(q3)*
            cos(q2)*q1')*Dy> + (q3'+sin(q2)*q1')*Dz>

    -> (39) alf_D_C> = (cos(q3)*q2'*q3'+sin(q3)*q2''+cos(q2)*cos(q3)*q1''-sin(q2)*
            cos(q3)*q1'*q2'-sin(q3)*cos(q2)*q1'*q3')*Dx> + (sin(q2)*sin(q3)*q1'*q2'
            +cos(q3)*q2''-sin(q3)*q2'*q3'-cos(q2)*cos(q3)*q1'*q3'-sin(q3)*cos(q2)*
            q1'')*Dy> + (cos(q2)*q1'*q2'+q3''+sin(q2)*q1'')*Dz>

       (40) %--------------------------------------------------------------------
       (41) % Example 4: Rotate (Euler parameters / quaternions).
       (42) %--------------------------------------------------------------------
       (43) Variable  e0'', e1'', e2'', e3''
       (44) E.Rotate( D,  EulerParameters, e0, e1, e2, e3 )
    -> (45) E_D[1,1] = -1 + 2*e0^2 + 2*e1^2
    -> (46) E_D[1,2] = 2*e0*e3 + 2*e1*e2
    -> (47) E_D[1,3] = 2*e1*e3 - 2*e0*e2
    -> (48) E_D[2,1] = 2*e1*e2 - 2*e0*e3
    -> (49) E_D[2,2] = -1 + 2*e0^2 + 2*e2^2
    -> (50) E_D[2,3] = 2*e0*e1 + 2*e2*e3
    -> (51) E_D[3,1] = 2*e0*e2 + 2*e1*e3
    -> (52) E_D[3,2] = 2*e2*e3 - 2*e0*e1
    -> (53) E_D[3,3] = -1 + 2*e0^2 + 2*e3^2
    -> (54) w_E_D> = (2*e0*e1'+2*e3*e2'-2*e1*e0'-2*e2*e3')*Ex> + (2*e0*e2'+2*e1*e3'
            -2*e2*e0'-2*e3*e1')*Ey> + (2*e0*e3'+2*e2*e1'-2*e1*e2'-2*e3*e0')*Ez>

    -> (55) alf_E_D> = (2*e0*e1''+2*e3*e2''-2*e1*e0''-2*e2*e3'')*Ex> + (2*e0*e2''+2
            *e1*e3''-2*e2*e0''-2*e3*e1'')*Ey> + (2*e0*e3''+2*e2*e1''-2*e1*e2''-2*
            e3*e0'')*Ez>

       (56) %--------------------------------------------------------------------
       (57) % Example 5: Rotate (Rodrigues parameters / Gibbs vector).
       (58) %--------------------------------------------------------------------
       (59) Variable  rho0'', rho1'', rho2''
       (60) F.Rotate( E,  RodriguesParameters, rho0, rho1, rho2 )
    -> (61) F_E[1,1] = (1+rho0^2-rho1^2-rho2^2)/(1+rho0^2+rho1^2+rho2^2)
    -> (62) F_E[1,2] = 2*(rho2+rho0*rho1)/(1+rho0^2+rho1^2+rho2^2)
    -> (63) F_E[1,3] = -2*(rho1-rho0*rho2)/(1+rho0^2+rho1^2+rho2^2)
    -> (64) F_E[2,1] = -2*(rho2-rho0*rho1)/(1+rho0^2+rho1^2+rho2^2)
    -> (65) F_E[2,2] = (1+rho1^2-rho0^2-rho2^2)/(1+rho0^2+rho1^2+rho2^2)
    -> (66) F_E[2,3] = 2*(rho0+rho1*rho2)/(1+rho0^2+rho1^2+rho2^2)
    -> (67) F_E[3,1] = 2*(rho1+rho0*rho2)/(1+rho0^2+rho1^2+rho2^2)
    -> (68) F_E[3,2] = -2*(rho0-rho1*rho2)/(1+rho0^2+rho1^2+rho2^2)
    -> (69) F_E[3,3] = -(-1+rho0^2+rho1^2-rho2^2)/(1+rho0^2+rho1^2+rho2^2)
    -> (70) w_F_E> = -2*(rho1*rho2'-rho0'-rho2*rho1')/(1+rho0^2+rho1^2+rho2^2)*Fx>
            + 2*(rho1'+rho0*rho2'-rho2*rho0')/(1+rho0^2+rho1^2+rho2^2)*Fy> - 2*(rh
            o0*rho1'-rho2'-rho1*rho0')/(1+rho0^2+rho1^2+rho2^2)*Fz>

    -> (71) alf_F_E> = 2*(2*(rho0*rho0'+rho1*rho1'+rho2*rho2')*(rho1*rho2'-rho0'-
            rho2*rho1')-(1+rho0^2+rho1^2+rho2^2)*(rho1*rho2''-rho0''-rho2*rho1''))/
            (1+rho0^2+rho1^2+rho2^2)^2*Fx> - 2*(2*(rho0*rho0'+rho1*rho1'+rho2*rho2')
            *(rho1'+rho0*rho2'-rho2*rho0')-(1+rho0^2+rho1^2+rho2^2)*(rho1''+rho0*
            rho2''-rho2*rho0''))/(1+rho0^2+rho1^2+rho2^2)^2*Fy> + 2*(2*(rho0*rho0'+
            rho1*rho1'+rho2*rho2')*(rho0*rho1'-rho2'-rho1*rho0')-(1+rho0^2+rho1^2+rho2^2)
            *(rho0*rho1''-rho2''-rho1*rho0''))/(1+rho0^2+rho1^2+rho2^2)^2*Fz>

       (72) %--------------------------------------------------------------------
       (73) % Example 6: RotateX (simple rotation about Gx> = Fx>).
       (74) %--------------------------------------------------------------------
       (75) G.RotateX( F,  theta )
    -> (76) G_F = [1, 0, 0;  0, cos(theta), sin(theta);  0, -sin(theta), cos(theta)]
    -> (77) w_G_F> = theta'*Gx>
    -> (78) alf_G_F> = theta''*Gx>

       (79) %--------------------------------------------------------------------
       (80) % Note: For more HELP, try:   RotateX   RotateY   RotateZ

#### RotateX

    RotateX    RotateNegativeX      (RotatePositiveX is identical to RotateX)

     Purpose:  Forms the rotation matrix (direction cosine matrix) associated
               with the right-handed rotation of a rigid basis (e.g., B) in
               another rigid basis (e.g., A).  Tries to form B's angular
               velocity/acceleration in A and in the NewtonianFrame.

    Syntax 1:  B.RotateX( A, q )
    Syntax 2:  B.RotateX( A, q, u )
    Syntax 3:  B.RotateNegativeX( A, q )
    Syntax 4:  B.RotateNegativeX( A, q, u )

       Input:  B, A -- name of a RigidFrame or RigidBody.
               q -- expression for an angle.
               u -- name of an angular velocity variable.

    Output 1:  Sets and returns the B_A rotation matrix formed by a right-handed
               rotation of B relative to A about  Ax> = Bx>  by the angle q.
               By convention, when q = 0:  Ay> = By> and  Az> = Bz>.

               B's angular velocity and angular acceleration in A
               are also formed if q can be time differentiated.

               B's angular velocity and angular acceleration in the NewtonianFrame
               are also formed if a NewtonianFrame was declared and A's angular
               velocity/acceleration in the NewtonianFrame are in the workspace.

    Output 2:  Same as Output 1, except tries to form an ODE relating q' to u that
               allows for more efficient angular velocity/acceleration expressions.

    Output 3:  Same as Output 1, except B rotates about  -Ax> = -Bx>.

     Related:  Rotate  RotateX  RotateY  RotateZ
               RotateNegativeX  RotateNegativeY  RotateNegativeZ
               SetRotationMatrixX  SetRotationMatrixY  SetRotationMatrixZ
               SetRotationMatrixNegativeX  SetRotationMatrixNegativeY  ...
               SetRotationMatrix  SetAngularVelocity  SetAngularAcceleration
               GetRotationMatrix  GetAngularVelocity  GetAngularAcceleration
               SetRotationMatrixODE

       (1) %--------------------------------------------------------------------
       (2) % Example 1:  RotateX   (with angle)
       (3) %--------------------------------------------------------------------
       (4) NewtonianFrame N
       (5) RigidFrame     A
       (6) Variable       qA''
       (7) A.RotateX( N, qA )
    -> (8) A_N = [1, 0, 0;  0, cos(qA), sin(qA);  0, -sin(qA), cos(qA)]
    -> (9) w_A_N> = qA'*Ax>
    -> (10) alf_A_N> = qA''*Ax>

       (11) %--------------------------------------------------------------------
       (12) % Example 2:  RotateNegativeX   (with angle and rate)
       (13) %--------------------------------------------------------------------
       (14) RigidFrame    B
       (15) Variable      qB'', wB'
       (16) B.RotateNegativeX( A, qB, wB )
    -> (17) B_A = [1, 0, 0;  0, cos(qB), -sin(qB);  0, sin(qB), cos(qB)]
    -> (18) qB' = wB + qA'
    -> (19) w_B_A> = -qB'*Bx>
    -> (20) w_B_N> = -wB*Ax>
    -> (21) qB'' = wB' + qA''
    -> (22) alf_B_A> = -qB''*Bx>
    -> (23) alf_B_N> = -wB'*Bx>

       (24) %--------------------------------------------------------------------
       (25) % Note: For more HELP, try:   Rotate   RotateX   RotateY   RotateZ

#### RotateY

    RotateY    RotateNegativeY      (RotatePositiveY is identical to RotateY)

     Purpose:  Forms the rotation matrix (direction cosine matrix) associated
               with the right-handed rotation of a rigid basis (e.g., B) in
               another rigid basis (e.g., A).  Tries to form B's angular
               velocity/acceleration in A and in the NewtonianFrame.

    Syntax 1:  B.RotateY( A, q )
    Syntax 2:  B.RotateY( A, q, u )
    Syntax 3:  B.RotateNegativeY( A, q )
    Syntax 4:  B.RotateNegativeY( A, q, u )

       Input:  B, A -- name of a RigidFrame or RigidBody.
               q -- expression for an angle.
               u -- name of an angular velocity variable.

    Output 1:  Sets and returns the B_A rotation matrix formed by a right-handed
               rotation of B relative to A about  Ay> = By>  by the angle q.
               By convention, when q = 0:  Ax> = Bx> and  Az> = Bz>.

               B's angular velocity and angular acceleration in A
               are also formed if q can be time differentiated.

               B's angular velocity and angular acceleration in the NewtonianFrame
               are also formed if a NewtonianFrame was declared and A's angular
               velocity/acceleration in the NewtonianFrame are in the workspace.

    Output 2:  Same as Output 1, except tries to form an ODE relating q' to u that
               allows for more efficient angular velocity/acceleration expressions.

    Output 3:  Same as Output 1, except B rotates about  -Ay> = -By>.

     Related:  Rotate  RotateX  RotateY  RotateZ
               RotateNegativeX  RotateNegativeY  RotateNegativeZ
               SetRotationMatrixX  SetRotationMatrixY  SetRotationMatrixZ
               SetRotationMatrixNegativeX  SetRotationMatrixNegativeY  ...
               SetRotationMatrix  SetAngularVelocity  SetAngularAcceleration
               GetRotationMatrix  GetAngularVelocity  GetAngularAcceleration
               SetRotationMatrixODE

       (1) %--------------------------------------------------------------------
       (2) % Example 1:  RotateY   (with angle)
       (3) %--------------------------------------------------------------------
       (4) NewtonianFrame N
       (5) RigidFrame     A
       (6) Variable       qA''
       (7) A.RotateY( N, qA )
    -> (8) A_N = [cos(qA), 0, -sin(qA);  0, 1, 0;  sin(qA), 0, cos(qA)]
    -> (9) w_A_N> = qA'*Ay>
    -> (10) alf_A_N> = qA''*Ay>

       (11) %--------------------------------------------------------------------
       (12) % Example 2:  RotateNegativeY   (with angle and rate)
       (13) %--------------------------------------------------------------------
       (14) RigidFrame    B
       (15) Variable      qB'', wB'
       (16) B.RotateNegativeY( A, qB, wB )
    -> (17) B_A = [cos(qB), 0, sin(qB);  0, 1, 0;  -sin(qB), 0, cos(qB)]
    -> (18) qB' = wB + qA'
    -> (19) w_B_A> = -qB'*By>
    -> (20) w_B_N> = -wB*Ay>
    -> (21) qB'' = wB' + qA''
    -> (22) alf_B_A> = -qB''*By>
    -> (23) alf_B_N> = -wB'*By>

       (24) %--------------------------------------------------------------------
       (25) % Note: For more HELP, try:   Rotate   RotateX   RotateY   RotateZ

#### RotateZ

    RotateZ    RotateNegativeZ      (RotatePositiveZ is identical to RotateZ)

     Purpose:  Forms the rotation matrix (direction cosine matrix) associated
               with the right-handed rotation of a rigid basis (e.g., B) in
               another rigid basis (e.g., A).  Tries to form B's angular
               velocity/acceleration in A and in the NewtonianFrame.

    Syntax 1:  B.RotateZ( A, q )
    Syntax 2:  B.RotateZ( A, q, u )
    Syntax 3:  B.RotateNegativeZ( A, q )
    Syntax 4:  B.RotateNegativeZ( A, q, u )

       Input:  B, A -- name of a RigidFrame or RigidBody.
               q -- expression for an angle.
               u -- name of an angular velocity variable.

    Output 1:  Sets and returns the B_A rotation matrix formed by a right-handed
               rotation of B relative to A about  Az> = Bz>  by the angle q.
               By convention, when q = 0:  Ax> = Bx> and  Ay> = By>.

               B's angular velocity and angular acceleration in A
               are also formed if q can be time differentiated.

               B's angular velocity and angular acceleration in the NewtonianFrame
               are also formed if a NewtonianFrame was declared and A's angular
               velocity/acceleration in the NewtonianFrame are in the workspace.

    Output 2:  Same as Output 1, except tries to form an ODE relating q' to u that
               allows for more efficient angular velocity/acceleration expressions.

    Output 3:  Same as Output 1, except B rotates about  -Az> = -Bz>.

     Related:  Rotate  RotateX  RotateY  RotateZ
               RotateNegativeX  RotateNegativeY  RotateNegativeZ
               SetRotationMatrixX  SetRotationMatrixY  SetRotationMatrixZ
               SetRotationMatrixNegativeX  SetRotationMatrixNegativeY  ...
               SetRotationMatrix  SetAngularVelocity  SetAngularAcceleration
               GetRotationMatrix  GetAngularVelocity  GetAngularAcceleration
               SetRotationMatrixODE

       (1) %--------------------------------------------------------------------
       (2) % Example 1:  RotateZ   (with angle)
       (3) %--------------------------------------------------------------------
       (4) NewtonianFrame N
       (5) RigidFrame     A
       (6) Variable       qA''
       (7) A.RotateZ( N, qA )
    -> (8) A_N = [cos(qA), sin(qA), 0;  -sin(qA), cos(qA), 0;  0, 0, 1]
    -> (9) w_A_N> = qA'*Az>
    -> (10) alf_A_N> = qA''*Az>

       (11) %--------------------------------------------------------------------
       (12) % Example 2:  RotateNegativeZ   (with angle and rate)
       (13) %--------------------------------------------------------------------
       (14) RigidFrame    B
       (15) Variable      qB'', wB'
       (16) B.RotateNegativeZ( A, qB, wB )
    -> (17) B_A = [cos(qB), -sin(qB), 0;  sin(qB), cos(qB), 0;  0, 0, 1]
    -> (18) qB' = wB + qA'
    -> (19) w_B_A> = -qB'*Bz>
    -> (20) w_B_N> = -wB*Az>
    -> (21) qB'' = wB' + qA''
    -> (22) alf_B_A> = -qB''*Bz>
    -> (23) alf_B_N> = -wB'*Bz>

       (24) %--------------------------------------------------------------------
       (25) % Note: For more HELP, try:   Rotate   RotateX   RotateY   RotateZ

#### Run

    Run

     Purpose:  Reads (loads) a file containing a sequence of program commands.

    Syntax 1:  Run FileName.txt
    Syntax 2:  Run

    Output 1:  Execution of commands in the file named FileName.txt
               The file name extension should be  .txt  or  .al

    Output 2:  Continued execution of lines in a command file that follow
               a line or error that previously caused execution to halt.

      Remark:  FileName.txt is the name of a command file located in the:
               (a) Current working directory
               (b) Directory specified via a relative path
               (c) Directory specified via an absolute path

               For example, valid commands include:
               Run Pendulum.txt
               Run ..\PendulumDirectory\Pendulum.txt   (PC/Windows)
               Run ../PendulumDirectory/Pendulum.txt   (Unix/Macintosh)
               Run \PendulumDirectory\Pendulum.txt     (PC/Windows)
               Run /PendulumDirectory/Pendulum.txt     (Unix/Macintosh)

      Remark:  Command files should be named with the extension  .txt  or  .al
               Just typing  FileName.txt   is identical to   Run FileName.txt

      Remark:  The Run command can be used within one command file to start
               execution of other command files.

      Remark:  Command files are ASCII text files with line breaks.
               Use a text editor or do a proper Save-As in a word processor.

     Related:  !  %  &  Clear  Save  Run  Quit  if  else  elseif

    --------------------------------------------------------------------
     Example:  Prepare the file "Test.txt" in ASCII text format as follows.
    --------------------------------------------------------------------
              % Test.txt
              a = 1 + 2 + pi + 3*t + 4*t

    --------------------------------------------------------------------
     At the MotionGenesis command prompt, type:  Run Test.txt
    --------------------------------------------------------------------

       (1) % Run.al
       (2) a = 1 + 2 + pi + 3*t + 4*t
    -> (3) a = 6.141593 + 7*t

#### Save

    Save  SaveOverwrite  (or Print)

     Purpose:  Creates a text file containing input or input and output.
               To print the file, open it with a text editor and print.

    Syntax 1:  Save FileName.txt
               Save FileName.txt,  m
               Save FileName.txt,  m:n
    Syntax 2:  Save FileName.all
               SaveOverwrite FileName.all
    Syntax 3:  SaveOverwrite FileName.html
               Save FileName.html
               Save FileName.html,  m
               Save FileName.html,  m:n

       Input:  FileName.txt  -- a file whose extension is .txt or .al
               FileName.all  -- a file whose extension is .all
               FileName.html -- a file whose extension is .html or .htm

               m -- the line number of the first line to be saved
               n -- the line number of the last  line to be saved
                    the default value for n is the last line.

    Output 1:  Creates a text file containing input lines only.
    Output 2:  Creates a text file containing input and program responses.
    Output 3:  Creates a html file containing input and program responses.

      Remark:  SaveOverwrite abc.all   overwrites abc.all  (no prompt to user).
               SaveOverwrite abc.html  overwrites abc.html (no prompt to user).

       Print:  To print a text file, open the file in a text editor
               (e.g., NotePad, TextWrangler, TextEdit, SimpleText, Emacs)
               or word-processor with Courier font (e.g., Microsoft Word)
               and print the file from within that program.

      Remark:  It is usually more efficient to use a text editor to
               create a command file and then use the Run command.

               If you instead choose to enter commands at the program prompt,
               save your commands with Save FileName.txt (not FileName.html).

      Remark:  FileName.txt is the name of a file to be located in the:
               (a) Current working directory
               (b) Directory specified via a relative path
               (c) Directory specified via an absolute path

               For example, valid commands include:
               Save Pendulum.txt
               Save ..\PendulumDirectory\Pendulum.txt   (PC/Windows)
               Save C:\PendulumDirectory\Pendulum.txt   (PC/Windows)
               Save ../PendulumDirectory/Pendulum.txt   (Unix/Macintosh)
               Save /PendulumDirectory/Pendulum.txt     (Unix/Macintosh)

     Related:  !  %  &  Clear  Save  Print  Run  Quit

    --------------------------------------------------------------------
     Example:  Type the following commands at the program prompt.
    --------------------------------------------------------------------
     a = 2 + 2
     b = 3 + 3
     Save SaveExample.txt
     Save SaveExample.all
     Save SaveExample.html
     Quit
    --------------------------------------------------------------------
     SaveExample.txt contains the following:
    --------------------------------------------------------------------
     a = 2 + 2
     b = 3 + 3
    --------------------------------------------------------------------
     SaveExample.all and SaveExample.html contain the following:
    --------------------------------------------------------------------
        (1) a = 2 + 2
     -> (2) a = 4

        (3) b = 3 + 3
     -> (4) b = 6

#### SetScratchDirectory

    SetScratchDirectory

     Purpose:  Specifies the operating system path to the directory
               used by the program for scratch files.

               PC/Windows:
               SetScratchDirectory C:\TempFolder

               MAC/Unix:
               SetScratchDirectory /TempFolder

      Remark:  To set the scratch directory, edit the MGDefaultPreferences.txt
               file that resides in the MotionGenesis MGToolbox folder.
               The previous examples show how to specify an existing folder
               on the computer's (hard) drive as the scratch directory.

      Remark:  If the scratch directory is not set (or is set improperly),
               scratch files are written to the current working directory.

      Remark:  The comment symbol % should not appear after SetScratchDirectory.

     Related:  GetDefaults  GetWorkingDirectory  SetWorkingDirectory
               GetEnvironmentValue   SetScratchDirectory

#### SetWorkingDirectory

    SetWorkingDirectory   GetWorkingDirectory

     Purpose:  Specifies the operating system path to write files.

    Syntax 1:  SetWorkingDirectory( pathToFolder )
    Syntax 2:  GetWorkingDirectory()

               PC/Windows:
               SetWorkingDirectory( C:\MotionGenesis )
               SetWorkingDirectory( "C:\Documents and Settings\Paul" )

               MAC/Unix:
               SetWorkingDirectory( /MotionGenesis )
               SetWorkingDirectory( /Paul/Mechanics/Simulations )

      Remark:  The syntax for pathToFolder depends on the operating system.
               The previous examples show how to specify an existing folder
               on the computer's (hard) drive as the working directory.

      Remark:  Alternately, edit the file  MGDefaultPreferences.txt
               that resides in the MotionGenesis MGToolbox folder.

     Related:  GetDefaults  GetWorkingDirectory  SetWorkingDirectory
               GetEnvironmentValue   SetScratchDirectory

#### SetAcceleration

    SetAcceleration

     Purpose:  Sets a point's acceleration in a reference frame.

    Syntax 1:  Q.SetAcceleration( N, fromPoint )
    Syntax 2:  Q.SetAcceleration( N, fromPoint, BFixed )
    Syntax 3:  Q.SetAcceleration( N, fromPoint, BFrame, BQ )
    Syntax 4:  Q.SetAcceleration( N, accelerationVector )

       Input:  Q -- name of a Point.
               N -- name of a RigidFrame or RigidBody.

               fromPoint -- Point whose velocity in N is already known.

               BFixed -- Rigid frame/body on which fromPoint and Q  are fixed.
               BFrame -- Rigid frame/body on which fromPoint and BQ are fixed.
                         Q is moving on BFrame.

               BQ -- Point of BFrame that is coincident with Q.

               accelerationVector -- an acceleration vector.

      Output:  Sets and returns Q's acceleration in N.

      Remark:  Syntax 2 may also set the following (if not in workspace):
                 fromPoint's velocity and acceleration in BFixed to 0>
                 Q's         velocity and acceleration in BFixed to 0>

               Syntax 3 may also set the following (if not in workspace):
                 fromPoint's velocity and acceleration in BFrame to 0>
                 BQ          may be defined as a physical point of BFrame
                 BQ's        velocity and acceleration in BFrame to 0>
                 BQ's        position from fromPoint
                 Q's         velocity in BFrame (via Q' position vector fromPoint)
                 Q's         acceleration in BFrame (via differentiation)

      Remark:  Q's position vector fromPoint is used by this command.

      Remark:  If Q is welded to rigid frame/body B, declare it:  Point Q(B).
               Alternately, if Q does not move on B (but is not welded or a
               physical point of B), use Q.SetVelocityAcceleration( B, 0> )

     Related:  Translate        SetPositionVelocity   SetVelocityAcceleration
               SetPosition      GetPosition   GetDistance  GetDistanceSquared
               SetVelocity      GetVelocity   GetSpeed     GetElongation
               SetAcceleration  GetAcceleration

       (1) %--------------------------------------------------------------------
       (2) % Example 1: SetAcceleration
       (3) % Set Q1's acceleration in N by differentiation.  Uses No fixed on N
       (4) %--------------------------------------------------------------------
       (5) RigidFrame N
       (6) Point      Q1
       (7) Variable   x1'', y1''
       (8) Q1.SetPosition( No,  x1*Nx> + y1*Ny> )
    -> (9) p_No_Q1> = x1*Nx> + y1*Ny>

       (10) Q1.SetAcceleration( N, No )
    -> (11) a_Q1_N> = x1''*Nx> + y1''*Ny>

       (12) %--------------------------------------------------------------------
       (13) % Example 2: SetAcceleration
       (14) % Set Q2's acceleration in N by differentiation and Q1's acceleration
       (15) %--------------------------------------------------------------------
       (16) Point     Q2
       (17) Variable  x2'', y2''
       (18) Q2.SetPosition( Q1,  x2*Nx> + y2*Ny> )
    -> (19) p_Q1_Q2> = x2*Nx> + y2*Ny>

       (20) Q2.SetAcceleration( N, Q1 )
    -> (21) a_Q2_N> = (x1''+x2'')*Nx> + (y1''+y2'')*Ny>

       (22) %--------------------------------------------------------------------
       (23) % Example 3: SetAcceleration
       (24) % Set Q3's acceleration in N via two points (Q3 and Bo) fixed on B.
       (25) %--------------------------------------------------------------------
       (26) RigidBody B                  % Body B translates and rotates in N.
       (27) Point     Q3( B )            % Q3 is a point fixed on B.
       (28) Constant  L                  % Distance between Bo and Q3.
       (29) Variable  wB'                % Angular rate and its time-derivative.
       (30) B.SetAngularVelocityAcceleration( N,  wB*Bz> )
    -> (31) w_B_N> = wB*Bz>
    -> (32) alf_B_N> = wB'*Bz>

       (33) Bo.SetAcceleration( N,  t*Nx> )
    -> (34) a_Bo_N> = t*Nx>

       (35) Q3.SetPosition( Bo,  L*Bx> )
    -> (36) p_Bo_Q3> = L*Bx>

       (37) Q3.SetAcceleration( N, Bo, B )
    -> (38) a_Q3_N> = -L*wB^2*Bx> + L*wB'*By> + t*Nx>

       (39) %--------------------------------------------------------------------
       (40) % Example 4: SetAcceleration
       (41) % Set Q4's acceleration in N via one point (Q4) moving on rigid-body B
       (42) %--------------------------------------------------------------------
       (43) Point      Q4,  BQ4( B )     % BQ4 is point of B coincident with Q4.
       (44) Variable   x4''
       (45) Q4.SetPosition( Bo,  x4*Bx> )
    -> (46) p_Bo_Q4> = x4*Bx>

       (47) Q4.SetAcceleration( N, Bo, B, BQ4 )
    -> (48) p_Bo_BQ4> = x4*Bx>
    -> (49) a_BQ4_N> = -x4*wB^2*Bx> + x4*wB'*By> + t*Nx>
    -> (50) v_Q4_B> = x4'*Bx>
    -> (51) a_Q4_B> = x4''*Bx>
    -> (52) a_Q4_N> = (x4''-x4*wB^2)*Bx> + (x4*wB'+2*wB*x4')*By> + t*Nx>

#### SetAngularAcceleration

    SetAngularAcceleration

     Purpose:  Sets a reference frame's angular acceleration.

    Syntax 1:  B.SetAngularAcceleration( N, angularAccelerationVector )
    Syntax 2:  B.SetAngularAcceleration( N )

       Input:  B, N -- name of a RigidFrame or RigidBody.
               angularAccelerationVector -- an angular acceleration vector.

    Output 1:  Sets and returns B's angular acceleration in N.
    Output 2:  Calculates, sets and returns B's angular acceleration in N.

     Related:  GetAngularAcceleration  Rotate  SetAngularVelocity  SetRotationMatrix

       (1) %--------------------------------------------------------------------
       (2) % Example: SetAngularAcceleration.al
       (3) %--------------------------------------------------------------------
       (4) RigidFrame N
       (5) RigidBody  A, B
       (6) Variable   wx', wy', wz',  w1', w2', w3'
       (7) A.SetAngularVelocityAcceleration( N, wx*Ax> + wy*Ay> + wz*Az> )
    -> (8) w_A_N> = wx*Ax> + wy*Ay> + wz*Az>
    -> (9) alf_A_N> = wx'*Ax> + wy'*Ay> + wz'*Az>

       (10) B.SetAngularVelocityAcceleration( A, w1*Ax> + w2*Ay> + w3*Az> )
    -> (11) w_B_A> = w1*Ax> + w2*Ay> + w3*Az>
    -> (12) alf_B_A> = w1'*Ax> + w2'*Ay> + w3'*Az>

       (13) B.SetAngularAcceleration( N )
    -> (14) alf_B_N> = (w3*wy+w1'+wx'-w2*wz)*Ax> + (w1*wz+w2'+wy'-w3*wx)*Ay> + (w2*
            wx+w3'+wz'-w1*wy)*Az>

#### SetAngularVelocity

    SetAngularVelocity

     Purpose:  Sets a reference frame's angular velocity.

    Syntax 1:  B.SetAngularVelocity( N, angularVelocityVector )
    Syntax 2:  B.SetAngularVelocity( A, SequenceI,   q1 )
    Syntax 3:  B.SetAngularVelocity( A, SequenceIJ,  q1, q2 )
    Syntax 4:  B.SetAngularVelocity( A, SequenceIJK, q1, q2, q3 )
    Syntax 5:  B.SetAngularVelocity( A, EulerParameters, e0, e1, e2, e3 )
               B.SetAngularVelocity( A, Quaternion,      e0, e1, e2, e3 )
    Syntax 6:  B.SetAngularVelocity( A, RodriguesParameters, rho1, rho2, rho3 )
    Syntax 7:  B.SetAngularVelocity( A, matrix33 )
    Syntax 8:  B.SetAngularVelocityFromRotationMatrix( N )
    Syntax 9:  B.SetAngularVelocity( N )

       Input:  B, N -- name of a RigidFrame or RigidBody.

               angularVelocityVector -- an angular velocity vector.

               q1, q2, q3 -- angles (scalar expressions).

               SequenceI -- BodyI or SpaceI where I is X, -X, Y, -Y, Z, -Z, e.g.,
                              BodyX,  BodyY,  BodyZ,  -BodyX,  Body-Y, etc.
                             SpaceX, SpaceY, SpaceZ, -SpaceX, Space-Y, etc.

               SequenceIJ -- BodyIJ or Space IJ where I and J are appropriate
                             combinations of X, -X, Y, -Y, Z, -Z, e.g.,
                             BodyXY,  BodyXZ,  BodyYX,  BodyYZ,  BodyZX,  BodyZY
                            SpaceXY, SpaceXZ, SpaceYX, SpaceYZ, SpaceZX, SpaceZY
                            Body-XY,  BodyX-Z,  Body-Y-X, Space-XY, etc.

               SequenceIJK -- BodyIJK or SpaceIJK where I, J, K are appropriate
                              combinations of X, -X, Y, -Y, Z, -Z, e.g.,
                       BodyXYZ,  BodyYZX,  BodyZXY,  BodyXZY,  BodyYXZ,  BodyZYX
                       BodyXYX,  BodyXZX,  BodyYXY,  BodyYZY,  BodyZXZ,  BodyZYZ
                      SpaceXYZ, SpaceYZX, SpaceZXY, SpaceXZY, SpaceYXZ, SpaceZYX
                      SpaceXYX, SpaceXZX, SpaceYXY, SpaceYZY, SpaceZXZ, SpaceZYZ
                      Body-XYZ, BodyX-YZ, BodyXY-Z, Body-X-YZ,  Space-X-Y-Z, etc.

               e0, e1, e2, e3 -- expressions for Euler parameters (quaternion).

               rho1, rho2, rho3 -- expressions for Rodrigues parameters.

               Rxx,Rxy,Rxz, Ryx,Ryy,Ryz, Rzx,Rzy,Rzz - expressions for elements.

               matrix33 -- 3x3 rotation matrix (direction cosine matrix).

     Output:   Calculates, sets, and returns B's angular velocity in N.
     Output 8: Calculates the B_N rotation matrix and calls Syntax 7.
     Output 9: Calculates B's angular velocity in N by the angular velocity addition
               theorem and/or time-derivatives of rotation matrices.

      Remark:  Definitions of orientation angles, Euler parameters (quaternion),
               Rodrigues parameters, and direction cosines are in
               Kane, Likins, Levinson: Spacecraft Dynamics, McGraw-Hill, Ch. 1, and
               Mitiguy, Paul, "Advanced Dynamics & Motion Simulation".

     Related:  Rotate  RotateX  RotateY  RotateZ
               RotateNegativeX  RotateNegativeY  RotateNegativeZ
               SetRotationMatrixX  SetRotationMatrixY  SetRotationMatrixZ
               SetRotationMatrixNegativeX  SetRotationMatrixNegativeY  ...
               SetRotationMatrix  SetAngularVelocity  SetAngularAcceleration
               GetRotationMatrix  GetAngularVelocity  GetAngularAcceleration
               SetRotationMatrixODE   SetRigidTransform
               SetAngularVelocityAcceleration

       (1) %--------------------------------------------------------------------
       (2) % Example: SetAngularVelocity
       (3) %--------------------------------------------------------------------
       (4) RigidFrame N
       (5) RigidBody  A, B
       (6) Variable   wx, wy, wz,  w1, w2, w3
       (7) A.SetAngularVelocity( N, wx*Ax> + wy*Ay> + wz*Az> )
    -> (8) w_A_N> = wx*Ax> + wy*Ay> + wz*Az>

       (9) B.SetAngularVelocity( A, w1*Bx> + w2*By> + w3*Bz> )
    -> (10) w_B_A> = w1*Bx> + w2*By> + w3*Bz>

       (11) B.SetAngularVelocity( N )
    -> (12) w_B_N> = wx*Ax> + wy*Ay> + wz*Az> + w1*Bx> + w2*By> + w3*Bz>

#### SetAngularVelocityAcceleration

    SetAngularVelocityAcceleration

     Purpose:  Sets a reference frame's angular velocity and angular acceleration.

      Syntax:  B.SetAngularVelocityAcceleration( A, angularVelocityVector )

       Input:  B, A -- name of a RigidFrame or RigidBody.
               angularVelocityVector -- an angular velocity vector.

      Output:  Sets B's angular velocity in A and B's angular acceleration in A.
               If possible, sets B's angular velocity in the NewtonianFrame.
               If possible, sets B's angular acceleration in NewtonianFrame.

     Related:  GetAngularVelocity  Rotate  SetAngularAcceleration  SetRotationMatrix

       (1) %--------------------------------------------------------------------
       (2) % Example 1: SetAngularVelocityAcceleration
       (3) % Set A's angular velocity and acceleration in N.
       (4) %--------------------------------------------------------------------
       (5) NewtonianFrame N
       (6) RigidFrame     A
       (7) Variable       wx', wy', wz'
       (8) A.SetAngularVelocityAcceleration( N, wx*Ax> + wy*Ay> + wz*Az> )
    -> (9) w_A_N> = wx*Ax> + wy*Ay> + wz*Az>
    -> (10) alf_A_N> = wx'*Ax> + wy'*Ay> + wz'*Az>

       (11) %--------------------------------------------------------------------
       (12) % Example 2: SetAngularVelocityAcceleration
       (13) % Set B's angular velocity and acceleration in both A and N.
       (14) %--------------------------------------------------------------------
       (15) RigidFrame    B
       (16) Variable      wBA'
       (17) B.SetAngularVelocityAcceleration( A, wBA*Az> )
    -> (18) w_B_A> = wBA*Az>
    -> (19) w_B_N> = wx*Ax> + wy*Ay> + (wBA+wz)*Az>
    -> (20) alf_B_A> = wBA'*Az>
    -> (21) alf_B_N> = (wBA*wy+wx')*Ax> + (wy'-wBA*wx)*Ay> + (wBA'+wz')*Az>

#### SetAutoDifferentiate

    SetAutoDifferentiate

     Purpose:  Controls whether or not ordinary derivatives of quantities
               declared as a Variable or Specified are automatically calculated.
               In other words, controls whether or not y', y'', y''', etc.,
               are automatically calculated and assigned when y is assigned.

      Syntax:  SetAutoDifferentiate( SETTING )

       Input:  SETTING -- ON or OFF

      Output:  When SETTING is ON, the ordinary derivatives of y are
               automatically assigned when y is assigned, e.g.,
               y', y'', and y''' are assigned when y is assigned.

      Remark:  Program default is SetAutoDifferentiate( OFF ).

     Related:  GetDefaults   SetAutoDifferentiate  SetAutoOverwrite
               Solve  SolveDt  SolveSetInput  SolveSetInputDt  ...
               SolveQuadraticPositiveRoot  SolveQuadraticPositiveRootDt  ...
               SetDt  SetNoDt   =   :=   +=   *=   /=   ^=

       (1) %--------------------------------------------------------------------
       (2) % Example 1:  No automatic differentiation
       (3) %--------------------------------------------------------------------
       (4) Variable  x'
       (5) SetAutoDifferentiate( OFF )
       (6) x = sin(t)
    -> (7) x = sin(t)

       (8) SetDt( x = cos(t) )
    -> (9) x = cos(t)
    -> (10) x' = -sin(t)

       (11) %--------------------------------------------------------------------
       (12) % Example 2:  Auto-differentiates y to assign  y'  and  y''
       (13) %--------------------------------------------------------------------
       (14) Variable  y''
       (15) SetAutoDifferentiate( ON )
       (16) y = t^3
    -> (17) y = t^3
    -> (18) y' = 3*t^2
    -> (19) y'' = 6*t

#### SetAutoEpsilon

    SetAutoEpsilon

     Purpose:  In every expression, rounds numbers suitably close to an integer.

    Syntax 1:  SetAutoEpsilon( absEpsilon )
    Syntax 2:  SetAutoEpsilon( absEpsilon, relEpsilon )
    Syntax 3:  GetAutoEpsilonAbsolute()
    Syntax 4:  GetAutoEpsilonRelative()

       Input:  absEpsilon a real number r such that:   0  <=  r  < 0.5
               relEpsilon a real number r such that:   0  <=  r  < 0.5

    Output 1:  In expressions, rounds any number that is within absEpsilon of
               an integer to that integer.  For a number of the form  x.y,  no
               rounding occurs if  absEpsilon <  abs(0.y)  <  1 - absEpsilon

    Output 2:  Rounds any number d within abs( d * relEpsilon) of an integer to
               that integer.  Also does the rounding described by Output 1.

    Output 3:  The first argument previously set by SetAutoEpsilon (or 0).
    Output 4:  The second argument previously set by SetAutoEpsilon (or 0).

      Remark:  Program default is SetAutoEpsilon( 0, 0 ), i.e., no rounding.
      Remark:  Use with caution.  AutoEpsilon has simplification side-effects.
               SetAutoEpsilon( 1.0E-14 )
               Expand( 2E-15 * t * (sin(t) + 3E+15 * t) )  simplifies to  6*t^2
                       2E-15 * t * (sin(t) + 3E+15 * t)    simplifies to  0.

     Related:  Epsilon  SetAutoEpsilon  SetDigits  RoundDigits  GetDefaults

       (1) %--------------------------------------------------------------------
       (2) % Examples:  SetAutoEpsilon
       (3) %--------------------------------------------------------------------
       (4) SetDigits 16
       (5) SetAutoEpsilon( 1.0E-14 )       % Absolute = 1.0E-14,  Relative = 0
       (6) v = 2E-11 + 1.00007*t + (9876 + 5E-8)*sin(t)
    -> (7) v = 2E-11 + 1.00007*t + 9876.00000005*sin(t)

       (8) %--------------------------------------------------------------------
       (9) SetAutoEpsilon( 1.0E-10 )       % Absolute = 1.0E-10,  Relative = 0
       (10) w = 2E-11 + 1.00007*t + (9876 + 5E-8)*sin(t)
    -> (11) w = 1.00007*t + 9876.00000005*sin(t)

       (12) %--------------------------------------------------------------------
       (13) SetAutoEpsilon( 0.0001 )        % Absolute = 1.0E-4,   Relative = 0
       (14) x = 2E-11 + 1.00007*t + (9876 + 5E-8)*sin(t)
    -> (15) x = t + 9876*sin(t)

       (16) %--------------------------------------------------------------------
       (17) SetAutoEpsilon( 0, 1E-7 )       % Absolute = 0,       Relative = 1E-7
       (18) y = 2E-11 + 1.00007*t + (9876 + 5E-8)*sin(t)
    -> (19) y = 2E-11 + 1.00007*t + 9876*sin(t)

       (20) %--------------------------------------------------------------------
       (21) SetAutoEpsilon( 0, 0.0001 )     % Absolute = 0,       Relative = 1E-4
       (22) z = 2E-11 + 1.00007*t + (9876 + 5E-8)*sin(t)
    -> (23) z = 2E-11 + t + 9876*sin(t)

       (24) %--------------------------------------------------------------------
       (25) % Note: AutoEpsilon has side-effects due to simplification.
       (26) SetAutoEpsilon( 1.0E-14 )       % Absolute = 1.0E-14,  Relative = 0
       (27) a = Expand( 2E-15 * t * (sin(t) + 3E+15 * t) )
    -> (28) a = 6*t^2

       (29) b =         2E-15 * t * (sin(t) + 3E+15 * t)
    -> (30) b = 0

#### SetAutoExpress

    SetAutoExpress

     Purpose:  For each rigid body, determines whether the body's angular velocity
               and angular acceleration in the NewtonianFrame are automatically
               expressed in terms of the body's unit vectors or in terms of
               unit vectors associated with the body's inertia dyadic.

      Syntax:  SetAutoExpress( SETTING )

       Input:  SETTING -- ON or OFF

      Remark:  For a RigidBody B,  SetAutoExpress( ON )  affects B's angular
               velocity and angular acceleration in the NewtonianFrame
               only if B's central inertia dyadic has been set.

      Remark:  Program default is SetAutoExpress( ON ).

     Related:  Express  GetDefaults

       (1) %--------------------------------------------------------------------
       (2) % Example 1:  SetAutoExpress( OFF )
       (3) %--------------------------------------------------------------------
       (4) SetAutoExpress( OFF )
       (5) NewtonianFrame N
       (6) RigidBody B
       (7) Variable  qB''
       (8) B.SetRotationMatrixX( N, qB )
    -> (9) B_N = [1, 0, 0;  0, cos(qB), sin(qB);  0, -sin(qB), cos(qB)]

       (10) B.SetAngularVelocityAcceleration( N, qB'*Nx> )
    -> (11) w_B_N> = qB'*Nx>
    -> (12) alf_B_N> = qB''*Nx>

       (13) %--------------------------------------------------------------------
       (14) % Example 2:  SetAutoExpress( ON )
       (15) %--------------------------------------------------------------------
       (16) SetAutoExpress( ON )
       (17) RigidBody C
       (18) Variable  qC''
       (19) C.SetInertia( Ccm, 3, 2, 1 )
       (20) C.SetRotationMatrixX( N, qC )
    -> (21) C_N = [1, 0, 0;  0, cos(qC), sin(qC);  0, -sin(qC), cos(qC)]

       (22) C.SetAngularVelocityAcceleration( N, qC'*Nx> )
    -> (23) w_C_N> = qC'*Cx>
    -> (24) alf_C_N> = qC''*Cx>

#### SetAutoFactor

    SetAutoFactor

     Purpose:  Determines whether or not to automatically factor expressions.

      Syntax:  SetAutoFactor( SETTING )

       Input:  SETTING -- ON or OFF

      Remark:  Program default is SetAutoFactor( ON ).

     Related:  Factor  GetDefaults

       (1) %--------------------------------------------------------------------
       (2) % Example 1:  SetAutoFactor( OFF )
       (3) %--------------------------------------------------------------------
       (4) Constant  A,B,C
       (5) SetAutoFactor( OFF )
       (6) x = A*B + A*C + A*(B+C)^2
    -> (7) x = A*B + A*C + A*(B+C)^2

       (8) %--------------------------------------------------------------------
       (9) % Example 2:  SetAutoFactor( ON )
       (10) %--------------------------------------------------------------------
       (11) SetAutoFactor( ON )
       (12) y = A*B + A*C + A*(B+C)^2
    -> (13) y = A*(B+C+(B+C)^2)

#### SetAutoOverWrite

    SetAutoOverWrite

     Purpose:  Determines whether to overwrite automatically or only
               when the user has responded affirmatively to a prompt.

      Syntax:  SetAutoOverWrite( SETTING )

       Input:  SETTING -- ON, OFF, or ALL

      Output:  SETTING  |  When a prompt is issued:
               ---------------------------------------------------
               OFF      |  Before symbols or files are overwritten
                        |
               ON       |  Before files are overwritten
                        |
               ALL      |  Never (use with caution!)
               ---------------------------------------------------

      Remark:  Use  :=  to assign and overwrite without query.
               Use  +=  to accumulate sums.
               Similarly for  -=  *=  /=

      Remark:  Use  :;  at the end of a statement to change SETTING to ON for only
               that statement. Thereafter, SETTING reverts to its previous value.

      Remark:  Program default is SetAutoOverwrite( OFF ).

     Related:  GetDefaults   SetAutoDifferentiate  SetAutoOverwrite
               Solve  SolveDt  SolveSetInput  SolveSetInputDt  ...
               SolveQuadraticPositiveRoot  SolveQuadraticPositiveRootDt  ...
               SetDt  SetNoDt   =   :=   +=   *=   /=   ^=

       (1) %--------------------------------------------------------------------
       (2) % Example 1:  SetAutoOverwrite( OFF ) with :=
       (3) %--------------------------------------------------------------------
       (4) Variable y = sin(t)
    -> (5) y = sin(t)

       (6) y := t^2                       % Use  :=  to  overwrite without query.
    -> (7) y = t^2

       (8) Solve( 6*y + 3*exp(t)*y := 9,  y )
    -> (9) y = 3/(2+exp(t))

       (10) %--------------------------------------------------------------------
       (11) % Example 2:  SetAutoOverwrite( OFF )  with :;
       (12) %--------------------------------------------------------------------
       (13) RigidFrame A, B
       (14) B.SetRotationMatrixX( A, t )
    -> (15) B_A = [1, 0, 0;  0, cos(t), sin(t);  0, -sin(t), cos(t)]

       (16) B.SetRotationMatrixX( A, 2*t ) :;   % Overwrite for entire statement.
    -> (17) B_A = [1, 0, 0;  0, cos(2*t), sin(2*t);  0, -sin(2*t), cos(2*t)]

       (18) %--------------------------------------------------------------------
       (19) % Example 2:  SetAutoOverwrite( ON )
       (20) %--------------------------------------------------------------------
       (21) SetAutoOverWrite( ON )              % Use with caution.
       (22) y = 3
    -> (23) y = 3

       (24) y = 4
    -> (25) y = 4

#### SetAutoRhs

    SetAutoRhs

     Purpose:  Determines whether or not to replace symbols appearing
               on  the  left-hand  sides of equations with the right-
               hand  sides  of  the  equations when these symbols are
               used in expressions.

      Syntax:  SetAutoRhs( SETTING )

       Input:  SETTING -- ON, OFF, or ALL

      Output:  SETTING  |  When a symbol is replaced by its right-hand-side:
               -------------------------------------------------------------
               OFF      |  The name of a user-defined matrix.
                        |  The name of a user-defined vector or dyadic.
                        |
               ON       |  Symbols  replaced when SETTING is OFF
                        |  are also replaced when SETTING is ON.
                        |  In addition, certain other symbols that
                        |  have "small" right-hand-sides are replaced.
                        |
               ALL      |  Any symbol that has a right-hand-side.
               -------------------------------------------------------------

      Remark:  Program default is SetAutoRhs( ON ).

     Related:  Evaluate  Explicit  GetDefaults  GetRhs  ReplaceString  SetAutoRhs

       (1) %--------------------------------------------------------------------
       (2) % Example 1:  SetAutoRhs( OFF )
       (3) %--------------------------------------------------------------------
       (4) SetAutoRhs( OFF )
       (5) a = 3
    -> (6) a = 3

       (7) b = 2 + a
    -> (8) b = 2 + a

       (9) %--------------------------------------------------------------------
       (10) % Example 2:  SetAutoRhs( ON )
       (11) %--------------------------------------------------------------------
       (12) SetAutoRhs( ON )
       (13) c = 2 + a
    -> (14) c = 5

       (15) d = cos(t) + c*sin(t)
    -> (16) d = cos(t) + 5*sin(t)

       (17) e = abs(t) + d
    -> (18) e = abs(t) + d

       (19) %--------------------------------------------------------------------
       (20) % Example 3:  SetAutoRhs( ALL )
       (21) %--------------------------------------------------------------------
       (22) SetAutoRhs( ALL )
       (23) f = abs(t) + d
    -> (24) f = abs(t) + cos(t) + 5*sin(t)

#### SetAutoSimplify

    SetAutoSimplify

     Purpose:  Determines whether or not to automatically simplify
               certain mathematical expressions.

      Syntax:  SetAutoSimplify( ACOS=SETTING, ASIN=SETTING, ATAN=SETTING )

       Input:  SETTING -- ON or OFF

      Output:  When SETTING is ON, replaces

               Acos( cos(X) )  with  X
               Asin( sin(X) )  with  X
               Atan( tan(X) )  with  X

               where  X  is any symbolic (non-numeric) expression.

      Remark:  The proper range for x for each simplification is:
               Acos( cos(X) ) =  X        when      0 <= X <= pi
               Asin( sin(X) ) =  X        when  -pi/2 <= X <= pi/2
               Atan( tan(X) ) =  X        when  -pi/2 <= X <= pi/2
               Acos( sin(X) ) = -X+pi/2   when  -pi/2 <= X <= pi/2
               Asin( cos(X) ) = -X+pi/2   when      0 <= X <= pi

      Remark:  Program default is SetAutoSimplify( ACOS=OFF, ASIN=OFF, ATAN=OFF ).

     Related:  GetDefaults

       (1) %--------------------------------------------------------------------
       (2) % Example:  SetAutoSimplify
       (3) %--------------------------------------------------------------------
       (4) SetAutoSimplify( ACOS=ON, ASIN=ON, ATAN=OFF )
       (5) a = Acos( cos(t^3) )
    -> (6) a = t^3

       (7) b = Asin( sin(t^3) )
    -> (8) b = t^3

       (9) c = Atan( tan(t^3) )
    -> (10) c = atan(tan(t^3))

       (11) d = Atan( tan(3) )
    -> (12) d = -0.1415927

#### SetAutoTaylorSeries

    SetAutoLinearize   SetAutoTaylorSeries

     Purpose:  Automatically expands all expressions in Taylor series.

    Syntax 1:  SetAutoLinearize(           arg1, arg2, ... )
    Syntax 2:  SetAutoTaylorSeries( Range, arg1, arg2, ... )
    Syntax 3:  SetAutoLinearize(    SETTING )
    Syntax 4:  SetAutoTaylorSeries( SETTING )

       Input:  Range -- n or n:m, where n and m are positive integers with n < m.
               Range -- 0:1  for SetAutoLinearize.

               argi -- the scalar name Ci (e.g., a constant or variable) or
                       the equation Ci = D (D is a scalar expression); or
                       the equation Ci = D:P, where P is a scalar name.

               SETTING -- ON or OFF

      Output:  The following table applies to the output expression F
               (F may be a scalar, vector, dyadic, or matrix expression).

               Range|    argi    |              Output
               -----|------------|-----------------------------------
                 n  |  Ci        |  nth term of the Taylor series
                    |            |  expansion of F about Ci = 0.
                    |            |
                 n  |  Ci = D    |  nth term of the Taylor series
                    |            |  expansion of F about Ci = D.
                    |            |
                 n  |  Ci = D:P  |  nth term of the Taylor series
                    |            |  expansion of F about Ci = D,
                    |            |  with P in place of Ci - D.
                    |            |
                n:m |  Ci        |  nth  through  mth  terms of Taylor
                    |            |  expansion of F about Ci = 0.
                    |            |
                n:m |  Ci = D    |  nth  through  mth  terms of Taylor
                    |            |  expansion of F about Ci = D.
                    |            |
                n:m |  Ci = D:P  |  nth  through  mth  terms of Taylor
                    |            |  expansion of F about Ei = D,
                    |            |  with P in place of Ci - D.

      Remark:  Syntax 1 and 2 automatically turns SETTING ON.
               Syntax 3 and 4 are useful only after using Syntax 1 or 2 and
               for subsequently turning SETTING OFF (and perhaps ON later).

      Remark:  Due to numerical round-off in Taylor series expansions, consider
               issuing an "epsilon" command  SetAutoEpsilon( 1.0E-13 ).

     Related:  GetDefaults  SetAutoZee
               GetTaylorSeries  Linearize  SetAutoLinearize  SetAutoTaylorSeries

#### SetAutoZee

    SetAutoZee

     Purpose:  Determines whether or not Zs are to automatically created.

      Syntax:  SetAutoZee( SETTING )

       Input:  SETTING -- OFF, ON, or AUTO

      Output:  When SETTING is ON, introduces, in selected expressions,
               Z1, Z2, ... as names for sub-expressions, and makes
               corresponding replacements.

               When SETTING is OFF, no Zs are automatically created.

               When SETTING is AUTO, no Zs are automatically created
               until a long expression is encountered, at which time,
               SETTING is turned ON.

      Remark:  Specific names can be excluded from Zs, provided the
               names occur only linearly in expressions.
               To this end, enter   SetNoZeeSymbol( M ),  where M is
               a name to be excluded or a matrix of names to be excluded.

      Remark:  The command SetAutoZee is not available with demonstration and
               certain educational and other licenses.

      Remark:  This command helps produce efficient equations and codes.

      Remark:  Program default is SetAutoZee( AUTO ).

     Related:  GetDefaults  SetAutoLinearize  SetAutoTaylorSeries  SetAutoZee
               Zee  SetNoZeeSymbol  ResetNoZeeSymbol  GetNoZeeSymbol

       (1) %--------------------------------------------------------------------
       (2) % Example 1:  SetAutoZee( OFF )
       (3) %--------------------------------------------------------------------
       (4) SetAutoZee( OFF )
       (5) NewtonianFrame  N
       (6) RigidBody A
       (7) Variable qA''
       (8) A.RotateX( N, qA )
    -> (9) A_N = [1, 0, 0;  0, cos(qA), sin(qA);  0, -sin(qA), cos(qA)]
    -> (10) w_A_N> = qA'*Ax>
    -> (11) alf_A_N> = qA''*Ax>

       (12) %--------------------------------------------------------------------
       (13) % Example 2:  SetAutoZee( ON )
       (14) %--------------------------------------------------------------------
       (15) SetAutoZee( ON )
       (16) RigidBody B
       (17) Variable qB''
       (18) B.RotateX( N, qB )
    -> (19) z1 = cos(qB)
    -> (20) z2 = sin(qB)
    -> (21) B_N = [1, 0, 0;  0, z1, z2;  0, -z2, z1]
    -> (22) w_B_N> = qB'*Bx>
    -> (23) alf_B_N> = qB''*Bx>

#### SetBasisSubscripts

    SetBasisSubscripts

     Purpose:  Designates the last alphanumeric character in the name of
               right-handed orthogonal, unit vectors created when a
               RigidBody, RigidFrame, or NewtonianFrame is declared.

      Syntax:  SetBasisSubscripts( x,y,z )

       Input:  x,y,z -- three distinct, comma delimited, alphabetic
               characters (letters) or the numbers 1,2,3

      Output:  SetBasisSubscripts( x,y,z )  creates right-handed orthogonal
               unit vectors Bx>, By>, Bz>  fixed in B when:  RigidBody B,
               RigidFrame B,  or  NewtonianFrame B  is issued.

      Remark:  Program default is SetBasisSubscripts( x, y, z ).
               Basis subscripts may be changed at anytime.

     Related:  GetBasisVector  GetDefaults  SetBasisSubscripts

       (1) %--------------------------------------------------------------------
       (2) % Example 1:  SetBasisSubscripts (default basis subscripts)
       (3) %--------------------------------------------------------------------
       (4) RigidBody A
       (5) v> = Vector( A, 10, 20, 30 )
    -> (6) v> = 10*Ax> + 20*Ay> + 30*Az>

       (7) %--------------------------------------------------------------------
       (8) % Example 2:  SetBasisSubscripts (vary basis subscripts)
       (9) %--------------------------------------------------------------------
       (10) SetBasisSubscripts( 1,2,3 )
       (11) w> = Vector( A, 10, 20, 30 )
    -> (12) w> = 10*A1> + 20*A2> + 30*A3>

       (13) vChangesToo> = v>
    -> (14) vChangesToo> = 10*A1> + 20*A2> + 30*A3>

       (15) %--------------------------------------------------------------------
       (16) % Example 3:  SetBasisSubscripts (vary basis subscripts again)
       (17) %--------------------------------------------------------------------
       (18) SetBasisSubscripts( i,j,k )
       (19) x> = Vector( A, 10, 20, 30 )
    -> (20) x> = 10*Ai> + 20*Aj> + 30*Ak>

       (21) sum> = v> + w>
    -> (22) sum> = 20*Ai> + 40*Aj> + 60*Ak>

#### SetBeepSoundOnError

    SetBeepSoundOnError

     Purpose:  Determines whether or not to issue an audible beep
               sound when a warning or error message is issued.

      Syntax:  SetBeepSoundOnError( SETTING )

       Input:  SETTING -- ON or OFF

      Remark:  Program default is SetBeepSoundOnError( OFF ).

     Related:  GetDefaults

#### SetCharge

    SetCharge

     Purpose:  Sets and returns the charge on a point or Particle.

    Syntax 1:  Q.SetCharge( qCharge )
    Syntax 2:  Q.SetCharge( expression )
    Syntax 3:  Q.SetCharge( qCharge = expression )

       Input:  Q -- The name of a point or Particle.
               qCharge -- The name of a scalar
               expression - A scalar expression, e.g., sin(t).

    Output 1:  Sets Q's charge to qCharge and returns qCharge.
               If not yet declared, qCharge is declared as a constant.

    Output 2:  Sets Q's charge to expression and returns expression.

    Output 3:  Sets Q's charge to qCharge.  Assigns qCharge to expression.
               Returns qCharge or expression.

     Related:  GetCharge  GetMass  SetCharge  SetMass
               AddForceElectrostatic

       (1) %--------------------------------------------------------------------
       (2) % Example: SetCharge
       (3) %--------------------------------------------------------------------
       (4) Point      P, Q
       (5) Particle   R, S
       (6) Variable   cS'
       (7) P.SetCharge( 17 )
       (8) Q.SetCharge( cQ )               % Declares cQ as a constant.
       (9) R.SetCharge( cR = 3 Coulombs )  % Declares cR and sets it INPUT to 3 Coulombs
       (10) S.SetCharge( cS )               % cS may be governed by an ODE or equation

#### SetCMSymbol

    SetCMSymbol

     Purpose:  Designates the symbol for the center of mass of bodies.

      Syntax:  SetCMSymbol( cm )

       Input:  cm -- alphanumeric  string with 10 or fewer characters
               used to identify the center of mass of bodies.

      Remark:  The SetCMSymbol command must be issued before any body is declared.

      Remark:  Program default is SetCMSymbol( cm ).

     Related:  GetDefaults

       (1) %--------------------------------------------------------------------
       (2) % Example:  SetCMSymbol
       (3) %--------------------------------------------------------------------
       (4) SetCMSymbol( cm )
       (5) NewtonianFrame N
       (6) RigidBody B
       (7) B.SetMass( m )
       (8) Bcm.Translate( No, t^3*Nx> + sin(t)*Ny> )
    -> (9) p_No_Bcm> = t^3*Nx> + sin(t)*Ny>
    -> (10) v_Bcm_N> = 3*t^2*Nx> + cos(t)*Ny>
    -> (11) a_Bcm_N> = 6*t*Nx> - sin(t)*Ny>

       (12) LinearMomentum> = B.GetLinearMomentum()
    -> (13) LinearMomentum> = 3*m*t^2*Nx> + m*cos(t)*Ny>

       (14) B.SetAngularVelocity( N, 0> )
    -> (15) w_B_N> = 0>

       (16) AngularMomentumAboutNo> = B.GetAngularMomentum( No )
    -> (17) AngularMomentumAboutNo> = -m*t^2*(3*sin(t)-t*cos(t))*Nz>

       (18) KinetEnergy = B.GetKineticEnergy()
    -> (19) KinetEnergy = 0.5*m*(9*t^4+cos(t)^2)

#### SetComplex

    SetComplex

     Purpose:  Determines whether to treat scalars as real or complex.

      Syntax:  SetComplex( SETTING )

       Input:  SETTING -- ON, OFF, or AUTO

      Remark:  SetComplex( Setting ) affects simplification.
               When Setting is OFF or AUTO, simplifications may assume that
               names declared by Constant, Specified, Variable, etc., are
               real (not imaginary or complex).

      Remark:  Expressions involving only real quantities are simplified
               maximally when SETTING is OFF, whereas expressions involving
               complex quantities are simplified maximally when SETTING is ON.
               When SETTING is AUTO, simplifications are made as if SETTING
               were OFF until the first imaginary number is encountered,
               at which time, SETTING is automatically changed to ON.

      Remark:  Program default is SetComplex( AUTO ).

     Related:  GetDefaults  ImaginaryNumber
               Constant  Specified  Variable

       (1) %--------------------------------------------------------------------
       (2) % Example 1:  SetComplex( OFF )
       (3) %--------------------------------------------------------------------
       (4) Variable x
       (5) SetComplex( OFF )
       (6) a = sqrt(x^2)
    -> (7) a = abs(x)

       (8) b = Evaluate( a, x = 2 + GetImaginaryNumber() )
    -> (9) b = abs(2+imaginary)

       (10) c = Exp( GetImaginaryNumber() * x )
    -> (11) c = exp(imaginary*x)

       (12) %--------------------------------------------------------------------
       (13) % Example 2:  SetComplex( ON )
       (14) %--------------------------------------------------------------------
       (15) SetComplex( ON )
       (16) d = sqrt(x^2)
    -> (17) d = sqrt(x^2)

       (18) e = Evaluate(   a,  x = 2 + GetImaginaryNumber() )
    -> (19) e = 2.236068

       (20) f = Evaluate( x^2,  x = 2 + GetImaginaryNumber() )
    -> (21) f = 3 + 4*imaginary

       (22) g = Evaluate(   d,  x = 2 + GetImaginaryNumber() )
    -> (23) g = 2 + 1*imaginary

       (24) h = Exp( GetImaginaryNumber() * x )
    -> (25) h = cos(x) + imaginary*sin(x)

       (26) %--------------------------------------------------------------------
       (27) % Example 3:  SetComplex( AUTO )
       (28) %--------------------------------------------------------------------
       (29) SetComplex( AUTO )
       (30) k = sqrt(x^2)                                 % Complex if OFF
    -> (31) k = abs(x)

       (32) L = Evaluate( a, x = 2+GetImaginaryNumber() ) % Complex turns ON
    -> (33) L = 2.236068

       (34) m = Exp( GetImaginaryNumber() * x )           % Complex is ON
    -> (35) m = cos(x) + imaginary*sin(x)

#### SetDigits

    SetDigits   GetDigits

     Purpose:  Sets an upper limit on the number of digits displayed on
               the screen when numerical values are reported.
               Governs the format and number of digits displayed in output
               files created in response to the ODE and Solve commands.

    Syntax 1:  SetDigits( n )
    Syntax 2:  GetDigits( )

       Input:  n -- a positive integer less than or equal to 17.
               expression -- a scalar, vector, dyadic, or matrix expression.

    Output 2:  Returns the number  n  previously set in a SetDigits command.

      Remark:  Regardless of the value of n, all computations are performed
               in double precision and to machine accuracy.

      Remark:  Program default is SetDigits( 7 ).

     Related:  ODE  Solve  Input  Output  OutputPlot  Plot  Animate
               SetDigits  SetAutoEpsilon  Epsilon  GetDefaults  ReplaceString

       (1) %--------------------------------------------------------------------
       (2) % Example 1:  SetDigits (default number of displayed digits)
       (3) %--------------------------------------------------------------------
       (4) x = exp(2)
    -> (5) x = 7.389056

       (6) %--------------------------------------------------------------------
       (7) % Example 2:  SetDigits (vary the number of displayed digits)
       (8) %--------------------------------------------------------------------
       (9) SetDigits( 12 )
       (10) y = x
    -> (11) y = 7.38905609893

       (12) SetDigits( 3 )
       (13) z = x
    -> (14) z = 7.39

       (15) numDigits = GetDigits()
    -> (16) numDigits = 3

#### SetDt

    SetDt  or   SetNoDt

     Purpose:  Assigns a scalar quantity and its ordinary derivatives.

    Syntax 1:  SetDt(   x = scalarExpression )
    Syntax 2:  SetNoDt( x = scalarExpression )

       Input:  x -- a scalar name (e.g., a Variable or Specified).
               scalarExpression -- a differentiable scalar expression.

    Output 1:  Assigns x   to       scalarExpression.
               Assigns x'  to   Dt( scalarExpression )
               Assigns x'' to DtDt( scalarExpression ) if x'' exists, etc.
               Returns x.

    Output 2:  Assigns x to scalarExpression and returns x.
               x', x'', etc., are not assigned.

      Remark:  SetDt will assign x and as many ordinary derivatives
               of x as exist, e.g., x', x'', x''', etc.

      Remark:  SetNoDt will not set x' and will skip warning
               messages about the possible use of SetDt.

     Related:  D  Dt  DtDt  Integrate  MathFunctions
               SetDt  Solve  SolveDt  SolveSetInput  SolveSetInputDt  ...
               SolveQuadraticPositiveRoot  SolveQuadraticPositiveRootDt  ...

       (1) %--------------------------------------------------------------------
       (2) % Example 1:  SetDt( ... )
       (3) %--------------------------------------------------------------------
       (4) Variable  x'
       (5) SetDt( x = sin(t) )
    -> (6) x = sin(t)
    -> (7) x' = cos(t)

       (8) %--------------------------------------------------------------------
       (9) % Example 2:  SetDt( ... )
       (10) %--------------------------------------------------------------------
       (11) Specified y''
       (12) SetDt( y = t^3 )
    -> (13) y = t^3
    -> (14) y' = 3*t^2
    -> (15) y'' = 6*t

       (16) %--------------------------------------------------------------------
       (17) % Example 3:  SetNoDt( ... )
       (18) %--------------------------------------------------------------------
       (19) SetNoDt( y = cos(t) )
    -> (20) y = cos(t)

#### SetGeneralizedSpeed

    SetGeneralizedSpeed       ResetGeneralizedSpeed       GetGeneralizedSpeed
    SetGeneralizedCoordinate  ResetGeneralizedCoordinate  GetGeneralizedCoordinate

      Purpose: Names generalized speeds for Kane's method.
               Names generalized coordinates for Lagrange and Kane methods and for
               calculating generalized forces associated with potential energy.
               Returns a column matrix of generalized speeds or coordinates.

    Syntax 1:  GetGeneralizedSpeed()
               GetGeneralizedCoordinate()
    Syntax 2:  SetGeneralizedSpeed( qA', qB', wz )
               SetGeneralizedCoordinate( x, y, theta )
    Syntax 3:  ResetGeneralizedSpeed( wx, wy )
               ResetGeneralizedCoordinate( x, y )
    Syntax 4:  ResetGeneralizedSpeed()
               ResetGeneralizedCoordinate()

       Input:  qA', qB', wz, x, y, theta -- names that start with a letter
               followed by a reasonable number of alphanumeric characters,
               Generalized speeds may end with one or more prime symbols '.

    Output 1:  Gets the column matrix of names declared as generalized speeds or
               gets the column matrix of names declared as generalized coordinates.
    Output 2:  Appends qA', qB', wz to the matrix of generalized speeds or
               appends x, y, theta  to the matrix of generalized coordinates.
               Returns the matrix described by Output 1.
    Output 3:  Resets generalized speeds to just wx, wy and returns [wx;  wy]  or
               resets generalized coordinates to just x, y and returns [x;  y].
    Output 4:  Resets to no generalized speeds and returns [0] or
               resets to no generalized coordinates and returns [0].

      Remark:  Use Dt( GetGeneralizedSpeed() ) to form a column matrix of the
               time derivatives of generalized speeds.

     Related:  Constant  ImaginaryNumber  Specified  Variable
               SetGeneralizedCoordinate  SetGeneralizedSpeed
               GetStatics   GetStaticsKane   GetStaticsLagrange
               GetDynamics  GetDynamicsKane  GetDynamicsLagrange

       (1) %--------------------------------------------------------------------
       (2) % Example 1: SetGeneralizedSpeed  (Projectile motion)
       (3) %--------------------------------------------------------------------
       (4) NewtonianFrame N
       (5) Particle Q
       (6) Q.SetMass( m = 1 kg )
       (7) Constant  g = 9.8 m/s^2
       (8) Variable  x'', y''
       (9) SetGeneralizedSpeed( x', y' )
       (10) Q.Translate( No, x*Nx> + y*Ny> )
    -> (11) p_No_Q> = x*Nx> + y*Ny>
    -> (12) v_Q_N> = x'*Nx> + y'*Ny>
    -> (13) a_Q_N> = x''*Nx> + y''*Ny>

       (14) Q.AddForce( -m*g*Ny> )
    -> (15) Force_Q> = -m*g*Ny>

       (16) KaneDynamics = System.GetDynamicsKane()
    -> (17) KaneDynamics = [m*x'';  m*(g+y'')]

       (18) Solve( KaneDynamics = 0,  Dt(GetGeneralizedSpeeds()) )
    -> (19) x'' = 0
    -> (20) y'' = -g

       (21) %--------------------------------------------------------------------
       (22) % Example 2: GetGeneralizedSpeed
       (23) %--------------------------------------------------------------------
       (24) speeds = GetGeneralizedSpeed()
    -> (25) speeds = [x';  y']

       (26) accels = Dt( GetGeneralizedSpeed() )
    -> (27) accels = [x'';  y'']

       (28) %--------------------------------------------------------------------
       (29) % Example 3: ResetGeneralizedSpeed
       (30) %--------------------------------------------------------------------
       (31) Variable wx', wy', wz'
       (32) speeds := ResetGeneralizedSpeed( GetGeneralizedSpeed(), wx, wy, wz )
    -> (33) speeds = [x';  y';  wx;  wy;  wz]

       (34) %--------------------------------------------------------------------
       (35) % Example 4: ResetGeneralizedSpeed
       (36) %--------------------------------------------------------------------
       (37) speeds := ResetGeneralizedSpeed()
    -> (38) speeds = [0]

#### SetNoZeeSymbol

    SetNoZeeSymbol  ResetNoZeeSymbol   GetNoZeeSymbol

     Purpose:  Identifies scalar quantities that are to be excluded from Zs.

    Syntax 1:  SetNoZeeSymbol( x, y, z )
    Syntax 2:  ResetNoZeeSymbol( )
    Syntax 3:  ResetNoZeeSymbol( x, y )
    Syntax 4:  GetNoZeeSymbol( )

       Input:  x, y, z -- names of a scalar symbol (e.g., a constant or variable)
                          or a matrix of scalar names.

    Output 1:  Appends x, y, z to the matrix of names to be excluded from Zs.
               Returns the matrix of all names to be excluded from Zs.

    Output 2:  Removes all names to be excluded from Zs.
               Returns 1x1 zero matrix.

    Output 3:  Removes all names to be excluded from Zs.
               Appends x, y to the matrix of names to be excluded from Zs.
               Returns the 2x1 matrix [x; y] -- names to be excluded from Zs.

    Output 4:  Returns the matrix of all names to be excluded from Zs.

      Remark:  Names can be excluded from Zs provided that occur only linearly.

     Related:  Explicit  Zee  GetRhs  SetAutoRhs
               SetNoZeeSymbol  ResetNoZeeSymbol  GetNoZeeSymbol

       (1) %--------------------------------------------------------------------
       (2) % Example 1: SetNoZeeSymbol  (with scalar expressions)
       (3) %--------------------------------------------------------------------
       (4) Constant   a, b, c
       (5) ScalarExpression = (a-b)*cos(t) + (b-c)*sin(t)
    -> (6) ScalarExpression = (a-b)*cos(t) + (b-c)*sin(t)

       (7) SetNoZeeSymbol( a )
       (8) testA = Zee( ScalarExpression )
    -> (9) z1 = cos(t)
    -> (10) z2 = sin(t)
    -> (11) z3 = b - c
    -> (12) z4 = z3*z2 - b*z1
    -> (13) testA = z4 + a*z1

       (14) SetNoZeeSymbol( b )
       (15) testB = Zee( ScalarExpression )
    -> (16) z5 = z2 - z1
    -> (17) z6 = c*z2
    -> (18) testB = a*z1 + b*z5 - z6

       (19) ResetNoZeeSymbol()
       (20) testC = Zee( ScalarExpression )
    -> (21) z7 = a - b
    -> (22) z8 = z3*z2 + z7*z1
    -> (23) testC = z8

       (24) %--------------------------------------------------------------------
       (25) % Example 2: SetNoZeeSymbol  (with matrix expressions)
       (26) %--------------------------------------------------------------------
       (27) Variable x, y
       (28) matrix[1] = 10 + a + b + c + abs(t)*x + sin(t)*exp(t)*cos(t^2)*y
    -> (29) matrix[1] = 10 + a + b + c + abs(t)*x + sin(t)*exp(t)*cos(t^2)*y

       (30) matrix[2] = 10 + a^2 + cos(b+c)*tan(t)*x
    -> (31) matrix[2] = 10 + a^2 + cos(b+c)*tan(t)*x

       (32) SetNoZeeSymbol( x, y )
       (33) testD = Zee( matrix )
    -> (34) z9 = abs(t)
    -> (35) z10 = exp(t)
    -> (36) z11 = cos(t^2)
    -> (37) z12 = z2*z10*z11
    -> (38) z13 = 10 + a + b + c
    -> (39) z14 = cos(b+c)
    -> (40) z15 = tan(t)
    -> (41) z16 = z14*z15
    -> (42) z17 = 10 + a^2
    -> (43) testD = [z13 + z9*x + z12*y;  z17 + z16*x]

       (44) noZeeSymbols = GetNoZeeSymbol()
    -> (45) noZeeSymbols = [x;  y]

#### SetLineSpacing

    SetLineSpacing

     Purpose:  Sets output line spacing.

      Syntax:  SetLineSpacing( n )

       Input:  n -- 0 or 1 or 2 or a positive integer (e.g., less than 10).

      Remark:  When n = 0, input lines follow each other without
               intervening blank lines, and an input line that
               follows a response line is preceded by a blank line.
               When n > 0, n-1 blank lines follow each input line
               and each response line.

      Remark:  Program default is SetLineSpacing( 0 ).

     Related:  GetDefaults  SetLineStepping

       (1) %--------------------------------------------------------------------
       (2) % Example 1: SetLineSpacing (uses the default value 0)
       (3) %--------------------------------------------------------------------
       (4) SetLineSpacing( 0 )
       (5) A = t^2
    -> (6) A = t^2

       (7) B = t^2
    -> (8) B = t^2

       (9) %--------------------------------------------------------------------
       (10) % Example 2: SetLineSpacing (single spacing)
       (11) %--------------------------------------------------------------------
       (12) SetLineSpacing( 1 )
       (13) A := t^2
    -> (14) A = t^2
       (15) B := t^2
    -> (16) B = t^2
       (17) %--------------------------------------------------------------------
       (18) % Example 3: SetLineSpacing (double spacing)
       (19) %--------------------------------------------------------------------
       (20) SetLineSpacing( 2 )

       (21) A := t^2

    -> (22) A = t^2

       (23) B := t^2

    -> (24) B = t^2

#### SetLineStepping

    SetLineStepping

     Purpose:  Runs an input file one line at a time.

      Syntax:  SetLineStepping( SETTING )

       Input:  SETTING -- ON or OFF

      Remark:  When running an input file with SETTING is ON, the cursor
               appears near a question mark to prompt the user.
               Pressing  Enter  causes the next input line to appear on
               the screen or causes all response lines corresponding to
               an input line to be displayed.

               When SETTING is ON, pressing the  Esc  key and pressing
               Enter causes any input lines that were read to be processed,
               causes the question mark to disappear, suspends running
               the input file, and enables normal operation.
               Subsequently, typing  RUN  at a line prompt runs the
               input file with the question mark and line stepping ON.

      Remark:  Program default is SetLineStepping( OFF ).

     Related:  GetDefaults  Run  SetLineStepping

    --------------------------------------------------------------------
     Example:  SetLineStepping
    --------------------------------------------------------------------

       (1) SetLineStepping( ON )
       (2) Run( TESTFILE )
       (2) ?

#### SetLineWidth

    SetLineWidth

     Purpose:  Sets the line width for writing output to .all or .html files
               (in conjunction with the SAVE command) or in writing C, Fortran,
               MATLAB(R) codes (in conjunction with the CODE or ODE commands).

      Syntax:  SetLineWidth( lineWidth )

       Input:  lineWidth -- 0 or a positive integer less than 65536.

      Remark:  If lineWidth = 0, the following program defaults are used:
               -------------------------------------------------------
                File type |  Line width |  Strict limit |  Use
               -------------------------------------------------------
               .all       |  80         |  No           |  Text file
               .html      |  80         |  No           |  Browser
               .m         |  128        |  No           |  MATLAB(R)
               .c         |  128        |  No           |  C
               .f         |  120        |  No           |  FORTRAN
               .for       |  72         |  Yes          |  FORTRAN 77

     Related:  Save  Code  ODE

    --------------------------------------------------------------------
     Example:  SetLineWidth  (tests SetLineWidth function)
    --------------------------------------------------------------------
     x = expand( (t+cos(t))^24,  0:24 )
     SetLineWidth( 150 )
     y = expand( (t+cos(t))^24,  0:24 )
     Save  SetLineWidth.html

     Input  t = 0.25
     OutputEncode  x, y
     CODE Algebraic() SetLineWidth.m

#### SetMass

    SetMass

     Purpose:  Sets and returns the mass of a Particle or RigidBody.

    Syntax 1:  B.SetMass( mB )
    Syntax 2:  B.SetMass( mB = 10 kg )
    Syntax 3:  B.SetMass( mB = expression )
    Syntax 4:  B.SetMass( expression )

       Input:   B -- Name of a Particle or RigidBody.
               mB -- Scalar name.
               expression -- Scalar expression, e.g., sin(t).

    Output 1:  Sets B's mass to mB.  If mB is not yet declared, declares mB as a
               non-negative mass constant. Returns mB.

    Output 2:  Sets B's mass to mB.  If mB is not yet declared, declares mB as a
               non-negative mass constant. Assigns the input value of mB to 10 kg.
               Returns mB.

    Output 3:  Sets B's mass to mB.  Assigns mB to expression.
               Returns mB or expression.

    Output 4:  Sets B's mass to expression and returns expression.

     Related:  SetMass          GetMass         SetInertia   SetMassInertia
               GetCMPosition    GetCMVelocity   GetCMAcceleration
               GetInertiaDyadic  GetInertiaMatrix  GetMomentOfInertia
               GetProductOfInertia  GetRadiusOfGyration  GetInertiaVector

       (1) %--------------------------------------------------------------------
       (2) % Example: SetMass
       (3) %--------------------------------------------------------------------
       (4) RigidBody  A, B, C
       (5) A.SetMass( mA )         % Declares mA as a non-negative mass constant.
       (6) B.SetMass( mB = 3 kg )  % Declares mB and sets its INPUT value to 3 kg.
       (7) C.SetMass( mC = 3*3 )   % Sets mC = 9.
    -> (8) mC = 9

       (9) Particle   P, Q
       (10) Variable   mQ'
       (11) P.SetMass( 3*t^2 )      % Sets P's mass to an expression.
       (12) Q.SetMass( mQ )         % mS may be governed by an ODE or equation.
       (13) mSystem= System.GetMass()
    -> (14) mSystem = mA + mB + mC + 3*t^2 + mQ

#### SetMassInertia

    SetMassInertia   (also see SetMass and SetInertia)

     Purpose:  Sets a RigidBody's mass and inertia about its center of mass.
               Returns the associated inertia dyadic.

    Syntax 1:  B.SetMassInertia( mB, IBxx, IByy, IBzz )
    Syntax 2:  B.SetMassInertia( mB, IBxx, IByy, IBzz, IBxy, IByz, IBzx )
    Syntax 3:  B.SetMassInertia( mB, aboutPoint, A, I11, I22, I33 )
    Syntax 4:  B.SetMassInertia( mB, aboutPoint, A, I11, I22, I33, I12, I23, I31 )
    Syntax 5:  B.SetMassInertia( mB, aboutPoint, symmetricInertiaDyadic )
    Syntax 6:  B.SetMassInertia( mB, aboutPoint, threeElementMatrix )
    Syntax 7:  B.SetMassInertia( mB, aboutPoint, 3x3symmetricMatrix  )

       Input:  B -- The name of a RigidBody.

               mB -- The mass of B.  This argument can be an expression such as
                     mB = sin(t) or set an input value with mB = 10 kg.

               aboutPoint -- The name of a point (typically fixed on B).

               IBxx, IByy, IBzz -- B's moments  of inertia about aboutPoint
                                   for Bx>, By>, and Bz>, respectively.

               IBxy, IByz, IBzx -- B's products of inertia about aboutPoint
                                   for  Bx>*By>,  By>*Bz>,  and  Bz>*Bx>.

               A -- The name of a RigidBody or RigidFrame.

               I11, I22, I33 -- B's moments  of inertia about aboutPoint
                                for Ax>, Ay>, and Az>, respectively.

               I12, I23, I31 -- B's products of inertia about aboutPoint
                                for  Ax>*Ay>,  Ay>*Az>,  and  Az>*Ax>.
                                Note the cyclical permutation ordering.

               symmetricInertiaDyadic -- A symmetric inertia dyadic.

               threeElementMatrix -- 3 x 1  or  1 x 3  matrix of real scalars.

               3x3symmetricMatrix -- 3 x 3  symmetric matrix of real scalars.

     Outputs:  In each case, sets and returns B's inertia dyadic about aboutPoint.

    Output:    Calls:  B.SetMass( mB )   then subsequently returns the following
    Output 1:  B.SetInertia( Bcm, IBxx, IByy, IBzz )
    Output 2:  B.SetInertia( Bcm, IBxx, IByy, IBzz, IBxy, IByz, IBzx )
    Output 3:  B.SetMassInertia( aboutPoint, I11, I22, I33 )
    Output i:  Corresponding  B.SetInertia( .... )  commands  (i = 4, 5, 6).

      Remark:  Declares mB as a non-negative mass constant (if not yet declared),
               declares IBxx, IByy, IBzz  as non-negative inertia constants and
               IBxy, IByz, IBzx as inertia constants (if not yet declared).

               Mass and inertia scalars can be declared along with an input value,
               e.g., as  mB = 3 kg,  IBxx = 3 kg*m^2.  Alternatively, they can be
               an expression such as  mB = t^2,  IBxx = m*r^2/2,  IBxy = -m*x*y.

      Remark:  Products of inertia adhere to the "negative sign convention".
               Example: For a 1 kg particle whose position from a point P is
               2*Nx> + 3*Ny>, the product of inertia Ixy = -m*x*y = -6 kg*m^2.

     Related:  SetMass              GetMass              SetInertia  SetMassInertia
               GetCMPosition        GetCMVelocity        GetCMAcceleration
               GetInertiaDyadic     GetInertiaMatrix     GetMomentOfInertia
               GetProductOfInertia  GetRadiusOfGyration  GetInertiaVector

       (1) %--------------------------------------------------------------------
       (2) % Example: SetMassInertia
       (3) %--------------------------------------------------------------------
       (4) RigidFrame N
       (5) RigidBody  A, B, C, D, E, F, G
       (6) A.SetMassInertia( m, IAxx, IAyy, IAzz )
       (7) B.SetMassInertia( m, IBxx, IByy, IBzz, IBxy, IByz, IBzx )
       (8) C.SetMassInertia( m, Ccm, N, I11, I22, I33 )
       (9) D.SetMassInertia( m, Dcm, 5*1>> )
       (10) E.SetMassInertia( m, Eo, [2, 3, 4] )
       (11) F.SetMassInertia( m, Fo, [2, -0.1, 0;  -0.1, 3, 0;  0, 0, 4] )
       (12) G.SetMassInertia( m = 3 kg, IGxx = 0.1 kg*m^2, IGyy = 2*IGxx, IGzz = 3*IGxx )
    -> (13) IGyy = 2*IGxx
    -> (14) IGzz = 3*IGxx

       (15) %--------------------------------------------------------------------
       (16) AInertiaAboutAcm>> = A.GetInertia( Acm )
    -> (17) AInertiaAboutAcm>> = IAxx*Ax>*Ax> + IAyy*Ay>*Ay> + IAzz*Az>*Az>

       (18) DInertiaAboutDcm>> = D.GetInertia( Dcm )
    -> (19) DInertiaAboutDcm>> = 5*1>>

       (20) EInertiaAboutEo>> = E.GetInertia( Eo )
    -> (21) EInertiaAboutEo>> = 2*Ex>*Ex> + 3*Ey>*Ey> + 4*Ez>*Ez>

#### SetInertia

    SetInertia   (also see SetMassInertia)

     Purpose:  Sets and returns a RigidBody's inertia dyadic about a point.

    Syntax 1:  B.SetInertia( aboutPoint, IBxx, IByy, IBzz )
    Syntax 2:  B.SetInertia( aboutPoint, IBxx, IByy, IBzz, IBxy, IByz, IBzx )
    Syntax 3:  B.SetInertia( aboutPoint, A, I11, I22, I33 )
    Syntax 4:  B.SetInertia( aboutPoint, A, I11, I22, I33, I12, I23, I31 )
    Syntax 5:  B.SetInertia( aboutPoint, symmetricInertiaDyadic )
    Syntax 6:  B.SetInertia( aboutPoint, threeElementMatrix )
    Syntax 7:  B.SetInertia( aboutPoint, 3x3symmetricMatrix  )

       Input:  B -- The name of a RigidBody.

               aboutPoint -- The name of a point (typically fixed on B).

               IBxx, IByy, IBzz -- B's moments  of inertia about aboutPoint
                                   for Bx>, By>, and Bz>, respectively.

               IBxy, IByz, IBzx -- B's products of inertia about aboutPoint
                                   for  Bx>*By>,  By>*Bz>,  and  Bz>*Bx>.
                                   Note the cyclical permutation ordering.

               A -- The name of a RigidBody or RigidFrame.

               I11, I22, I33 -- B's moments  of inertia about aboutPoint
                                for Ax>, Ay>, and Az>, respectively.

               I12, I23, I31 -- B's products of inertia about aboutPoint
                                for  Ax>*Ay>,  Ay>*Az>,  and  Az>*Ax>.
                                Note the cyclical permutation ordering.

               symmetricInertiaDyadic -- A symmetric inertia dyadic.

               threeElementMatrix -- 3 x 1  or  1 x 3  matrix of real scalars.

               3x3symmetricMatrix -- 3 x 3  symmetric matrix of real scalars.

     Outputs:  In each case, sets and returns B's inertia dyadic about aboutPoint.

    Output 1:  Sets and returns IBxx*Bx>*Bx> + IByy*By>*By> + IBzz*Bz>*Bz>

    Output 2:  Sets and returns IBxx*Bx>*Bx> + IBxy*Bx>*By> + IBzx*Bx>*Bz> +
                                IBxy*By>*Bx> + IByy*By>*By> + IByz*By>*Bz> +
                                IBzx*Bz>*Bx> + IByz*Bz>*Bx> + IBzz*Bz>*Bz>

    Output 3:  Sets and returns I11*Ax>*Ax> + I22*Ay>*Ay> + I33*Az>*Az>

    Output 4:  Sets and returns I11*Ax>*Ax> + I12*Ax>*Ay> + I31*Ax>*Az> +
                                I12*Ay>*Ax> + I22*Ay>*Ay> + I23*Ay>*Az> +
                                I31*Az>*Ax> + I23*Az>*Ax> + I33*Az>*Az>

    Output 5:  Sets and returns symmetricInertiaDyadic.

    Output 6:  When threeElementMatrix is the 3x1 matrix m,
               sets and returns m[1]*Bx>*Bx> + m[2]*By>*By> + m[3]*Bz>*Bz>

    Output 7:  When 3x3symmetricMatrix is the matrix I,
               Sets and returns I[1,1]*Bx>*Bx> + I[1,2]*Bx>*By> + I[1,3]*Bx>*Bz> +
                                I[2,1]*By>*Bx> + I[2,2]*By>*By> + I[2,3]*By>*Bz> +
                                I[3,1]*Bz>*Bx> + I[3,2]*Bz>*Bx> + I[3,3]*Bz>*Bz>

      Remark:  If moments of inertia such as IBxx are not already declared, they
               are declared as non-negative inertia constants.

               If products of inertia such as IBxy are not already declared, they
               are declared as inertia constants (negative, zero, or positive).

               Inertia scalars can be declared along with an input value, e.g., as
               IBxx = 3 kg*m^2.  Alternatively, they can be an expression such as
               IBxx = m*r^2/2  or   IBxy = -m*x*y.

      Remark:  Products of inertia adhere to the "negative sign convention".
               Example: For a 1 kg particle whose position from a point P is
               2*Nx> + 3*Ny>, the product of inertia Ixy = -m*x*y = -6 kg*m^2.

     Related:  SetMass          GetMass         SetInertia   SetMassInertia
               GetCMPosition    GetCMVelocity   GetCMAcceleration
               GetInertiaDyadic  GetInertiaMatrix  GetMomentOfInertia
               GetProductOfInertia  GetRadiusOfGyration  GetInertiaVector

       (1) %--------------------------------------------------------------------
       (2) % Example: SetInertia
       (3) %--------------------------------------------------------------------
       (4) RigidFrame N
       (5) RigidBody  A, B, C, D, E, F, G
       (6) A.SetInertia( Acm, IAxx, IAyy, IAzz )
       (7) B.SetInertia( Bcm, IBxx, IByy, IBzz, IBxy, IByz, IBzx )
       (8) C.SetInertia( Ccm, N, I11, I22, I33 )
       (9) D.SetInertia( Dcm, 5*1>> )
       (10) E.SetInertia( Eo, [2, 3, 4] )
       (11) F.SetInertia( Fo, [2, -0.1, 0;  -0.1, 3, 0;  0, 0, 4] )
       (12) G.SetInertia( Gcm, IGxx = 0.1 kg*m^2, IGyy = 2*IGxx, IGzz = 3*IGxx )
    -> (13) IGyy = 2*IGxx
    -> (14) IGzz = 3*IGxx

       (15) %--------------------------------------------------------------------
       (16) AInertiaAboutAcm>> = A.GetInertia( Acm )
    -> (17) AInertiaAboutAcm>> = IAxx*Ax>*Ax> + IAyy*Ay>*Ay> + IAzz*Az>*Az>

       (18) DInertiaAboutDcm>> = D.GetInertia( Dcm )
    -> (19) DInertiaAboutDcm>> = 5*1>>

       (20) EInertiaAboutEo>> = E.GetInertia( Eo )
    -> (21) EInertiaAboutEo>> = 2*Ex>*Ex> + 3*Ey>*Ey> + 4*Ez>*Ez>

#### SetPauseOnWarning

    SetPauseOnWarning

     Purpose:  Sets the duration of the pause that occurs when a warning is
               issued during execution of an input file.

    Syntax 1:  SetPauseOnWarning( numberOfSeconds )
    Syntax 2:  SetPauseOnWarning( WAIT )

       Input:  numberOfSeconds -- an integer between 0 and 60, equal to the
               desired duration, in seconds, of the pause following a warning.
               Note: No pause occurs when numberOfSeconds is 0.

               WAIT -- WAIT

    Output 1:  Suspends program execution for numberOfSeconds.
    Output 2:  Suspends program execution until the user presses the ENTER key.

      Remark:  Program default is SetPauseOnWarning( WAIT ).
               This default can be set in the MGDefaultPreferences.txt
               file that resides in the program's MGToolbox folder.

      Remark:  If reading from an input file stops, you may type RUN
               to resume execution from the input file.

     Related:  Pause  SetPauseOnWarning  GetDefaults

#### SetRotationMatrix

    SetRotationMatrix

     Purpose:  Sets the rotation matrix relating two sets of bases vectors
               associated with right-handed rotations of B relative to A.

    Syntax 1:  B.SetRotationMatrix( A, aboutUnitVector, theta )
    Syntax 2:  B.SetRotationMatrix( A, SequenceI,   q1 )
    Syntax 3:  B.SetRotationMatrix( A, SequenceIJ,  q1, q2 )
    Syntax 4:  B.SetRotationMatrix( A, SequenceIJK, q1, q2, q3 )
    Syntax 5:  B.SetRotationMatrix( A, EulerParameters, e0, e1, e2, e3 )
               B.SetRotationMatrix( A, Quaternion,      e0, e1, e2, e3 )
    Syntax 6:  B.SetRotationMatrix( A, RodriguesParameters, rho1, rho2, rho3 )
    Syntax 7:  B.SetRotationMatrix( A, PoissonParameters, Rxx,Rxy, ..., Rzz )
    Syntax 8:  B.SetRotationMatrix( A, Indirect,  pB>, qB>, rB>,  pA>, qA>, rA> )
               B.SetRotationMatrix( A, Indirect,  pB>, qB>,       pA>, qA>      )
    Syntax 9:  B.SetRotationMatrix( A, matrix33 )
    Syntax 10: B.SetRotationMatrix( A )
    Syntax 11: B.SetRotationMatrixX( A, q )  B.SetRotationMatrixNegativeX( A, q )
               B.SetRotationMatrixY( A, q )  B.SetRotationMatrixNegativeY( A, q )
               B.SetRotationMatrixZ( A, q )  B.SetRotationMatrixNegativeZ( A, q )
               Type  HELP SetRotationMatrixX  for examples.

       Input:  B, A -- name of a RigidFrame or RigidBody.

               theta, q1, q2, q3 -- angles (scalar expressions).

     Input 1:  aboutUnitVector -- unit vector that can be expressed in terms of
                                  either  Ax>, Ay>, Az>  or  Bx>, By>, Bz>.

     Input 2:  SequenceI -- BodyI or SpaceI where I is X, -X, Y, -Y, Z, -Z, e.g.,
                            BodyX,  BodyY,  BodyZ,  -BodyX,  Body-Y, etc.
                           SpaceX, SpaceY, SpaceZ, -SpaceX, Space-Y, etc.

     Input 3:  SequenceIJ -- BodyIJ or Space IJ where I and J are appropriate
                             combinations of X, -X, Y, -Y, Z, -Z, e.g.,
                             BodyXY,  BodyXZ,  BodyYX,  BodyYZ,  BodyZX,  BodyZY
                            SpaceXY, SpaceXZ, SpaceYX, SpaceYZ, SpaceZX, SpaceZY
                            Body-XY, BodyX-Z, Body-Y-X, Space-XY, etc.

     Input 4:  SequenceIJK -- BodyIJK or SpaceIJK where I, J, K are appropriate
                              combinations of X, -X, Y, -Y, Z, -Z, e.g.,
                       BodyXYZ,  BodyYZX,  BodyZXY,  BodyXZY,  BodyYXZ,  BodyZYX
                       BodyXYX,  BodyXZX,  BodyYXY,  BodyYZY,  BodyZXZ,  BodyZYZ
                      SpaceXYZ, SpaceYZX, SpaceZXY, SpaceXZY, SpaceYXZ, SpaceZYX
                      SpaceXYX, SpaceXZX, SpaceYXY, SpaceYZY, SpaceZXZ, SpaceZYZ
                      Body-XYZ, BodyX-YZ, BodyXY-Z, Body-X-YZ,  Space-X-Y-Z, etc.

     Input 5:  e0, e1, e2, e3 -- expressions for Euler parameters (quaternion).

     Input 6:  rho1, rho2, rho3 -- expressions for Rodrigues parameters.

     Input 7:  Rxx,Rxy,Rxz, Ryx,Ryy,Ryz, Rzx,Rzy,Rzz - expressions for elements.

     Input 8:  pB>, qB>, rB> -- vectors expressed in terms of Bx>, By>, Bz>.
               pA>, qA>, rA> -- the same vectors pB>, qB>, rB> (same magnitude and
               same direction) but instead of expressed in terms of Bx>, By>, Bz>,
               pA>, qA>, rA> are expressed in terms of Ax>, Ay>, Az>.
               See Mitiguy, Paul, "Advanced Dynamics & Motion Simulation".

     Input 9:   matrix33 -- 3x3 rotation matrix (direction cosine matrix).

      Output:  Sets and returns the rotation matrix B_A that is associated with
               right-handed rotations of B relative to A.  This rotation matrix
               relates unit vectors Bx>, By>, Bz>  to  Ax>, Ay>, Az>.

    Output 8:  Uses indirect determination of orientation to form the B_A
               rotation matrix with the algorithm in the textbook:
               Mitiguy, Paul, "Advanced Dynamics & Motion Simulation".

    Output 10: Attempts to calculate B.GetRotationMatrix(A) e.g., by successive
               matrix multiplication of previously stored rotation matrices and
               then sets and returns the rotation matrix B_A.

      Remark:  The command SetRotationMatrixODE also forms ODEs for the
               associated variables, e.g., the angles, or quaternion or ...

      Remark:  Definitions of orientation angles, Euler parameters (quaternion),
               Rodrigues parameters, and direction cosines are in
               Kane, Likins, Levinson: Spacecraft Dynamics, McGraw-Hill, Ch. 1, and
               Mitiguy, Paul, "Advanced Dynamics & Motion Simulation".

     Related:  Rotate  RotateX  RotateY  RotateZ
               RotateNegativeX  RotateNegativeY  RotateNegativeZ
               SetRotationMatrixX  SetRotationMatrixY  SetRotationMatrixZ
               SetRotationMatrixPositiveX  SetRotationMatrixPositiveY  ...
               SetRotationMatrixNegativeX  SetRotationMatrixNegativeY  ...
               SetRotationMatrix  SetAngularVelocity  SetAngularAcceleration
               GetRotationMatrix  GetAngularVelocity  GetAngularAcceleration
               SetRotationMatrixODE   SetRigidTransform

       (1) %--------------------------------------------------------------------
       (2) % Examples 1 & 2: SetRotationMatrix (simple rotations with one angle)
       (3) %--------------------------------------------------------------------
       (4) SetAutoOverwrite ON
       (5) RigidFrame A, B, C
       (6) Variable   q1, q2, q3
       (7) %--------------------------------------------------------------------
       (8) B.SetRotationMatrix( A, -BodyZ,  q1 )
    -> (9) B_A = [cos(q1), -sin(q1), 0;  sin(q1), cos(q1), 0;  0, 0, 1]

       (10) B.SetRotationMatrix( A, UnitVector(3*By>+4*Bz>), q1 )
    -> (11) B_A[1,1] = cos(q1)
    -> (12) B_A[1,2] = 0.8*sin(q1)
    -> (13) B_A[1,3] = -0.6*sin(q1)
    -> (14) B_A[2,1] = -0.8*sin(q1)
    -> (15) B_A[2,2] = 0.36 + 0.64*cos(q1)
    -> (16) B_A[2,3] = 0.48 - 0.48*cos(q1)
    -> (17) B_A[3,1] = 0.6*sin(q1)
    -> (18) B_A[3,2] = 0.48 - 0.48*cos(q1)
    -> (19) B_A[3,3] = 0.64 + 0.36*cos(q1)

       (20) %--------------------------------------------------------------------
       (21) % Example 3: SetRotationMatrix (successive rotations with two angles)
       (22) %--------------------------------------------------------------------
       (23) B.SetRotationMatrix( A,  Space-Y-X,  q1, q2 )
    -> (24) B_A[1,1] = cos(q1)
    -> (25) B_A[1,2] = sin(q1)*sin(q2)
    -> (26) B_A[1,3] = sin(q1)*cos(q2)
    -> (27) B_A[2,1] = 0
    -> (28) B_A[2,2] = cos(q2)
    -> (29) B_A[2,3] = -sin(q2)
    -> (30) B_A[3,1] = -sin(q1)
    -> (31) B_A[3,2] = sin(q2)*cos(q1)
    -> (32) B_A[3,3] = cos(q1)*cos(q2)

       (33) %--------------------------------------------------------------------
       (34) % Example 4: SetRotationMatrix (successive rotations with three angles)
       (35) %--------------------------------------------------------------------
       (36) B.SetRotationMatrix( A, BodyXYZ,   q1, q2, q3 )
    -> (37) B_A[1,1] = cos(q2)*cos(q3)
    -> (38) B_A[1,2] = sin(q3)*cos(q1) + sin(q1)*sin(q2)*cos(q3)
    -> (39) B_A[1,3] = sin(q1)*sin(q3) - sin(q2)*cos(q1)*cos(q3)
    -> (40) B_A[2,1] = -sin(q3)*cos(q2)
    -> (41) B_A[2,2] = cos(q1)*cos(q3) - sin(q1)*sin(q2)*sin(q3)
    -> (42) B_A[2,3] = sin(q1)*cos(q3) + sin(q2)*sin(q3)*cos(q1)
    -> (43) B_A[3,1] = sin(q2)
    -> (44) B_A[3,2] = -sin(q1)*cos(q2)
    -> (45) B_A[3,3] = cos(q1)*cos(q2)

       (46) %--------------------------------------------------------------------
       (47) % Example 5: SetRotationMatrix (Euler parameters i.e., quaternion)
       (48) %--------------------------------------------------------------------
       (49) Variable  e0, e1, e2, e3
       (50) B.SetRotationMatrix( A,  EulerParameters, e0, e1, e2, e3 )
    -> (51) B_A[1,1] = -1 + 2*e0^2 + 2*e1^2
    -> (52) B_A[1,2] = 2*e0*e3 + 2*e1*e2
    -> (53) B_A[1,3] = 2*e1*e3 - 2*e0*e2
    -> (54) B_A[2,1] = 2*e1*e2 - 2*e0*e3
    -> (55) B_A[2,2] = -1 + 2*e0^2 + 2*e2^2
    -> (56) B_A[2,3] = 2*e0*e1 + 2*e2*e3
    -> (57) B_A[3,1] = 2*e0*e2 + 2*e1*e3
    -> (58) B_A[3,2] = 2*e2*e3 - 2*e0*e1
    -> (59) B_A[3,3] = -1 + 2*e0^2 + 2*e3^2

       (60) B.SetRotationMatrix( A,  Quaternion, e0, e1, e2, e3 )
    -> (61) B_A[1,1] = -1 + 2*e0^2 + 2*e1^2
    -> (62) B_A[1,2] = 2*e0*e3 + 2*e1*e2
    -> (63) B_A[1,3] = 2*e1*e3 - 2*e0*e2
    -> (64) B_A[2,1] = 2*e1*e2 - 2*e0*e3
    -> (65) B_A[2,2] = -1 + 2*e0^2 + 2*e2^2
    -> (66) B_A[2,3] = 2*e0*e1 + 2*e2*e3
    -> (67) B_A[3,1] = 2*e0*e2 + 2*e1*e3
    -> (68) B_A[3,2] = 2*e2*e3 - 2*e0*e1
    -> (69) B_A[3,3] = -1 + 2*e0^2 + 2*e3^2

       (70) %--------------------------------------------------------------------
       (71) % Example 6: SetRotationMatrix (Rodrigues parameters / Gibbs vector)
       (72) %--------------------------------------------------------------------
       (73) Variable  rho0, rho1, rho2
       (74) B.SetRotationMatrix( A,  RodriguesParameters, rho0, rho1, rho2 )
    -> (75) B_A[1,1] = (1+rho0^2-rho1^2-rho2^2)/(1+rho0^2+rho1^2+rho2^2)
    -> (76) B_A[1,2] = 2*(rho2+rho0*rho1)/(1+rho0^2+rho1^2+rho2^2)
    -> (77) B_A[1,3] = -2*(rho1-rho0*rho2)/(1+rho0^2+rho1^2+rho2^2)
    -> (78) B_A[2,1] = -2*(rho2-rho0*rho1)/(1+rho0^2+rho1^2+rho2^2)
    -> (79) B_A[2,2] = (1+rho1^2-rho0^2-rho2^2)/(1+rho0^2+rho1^2+rho2^2)
    -> (80) B_A[2,3] = 2*(rho0+rho1*rho2)/(1+rho0^2+rho1^2+rho2^2)
    -> (81) B_A[3,1] = 2*(rho1+rho0*rho2)/(1+rho0^2+rho1^2+rho2^2)
    -> (82) B_A[3,2] = -2*(rho0-rho1*rho2)/(1+rho0^2+rho1^2+rho2^2)
    -> (83) B_A[3,3] = -(-1+rho0^2+rho1^2-rho2^2)/(1+rho0^2+rho1^2+rho2^2)

       (84) %--------------------------------------------------------------------
       (85) % Example 7: SetRotationMatrix (Poisson parameters)
       (86) %--------------------------------------------------------------------
       (87) Variable  R{1:3}{1:3}
       (88) B.SetRotationMatrix( A, PoissonParameters, R11,R12,R13, R21,R22,R23, R31,R32,R33 )
    -> (89) B_A = [R11, R12, R13;  R21, R22, R23;  R31, R32, R33]

       (90) %--------------------------------------------------------------------
       (91) % Example 8: SetRotationMatrix (Indirect orientation)
       (92) %--------------------------------------------------------------------
       (93) pB> = Bx> + By>;    qB> = Bx> - By>;    rB> = Bz>
    -> (94) pB> = Bx> + By>
    -> (95) qB> = Bx> - By>
    -> (96) rB> = Bz>

       (97) pA> = sqrt(2)*Ay>;  qA> = sqrt(2)*Ax>;  rA> = Az>
    -> (98) pA> = 1.414214*Ay>
    -> (99) qA> = 1.414214*Ax>
    -> (100) rA> = Az>

       (101) B.SetRotationMatrix( A, Indirect, pB>, qB>, rB>,  pA>, qA>, rA> )
    -> (102) B_A = [0.7071068, 0.7071068, 0;  -0.7071068, 0.7071068, 0;  0, 0, 1]

       (103) B.SetRotationMatrix( A, Indirect, pB>, qB>,       pA>, qA>      )
    -> (104) B_A = [0.7071068, 0.7071068, 0;  -0.7071068, 0.7071068, 0;  0, 0, 1]

       (105) %--------------------------------------------------------------------
       (106) % Example 9: SetRotationMatrix (Directly from 3x3 matrix)
       (107) %--------------------------------------------------------------------
       (108) C.SetRotationMatrix( B, [R11,R12,R13; R21,R22,R23; R31,R32,R33] )
    -> (109) C_B = [R11, R12, R13;  R21, R22, R23;  R31, R32, R33]

       (110) %--------------------------------------------------------------------
       (111) % Example 10: SetRotationMatrix (by calculation C_A = C_B * B_A)
       (112) %--------------------------------------------------------------------
       (113) C.SetRotationMatrix( A )
    -> (114) C_A[1,1] = 0.7071068*R11 - 0.7071068*R12
    -> (115) C_A[1,2] = 0.7071068*R11 + 0.7071068*R12
    -> (116) C_A[1,3] = 1*R13
    -> (117) C_A[2,1] = 0.7071068*R21 - 0.7071068*R22
    -> (118) C_A[2,2] = 0.7071068*R21 + 0.7071068*R22
    -> (119) C_A[2,3] = 1*R23
    -> (120) C_A[3,1] = 0.7071068*R31 - 0.7071068*R32
    -> (121) C_A[3,2] = 0.7071068*R31 + 0.7071068*R32
    -> (122) C_A[3,3] = 1*R33

       (123) %--------------------------------------------------------------------
       (124) % Example 11  SetRotationMatrix (simple rotations with one angle)
       (125) %--------------------------------------------------------------------
       (126) B.SetRotationMatrixZ( A, q1 )
    -> (127) B_A = [cos(q1), sin(q1), 0;  -sin(q1), cos(q1), 0;  0, 0, 1]

       (128) B.SetRotationMatrixPositiveZ( A, q1 )
    -> (129) B_A = [cos(q1), sin(q1), 0;  -sin(q1), cos(q1), 0;  0, 0, 1]

       (130) B.SetRotationMatrixNegativeZ( A, q1 )
    -> (131) B_A = [cos(q1), -sin(q1), 0;  sin(q1), cos(q1), 0;  0, 0, 1]

#### SetRotationMatrixAndPosition

    SetRotationMatrixAndPosition

     Purpose:  Sets the rotation matrix and position vector associated with
               two rigid frames (or rigid bodies).

      Syntax:  B.SetRotationMatrixAndPosition( A, rotMatrix33, posVector )

       Input:  A, B -- names of reference frames (RigidFrame or RigidBody).

               rotMatrix33 -- expression that resolves to a 3x3 rotation matrix.
                              SetRotationMatrix shows may ways this can be done.
               posVector   -- expression that resolves to a vector
                              Example: x*Ax> + y*Ay> + z*Az>
                              or if posVector is the 3 element matrix [x, y, z],
                              posVector resolves to x*Ax> + y*Ay> + z*Az>.

      Output:  Assigns the rotation matrix B_A and position vector p_Ao_Bo> as:
               B.SetRotationMatrix( A, rotMatrix33 )
               Bo.SetPosition( Ao, posVector )

               Returns true if this method succeeds.

      Remark:  This is a convenience command. For clarity, we recommend:
               B.SetRotationMatrix( A, rotMatrix33 )
               Bo.SetPosition( Ao, posVector )

     Related:  SetRotationMatrix   SetPosition
               SetRigidTransform   GetRigidTransform
               SetVelocityAccelerationForGetGeometry  TranslateAcrossJoint

       (1) %--------------------------------------------------------------------
       (2) % Example: SetRotationMatrixAndPosition
       (3) %--------------------------------------------------------------------
       (4) RigidFrame A, B, C, D, E
       (5) Variable   Rxx, Rxy, Rxz,  Ryx, Ryy, Ryz,  Rzx, Rzy, Rzz
       (6) Variable   x, y, z
       (7) rotationMatrix = [Rxx, Rxy, Rxz;  Ryx, Ryy, Ryz;  Rzx, Rzy, Rzz]
    -> (8) rotationMatrix = [Rxx, Rxy, Rxz;  Ryx, Ryy, Ryz;  Rzx, Rzy, Rzz]

       (9) positionMatrix = [x;  y;  z]
    -> (10) positionMatrix = [x;  y;  z]

       (11) B.SetRotationMatrixAndPosition( A,  rotationMatrix,  positionMatrix )
    -> (12) B_A = [Rxx, Rxy, Rxz;  Ryx, Ryy, Ryz;  Rzx, Rzy, Rzz]
    -> (13) p_Ao_Bo> = x*Ax> + y*Ay> + z*Az>

       (14) %--------------------------------------------------------------------
       (15) % Example: SetRotationMatrixAndPosition
       (16) %--------------------------------------------------------------------
       (17) C.SetRotationMatrixAndPosition( B,  BodyZ(pi/6),  x*Bx> + y*By> + z*Bz> )
    -> (18) C_B = [0.8660254, 0.5, 0;  -0.5, 0.8660254, 0;  0, 0, 1]
    -> (19) p_Bo_Co> = x*Bx> + y*By> + z*Bz>

       (20) %--------------------------------------------------------------------
       (21) % Example: SetRotationMatrixAndPosition
       (22) %--------------------------------------------------------------------
       (23) D.SetRotationMatrixAndPosition( C,  BodyXYZ(pi, pi/2, pi/3),  x*Cx> + y*Cy> + z*Cz> )
    -> (24) D_C = [0, -0.8660254, 0.5;  0, -0.5, -0.8660254;  1, 0, 0]
    -> (25) p_Co_Do> = x*Cx> + y*Cy> + z*Cz>

       (26) %--------------------------------------------------------------------
       (27) % Example: SetRotationMatrixAndPosition
       (28) %--------------------------------------------------------------------
       (29) E.SetRotationMatrixAndPosition( D,  Quaternion( cos(pi/6/2), 0, 0, sin(pi/6/2) ),  x*Dx> + y*Dy> + z*Dz> )
    -> (30) E_D = [0.8660254, 0.5, 0;  -0.5, 0.8660254, 0;  0, 0, 1]
    -> (31) p_Do_Eo> = x*Dx> + y*Dy> + z*Dz>

#### SetRigidTransform

    SetRigidTransform   (EXPERIMENTAL COMMAND, NOT RECOMMEND FOR USE).

     Purpose:  Sets the rotation matrix and position vector associated with
               two rigid frames (or rigid bodies).

    Syntax 1:  B.SetRigidTransform( A, rotMatrix33, posVector )
    Syntax 2:  B.SetRigidTransform( A, matrix34 )
    Syntax 3:  B.SetRigidTransform( A, matrix44 )

       Input:  A, B -- names of reference frames (RigidFrame or RigidBody).

     Input 1:  rotMatrix33 -- expression that resolves to a 3x3 rotation matrix.
               posVector   -- expression that resolves to a vector. For example,
                              if posVector is the 3 element matrix [x, y, z],
                              posVector resolves to x*Ax> + y*Ay> + z*Az>.

     Input 2:  matrix34  -- 3x4 matrix that contains a 3x3 rotation matrix and a
                            3x1 position vector matrix expressed in A, i.e.,
                            [ A_B  |  p_Ao_Bo ]

     Input 3:  matrix44  -- 4x4 matrix that contains a 3x3 rotation matrix, a
                            3x1 position vector matrix expressed in A, and
                            a bottom row of 0, 0, 0, 1, i.e.,
                            [   A_B    |  p_Ao_Bo ]
                            [ 0, 0, 0  |    1     ]

      Output:  Assigns a rotation matrix and position vector, e.g., as follows:
               A_B = Transpose( rotMatrix33 )  % i.e., B_A = rotMatrix33
               p_Ao_Bo> = posVector

               Returns true if this method succeeds.

     Related:  SetRotationMatrix   SetPosition
               SetRigidTransform   GetRigidTransform
               SetVelocityAccelerationForGetGeometry  TranslateAcrossJoint

       (1) %--------------------------------------------------------------------
       (2) % Example: SetRigidTransform from a rotation matrix and position matrix.
       (3) %--------------------------------------------------------------------
       (4) RigidFrame A, B, C, D
       (5) Variable   Rxx, Rxy, Rxz,  Ryx, Ryy, Ryz,  Rzx, Rzy, Rzz
       (6) rotationMatrix = [Rxx, Rxy, Rxz;  Ryx, Ryy, Ryz;  Rzx, Rzy, Rzz]
    -> (7) rotationMatrix = [Rxx, Rxy, Rxz;  Ryx, Ryy, Ryz;  Rzx, Rzy, Rzz]

       (8) positionMatrix = [7;  8;  9]
    -> (9) positionMatrix = [7;  8;  9]

       (10) B.SetRigidTransform( A,  rotationMatrix,  positionMatrix )
    -> (11) B_A = [Rxx, Rxy, Rxz;  Ryx, Ryy, Ryz;  Rzx, Rzy, Rzz]
    -> (12) p_Ao_Bo> = 7*Ax> + 8*Ay> + 9*Az>

       (13) X_AB = GetRigidTransform34( A, B )
    -> (14) X_AB = [Rxx, Ryx, Rzx, 7;  Rxy, Ryy, Rzy, 8;  Rxz, Ryz, Rzz, 9]

       (15) %--------------------------------------------------------------------
       (16) % Example: SetRigidTransform from a 3x4 (or 4x4) matrix
       (17) %--------------------------------------------------------------------
       (18) matrix34 = [Rxx, Rxy, Rxz, 7;  Ryx, Ryy, Ryz, 8;  Rzx, Rzy, Rzz, 9]
    -> (19) matrix34 = [Rxx, Rxy, Rxz, 7;  Ryx, Ryy, Ryz, 8;  Rzx, Rzy, Rzz, 9]

       (20) C.SetRigidTransform( B,  matrix34 )
    -> (21) C_B = [Rxx, Rxy, Rxz;  Ryx, Ryy, Ryz;  Rzx, Rzy, Rzz]
    -> (22) p_Bo_Co> = 7*Bx> + 8*By> + 9*Bz>

       (23) X_BC = GetRigidTransform44( B, C )
    -> (24) X_BC = [Rxx, Ryx, Rzx, 7;  Rxy, Ryy, Rzy, 8;  Rxz, Ryz, Rzz, 9;  0, 0, 0, 1]

       (25) %--------------------------------------------------------------------
       (26) % Example: SetRigidTransform
       (27) %--------------------------------------------------------------------
       (28) Variable   x,  y, z
       (29) D.SetRigidTransform( C,  BodyXYZ(pi, pi/2, pi/3),  x*Cx> + y*Cy> + z*Cz> )
    -> (30) D_C = [0, -0.8660254, 0.5;  0, -0.5, -0.8660254;  1, 0, 0]
    -> (31) p_Co_Do> = x*Cx> + y*Cy> + z*Cz>

       (32) X_CD = GetRigidTransform34( C, D )
    -> (33) X_CD = [0, 0, 1, x;  -0.8660254, -0.5, 0, y;  0.5, -0.8660254, 0, z]

#### GetRigidTransform

    GetRigidTransform34  or  GetRigidTransform44   (RESERVED SYNTAX)

     Purpose:  Gets a matrix that contains the rotation matrix and position vector
               matrix associated with two rigid frames (or rigid bodies).

    Syntax 1:  GetRigidTransform34( A, B )
    Syntax 2:  GetRigidTransform44( A, B )

       Input:  A, B -- names of reference frames (RigidFrame or RigidBody).

    Output 1:  Contains a 3x3 rotation matrix and 3x1 position vector matrix, with:
               A_B = A.GetRotationMatrix( B )
               p_Ao_Bo = Dot( p_Ao_Bo>, [Ax>; Ay>; Az>] )
               Returns 3x4 matrix:  [   A_B    |  p_Ao_Bo ]

    Output 2:  Returns 4x4 matrix:  [   A_B    |  p_Ao_Bo ]
                                    [ 0, 0, 0  |    1     ]

     Related:  SetRotationMatrix   SetPosition
               SetRigidTransform   GetRigidTransform
               SetVelocityAccelerationForGetGeometry  TranslateAcrossJoint

       (1) %--------------------------------------------------------------------
       (2) % Example: GetRigidTransform34
       (3) %--------------------------------------------------------------------
       (4) RigidFrame A, B
       (5) Variables  Rxx, Rxy, Rxz,  Ryx, Ryy, Ryz,  Rzx, Rzy, Rzz
       (6) B.SetRigidTransform( A,  [Rxx, Rxy, Rxz;  Ryx, Ryy, Ryz;  Rzx, Rzy, Rzz],  [7, 8, 9] )
    -> (7) B_A = [Rxx, Rxy, Rxz;  Ryx, Ryy, Ryz;  Rzx, Rzy, Rzz]
    -> (8) p_Ao_Bo> = 7*Ax> + 8*Ay> + 9*Az>

       (9) X_AB = GetRigidTransform34( A, B )
    -> (10) X_AB = [Rxx, Ryx, Rzx, 7;  Rxy, Ryy, Rzy, 8;  Rxz, Ryz, Rzz, 9]

       (11) %--------------------------------------------------------------------
       (12) % Example: GetRigidTransform44
       (13) %--------------------------------------------------------------------
       (14) X_AB := GetRigidTransform44( A, B )
    -> (15) X_AB = [Rxx, Ryx, Rzx, 7;  Rxy, Ryy, Rzy, 8;  Rxz, Ryz, Rzz, 9;  0, 0, 0, 1]

       (16) %--------------------------------------------------------------------
       (17) % Example: GetRigidTransform34
       (18) %--------------------------------------------------------------------
       (19) RigidFrame C, D
       (20) Constant   q, r, s
       (21) D.SetRigidTransform( C,  BodyXYZ(pi, pi/2, pi/3),  q*Cx> + r*Cy> + s*Cz> )
    -> (22) D_C = [0, -0.8660254, 0.5;  0, -0.5, -0.8660254;  1, 0, 0]
    -> (23) p_Co_Do> = q*Cx> + r*Cy> + s*Cz>

       (24) X_CD = GetRigidTransform34( C, D )
    -> (25) X_CD = [0, 0, 1, q;  -0.8660254, -0.5, 0, r;  0.5, -0.8660254, 0, s]

#### SetRotationMatrixODE

    SetRotationMatrixODE

     Purpose:  Sets the rotation matrix relating two sets of bases vectors.
               Forms differential equations that relate the time-derivatives
               of orientation angles, Euler parameters, Rodrigues parameters,
               or rotation matrix elements (direction cosines) to
               angular velocity measures.

    Syntax 1:  B.SetRotationMatrixODE( A, SequenceIJK,      q1, q2, q3 )
    Syntax 2:  B.SetRotationMatrixODE( A, EulerParameters,  e0, e1, e2, e3 )
               B.SetRotationMatrixODE( A, Quaternion,       e0, e1, e2, e3 )
    Syntax 3:  B.SetRotationMatrixODE( A, RodriguesParameters, rho1, rho2, rho3 )
    Syntax 4:  B.SetRotationMatrixODE( A, PoissonParameters, Rxx,Rxy, ..., Rzz )

       Input:  B, A -- name of a RigidFrame or RigidBody.

               SequenceIJK -- one of the following:
                       BodyXYZ,  BodyYZX,  BodyZXY,  BodyXZY,  BodyYXZ,  BodyZYX
                       BodyXYX,  BodyXZX,  BodyYXY,  BodyYZY,  BodyZXZ,  BodyZYZ
                      SpaceXYZ, SpaceYZX, SpaceZXY, SpaceXZY, SpaceYXZ, SpaceZYX
                      SpaceXYX, SpaceXZX, SpaceYXY, SpaceYZY, SpaceZXZ, SpaceZYZ

               q1, q2, q3 -- names of radian measures of orientation angles
               associated with right-handed rotations of B relative to A,
               that relate Bi> to Aj>  (i,j = x,y,z).

               e0, e1, e2, e3 -- names of Euler parameters (quaternion)
               that relate Bi> to Aj>  (i,j = x,y,z).

               rho1, rho2, rho3 -- names of Rodrigues parameters
               that relate Bi> to Aj>  (i,j = x,y,z).

               Rxx,Rxy,Rxz, Ryx,Ryy,Ryz, Rzx,Rzy,Rzz - names of rotation matrix
               elements that relate Bi> to Aj>  (i,j = x,y,z).

      Always:  Sets and returns the rotation matrix B_A that relates
               Bx>, By>, Bz>  to  Ax>, Ay>, Az>

    Output 1:  Expresses q1', q2', and q3' in terms of q1, q2, q3,
               and B's angular velocity in A.

    Output 2:  Expresses e0', e1', e2', e3' in terms of e0, e1, e2, e3,
               and B's angular velocity in A.

    Output 3:  Expresses rho1', rho2', and rho3' in terms of rho1, rho2, rho3,
               and B's angular velocity in A.

    Output 4:  Expresses Rxx', ... Rzz' in terms of Rxx, ... Rzz,
               and B's angular velocity in A.

      Remark:  B's angular velocity in A or its equivalent must be in the
               workspace before this command can be issued.

      Remark:  Definitions of orientation angles, Euler parameters (quaternion),
               Rodrigues parameters, and direction cosines are in
               Kane, Likins, Levinson: Spacecraft Dynamics, McGraw-Hill, Ch. 1, and
               Mitiguy, Paul, "Advanced Dynamics & Motion Simulation".

     Related:  Rotate  RotateX  RotateY  RotateZ
               RotateNegativeX  RotateNegativeY  RotateNegativeZ
               SetRotationMatrixX  SetRotationMatrixY  SetRotationMatrixZ
               SetRotationMatrixNegativeX  SetRotationMatrixNegativeY  ...
               SetRotationMatrix  SetAngularVelocity  SetAngularAcceleration
               GetRotationMatrix  GetAngularVelocity  GetAngularAcceleration
               SetRotationMatrixODE  SetEulerParameterODE  SetRodriguesParameterODE
               SetPoissonParameterODE

       (1) %--------------------------------------------------------------------
       (2) % Example 1: SetRotationMatrixODE  (Orientation angles)
       (3) %--------------------------------------------------------------------
       (4) RigidFrame  A, B
       (5) Variable    q1',  q2', q3'
       (6) Variable    wx',  wy', wz'
       (7) B.SetAngularVelocity( A, wx*Bx> + wy*By> + wz*Bz> )
    -> (8) w_B_A> = wx*Bx> + wy*By> + wz*Bz>

       (9) B.SetRotationMatrixODE( A, BodyXYZ, q1, q2, q3 )
    -> (10) B_A[1,1] = cos(q2)*cos(q3)
    -> (11) B_A[1,2] = sin(q3)*cos(q1) + sin(q1)*sin(q2)*cos(q3)
    -> (12) B_A[1,3] = sin(q1)*sin(q3) - sin(q2)*cos(q1)*cos(q3)
    -> (13) B_A[2,1] = -sin(q3)*cos(q2)
    -> (14) B_A[2,2] = cos(q1)*cos(q3) - sin(q1)*sin(q2)*sin(q3)
    -> (15) B_A[2,3] = sin(q1)*cos(q3) + sin(q2)*sin(q3)*cos(q1)
    -> (16) B_A[3,1] = sin(q2)
    -> (17) B_A[3,2] = -sin(q1)*cos(q2)
    -> (18) B_A[3,3] = cos(q1)*cos(q2)
    -> (19) q1' = (wx*cos(q3)-wy*sin(q3))/cos(q2)
    -> (20) q2' = wx*sin(q3) + wy*cos(q3)
    -> (21) q3' = wz - tan(q2)*(wx*cos(q3)-wy*sin(q3))

       (22) %--------------------------------------------------------------------
       (23) % Example 2: SetRotationMatrixODE (Euler parameters / quaternion )
       (24) %--------------------------------------------------------------------
       (25) RigidFrame  C
       (26) Variable    e0', e1', e2', e3'
       (27) C.SetAngularVelocity( A, wx*Cx> + wy*Cy> + wz*Cz> )
    -> (28) w_C_A> = wx*Cx> + wy*Cy> + wz*Cz>

       (29) C.SetRotationMatrixODE( A, EulerParameters, e0, e1, e2, e3 )
    -> (30) C_A[1,1] = -1 + 2*e0^2 + 2*e1^2
    -> (31) C_A[1,2] = 2*e0*e3 + 2*e1*e2
    -> (32) C_A[1,3] = 2*e1*e3 - 2*e0*e2
    -> (33) C_A[2,1] = 2*e1*e2 - 2*e0*e3
    -> (34) C_A[2,2] = -1 + 2*e0^2 + 2*e2^2
    -> (35) C_A[2,3] = 2*e0*e1 + 2*e2*e3
    -> (36) C_A[3,1] = 2*e0*e2 + 2*e1*e3
    -> (37) C_A[3,2] = 2*e2*e3 - 2*e0*e1
    -> (38) C_A[3,3] = -1 + 2*e0^2 + 2*e3^2
    -> (39) e0' = -0.5*e1*wx - 0.5*e2*wy - 0.5*e3*wz
    -> (40) e1' = 0.5*e0*wx + 0.5*e2*wz - 0.5*e3*wy
    -> (41) e2' = 0.5*e0*wy + 0.5*e3*wx - 0.5*e1*wz
    -> (42) e3' = 0.5*e0*wz + 0.5*e1*wy - 0.5*e2*wx

       (43) %--------------------------------------------------------------------
       (44) % Example 3: SetRotationMatrixODE  (Rodrigues parameters)
       (45) %--------------------------------------------------------------------
       (46) RigidFrame  D
       (47) Variable    r1', r2', r3'
       (48) D.SetAngularVelocity( A, wx*Dx> + wy*Dy> + wz*Dz> )
    -> (49) w_D_A> = wx*Dx> + wy*Dy> + wz*Dz>

       (50) D.SetRotationMatrixODE( A, RodriguesParameters, r1, r2, r3 )
    -> (51) D_A[1,1] = (1+r1^2-r2^2-r3^2)/(1+r1^2+r2^2+r3^2)
    -> (52) D_A[1,2] = 2*(r3+r1*r2)/(1+r1^2+r2^2+r3^2)
    -> (53) D_A[1,3] = -2*(r2-r1*r3)/(1+r1^2+r2^2+r3^2)
    -> (54) D_A[2,1] = -2*(r3-r1*r2)/(1+r1^2+r2^2+r3^2)
    -> (55) D_A[2,2] = (1+r2^2-r1^2-r3^2)/(1+r1^2+r2^2+r3^2)
    -> (56) D_A[2,3] = 2*(r1+r2*r3)/(1+r1^2+r2^2+r3^2)
    -> (57) D_A[3,1] = 2*(r2+r1*r3)/(1+r1^2+r2^2+r3^2)
    -> (58) D_A[3,2] = -2*(r1-r2*r3)/(1+r1^2+r2^2+r3^2)
    -> (59) D_A[3,3] = -(-1+r1^2+r2^2-r3^2)/(1+r1^2+r2^2+r3^2)
    -> (60) r1' = 0.5*wx*(1+r1^2) + 0.5*wz*(r2+r1*r3) - 0.5*wy*(r3-r1*r2)
    -> (61) r2' = 0.5*wx*(r3+r1*r2) + 0.5*wy*(1+r2^2) - 0.5*wz*(r1-r2*r3)
    -> (62) r3' = 0.5*wy*(r1+r2*r3) + 0.5*wz*(1+r3^2) - 0.5*wx*(r2-r1*r3)

       (63) %--------------------------------------------------------------------
       (64) % Example 4: SetRotationMatrixODE  (Direction cosines)
       (65) %--------------------------------------------------------------------
       (66) RigidFrame  F
       (67) Variable    C{1:3,1:3}'
       (68) F.SetAngularVelocity( A, wx*Fx> + wy*Fy> + wz*Fz> )
    -> (69) w_F_A> = wx*Fx> + wy*Fy> + wz*Fz>

       (70) F.SetRotationMatrixODE( A, PoissonParameters, C11,C12,C13, C21,C22,C23, C31,C32,C33 )
    -> (71) F_A = [C11, C12, C13;  C21, C22, C23;  C31, C32, C33]
    -> (72) C11' = C21*wz - C31*wy
    -> (73) C12' = C22*wz - C32*wy
    -> (74) C13' = C23*wz - C33*wy
    -> (75) C21' = C31*wx - C11*wz
    -> (76) C22' = C32*wx - C12*wz
    -> (77) C23' = C33*wx - C13*wz
    -> (78) C31' = C11*wy - C21*wx
    -> (79) C32' = C12*wy - C22*wx
    -> (80) C33' = C13*wy - C23*wx

#### SetEulerParameterODE

    SetEulerParameterODE  or  SetQuaternionODE

     Purpose:  Forms differential equations by relating the time-derivatives
               of Euler parameters (quaternion) to angular velocity measures.

      Syntax:  B.SetEulerParameterODE( A, e0, e1, e2, e3 )
               B.SetQuaternionODE(     A, e0, e1, e2, e3 )

       Input:  B, A -- name of a RigidFrame or RigidBody.

               e0, e1, e2, e3 -- names of Euler parameters (quaternion)
               that relate Bi> to Aj>  (i,j = x,y,z).

      Output:  Expresses e0', e1', e2', e3' in terms of e0, e1, e2, e3,
               and B's angular velocity in A.
               Returns the column matrix [e0; e1; e2; e3]

      Remark:  B's angular velocity in A or its equivalent must be in the
               workspace before this command can be issued.

      Remark:  Definitions of Euler parameters (quaternions) are in
               Kane, Likins, Levinson: Spacecraft Dynamics, McGraw-Hill, Ch. 1, and
               Mitiguy, Paul, "Advanced Dynamics & Motion Simulation".

     Related:  Rotate  RotateX  RotateY  RotateZ
               RotateNegativeX  RotateNegativeY  RotateNegativeZ
               SetRotationMatrixX  SetRotationMatrixY  SetRotationMatrixZ
               SetRotationMatrixNegativeX  SetRotationMatrixNegativeY  ...
               SetRotationMatrix  SetAngularVelocity  SetAngularAcceleration
               GetRotationMatrix  GetAngularVelocity  GetAngularAcceleration
               SetRotationMatrixODE  SetEulerParameterODE  SetRodriguesParameterODE
               SetPoissonParameterODE

       (1) %--------------------------------------------------------------------
       (2) % Example: SetEulerParameterODE
       (3) %--------------------------------------------------------------------
       (4) RigidFrame  A, B
       (5) Variable    wx,  wy,  wz
       (6) Variable    e0', e1', e2', e3'
       (7) B.SetAngularVelocity( A, wx*Bx> + wy*By> + wz*Bz> )
    -> (8) w_B_A> = wx*Bx> + wy*By> + wz*Bz>

       (9) B.SetEulerParameterODE( A, e0, e1, e2, e3 )
    -> (10) e0' = -0.5*e1*wx - 0.5*e2*wy - 0.5*e3*wz
    -> (11) e1' = 0.5*e0*wx + 0.5*e2*wz - 0.5*e3*wy
    -> (12) e2' = 0.5*e0*wy + 0.5*e3*wx - 0.5*e1*wz
    -> (13) e3' = 0.5*e0*wz + 0.5*e1*wy - 0.5*e2*wx

#### SetRodriguesParameterODE

    SetRodriguesParameterODE

     Purpose:  Forms differential equations by relating the time-derivatives
               of Rodrigues parameters to angular velocity measures.

      Syntax:  B.SetRodriguesParameterODE( A, r1, r2, r3 )

       Input:  B, A -- name of a RigidFrame or RigidBody.

               r1, r2, r3 -- names of Rodrigues parameters
               that relate Bi> to Aj>  (i,j = x,y,z).

      Output:  Expresses r1', r2', and r3' in terms of r1, r2, r3,
               and B's angular velocity in A.
               Returns the column matrix [r1; r2; r3]

      Remark:  B's angular velocity in A or its equivalent must be in the
               workspace before this command can be issued.

      Remark:  Euler-Rodrigues parameters (or Gibbs vector) were invented
               by Euler 1770 and rediscovered by Rodrigues in 1840.
               Definitions of Rodrigues parameters (Gibbs vectors) are in
               Kane, Likins, Levinson: Spacecraft Dynamics, McGraw-Hill, Ch. 1, and
               Mitiguy, Paul, "Advanced Dynamics & Motion Simulation".

     Related:  Rotate  RotateX  RotateY  RotateZ
               RotateNegativeX  RotateNegativeY  RotateNegativeZ
               SetRotationMatrixX  SetRotationMatrixY  SetRotationMatrixZ
               SetRotationMatrixNegativeX  SetRotationMatrixNegativeY  ...
               SetRotationMatrix  SetAngularVelocity  SetAngularAcceleration
               GetRotationMatrix  GetAngularVelocity  GetAngularAcceleration
               SetRotationMatrixODE  SetEulerParameterODE  SetRodriguesParameterODE
               SetPoissonParameterODE

       (1) %--------------------------------------------------------------------
       (2) % Example: SetRodriguesParameterODE
       (3) %--------------------------------------------------------------------
       (4) RigidFrame  A, B
       (5) Variable    wx,  wy,  wz
       (6) Variable    r1', r2', r3'
       (7) B.SetAngularVelocity( A, wx*Bx> + wy*By> + wz*Bz> )
    -> (8) w_B_A> = wx*Bx> + wy*By> + wz*Bz>

       (9) B.SetRodriguesParameterODE( A, r1, r2, r3 )
    -> (10) r1' = 0.5*wx*(1+r1^2) + 0.5*wz*(r2+r1*r3) - 0.5*wy*(r3-r1*r2)
    -> (11) r2' = 0.5*wx*(r3+r1*r2) + 0.5*wy*(1+r2^2) - 0.5*wz*(r1-r2*r3)
    -> (12) r3' = 0.5*wy*(r1+r2*r3) + 0.5*wz*(1+r3^2) - 0.5*wx*(r2-r1*r3)

#### SetPoissonParameterODE

    SetPoissonParameterODE

     Purpose:  Forms differential equations by relating the time-derivatives
               of Rodrigues parameters to angular velocity measures.

      Syntax:  B.SetPoissonParameterODE( A, Rxx,Rxy,Rxz, Ryx,Ryy,Ryz, Rzx,Rzy,Rzz )

       Input:  B, A -- name of a RigidFrame or RigidBody.

               Rxx,Rxy,Rxz, Ryx,Ryy,Ryz, Rzx,Rzy,Rzz - names of rotation matrix
               elements that relate Bi> to Aj>  (i,j = x,y,z).

      Output:  Expresses Rxx', ... Rzz', in terms of Rxx, ... Rzz,
               and B's angular velocity in A.
               Returns 3x3 matrix [Rxx,Rxy,Rxz; Ryx,Ryy,Ryz; Rzx,Rzy,Rzz]

      Remark:  B's angular velocity in A or its equivalent must be in the
               workspace before this command can be issued.

      Remark:  Definitions of Poisson parameters are in
               Kane, Likins, Levinson: Spacecraft Dynamics, McGraw-Hill, Ch. 1, and
               Mitiguy, Paul, "Advanced Dynamics & Motion Simulation".

     Related:  Rotate  RotateX  RotateY  RotateZ
               RotateNegativeX  RotateNegativeY  RotateNegativeZ
               SetRotationMatrixX  SetRotationMatrixY  SetRotationMatrixZ
               SetRotationMatrixNegativeX  SetRotationMatrixNegativeY  ...
               SetRotationMatrix  SetAngularVelocity  SetAngularAcceleration
               GetRotationMatrix  GetAngularVelocity  GetAngularAcceleration
               SetRotationMatrixODE  SetEulerParameterODE  SetRodriguesParameterODE
               SetPoissonParameterODE

       (1) %--------------------------------------------------------------------
       (2) % Example: SetPoissonParameterODE
       (3) %--------------------------------------------------------------------
       (4) RigidFrame  A, B
       (5) Variable    wx,  wy,  wz
       (6) Variable    Rxx', Rxy', Rxz'
       (7) Variable    Ryx', Ryy', Ryz'
       (8) Variable    Rzx', Rzy', Rzz'
       (9) B.SetAngularVelocity( A, wx*Bx> + wy*By> + wz*Bz> )
    -> (10) w_B_A> = wx*Bx> + wy*By> + wz*Bz>

       (11) B.SetPoissonParameterODE( A, Rxx,Rxy,Rxz, Ryx,Ryy,Ryz, Rzx,Rzy,Rzz )
    -> (12) Rxx' = Ryx*wz - Rzx*wy
    -> (13) Rxy' = Ryy*wz - Rzy*wy
    -> (14) Rxz' = Ryz*wz - Rzz*wy
    -> (15) Ryx' = Rzx*wx - Rxx*wz
    -> (16) Ryy' = Rzy*wx - Rxy*wz
    -> (17) Ryz' = Rzz*wx - Rxz*wz
    -> (18) Rzx' = Rxx*wy - Ryx*wx
    -> (19) Rzy' = Rxy*wy - Ryy*wx
    -> (20) Rzz' = Rxz*wy - Ryz*wx

#### SetRotationMatrixX

    SetRotationMatrixX     SetRotationMatrixNegativeX

     Purpose:  Forms the rotation matrix (direction cosine matrix) associated
               with the right-handed rotation of a rigid basis (e.g., B)
               relative to another rigid basis (e.g., A).

    Syntax 1:  B.SetRotationMatrixX( A, q )
    Syntax 2:  B.SetRotationMatrixNegativeX( A, q )

       Input:  B, A -- name of a RigidFrame or RigidBody.
               q -- expressions for an angle.

    Output 1:  Sets and returns the B_A rotation matrix formed by a right-handed
               rotation of B relative to A about  Ax> = Bx>  by the angle q.

    Output 2:  Same as Output 1, except B rotates about  -Ax> = -Bx>.

      Remark:  SetRotationMatrixPositiveX is identical to SetRotationMatrixX

     Related:  Rotate  RotateX  RotateY  RotateZ
               RotateNegativeX  RotateNegativeY  RotateNegativeZ
               SetRotationMatrixX  SetRotationMatrixY  SetRotationMatrixZ
               SetRotationMatrixNegativeX  SetRotationMatrixNegativeY  ...
               SetRotationMatrix  SetAngularVelocity  SetAngularAcceleration
               GetRotationMatrix  GetAngularVelocity  GetAngularAcceleration
               SetRotationMatrixODE

       (1) %--------------------------------------------------------------------
       (2) % Example 1:  SetRotationMatrixX
       (3) %--------------------------------------------------------------------
       (4) RigidFrame     A, B, C
       (5) Variable       q
       (6) B.SetRotationMatrixX( A, q )
    -> (7) B_A = [1, 0, 0;  0, cos(q), sin(q);  0, -sin(q), cos(q)]

       (8) %--------------------------------------------------------------------
       (9) % Example 2:  SetRotationMatrixNegativeX
       (10) %--------------------------------------------------------------------
       (11) C.SetRotationMatrixNegativeX( B, t )
    -> (12) C_B = [1, 0, 0;  0, cos(t), -sin(t);  0, sin(t), cos(t)]

       (13) %--------------------------------------------------------------------
       (14) % Note: For more HELP, try:  Rotate     SetRotationMatrix
       (15) %                            RotateX    SetRotationMatrixX
       (16) %                            RotateY    SetRotationMatrixY
       (17) %                            RotateZ    SetRotationMatrixZ

#### SetRotationMatrixY

    SetRotationMatrixY     SetRotationMatrixNegativeY

     Purpose:  Forms the rotation matrix (direction cosine matrix) associated
               with the right-handed rotation of a rigid basis (e.g., B)
               relative to another rigid basis (e.g., A).

    Syntax 1:  B.SetRotationMatrixY( A, q )
    Syntax 2:  B.SetRotationMatrixNegativeY( A, q )

       Input:  B, A -- name of a RigidFrame or RigidBody.
               q -- expressions for an angle

    Output 1:  Sets and returns the B_A rotation matrix formed by a right-handed
               rotation of B relative to A about  Ay> = By>  by the angle q.

    Output 2:  Same as Output 1, except B rotates about  -Ay> = -By>.

      Remark:  SetRotationMatrixPositiveY is identical to SetRotationMatrixY.

     Related:  Rotate  RotateX  RotateY  RotateZ
               RotateNegativeX  RotateNegativeY  RotateNegativeZ
               SetRotationMatrixX  SetRotationMatrixY  SetRotationMatrixZ
               SetRotationMatrixNegativeX  SetRotationMatrixNegativeY  ...
               SetRotationMatrix  SetAngularVelocity  SetAngularAcceleration
               GetRotationMatrix  GetAngularVelocity  GetAngularAcceleration
               SetRotationMatrixODE

       (1) %--------------------------------------------------------------------
       (2) % Example 1:  SetRotationMatrixY
       (3) %--------------------------------------------------------------------
       (4) RigidFrame     A, B, C
       (5) Variable       q
       (6) B.SetRotationMatrixY( A, q )
    -> (7) B_A = [cos(q), 0, -sin(q);  0, 1, 0;  sin(q), 0, cos(q)]

       (8) %--------------------------------------------------------------------
       (9) % Example 2:  SetRotationMatrixNegativeY
       (10) %--------------------------------------------------------------------
       (11) C.SetRotationMatrixNegativeY( B, t )
    -> (12) C_B = [cos(t), 0, sin(t);  0, 1, 0;  -sin(t), 0, cos(t)]

       (13) %--------------------------------------------------------------------
       (14) % Note: For more HELP, try:  Rotate     SetRotationMatrix
       (15) %                            RotateX    SetRotationMatrixX
       (16) %                            RotateY    SetRotationMatrixY
       (17) %                            RotateZ    SetRotationMatrixZ

#### SetRotationMatrixZ

    SetRotationMatrixZ     SetRotationMatrixNegativeZ

     Purpose:  Forms the rotation matrix (direction cosine matrix) associated
               with the right-handed rotation of a rigid basis (e.g., B)
               relative to another rigid basis (e.g., A).

    Syntax 1:  B.SetRotationMatrixZ( A, q )
    Syntax 2:  B.SetRotationMatrixNegativeZ( A, q )

       Input:  B, A -- name of a RigidFrame or RigidBody.
               q -- expressions for an angle

    Output 1:  Sets and returns the B_A rotation matrix formed by a right-handed
               rotation of B relative to A about  Az> = Bz>  by the angle q.

    Output 2:  Same as Output 1, except B rotates about  -Az> = -Bz>.

      Remark:  SetRotationMatrixPositiveZ is identical to SetRotationMatrixY.

     Related:  Rotate  RotateX  RotateY  RotateZ
               RotateNegativeX  RotateNegativeY  RotateNegativeZ
               SetRotationMatrixX  SetRotationMatrixY  SetRotationMatrixZ
               SetRotationMatrixNegativeX  SetRotationMatrixNegativeY  ...
               SetRotationMatrix  SetAngularVelocity  SetAngularAcceleration
               GetRotationMatrix  GetAngularVelocity  GetAngularAcceleration
               SetRotationMatrixODE

       (1) %--------------------------------------------------------------------
       (2) % Example:  SetRotationMatrixZ
       (3) %--------------------------------------------------------------------
       (4) RigidFrame     A, B, C
       (5) Variable       q
       (6) B.SetRotationMatrixZ( A, q )
    -> (7) B_A = [cos(q), sin(q), 0;  -sin(q), cos(q), 0;  0, 0, 1]

       (8) %--------------------------------------------------------------------
       (9) % Example:  SetRotationMatrixNegativeZ
       (10) %--------------------------------------------------------------------
       (11) C.SetRotationMatrixNegativeZ( B, t )
    -> (12) C_B = [cos(t), -sin(t), 0;  sin(t), cos(t), 0;  0, 0, 1]

       (13) %--------------------------------------------------------------------
       (14) % Note: For more HELP, try:  Rotate     SetRotationMatrix
       (15) %                            RotateX    SetRotationMatrixX
       (16) %                            RotateY    SetRotationMatrixY
       (17) %                            RotateZ    SetRotationMatrixZ

#### SetPosition

    SetPosition

     Purpose:  Sets a point's position from another point.

      Syntax:  Q.SetPosition( fromPoint, positionVector )

       Input:  Q, fromPoint -- names of points (e.g., Point or Particle).
               positionVector -- a position vector.

      Output:  Sets and returns Q's position vector from fromPoint.

     Related:  Translate        SetPositionVelocity   SetVelocityAcceleration
               SetPosition      GetPosition   GetDistance  GetDistanceSquared
               SetVelocity      GetVelocity   GetSpeed     GetElongation
               SetAcceleration  GetAcceleration

       (1) %--------------------------------------------------------------------
       (2) % Example: SetPosition
       (3) %--------------------------------------------------------------------
       (4) RigidFrame N
       (5) Point      P
       (6) Particle   Q
       (7) Variable   xP, yP, zP
       (8) Variable   xQ, yQ, zQ
       (9) P.SetPosition( No, xP*Nx> + yP*Ny> + zP*Nz> )
    -> (10) p_No_P> = xP*Nx> + yP*Ny> + zP*Nz>

       (11) Q.SetPosition( P,  xQ*Nx> + yQ*Ny> + zQ*Nz> )
    -> (12) p_P_Q> = xQ*Nx> + yQ*Ny> + zQ*Nz>

       (13) QPositionVectorFromNo> = Q.GetPosition( No )
    -> (14) QPositionVectorFromNo> = (xP+xQ)*Nx> + (yP+yQ)*Ny> + (zP+zQ)*Nz>

#### SetPositionVelocity

    SetPositionVelocity

     Purpose:  Sets a point's position from another point.
               Sets a point's velocity in a reference frame.

    Syntax 1:  Q.SetPositionVelocity( fromPoint, positionVector )
               (Note: positionVector may be differentiated).

    Syntax 2:  Q.SetPositionVelocity( fromPoint, positionVector, BFixed )
               (Note: positionVector will NOT be differentiated).

    Syntax 3:  Q.SetPositionVelocity( fromPoint, positionVector, BFrame, BQ )
               (Note: positionVector may be differentiated).

       Input:  Q -- name of a point.

               fromPoint -- Point whose velocity in the NewtonianFrame
                            (or designated frame) is known (in the workspace).

               BFixed -- Rigid frame/body on which fromPoint and Q  are fixed.
               BFrame -- Rigid frame/body on which fromPoint and BQ are fixed.
                         Q is moving on BFrame.

               BQ -- Point of BFrame that is coincident with Q.

      Output:  Sets Q's position vector from fromPoint to positionVector.
               Sets Q's velocity in the NewtonianFrame (or designated refFrame).

      Remark:  To set Q's velocity in a non-NewtonianFrame, insert refFrame (name
               of a RigidFrame or RigidBody) as the optional first argument, e.g.,
    Syntax 1:  Q.SetPositionVelocity( refFrame, fromPoint, positionVector )
    Syntax 2:  Q.SetPositionVelocity( refFrame, fromPoint, positionVector, BFixed )
    Syntax 3:  Q.SetPositionVelocity( refFrame, fromPoint, positionVector,BFrame,BQ)

      Remark:  Use of Syntax 2 may also set the following (if not in workspace):
                 fromPoint's velocity and acceleration in BFixed to 0>
                 Q's         velocity and acceleration in BFixed to 0>

               Use of Syntax 3 may also set the following (if not in workspace):
                 fromPoint's velocity and acceleration in BFrame to 0>
                 BQ          may be defined as a physical point of BFrame
                 BQ's        velocity and acceleration in BFrame to 0>
                 BQ's        position from fromPoint
                 Q's         velocity in BFrame (via Q' position vector fromPoint)

      Remark:  If Q is welded to rigid frame/body B, declare it:  Point Q(B).
               Alternately, if Q does not move on B (but is not welded or a
               physical point of B), use Q.SetVelocityAcceleration( B, 0> )

     Related:  Translate        SetPositionVelocity   SetVelocityAcceleration
               SetPosition      GetPosition   GetDistance  GetDistanceSquared
               SetVelocity      GetVelocity   GetSpeed     GetElongation
               SetAcceleration  GetAcceleration

       (1) %--------------------------------------------------------------------
       (2) % Example 1: SetPositionVelocity
       (3) % Set Q1's velocity in N by differentiation.
       (4) %--------------------------------------------------------------------
       (5) NewtonianFrame N
       (6) Point     Q1
       (7) Variable  x1', y1'
       (8) Q1.SetPositionVelocity( No,  x1*Nx> + y1*Ny> )
    -> (9) p_No_Q1> = x1*Nx> + y1*Ny>
    -> (10) v_Q1_N> = x1'*Nx> + y1'*Ny>

       (11) %--------------------------------------------------------------------
       (12) % Example 2: SetPositionVelocity
       (13) % Set Q2's velocity in N by differentiation.
       (14) %--------------------------------------------------------------------
       (15) Point     Q2
       (16) Variable  x2', y2'
       (17) Q2.SetPositionVelocity( Q1,  x2*Nx> + y2*Ny> )
    -> (18) p_Q1_Q2> = x2*Nx> + y2*Ny>
    -> (19) v_Q2_N> = (x1'+x2')*Nx> + (y1'+y2')*Ny>

       (20) %--------------------------------------------------------------------
       (21) % Example 3: SetPositionVelocity
       (22) % Set Q3's velocity in N via two points (Q3 and Bo) fixed on B.
       (23) %--------------------------------------------------------------------
       (24) RigidBody B                  % Body B translates and rotates in N.
       (25) Point     Q3( B )            % Q3 is a point fixed on B.
       (26) Constant  L                  % Distance between Bo and Q3.
       (27) Variable  wB                 % Angular rate.
       (28) B.SetAngularVelocity( N,  wB*Bz> )
    -> (29) w_B_N> = wB*Bz>

       (30) Bo.SetPositionVelocity( No,  t^2/2*Nx> )
    -> (31) p_No_Bo> = 0.5*t^2*Nx>
    -> (32) v_Bo_N> = t*Nx>

       (33) Q3.SetPositionVelocity( Bo,  L*Bx>,  B )
    -> (34) p_Bo_Q3> = L*Bx>
    -> (35) v_Q3_N> = L*wB*By> + t*Nx>

       (36) %--------------------------------------------------------------------
       (37) % Example 4: SetPositionVelocity
       (38) % Set Q4's velocity in N via one point moving on B
       (39) %--------------------------------------------------------------------
       (40) Point      Q4,  BQ4( B )     % BQ4 is point of B coincident with Q4.
       (41) Variable   x4'
       (42) Q4.SetPositionVelocity( Bo,  x4*Bx>, B, BQ4 )
    -> (43) p_Bo_Q4> = x4*Bx>
    -> (44) p_Bo_BQ4> = x4*Bx>
    -> (45) v_BQ4_N> = wB*x4*By> + t*Nx>
    -> (46) v_Q4_B> = x4'*Bx>
    -> (47) v_Q4_N> = x4'*Bx> + wB*x4*By> + t*Nx>

#### SetScreenDisplay

    SetScreenDisplay  (Experimental - not recommended for use)

     Purpose:  Determines whether or not to print input lines or
               response lines to the screen.

      Syntax:  SetScreenDisplay( SETTING )

       Input:  SETTING -- ON, OFF, or NONE

     Outputs:  With SetScreenDisplay(ON), all input and output information
               is displayed on screen (default behavior).

               With SetScreenDisplay(OFF), only input lines and prompts are
               displayed on screen and output response are suppressed.

               With SetScreenDisplay(NONE), neither input or output is displayed.

     Related:  GetDefaults

#### SetSFunctionInput

    SetSFunctionInput  ResetSFunctionInput   GetSFunctionInput

     Purpose:  Identifies scalar quantities that are to be used by the ODE and
               Solve commands while generating .mSFunction and .cSFunction codes.
               These quantities are inputs to SFunction blocks.

    Syntax 1:  SetSFunctionInput( x, y, z)
    Syntax 2:  ResetSFunctionInput( )
    Syntax 3:  ResetSFunctionInput( x, y )
    Syntax 4:  GetSFunctionInput()

       Input:  x, y, z ... -- names appearing in Specified declarations.

    Output 1:  Appends x, y, z  to the matrix of names for SFunction input.
               Returns the matrix of all names for SFunction input.

    Output 2:  Removes all names from SFunction input.
               Returns 1x1 zero matrix.

    Output 3:  Removes all names from SFunction input.
               Appends x, y to the matrix of names for SFunction input.
               Returns the matrix of all names for SFunction input.

    Output 4:  Returns the matrix of all names for SFunction input.

     Related:  ODE  Solve  Input  Output  OutputPlot  Plot  Animate
               ConvertUnits  GetUnitSystem  SetUnitSystem  SetDigits
               Solve  SolveDt  SolveSetInput  SolveSetInputDt  ...
               SetSFunctionInput   ResetSFunctionInput  GetSFunctionInput

       (1) %---------------------------------------------------------------------
       (2) % Example: SetSFunctionInput
       (3) %---------------------------------------------------------------------
       (4) Specified  Fx = 0
    -> (5) Fx = 0

       (6) Constant   m = 1000 kg
       (7) Variable   x'' = Fx / m
    -> (8) x'' = Fx/m

       (9) SetSFunctionInput( Fx )
       (10) Input  x=2 m, x'=0 km/sec
       (11) Output t sec,  x meter,  x' km/sec
       (12) ODE() CarCruiseControl.mSFunction

#### SetPlotInterface

    SetPlotInterface  (experimental command -- subject to change).

     Purpose:  Designates how plots are displayed.

    Syntax 1:  SetPlotInterface  OFF
               No plots are displayed (plotting is disabled).

    Syntax 2:  SetPlotInterface  Gnuplot
               Plots are displayed with Gnuplot only.
               On MacOSX, requires XQuartz to be installed.

    Syntax 3:  SetPlotInterface  PlotGenesis
               Plots are displayed with the easy-to-use PlotGenesis interface.
               On MacOSX, requires XQuartz and Java JDK to be installed.

    Syntax 4:  SetPlotInterface  AUTO
               If possible, plots are displayed with PlotGenesis.
               Otherwise, attempts to use Gnuplot.
               On MacOSX, requires XQuartz to be installed.

      Remark:  SetPlotInterface can be set in the MGDefaultPreferences.txt file
               that resides in the program's MGToolbox folder.

     Related:  GetDefaults  Plot  OutputPlot  SetPlotInterface

       (1) %--------------------------------------------------------------------
       (2) % Example: SetPlotInterface OFF     (no plot appears)
       (3) %--------------------------------------------------------------------
       (4) Variable  y' = sin(t)
    -> (5) y' = sin(t)

       (6) Input     y = 2 m,  tFinal = 2 sec,  tStep = 0.1 sec
       (7) OutputPlot t sec,  y m,  y' m/s
       (8) OutputPlot t sec,  cos(y) m
       (9) SetPlotInterface  OFF
       (10) ODE() PlotInterfaceTest

       (11) %--------------------------------------------------------------------
       (12) % Example: SetPlotInterface Gnuplot (minimal plotting interface)
       (13) %--------------------------------------------------------------------
       (14) SetPlotInterface  Gnuplot
       (15) ODE() PlotInterfaceTest

       (16) %--------------------------------------------------------------------
       (17) % Example: SetPlotInterface Auto    (attempts easy-to-use interface)
       (18) %--------------------------------------------------------------------
       (19) SetPlotInterface  Auto
       (20) ODE() PlotInterfaceTest

#### SetUnitSystem

    SetUnitSystem

     Purpose:  Sets a unit system for unit conversions, e.g., for units set
               in Input and Output statements and Evaluate and Solve commands.

    Syntax 1:  SetUnitSystem( massUnit, lengthUnit, timeUnit )
    Syntax 2:  SetUnitSystem()

       Input:  massUnit   -- the name of a unit of mass,   e.g., kg
               lengthUnit -- the name of a unit of length, e.g., cm
               timeUnit   -- the name of a unit of time,   e.g., seconds

    Output 1:  Conversions are employed when the program uses Input and Output
               statements and for arguments of the Evaluate and Solve commands.

    Output 2:  On-screen display of massUnit, lengthUnit, and timeUnit.

      Remark:  Program default is SetUnitSystem( kilogram, meter, second ).

     Related:  ODE  Solve  Input  Output  OutputPlot  Plot  Animate
               Evaluate  Solve  SolveDt  SolveSetInput  SolveSetInputDt  ...
               ConvertUnits  GetUnitSystem  SetUnitSystem
               GetMassUnit   GetLengthUnit   GetTimeUnit   GetAngleUnit

    --------------------------------------------------------------------
    Example 1: SetUnitSystem
    --------------------------------------------------------------------
       (1) SetUnitSystem( kilogram, meter, second )
       (2) SetUnitSystem()
           kilogram, meter, second

    --------------------------------------------------------------------
    Example 2: SetUnitSystem
    --------------------------------------------------------------------
       (1) SetDigits( 3 )
       (2) Constant  F, m, g
       (3) Variable  v'
       (3) v' = g + F/m
    -> (4) v' = g + F/m
       (5) SetUnitSystem( kg, meter, sec )
       (6) Input  F=100 milliNewtons,  m=2 grams,  g=9.8 m/sec^2
       (7) Input  tFinal = 1 min,  tStep = 0.5 sec
       (8) Output  t, v, v km/hour, 1/2*m*v^2 milliJoules
       (9) ODE() Test.c

       The ODE command creates the C program Test.c, which on input,
       converts F from milliNewtons to kg*meter/sec^2 (Newtons) and
       converts m from grams to kg, e.g., with C statements such as

          F = 0.001 * F;
          m = 0.001 * m;

       On output, t is output in seconds (because no output units were
       specified and sec was designated as the time unit in SetUnitSystem);
       v is output with the label UNITS (which means no unit conversions
       were applied);  v is output in km/hour (a conversion from meter/sec
       to km/hour is applied); and  1/2*m*v^2 is output in milliJoules
       [a conversion from kg*meter^2/sec^2 to milliJoules is applied as
       the derived energy units designated by SetUnitSystem( kg, meter, sec)
       is kg*meter^2/sec^2 (Joules).]

       Execution of Test.c produces output file Test.1, e.g., as follows:
       Note: To produce output file Test.1 without first creating C code,
       remove the .c extension by changing line (9) to   ODE() Test

     FILE: Test.1

          t          v          v      1/2*m*v^2
        (sec)     (UNITS)   (km/hour) (milliJoules)

      0.00E-001  0.00E-001  0.00E-001  0.00E-001
      5.00E-001  2.99E+001  1.08E+002  8.94E+002
      1.00E+000  5.98E+001  2.15E+002  3.58E+003

       (1) %--------------------------------------------------------------------
       (2) % Example 3: SetUnitSystem  (affects unit conversions)
       (3) %--------------------------------------------------------------------
       (4) SetUnitSystem( gram, cm, sec )
       (5) MetersPerCm = ConvertUnits( meter, GetUnitSystem )
    -> (6) MetersPerCm = 100

       (7) InchesPerCm = ConvertUnits( inch,  GetUnitSystem )
    -> (8) InchesPerCm = 2.54

       (9) a1 = Evaluate( t^2, t = 2 inches )
    -> (10) a1 = 25.8064

       (11) a2 = Evaluate( t^2, t = 2 meters )
    -> (12) a2 = 40000

       (13) s1 = Solve( t^5 - 1, t=1 inch )
    ->   %  Note: t = 1 cm  was converted from  t = 0.3937008 inch.
    -> (14) s1 = [1]

       (15) s2 = Solve( t^5 - 1, t=1 meter )
    ->   %  Note: t = 1 cm  was converted from  t = 0.01 meter.
    -> (16) s2 = [1]

#### SetVelocity

    SetVelocity

     Purpose:  Sets a point's velocity in a reference frame.

    Syntax 1:  Q.SetVelocity( N, fromPoint )
    Syntax 2:  Q.SetVelocity( N, fromPoint, BFixed )
    Syntax 3:  Q.SetVelocity( N, fromPoint, BFrame, BQ )
    Syntax 4:  Q.SetVelocity( N, velocityVector )

       Input:  Q -- name of a point.
               N -- name of a RigidFrame or RigidBody.

               fromPoint -- Point whose velocity in N is already known.

               BFixed -- Rigid frame/body on which fromPoint and Q  are fixed.
               BFrame -- Rigid frame/body on which fromPoint and BQ are fixed.
                         Q is moving on BFrame.

               BQ -- Point of BFrame that is coincident with Q.

               velocityVector -- a velocity vector.

      Output:  Sets and returns Q's velocity in N.

      Remark:  Use of Syntax 2 may also set the following (if not in workspace):
                 fromPoint's velocity and acceleration in BFixed to 0>
                 Q's         velocity and acceleration in BFixed to 0>

               Use of Syntax 3 may also set the following (if not in workspace):
                 fromPoint's velocity and acceleration in BFrame to 0>
                 BQ          may be defined as a physical point of BFrame
                 BQ's        velocity and acceleration in BFrame to 0>
                 BQ's        position from fromPoint
                 Q's         velocity in BFrame (via Q' position vector fromPoint)

      Remark:  Q's position vector fromPoint is used by this command.

      Remark:  If Q is welded to rigid frame/body B, declare it:  Point Q(B).
               Alternately, if Q does not move on B (but is not welded or a
               physical point of B), use Q.SetVelocityAcceleration( B, 0> )

     Related:  Translate        SetPositionVelocity   SetVelocityAcceleration
               SetPosition      GetPosition   GetDistance  GetDistanceSquared
               SetVelocity      GetVelocity   GetSpeed     GetElongation
               SetAcceleration  GetAcceleration

       (1) %--------------------------------------------------------------------
       (2) % Example 1: SetVelocity
       (3) % Set Q1's velocity in N by differentiation.  Uses No fixed on N.
       (4) %--------------------------------------------------------------------
       (5) RigidFrame N
       (6) Point      Q1
       (7) Variable   x1', y1'
       (8) Q1.SetPosition( No,  x1*Nx> + y1*Ny> )
    -> (9) p_No_Q1> = x1*Nx> + y1*Ny>

       (10) Q1.SetVelocity( N, No )
    -> (11) v_Q1_N> = x1'*Nx> + y1'*Ny>

       (12) %--------------------------------------------------------------------
       (13) % Example 2: SetVelocity
       (14) % Set Q2's velocity in N by differentiation and Q1's velocity in N.
       (15) %--------------------------------------------------------------------
       (16) Point     Q2
       (17) Variable  x2', y2'
       (18) Q2.SetPosition( Q1,  x2*Nx> + y2*Ny> )
    -> (19) p_Q1_Q2> = x2*Nx> + y2*Ny>

       (20) Q2.SetVelocity( N, Q1 )
    -> (21) v_Q2_N> = (x1'+x2')*Nx> + (y1'+y2')*Ny>

       (22) %--------------------------------------------------------------------
       (23) % Example 3: SetVelocity
       (24) % Set Q3's velocity in N via two points (Q3 and Bo) fixed on B.
       (25) %--------------------------------------------------------------------
       (26) RigidBody B                  % Body B translates and rotates in N.
       (27) Point     Q3( B )            % Q3 is a point fixed on B.
       (28) Constant  L                  % Distance between Bo and Q3.
       (29) Variable  wB                 % Angular rate.
       (30) B.SetAngularVelocity( N,  wB*Bz> )
    -> (31) w_B_N> = wB*Bz>

       (32) Bo.SetVelocity( N,  t*Nx> )
    -> (33) v_Bo_N> = t*Nx>

       (34) Q3.SetPosition( Bo,  L*Bx> )
    -> (35) p_Bo_Q3> = L*Bx>

       (36) Q3.SetVelocity( N, Bo, B )
    -> (37) v_Q3_N> = L*wB*By> + t*Nx>

       (38) %--------------------------------------------------------------------
       (39) % Example 4: SetVelocity
       (40) % Set Q4's velocity in N via one point (Q4) moving on rigid-body B.
       (41) %--------------------------------------------------------------------
       (42) Point      Q4,  BQ4( B )     % BQ4 is point of B coincident with Q4.
       (43) Variable   x4'
       (44) Q4.SetPosition( Bo,  x4*Bx> )
    -> (45) p_Bo_Q4> = x4*Bx>

       (46) Q4.SetVelocity( N, Bo, B, BQ4 )
    -> (47) p_Bo_BQ4> = x4*Bx>
    -> (48) v_BQ4_N> = wB*x4*By> + t*Nx>
    -> (49) v_Q4_B> = x4'*Bx>
    -> (50) v_Q4_N> = x4'*Bx> + wB*x4*By> + t*Nx>

#### SetVelocityAcceleration

    SetVelocityAcceleration

     Purpose:  Sets a point's velocity and acceleration in a reference frame.

    Syntax 1:  Q.SetVelocityAcceleration( N, fromPoint )
    Syntax 2:  Q.SetVelocityAcceleration( N, fromPoint, BFixed )
    Syntax 3:  Q.SetVelocityAcceleration( N, fromPoint, BFrame, BQ )
    Syntax 4:  Q.SetVelocityAcceleration( N, velocityVector )

       Input:  Q -- name of a point.
               N -- name of a RigidFrame or RigidBody.

               fromPoint -- Point whose velocity and acceleration in N is known.

               BFixed -- Rigid frame/body on which fromPoint and Q  are fixed.
               BFrame -- Rigid frame/body on which fromPoint and BQ are fixed.
                         Q is moving on BFrame.

               BQ -- Point of BFrame that is coincident with Q.

               velocityVector -- a velocity vector.

      Output:  Sets Q's velocity and acceleration in N.

      Remark:  Use of Syntax 2 may also set the following (if not in workspace):
                 fromPoint's velocity and acceleration in BFixed to 0>
                 Q's         velocity and acceleration in BFixed to 0>

               Use of Syntax 3 may also set the following (if not in workspace):
                 fromPoint's velocity and acceleration in BFrame to 0>
                 BQ          may be defined as a physical point of BFrame
                 BQ's        velocity and acceleration in BFrame to 0>
                 BQ's        position from fromPoint
                 Q's         velocity in BFrame (via Q' position vector fromPoint)
                 Q's         acceleration in BFrame (via differentiation)

      Remark:  Q's position vector fromPoint is used by this command.

      Remark:  If Q is welded to rigid frame/body B, declare it:  Point Q(B).
               Alternately, if Q does not move on B (but is not welded or a
               physical point of B), use Q.SetVelocityAcceleration( B, 0> )

     Related:  Translate        SetPositionVelocity   SetVelocityAcceleration
               SetPosition      GetPosition   GetDistance  GetDistanceSquared
               SetVelocity      GetVelocity   GetSpeed     GetElongation
               SetAcceleration  GetAcceleration

       (1) %--------------------------------------------------------------------
       (2) % Example 1: SetVelocityAcceleration
       (3) % Set Q1's velocity and acceleration in N by differentiation.
       (4) %--------------------------------------------------------------------
       (5) RigidFrame N
       (6) Point      Q1
       (7) Variable   x1'', y1''
       (8) Q1.SetPosition( No,  x1*Nx> + y1*Ny> )
    -> (9) p_No_Q1> = x1*Nx> + y1*Ny>

       (10) Q1.SetVelocityAcceleration( N, No )
    -> (11) v_Q1_N> = x1'*Nx> + y1'*Ny>
    -> (12) a_Q1_N> = x1''*Nx> + y1''*Ny>

       (13) %--------------------------------------------------------------------
       (14) % Example 2: SetVelocityAcceleration
       (15) % Set Q2's velocity and acceleration in N by differentiation.
       (16) %--------------------------------------------------------------------
       (17) Point     Q2
       (18) Variable  x2'', y2''
       (19) Q2.SetPosition( Q1,  x2*Nx> + y2*Ny> )
    -> (20) p_Q1_Q2> = x2*Nx> + y2*Ny>

       (21) Q2.SetVelocityAcceleration( N, Q1 )
    -> (22) v_Q2_N> = (x1'+x2')*Nx> + (y1'+y2')*Ny>
    -> (23) a_Q2_N> = (x1''+x2'')*Nx> + (y1''+y2'')*Ny>

       (24) %--------------------------------------------------------------------
       (25) % Example 3: SetVelocityAcceleration
       (26) % Set Q3's velocity and acceleration in N via two points fixed on B.
       (27) %--------------------------------------------------------------------
       (28) RigidBody B                  % Body B translates and rotates in N.
       (29) Point     Q3( B )            % Q3 is a point fixed on B.
       (30) Constant  L                  % Distance between Bo and Q3.
       (31) Variable  wB'                % Angular rate and its time-derivative.
       (32) B.SetAngularVelocityAcceleration( N,  wB*Bz> )
    -> (33) w_B_N> = wB*Bz>
    -> (34) alf_B_N> = wB'*Bz>

       (35) Bo.SetVelocityAcceleration( N,  t*Nx> )
    -> (36) v_Bo_N> = t*Nx>
    -> (37) a_Bo_N> = Nx>

       (38) Q3.SetPosition( Bo,  L*Bx> )
    -> (39) p_Bo_Q3> = L*Bx>

       (40) Q3.SetVelocityAcceleration( N, Bo, B )
    -> (41) v_Q3_N> = L*wB*By> + t*Nx>
    -> (42) a_Q3_N> = -L*wB^2*Bx> + L*wB'*By> + Nx>

       (43) %--------------------------------------------------------------------
       (44) % Example 4: SetVelocityAcceleration
       (45) % Set Q4's velocity and acceleration in N via one point moving on B.
       (46) %--------------------------------------------------------------------
       (47) Point      Q4,  BQ4( B )     % BQ4 is point of B coincident with Q4.
       (48) Variable   x4''
       (49) Q4.SetPosition( Bo,  x4*Bx> )
    -> (50) p_Bo_Q4> = x4*Bx>

       (51) Q4.SetVelocityAcceleration( N, Bo, B, BQ4 )
    -> (52) p_Bo_BQ4> = x4*Bx>
    -> (53) v_BQ4_N> = wB*x4*By> + t*Nx>
    -> (54) v_Q4_B> = x4'*Bx>
    -> (55) v_Q4_N> = x4'*Bx> + wB*x4*By> + t*Nx>
    -> (56) a_BQ4_N> = -x4*wB^2*Bx> + x4*wB'*By> + Nx>
    -> (57) a_Q4_B> = x4''*Bx>
    -> (58) a_Q4_N> = (x4''-x4*wB^2)*Bx> + (x4*wB'+2*wB*x4')*By> + Nx>

#### SetWorkODE

    SetWorkODE

     Purpose:  Forms an ODE (ordinary differential equation) that governs the work
               of a force or torque (or set of forces and/or torques).

    Syntax 1:  SetWorkODE( workName, power )

       Input:  workName -- scalar name which will be declared as a variable and
                           whose first derivative will be declared as a variable.
               power -- scalar expression with units of power that will be
                        time-integrated to calculate workName.

      Output:  Creates the ODE workName' = power, and sets the initial value of
               workName to 0, (with units that depend on SetUnitSystem), e.g., as:

               Variable  work' = power
               Input  work = 0 Joules

     Related:  AddForce  AddForceDamper  AddForceElectrostatic  AddForceGravity
               AddForceInverseSquare  AddForceLinearActuator  AddForceSpring
               AddTorque  AddTorqueDamper
               GetMomentOfForces  GetResultantForce  GetResultantTorque
               GetForceGravityPotentialEnergy  GetForceSpringPotentialEnergy
               GetStatics   GetStaticsKane   GetStaticsLagrange   GetPower
               GetDynamics  GetDynamicsKane  GetDynamicsLagrange  GetKineticEnergy

       (1) %----------------------------------------------------------------------
       (2) % Example 1: SetWorkODE  (from power of external force on a particle Q)
       (3) %----------------------------------------------------------------------
       (4) NewtonianFrame  N
       (5) Particle        Q
       (6) Variable        vx, vy, wz
       (7) Specified       Fx, Fy, Tz
       (8) Q.SetVelocity( N,  vx*Nx> + vy*Ny> )
    -> (9) v_Q_N> = vx*Nx> + vy*Ny>

       (10) Q.AddForce( Fx*Nx> + Fy*Ny> )
    -> (11) Force_Q> = Fx*Nx> + Fy*Ny>

       (12) SetWorkODE( workOnQ, Q.GetPowerForce() )
    -> (13) workOnQ' = Fx*vx + Fy*vy

       (14) %----------------------------------------------------------------------
       (15) % Example 2: SetWorkODE  (from power of torque on body B from body A)
       (16) %----------------------------------------------------------------------
       (17) RigidBody       A, B
       (18) B.SetAngularVelocity( A, wz*Bz> )
    -> (19) w_B_A> = wz*Bz>

       (20) B.AddTorque( A,  Tz*Bz> )
    -> (21) Torque_B_A> = Tz*Bz>

       (22) SetWorkODE( workOnBFromA, B.GetPowerTorque(A) )
    -> (23) workOnBFromA' = Tz*wz

       (24) %----------------------------------------------------------------------
       (25) % Example 3: SetWorkODE  (from power of all forces and torques on the system)
       (26) %----------------------------------------------------------------------
       (27) powerOfSystem = System.GetPower()
    -> (28) powerOfSystem = Fx*vx + Fy*vy + Tz*wz

       (29) SetWorkODE( workOnSystem, powerOfSystem )
    -> (30) workOnSystem' = powerOfSystem

       (31) %----------------------------------------------------------------------
       (32) % Example 4: SetWorkODE  (from a generic expression)
       (33) %----------------------------------------------------------------------
       (34) SetWorkODE( work, Fx*vx + Fy*vy + Tz*wz )
    -> (35) work' = Fx*vx + Fy*vy + Tz*wz

#### sign

    sign   sign0IsPositive1   sign0IsNegative1   signDerivative

     Purpose:  Returns the sign of a real scalar expression.

    Syntax 1:  sign( x )               % 1 if x > 0,   0 if x = 0,   -1 if x < 0.
    Syntax 2:  sign0IsPositive1( x )   % Returns  1  if x >= 0,  otherwise -1.
    Syntax 3:  sign0IsNegative1( x )   % Returns -1  if x <= 0,  otherwise  1.
    Syntax 4:  signDerivative( x )     % Undefined   if x =  0,  otherwise  0.

       Input:  x -- a real scalar expression.

      Remark:  The sign function can combine with ceil or floor for if statements:
               isPositive      = ceil(  sign(t)/2 )              % Returns 0 or  1.
               isPositiveOr0   = ceil(  sign(t)/2 + 0.1 )        % Returns 0 or  1.
               isNegative      = floor( sign(t)/2 )              % Returns 0 or -1.
               isTGreaterThan5 = ceil( sign(t-5) / 2 )           % Returns 0 or  1.
               isTLessThan9    = ceil( sign(9-t) / 2 )           % Returns 0 or  1.
               isTBetween5And9 = isTGreaterThan5 * isTLessThan9  % Returns 0 or  1.

     Related:  ceil  floor  int  max  min  round  sign  MathFunctions
               IsNegative  IsNegativeOr0  IsPositiveOr0  IsPositive

       (1) %--------------------------------------------------------------------
       (2) % Example 1: Sign
       (3) %--------------------------------------------------------------------
       (4) A1 = sign( 2.3 )
    -> (5) A1 = 1

       (6) B1 = sign( 0 )
    -> (7) B1 = 0

       (8) C1 = sign( -2.3 ) + sign(5+t)
    -> (9) C1 = -1 + sign(5+t)

       (10) %--------------------------------------------------------------------
       (11) % Example 2: Sign0IsPositive1
       (12) %--------------------------------------------------------------------
       (13) A2 = Sign0IsPositive1( 2.3 ) + Sign0IsPositive1( 0 )
    -> (14) A2 = 2

       (15) B2 = Sign0IsPositive1( -2.3 )
    -> (16) B2 = -1

       (17) %--------------------------------------------------------------------
       (18) % Example 3: Sign0IsNegative1
       (19) %--------------------------------------------------------------------
       (20) A3 = Sign0IsNegative1( 2.3 )
    -> (21) A3 = 1

       (22) B3 = Sign0IsNegative1( 0 ) + Sign0IsNegative1( -2.3 )
    -> (23) B3 = -2

       (24) %--------------------------------------------------------------------
       (25) % Example 4: SignDerivative
       (26) %--------------------------------------------------------------------
       (27) signDt = Dt( sign(t) + Sign0IsPositive1(1+t^3) )
    -> (28) signDt = signDerivative(t) + 3*t^2*signDerivative(1+t^3)

#### sin

    sin and csc

     Purpose:  Returns the sine or cosecant of a scalar expression.

    Syntax 1:  sin(x)  or  csc(x)
    Syntax 2:  sinDegrees( realNumberDeg )

       Input:  x -- the radian measure of a real or complex scalar expression.
               realNumberDeg -- expression that resolves to a real number.

    Output 1:  sin(x) returns the sine of x.
               csc(x) returns the secant of x, which is 1/sin(x).
    Output 2:  Returns the sine of realNumberDeg.

     Related:  ConvertUnits  ImaginaryNumber  MathFunctions
               cos  sin  tan  acos  asin  atan  atan2  cosDegrees  ...

       (1) %--------------------------------------------------------------------
       (2) % Example 1: sin, csc   (real scalar expressions)
       (3) %--------------------------------------------------------------------
       (4) A = sin( pi/6 )
    -> (5) A = 0.5

       (6) B = sinDegrees( 30 )
    -> (7) B = 0.5

       (8) C = sin(t) + sin( t * ConvertUnits(deg,rad) )
    -> (9) C = sin(t) + sin(0.01745329*t)

       (10) D = csc( pi/6 ) + sin(0.5+2*t) + csc(t^2)
    -> (11) D = 2 + sin(0.5+2*t) + 1/sin(t^2)

       (12) %--------------------------------------------------------------------
       (13) % Example 2: sin, csc   (complex scalar expressions)
       (14) %--------------------------------------------------------------------
       (15) E = sin( 2 + 3*GetImaginaryNumber() )
    -> (16) E = 9.154499 - 4.168907*imaginary

       (17) F = sin( 3*GetImaginaryNumber() + t )
    -> (18) F = sin(3*imaginary+t)

       (19) G = csc( GetImaginaryNumber() )
    -> (20) G = -0.8509181*imaginary

#### Solve

    Solve  --  also see SolveDt, SolveSetInput, SolveSetInputDt.

     Purpose:  Solves linear and nonlinear algebraic equations.

    Syntax 1:  Solve(         EqnsToSolve,  x1, x2, ... )
               Solve( METHOD, EqnsToSolve,  x1, x2, ... )
    Syntax 2:  Solve(         EqnsToSolve,  x1=Guess1,  x2=Guess2,  ... )
    Syntax 3:  answer = Solve( METHOD, EqnsToSolve,  x1,  x2,  ... )
    Syntax 4:  answer = Solve(         EqnsToSolve,  x1=Guess1,  x2=Guess2,  ... )

       Input:  EqnsToSolve -- matrix of (or single) scalar expressions that
               are functions of x1, x2, ..., and regarded as equal to zero.
               Treated as:  EqnsToSolve[1] = 0,   EqnsToSolve[2] = 0, ...
               EqnsToSolve has various forms, whose examples include:
               EqnsToSolve          2*x - 8*t
               EqnsToSolve  = 0     2*x - 8*t  = 0
               EqnsToSolve := 0     2*x - 8*t := 0  (overwrites x without query)
               EqnsToSolve  = Rhs   2*x = 8*t
               EqnsToSolve := Rhs   2*x = 8*t       (overwrites x without query)

               x1, x2 -- the names of scalars or a matrix of scalar names.

               METHOD -- Minors, MinorsImplicit, MinorsExplicit,
                         Gauss,  GaussImplicit,  GaussExplicit,  Implicit, or
                         relError = smallNumber (where smallNumber is e.g., 1E-7).
               When METHOD is anything other than relError = smallNumber,
               EqnsToSolve must be linear in x1, x2, ...

               Guess1, Guess2 -- expressions that resolve to real numbers.

    Output 1:  Solutions (symbolic expressions) are assigned to x1, x2, ...
    Output 2:  Solutions (real numbers) are assigned to x1, x2, ...
    Output 3:  Solutions (symbolic expressions) are returned in a matrix.
               Solutions are NOT assigned to x1, x2, ...
    Output 4:  Solutions (real numbers) are returned in a matrix.
               Solutions are NOT assigned to x1, x2, ...

      Remark:  MINORS is advantageous for a small number of equations and
               for avoiding divide-by-zero problems other than when the
               set of equations are truly singular (the determinant of
               its coefficient matrix is zero).

               GAUSS may be better than MINORS for solving larger number
               of equations when divide-by-zero problem associated with
               pivots in Gaussian elimination can be avoided.

               IMPLICIT may be more efficient when some of the unknowns x1, x2,
               ..., are allowed to be expressed in terms of other unknowns.

               If no method is specified, a method is chosen based on
               the number of equations and number of non-zero and
               non-numerical elements in the coefficient matrix.

     Remark:   A set of n linear algebraic equations in n unknowns may
               have one unique solution or is singular (no solution or
               an infinite number of solutions).

     Remark:   Nonlinear algebraic equations may have 0, 1, 2, 3, ..., solutions.
               Their solution is approximate and its accuracy tends to improve
               as the input value assigned to absError gets smaller.
               To change the default value of absError to 1.234E-5, enter
               Input  absError = 1.234E-5

     Remark:   Providing Guess1, Guess2, ..., instructs the Solve command to
               produce a NUMERICAL solution for x1, x2, ...
               A numerical solution (and hence Guess1, Guess2) is
               required when EqnsToSolve is nonlinear in x1, x2, ...
               If necessary, symbols resolve to numbers using INPUT values.
               When EqnsToSolve are nonlinear, the numerical algorithm attempts
               to converge to a solution closest to Guess1, Guess2, ...
               When arguments have the form  x1 = 30 deg,  x2 = 45 cm/hour,
               solutions for x1 and x2 are returned in units determined by
               SetUnitSystem e.g., x1 in units of radians and x2 in meter/second
               (by default SetUnitSystem has units of radians, kg, meter, second).

     Remark:   A solution may be reported even though one does not exist.
               For example,  Solve( exp(-t) = 0,  t = 4 )  may report a solution
               for t greater than 16.2 because the absolute value of
               exp(-16.2) is less than the default value of absError.

     Related:  ODE  Solve  SolveDt  SolveSetInput  SolveSetInputDt  ...
               GetPolynomialRoots  GetQuadraticRoots  GetQuadraticPositiveRoot  ...
               SolveQuadraticPositiveRoot  SolveQuadraticPositiveRootDt  ...
               SetAutoDifferentiate  SetAutoOverwrite
               SetDt  SetNoDt   =   :=   +=   *=   /=   ^=

       (1) %--------------------------------------------------------------------
       (2) % Example 1: Solve  (1 linear equation in 1 unknown)
       (3) %--------------------------------------------------------------------
       (4) Variable  unknown
       (5) Solve( 2*unknown = 8*t,  unknown )
    -> (6) unknown = 4*t

       (7) %--------------------------------------------------------------------
       (8) % Example 2: Solve  (2 linear equations in 2 unknowns)
       (9) %--------------------------------------------------------------------
       (10) Variable  x, y
       (11) eqn[1] = 2*x + 4*y - 8*t
    -> (12) eqn[1] = 2*x + 4*y - 8*t

       (13) eqn[2] = 2*x + 6*y - cos(t)
    -> (14) eqn[2] = 2*x + 6*y - cos(t)

       (15) Solve( eqn = 0,   x, y )
    -> (16) x = 12*t - cos(t)
    -> (17) y = 0.5*cos(t) - 4*t

       (18) %--------------------------------------------------------------------
       (19) % Example 3: Solve (2 linear equations in 2 unknowns, MethodName)
       (20) %--------------------------------------------------------------------
       (21) Constant  a, b, c, d,  m, n
       (22) eqnZero[1] = a*x + b*y - m
    -> (23) eqnZero[1] = a*x + b*y - m

       (24) eqnZero[2] = c*x + d*y - n
    -> (25) eqnZero[2] = c*x + d*y - n

       (26) Solve( Minors,  eqnZero := 0,   x, y )
    -> (27) x = -(b*n-d*m)/(a*d-b*c)
    -> (28) y = (a*n-c*m)/(a*d-b*c)

       (29) Solve( Gauss,   eqnZero := 0,   x, y )
    -> (30) x = (m-b*y)/a
    -> (31) y = (n-c*m/a)/(d-b*c/a)

       (32) %--------------------------------------------------------------------
       (33) % Example 4: Solve  (1 nonlinear equation in 1 unknown with units)
       (34) %--------------------------------------------------------------------
       (35) Solve( sin(x) := 0.75,   x = 70 deg )       % 70 degrees is a guess.
    -> (36) x = 0.8480621       %  or  x = 48.59038 deg.

       (37) %--------------------------------------------------------------------
       (38) % Example 5: Solve  (2 nonlinear equations in 2 unknowns)
       (39) %--------------------------------------------------------------------
       (40) nonlinearEqn[1] = -1 + x^2 + y^2            % Equation for a circle.
    -> (41) nonlinearEqn[1] = -1 + x^2 + y^2

       (42) nonlinearEqn[2] = y - sin(x)                % Sine function.
    -> (43) nonlinearEqn[2] = y - sin(x)

       (44) Solve( nonlinearEqn := 0,   x=2, y=3 )      % x=2, y=3 is a guess.
    -> (45) x = 0.7390851
    -> (46) y = 0.673612

       (47) %--------------------------------------------------------------------
       (48) % Example 6: Solve  (2 nonlinear equations in 2 unknowns with input)
       (49) %--------------------------------------------------------------------
       (50) Input  a = 2 meters,  b = 1 meters
       (51) ellipseEquation = -1 + x^2/a^2 + y^2/b^2
    -> (52) ellipseEquation = -1 + x^2/a^2 + y^2/b^2

       (53) sineFunction = y - sin(x)
    -> (54) sineFunction = y - sin(x)

       (55) Solve( [ellipseEquation; sineFunction] := 0,   x = 1 meter,  y = 2 meter )
    -> (56) x = 1.029867
    -> (57) y = 0.8572303

       (58) %--------------------------------------------------------------------
       (59) % Example 7: Solve (return the solutions without assignment)
       (60) %--------------------------------------------------------------------
       (61) solutionA = Solve( 2*x - 5*t = 0,   x )
    -> (62) solutionA = [2.5*t]

       (63) solutionB = Solve( x^2 + sin(x)^2.2 - 1 = 0,   x = 2 )
    -> (64) solutionB = [0.7528387]

#### SolveDt

    SolveDt  --  also see Solve, SolveSetInput, SolveSetInputDt.

     Purpose:  Solves _linear_ algebraic equations.
               Differentiates the equations and solves for derivatives.

      Syntax:  SolveDt(          EqnsToSolve,  x1, x2, ... )
               SolveDt( METHOD,  EqnsToSolve,  x1, x2, ... )

       Input:  EqnsToSolve -- matrix of (or single) scalar expressions that are
               LINEAR functions of x1, x2, ..., and regarded as equal to zero.
               Treated as:  EqnsToSolve[1] = 0,   EqnsToSolve[2] = 0, ...
               EqnsToSolve has various forms, whose examples include:
               EqnsToSolve          2*x - 8*t
               EqnsToSolve  = 0     2*x - 8*t  = 0
               EqnsToSolve := 0     2*x - 8*t := 0  (overwrites x without query)
               EqnsToSolve  = Rhs   2*x = 8*t
               EqnsToSolve := Rhs   2*x = 8*t       (overwrites x without query)

               x1, x2 -- the names of scalars or a matrix of scalar names.

               METHOD -- Minors, MinorsImplicit, MinorsExplicit,
                         Gauss,  GaussImplicit,  GaussExplicit,  Implicit.

      Output:  Solutions are assigned to x1, x2, ... and x1', x2', ...

      Remark:  SolveDt recursively differentiates to form the
               1st, 2nd, 3rd, ... derivatives of x1, x2, ..., and
               stops differentiating when an nth derivative of x1, x2, ...,
               has not been declared (e.g., x1'' does not exist).

      Remark:  The command SolveDtSetDt() is similar to the command SolveDt() but
               SolveDtSetDt() continues to assign derivatives when there is a mix
               of x1, x2, ... that have derivatives and that do not have derivatives.

      Remark:  See additional remarks and examples by typing Help Solve.

     Related:  ODE  Solve  SolveDt  SolveSetInput  SolveSetInputDt  ...
               GetPolynomialRoots  GetQuadraticRoots  GetQuadraticPositiveRoot  ...
               SolveQuadraticPositiveRoot  SolveQuadraticPositiveRootDt  ...
               SetAutoDifferentiate  SetAutoOverwrite
               SetDt  SetNoDt   =   :=   +=   *=   /=   ^=

       (1) %--------------------------------------------------------------------
       (2) % Example 1: SolveDt  (1 linear equation in 1 unknown)
       (3) %--------------------------------------------------------------------
       (4) Variable  z'
       (5) SolveDt(  2*z = 8*t,   z )
    -> (6) z = 4*t
    -> (7) z' = 4

       (8) %--------------------------------------------------------------------
       (9) % Example 2: SolveDt  (2 linear equations in 2 unknowns)
       (10) %--------------------------------------------------------------------
       (11) Variable  s1'',  s2''
       (12) eqn[1] = s1 + 2*s2 - 8*t
    -> (13) eqn[1] = s1 + 2*s2 - 8*t

       (14) eqn[2] = s1 + 4*s2 - cos(t)
    -> (15) eqn[2] = s1 + 4*s2 - cos(t)

       (16) SolveDt(  eqn = 0,   s1, s2 )
    -> (17) s1 = 16*t - cos(t)
    -> (18) s2 = 0.5*cos(t) - 4*t
    -> (19) s1' = 16 + sin(t)
    -> (20) s2' = -4 - 0.5*sin(t)
    -> (21) s1'' = cos(t)
    -> (22) s2'' = -0.5*cos(t)

       (23) %--------------------------------------------------------------------
       (24) % Example 3: SolveDt (2 linear equations in 2 unknowns, MethodName)
       (25) %--------------------------------------------------------------------
       (26) Variable  x',  y'
       (27) Constant  a, b, c, d
       (28) eqnZero[1] = a*x + b*y - t
    -> (29) eqnZero[1] = a*x + b*y - t

       (30) eqnZero[2] = c*x + d*y - sin(t)
    -> (31) eqnZero[2] = c*x + d*y - sin(t)

       (32) SolveDt( Minors,  eqnZero  = 0,   x, y )
    -> (33) x = (d*t-b*sin(t))/(a*d-b*c)
    -> (34) y = -(c*t-a*sin(t))/(a*d-b*c)
    -> (35) x' = (d-b*cos(t))/(a*d-b*c)
    -> (36) y' = -(c-a*cos(t))/(a*d-b*c)

       (37) SolveDt( Gauss,   eqnZero := 0,   x, y )
    -> (38) x = (t-b*y)/a
    -> (39) y = (sin(t)-c*t/a)/(d-b*c/a)
    -> (40) x' = (1-b*y')/a
    -> (41) y' = -(c/a-cos(t))/(d-b*c/a)

       (42) %--------------------------------------------------------------------
       (43) % Example 4: SolveDtSetDt (assigns x''' even though y''' does not exist).
       (44) %--------------------------------------------------------------------
       (45) Variable x'''
       (46) SolveDtSetDt( eqnZero := 0,   x, y )
    -> (47) x = (d*t-b*sin(t))/(a*d-b*c)
    -> (48) y = -(c*t-a*sin(t))/(a*d-b*c)
    -> (49) x' = (d-b*cos(t))/(a*d-b*c)
    -> (50) y' = -(c-a*cos(t))/(a*d-b*c)
    -> (51) x'' = b*sin(t)/(a*d-b*c)
    -> (52) x''' = b*cos(t)/(a*d-b*c)

       (53) %--------------------------------------------------------------------
       (54) % Example 5: SolveDt (solution is value for q and symbolic for q', q'')
       (55) %--------------------------------------------------------------------
       (56) Variable  q''                % Unknown to be solved.
       (57) Specified k''                % Regarded as known.
       (58) Input  k = 72 degrees
       (59) SolveDt(  q + cos(q) = k,   q = 20 deg )
    -> (60) q = 0.3018485       %  or  q = 17.29464 deg.
    -> (61) q' = k'/(1-sin(q))
    -> (62) q'' = (k''+cos(q)*q'^2)/(1-sin(q))

#### SolveSetInput

    SolveSetInput  --  also see Solve, SolveDt, SolveSetInputDt.

     Purpose:  Solves NUMERICAL linear and nonlinear algebraic equations
               and sets Input values for the unknowns.

      Syntax:  SolveSetInput( EqnsToSolve,  x1=Guess1,  x2=Guess2,  ... )

       Input:  EqnsToSolve -- matrix of (or single) scalar expressions that
               are functions of x1, x2, ..., and regarded as equal to zero.
               Treated as:  EqnsToSolve[1] = 0,   EqnsToSolve[2] = 0, ...
               EqnsToSolve has various forms, whose examples include:
               EqnsToSolve          2*x - 8*t
               EqnsToSolve  = 0     2*x - 8*t  = 0
               EqnsToSolve := 0     2*x - 8*t := 0  (overwrites x without query)
               EqnsToSolve  = Rhs   2*x = 8*t
               EqnsToSolve := Rhs   2*x = 8*t       (overwrites x without query)

               x1, x2 -- the names of scalars.

               Guess1, Guess2, -- expressions that resolve to real numbers.
               Note: When arguments have the form  x1 = 30 deg, x2 = 45 cm/hr,
               solutions for x1 and x2 are returned in units determined by
               SetUnitSystem, e.g., x1 in units of radians and x2 in m/sec.

      Output:  Solutions (real numbers) and associated units (if designated in
               Guess1, Guess2, ...) are assigned to Input values for x1, x2, ...
               Solutions (real numbers) that have been converted to the units
               designated in SetUnitSystem are returned in a matrix.

      Remark:  See additional remarks by typing Help Solve.

     Related:  ODE  Solve  SolveDt  SolveSetInput  SolveSetInputDt  ...
               GetPolynomialRoots  GetQuadraticRoots  GetQuadraticPositiveRoot  ...
               SolveQuadraticPositiveRoot  SolveQuadraticPositiveRootDt  ...
               SetAutoDifferentiate  SetAutoOverwrite
               SetDt  SetNoDt   =   :=   +=   *=   /=   ^=

       (1) %--------------------------------------------------------------------
       (2) % Example 1: SolveSetInput  (1 equation in 1 unknown)
       (3) %--------------------------------------------------------------------
       (4) Variable z
       (5) SolveSetInput(  z^2 + sin(z)^2.2 = 1,   z = 2 )

    ->  %  INPUT has been assigned as follows:
    ->  %   z                         0.7528386616717591

       (6) %--------------------------------------------------------------------
       (7) % Example 2: SolveSetInput  (2 equations in 2 unknowns)
       (8) %--------------------------------------------------------------------
       (9) Variable  x, y
       (10) eqn[1] = -1 + x^2 + y^2                   % Equation for a circle.
    -> (11) eqn[1] = -1 + x^2 + y^2

       (12) eqn[2] = y - sin(x)                       % Sine function.
    -> (13) eqn[2] = y - sin(x)

       (14) SolveSetInput(  eqn = 0,   x=2, y=3 )     % x=2, y=3 is a guess.

    ->   %  INPUT has been assigned as follows:
    ->   %   x                         0.7390851332151607
    ->   %   y                         0.6736120291832148

       (15) %--------------------------------------------------------------------
       (16) % Example 3: SolveSetInput  (2 equations in 2 unknowns with input)
       (17) %--------------------------------------------------------------------
       (18) Constant  a = 2 meters,  b = 1 meter
       (19) funct[1] = -1 + x^2/a^2 + y^2/b^2         % Equation for an ellipse.
    -> (20) funct[1] = -1 + x^2/a^2 + y^2/b^2

       (21) funct[2] = y - sin(x)                     % Sine function.
    -> (22) funct[2] = y - sin(x)

       (23) SolveSetInput( funct = 0,  x=1, y=9 )     % x=1, y=9 is a guess.

    ->   %  INPUT has been assigned as follows:
    ->   %   x                         1.029866529322259
    ->   %   y                         0.8572302683325125

       (24) %--------------------------------------------------------------------
       (25) % Example 4: SolveSetInput  (guess and solution have units)
       (26) %--------------------------------------------------------------------
       (27) SolveSetInput( [sin(x); sin(y)] = [0.3; 0.3],  x=30 deg,  y=150 deg )

    ->   %  INPUT has been assigned as follows:
    ->   %   x                         17.45760312372209       deg
    ->   %   y                         162.5423968762779       deg

       (28) %--------------------------------------------------------------------
       (29) % Example 5: SolveSetInput (SolveSetInput for x, return solution)
       (30) %--------------------------------------------------------------------
       (31) answer = SolveSetInput(  cos(x) = 0,   x = 1 degree )

    ->   %  INPUT has been assigned as follows:
    ->   %   x                         90                      degree

    ->   %  Note: x = 1.570796 radian  was converted from  x = 90 degree.
    -> (32) answer = [1.570796]

#### SolveSetInputDt

    SolveSetInputDt  --  also see Solve, SolveDt, SolveSetInput.

     Purpose:  Solves linear and nonlinear algebraic equations to set NUMERICAL
               Input values for the unknowns, differentiates to find  SYMBOLIC
               expressions for the derivatives of the unknowns.

      Syntax:  SolveSetInputDt( EqnsToSolve, x1=Guess1, x2=Guess2,  ... )

       Input:  EqnsToSolve -- matrix of (or single) scalar expressions that
               are functions of x1, x2, ..., and regarded as equal to zero.
               Treated as:  EqnsToSolve[1] = 0,   EqnsToSolve[2] = 0, ...
               EqnsToSolve has various forms, whose examples include:
               EqnsToSolve          2*x - 8*t
               EqnsToSolve  = 0     2*x - 8*t  = 0
               EqnsToSolve := 0     2*x - 8*t := 0  (overwrites x without query)
               EqnsToSolve  = Rhs   2*x = 8*t
               EqnsToSolve := Rhs   2*x = 8*t       (overwrites x without query)

               x1, x2 -- the names of scalars.

               Guess1, Guess2, -- expressions that resolve to real numbers.
               Note: When arguments have the form  x1 = 30 deg, x2 = 45 cm/hr,
               solutions for x1 and x2 are returned in units determined by
               SetUnitSystem, e.g., x1 in units of radians and x2 in m/sec.

      Output:  Solutions (real numbers) and associated units (if designated in
               Guess1, Guess2, ...) are assigned to Input values for x1, x2, ...
               Solutions (real numbers) that have been converted to the units
               designated in SetUnitSystem are returned in a matrix.
               Solutions (expressions)  are assigned to x1', x2', ...

      Remark:  SolveSetInputDt recursively differentiates to form the
               1st, 2nd, 3rd, ... derivatives of x1, x2, ..., and
               stops differentiating when an nth derivative of x1, x2, ...,
               has not been declared (e.g., x1''' does not exist).

      Remark:  See additional remarks by typing Help Solve.

     Related:  ODE  Solve  SolveDt  SolveSetInput  SolveSetInputDt  ...
               GetPolynomialRoots  GetQuadraticRoots  GetQuadraticPositiveRoot  ...
               SolveQuadraticPositiveRoot  SolveQuadraticPositiveRootDt  ...
               SetAutoDifferentiate  SetAutoOverwrite
               SetDt  SetNoDt   =   :=   +=   *=   /=   ^=

       (1) %--------------------------------------------------------------------
       (2) % Example 1: SolveSetInputDt  (1 equation in 1 unknown)
       (3) %--------------------------------------------------------------------
       (4) Variable z'
       (5) Input     t = 0 sec
       (6) SolveSetInputDt(  z + sin(z)^3 = cos(t),   z = 2 )

    ->  %  INPUT has been assigned as follows:
    ->  %   z                         0.7166169624667624

    -> (7) z' = -sin(t)/(1+3*cos(z)*sin(z)^2)

       (8) %--------------------------------------------------------------------
       (9) % Example 2: SolveSetInputDt  (2 equations in 2 unknowns with input)
       (10) %--------------------------------------------------------------------
       (11) Variable  x', y'
       (12) Constant  a = 1 meter,  b = 1 meter
       (13) funct[1] = x^2 + y^2 - cos(t)              % Time-varying circle.
    -> (14) funct[1] = x^2 + y^2 - cos(t)

       (15) funct[2] = a*y - b*sin(x)                  % Sine function.
    -> (16) funct[2] = a*y - b*sin(x)

       (17) SolveSetInputDt(  funct = 0,  x=2, y=3 )   % x=2,  y=3 is a guess.

    ->   %  INPUT has been assigned as follows:
    ->   %   x                         0.7390851332151607
    ->   %   y                         0.6736120291832148

    -> (18) x' = -0.5*a*sin(t)/(a*x+b*y*cos(x))
    -> (19) y' = -0.5*b*sin(t)*cos(x)/(a*x+b*y*cos(x))

       (20) %--------------------------------------------------------------------
       (21) % Example 3: SolveSetInputDt (returns value of and solves for x', x'')
       (22) %--------------------------------------------------------------------
       (23) Variable  x''
       (24) answer = SolveSetInputDt(  x^2 = cos(x) + t,   x = 12 deg )

    ->   %  INPUT has been assigned as follows:
    ->   %   x                         47.21930325529203       deg

    ->   %  Note: x = 0.8241323 radian  was converted from  x = 47.2193 deg.
    -> (25) x' = 1/(2*x+sin(x))
    -> (26) x'' = -(2+cos(x))*x'^2/(2*x+sin(x))
    -> (27) answer = [0.8241323]

#### SolveQuadraticPositiveRoot

    SolveQuadraticPositiveRoot,    SolveQuadraticNegativeRoot
    SolveQuadraticPositiveRootDt,  SolveQuadraticNegativeRootDt

     Purpose:  Solve for the positive or negative roots of a polynomial
               of degree 2 (and possibly its ordinary derivatives).

    Syntax 1:  SolveQuadraticPositiveRoot( expression = 0,  x )
               SolveQuadraticNegativeRoot( expression = 0,  x )
               SolveQuadraticPositiveRoot( M,  x )
               SolveQuadraticNegativeRoot( M,  x )
    Syntax 2:  SolveQuadraticPositiveRootDt( expression = 0,  x )
               SolveQuadraticNegativeRootDt( expression = 0,  x )
               SolveQuadraticPositiveRootDt( M,  x )
               SolveQuadraticNegativeRootDt( M,  x )

       Input:  M -- row or column matrix with 3 elements.  For example,
               M = [3, 5, 7]  may represent  3*x^2 + 5*x + 7.

               x   -- scalar name (variable, constant, specified, ...)
               expression -- scalar expression that is a function of x.
               A 2nd-order polynomial of the form  a*x^2 + b*x + c  is created
               from a Taylor series expansion of expression about x = 0.

    Output 1:  For quadratic formula:  a*x^2 + b*x + c = 0,
               SolveQuadraticPositiveRoot sets  x = (-b + sqrt(b^2 - 4*a*c)) / 2*a
               SolveQuadraticNegativeRoot sets  x = (-b - sqrt(b^2 - 4*a*c)) / 2*a

    Output 2:  Differentiates and solves to form x', x'', ...  and stops
               differentiating when the nth derivative of x has not been
               declared (e.g., x''' does not exist).

      Remark:  Use  GetQuadraticRoots  to return the positive and negative roots
               in a 2 element matrix (without assigning the result to x).
               Use  GetQuadraticPositiveRoot  to return the positive root without
               assigning the result to x.  Similarly for GetQuadraticNegativeRoot.

     Related:  GetQuadraticPolynomial( expression, x )
               returns a 3x1 column matrix whose elements are the coefficients of
               the polynomial created from a Taylor series expansion about x = 0.

     Related:  GetPolynomialRoots  GetQuadraticRoots  GetQuadraticPositiveRoot  ...
               SetDt  Solve  SolveDt  SolveSetInput  SolveSetInputDt  ...
               SolveQuadraticPositiveRoot  SolveQuadraticPositiveRootDt  ...
               FactorLinear  FactorQuadratic

       (1) %--------------------------------------------------------------------
       (2) % Example 1: SolveQuadraticPositiveRoot  (root of quadratic equation)
       (3) %--------------------------------------------------------------------
       (4) Constant a, b, c
       (5) Variable x, y
       (6) SolveQuadraticPositiveRoot( a*x^2 + b*x + c = 0,  x )
    -> (7) x = -0.5*(b-sqrt(b^2-4*a*c))/a

       (8) SolveQuadraticNegativeRoot( a*y^2 + b*y + c = 0,  y )
    -> (9) y = -0.5*(b+sqrt(b^2-4*a*c))/a

       (10) %--------------------------------------------------------------------
       (11) % Example 2: SolveQuadraticPositiveRootDt  (roots with differentiation)
       (12) %--------------------------------------------------------------------
       (13) Variable z''
       (14) SolveQuadraticPositiveRootDt( a*z^2 = sin(t),  z )
    -> (15) z = sqrt(sin(t)/a)
    -> (16) z' = 0.5*cos(t)/(a*z)
    -> (17) z'' = -0.5*(sin(t)+2*a*z'^2)/(a*z)

#### Specified

    Specified  or  SpecifiedEncode

     Purpose:  Declares the names of specified quantities.
               Creates an array of all names declared as Specified.

    Syntax 1:  Specified        a,  b,  x+,  y-,  ...
    Syntax 2:  Specified        u',  q'',  ...
    Syntax 3:  SpecifiedEncode  u',  q'',  ...
    Syntax 4:  Specified()

       Input:  a -- name that starts with a letter, followed by a reasonable
                    number of alphanumeric characters (similarly for b).
               a, b, ... are regarded as REAL until SetComplex is ON.

               x+ -- declares x as real and non-negative.
               y- -- declares y as real and non-positive.
               Helps simplification such as  abs(x) = x  or  abs(y) = -y.

               u'  -- declares u' and u as Specified.
               q'' -- declares q'', q', and q as Specified.

    Output 3:  SpecifiedEncode forces MATLAB(R), C, and Fortran programs to include
               quantities that may not otherwise appear due to code-optimization.

    Output 4:  Creates an array of all names declared as Specified.

      Remark:  The 1st and 2nd ordinary derivatives of s are denoted s' and s''.
               If s is Specified, Dt(s) is permitted only if s' was also declared.

      Remark:  Variable  vs.  Specified ??
               Variable:  Regarded as unknown (to be solved).
                          Partial velocities account for assignment of Variable.
               Specified: Regarded as known   (prescribed).
                          Assigned in program  OR  leave "to be specified" in
                          special functions in MATLAB(R), C, and Fortran codes.
                          Partial velocities ignore assignment of Specified.

      Remark:  The name  a{i}bb    declares a1bb ... aibb  (i is positive integer).
               The name  a{i:j}bb  declares aibb ... ajbb  (i >= 0  and  i <= j).
               The name  a{m,n}bb  declares amnbb     (m, n are integers 0 to 9).
               The name  a{m:x,n:y}  declares amn ... axy    (m <= x and n <= y).

      Remark:  The default name of the independent variable is t.

      Remark:  To both declare and assign a Specified, type e.g.,
               Specified x'' = 2*sin(t)

     Related:  Constant  ImaginaryNumber  Specified  Variable
               SetGeneralizedCoordinate  SetGeneralizedSpeed
               SetDt  SolveDt  SetAutoDifferentiate

       (1) %--------------------------------------------------------------------
       (2) % Example: Specified
       (3) %--------------------------------------------------------------------
       (4) Specified  x'+,  y-,  e{0:3}'
       (5) Specified  q'',  u'
       (6) b = sin(t) + abs(x) + x' - abs(x') + y + abs(y)
    -> (7) b = sin(t) + x

       (8) derivExample = dt(b) + dt(e0) + dt(q) + dt(q') + dt(u)
    -> (9) derivExample = cos(t) + e0' + q' + u' + x' + q''

       (10) u = sin(t)
    -> (11) u = sin(t)

       (12) SetDt( q = t^3 )
    -> (13) q = t^3
    -> (14) q' = 3*t^2
    -> (15) q'' = 6*t

       (16) arrayOfSpecified = Specified()
    -> (17) arrayOfSpecified = [e0;  e0';  e1;  e1';  e2;  e2';  e3;  e3';  q;  q';
            q'';  u;  u';  x;  x';  y]

#### Spline

    Spline

     Purpose:  Fits a curve through two points with various functions: transition,
               step, pulse, bell, and polynomial.  The examples below use a
               function y(t) that connects points (t0,y0) and (tF,yF).

    Syntax 1:  Spline( TRANSITION, t, t0, tF, y0, yF )
    Syntax 2:  Spline( STEP,       t, t0, tF, y0, yF )
    Syntax 3:  Spline( PULSE,      t, t0, tF, y0, yExtremum )
    Syntax 4:  Spline( BELL,       t, t0, tF, y0, yExtremum )
    Syntax 5:  Spline( LINE,       t, t0, tF, y0, yF )
               Spline( 1,          t, t0, tF, y0, yF )
    Syntax 6:  Spline( CUBIC,      t, t0, tF, y0, yF, dy/dt(t0), dy/dt(tF) )
               Spline( 3,          t, t0, tF, y0, yF, dy/dt(t0), dy/dt(tF) )
    Syntax 7:  Spline( n,          t, t0, tF, y0, yF,
                                   d1_y0, d1_yF, d2_y0, d2_yF, ... )

       Input:  t -- name of the function's independent variable

               t0 -- value of t at one   endpoint of the function
               tF -- value of t at other endpoint of the function

               y0 -- value of the function at t = t0
               yF -- value of the function at t = tF

               yExtremum -- yMax or yMin (function's maximum or minimum value)

               n -- 1,  3,  5,  7,  9

               di_y0 --  the function's ith derivative with respect to t,
                         evaluated at t = t0.

               di_yF --  the function's ith derivative with respect to t,
                         evaluated at t = tF

    Output 1:  Spline(  TRANSITION,  t, t0, tF, y0, yF )
               y0 + (yF-y0)*(t-t0)/(tF-t0) - (yF-y0)/(2*pi)*sin[2*pi*(t-t0)/(tF-t0)]
           or  y0 + (yF-y0)*dT - (yF-y0)/(2*pi) * sin(2*pi*dT)  dT = (t-t0)/(tF-t0)

               The function attains its minimum and maximum values at end-points.
               The function's 1st and 2nd (but not 3rd) derivatives with respect
               to t are zero at both the initial and terminal point of the curve.
                 y(t=t0) = y0      y(t=tF) = yF
                y'(t=t0) = 0      y'(t=tF) = 0
               y''(t=t0) = 0     y''(t=tF) = 0

    Output 2:  Spline(  STEP,  t, t0, tF, y0, yF )
               0.5*y0 + 0.5*yF - (1/pi)*(y0-yF)*atan(31.821*(t0+tF-2*t)/(t0-tF))

               The function approaches y0 as t approaches negative infinity.
               The function approaches yF as t approaches positive infinity.
               At t = t0, the function is y0 + 0.01*(yF - y0).
               At t = tF, the function is y0 + 0.99*(yF - y0).

    Output 3:  Spline(  PULSE,  t, t0, tF, y0, yMax )
               y0 + (yMax-y0)/(1-5*pi/16)*( pi*(-dT + 2*dT^3 - dT^4) + sin(pi*dT) )
               where dT = (t-t0)/(tF-t0)

               The function's end-points have the same value.
               The function has its maximum (or minimum) value midway
               between its end points, e.g., at t = (t0 + tF)/2
               The function's 1st and 2nd derivatives with respect to t are both
               zero at both the initial and terminal point of the curve.
                 y(t=t0) =   y(y=tF) = y0        y(t=tF/2) = yMax
                y'(t=t0) =  y'(y=tF) = 0        y'(t=tF/2) = 0
               y''(t=t0) = y''(y=tF) = 0

    Output 4:  Spline(  BELL,  t, t0, tF, y0, yMax )
               y0 - (y0-yMax)*exp( -2 * log(10) * (t0+tF-2*t)^2/(t0-tF)^2 )

               The function approaches y0 as t approaches +- infinity.
               The function has its maximum (or minimum) value midway
               between its end points, e.g., at t = (t0 + tF)/2
               At t = t0 and t = tF, the function is  y0 + 0.01*(yF - y0).

    Output 5:  Spline(  LINE,  t, t0, tF, y0, yF )
               y0 + (yF-y0) * dT    where dT = (t-t0)/(tF-t0)

               This function is linear in t (polynomial of degree 1 in t).
               At t = t0, the function is equal to y0.
               At t = tF, the function is equal to yF.
               The function has a constant slope.
                 y(t=t0) = y0    y(y=tF) = yF    y'(t) = (yF-y0) / (tF-t0)

    Output 6:  Spline(  CUBIC,  t, t0, tF, y0, yF, slope0, slopeF )

               This function is cubic in t (polynomial of degree 3 in t).
               At t = t0, the function is equal to y0 and its slope is slope0.
               At t = tF, the function is equal to yF and its slope is slopeF.
                 y(t=t0) = y0           y(y=tF) = yF
                y'(t=t0) = slope0      y'(t=tF) = slopeF

    Output 7:  Polynomial of degree n in t   (n = 1, 3, 5, 7, or 9).
               For n = 1, no derivatives are needed.
               For n = 3, d1_y0, d1_yF are needed.
               For n = 5, d1_y0, d1_yF, d2_y0, d2_yF are needed.
               For n = 7, d1_y0, d1_yF, d2_y0, d2_yF, d3_y0, d3_yF are needed.
               For n = 9, d1_y0, d1_yF, d2_y0, d2_yF, d3_y0, d3_yF, d4_y0, d4_yF.

       (1) %--------------------------------------------------------------------
       (2) % Example 1: Spline  (TRANSITION)
       (3) %--------------------------------------------------------------------
       (4) Variable  x
       (5) Constant xF, y0, yF
       (6) x0 = 0
    -> (7) x0 = 0

       (8) TransitionSpline = Spline( TRANSITION, x, x0, xF, y0, yF )
    -> (9) TransitionSpline = y0 + 0.1591549*(y0-yF)*sin(6.283185*x/xF) - (y0-yF)*x
           /xF

       (10) %--------------------------------------------------------------------
       (11) % Example 2: Spline  (STEP)
       (12) %--------------------------------------------------------------------
       (13) Constant  t0, tF
       (14) StepSpline = Spline( STEP, t, t0, tF, y0, yF )
    -> (15) StepSpline = 0.5*y0 + 0.5*yF - 0.3183099*(y0-yF)*atan(31.82052*(t0+tF-2
            *t)/(t0-tF))

       (16) %--------------------------------------------------------------------
       (17) % Example 3: Spline  (PULSE)
       (18) %--------------------------------------------------------------------
       (19) Constant  yExtremum
       (20) PulseSpline = Spline( PULSE, x, x0, xF, y0, yExtremum )
    -> (21) PulseSpline = y0 - 54.78763*(y0-yExtremum)*(sin(pi*x/xF)-pi*x*(xF^3+x^3
            -2*xF*x^2)/xF^4)

       (22) %--------------------------------------------------------------------
       (23) % Example 4: Spline  (BELL)
       (24) %--------------------------------------------------------------------
       (25) BellSpline = Spline( BELL, t, t0, tF, y0, yExtremum )
    -> (26) BellSpline = y0 - (y0-yExtremum)*exp(-4.60517*(t0+tF-2*t)^2/(t0-tF)^2)

       (27) %--------------------------------------------------------------------
       (28) % Example 5: Spline  (LINE)
       (29) LinearSpline = Spline( LINE, t, 0, tF, y0, yF )
    -> (30) LinearSpline = y0 - (y0-yF)*t/tF

       (31) %--------------------------------------------------------------------
       (32) % Example 6: Spline  (CUBIC)
       (33) CubicSpline = Spline( CUBIC, t, 0, tF, y0, yF, 0, 0 )
    -> (34) CubicSpline = y0 + 2*(y0-yF)*t^3/tF^3 - 3*(y0-yF)*t^2/tF^2

       (35) %--------------------------------------------------------------------
       (36) % Example 7: Spline  (Polynomial of degree n = 5)
       (37) %--------------------------------------------------------------------
       (38) PolynomialSpline = Spline( 5, x, 0, xF, y0, yF, 0,0, 0,0 )
    -> (39) PolynomialSpline = y0 + 15*(y0-yF)*x^4/xF^4 - 10*(y0-yF)*x^3/xF^3
            - 6*(y0-yF)*x^5/xF^5

#### Squared

    Squared

     Purpose:  Forms the square of a scalar, a matrix, or a vector.

    Syntax 1:  Squared( scalarExpression )
    Syntax 2:  Squared( matrixExpression )
    Syntax 3:  Squared( vectorExpression )

       Input:  scalarExpression -- a real or complex scalar expression.
               matrixExpression -- a matrix expression.
               vectorExpression -- a vector expression.

    Output 1:  Returns scalarExpression^2.
    Output 2:  Returns matrixExpression * matrixExpression.
    Output 3:  Returns Dot( vectorExpression, vectorExpression ).

     Related:  ImaginaryNumber  MathFunctions
               GetMagnitude  GetMagnitudeSquared  Squared  sqrt

       (1) %--------------------------------------------------------------------
       (2) % Example 1: Squared  (scalar expressions)
       (3) %--------------------------------------------------------------------
       (4) A = Squared( -3 )
    -> (5) A = 9

       (6) B = Squared( 3.2 * GetImaginaryNumber() )
    -> (7) B = -10.24

       (8) C = Squared( -3 + GetImaginaryNumber() )
    -> (9) C = 8 - 6*imaginary

       (10) %--------------------------------------------------------------------
       (11) % Example 2: Squared  (matrix expressions)
       (12) %--------------------------------------------------------------------
       (13) D = Squared( [1, 2;  3, 4] )
    -> (14) D = [7, 10;  15, 22]

       (15) E = Squared( [1, 2;  3, 4 + GetImaginaryNumber()] )
    -> (16) E = [7, 10 + 2*imaginary;  15 + 3*imaginary, 21 + 8*imaginary]

       (17) %--------------------------------------------------------------------
       (18) % Example 3: Squared  (vector expressions)
       (19) %--------------------------------------------------------------------
       (20) RigidFrame N
       (21) F = Squared( sin(t)*Nx> - 2*Ny> + 3*Nz> )
    -> (22) F = 13 + sin(t)^2

#### sqrt

    sqrt

     Purpose:  Returns the square-root of a scalar expression.

      Syntax:  sqrt( scalarExpression )

       Input:  scalarExpression -- a real or complex scalar expression.

      Output:  sqrt( scalarExpression ).

     Related:  ImaginaryNumber  MathFunctions
               GetMagnitude  GetMagnitudeSquared  Squared  sqrt

       (1) %--------------------------------------------------------------------
       (2) % Example 1: sqrt   (real scalar expressions)
       (3) %--------------------------------------------------------------------
       (4) A = sqrt( 9 )
    -> (5) A = 3

       (6) B = sqrt( 9.5 )
    -> (7) B = 3.082207

       (8) C = sqrt(2*t)
    -> (9) C = 1.414214*sqrt(t)

       (10) %--------------------------------------------------------------------
       (11) % Example 2: sqrt   (complex scalar expressions)
       (12) %--------------------------------------------------------------------
       (13) D = sqrt( -9 )
    -> (14) D = 3*imaginary

       (15) E = sqrt( 9 + 4*GetImaginaryNumber() )
    -> (16) E = 3.069923 + 0.6514821*imaginary

       (17) F = sqrt( 3*GetImaginaryNumber() + t )
    -> (18) F = sqrt(3*imaginary+t)

#### System

    System

     Purpose:  Defines a collection of the following physical objects:
               Point,  Particle,  RigidFrame,  RigidBody.

    Syntax 1:  System
    Syntax 1:  System  Fred( A, B, C )
    Syntax 2:  K = System.GetKineticEnergy()
    Syntax 3:  L = System(B,C).GetTranslationalMomentum()

       Input:  Fred -- name that starts with a letter, followed by a reasonable
                       number of alphanumeric characters.

       Input:  A, B, C -- names that were previously declared as a Point,
                          Particle, RigidFrame, RigidBody, or System.

    Output 1:  Creates a system containing all objects named in a Point, Particle,
               RigidFrame, or RigidBody declaration -- except the NewtonianFrame.

    Output 2:  Creates a system named Fred containing A, B, C.

    Output 3:  By itself, the  "System"  keyword refers to the collection of all
               objects declared as  Point,  Particle,  RigidFrame, and RigidBody
               that are not part of (welded to) the NewtonianFrame.

    Output 4:  Constructs an unnamed system consisting of B and C and calculates
               the sum of the translational (linear) momentum of B and C.

      Remark:  The NewtonianFrame is not part of the System.

      Remark:  Systems are used in connection with the commands:
               AddForceGravity     GetForceGravityPotentialEnergy
               GetMass             GetInertia ...            (several variants)
               GetCMPosition       GetCMVelocity             GetCMAcceleration
               GetAngularMomentum  GetTranslationalMomentum  GetGeneralizedMomentum
               GetResultantForce   GetResultantMoment        GetResultantTorque
               GetKineticEnergy    GetPower                  GetEnergyCheckKane
               GetStatics          GetDynamics
               GetStaticsKane      GetDynamicsKane

     Related:  NewtonianFrame  Particle  Point  RigidBody  RigidFrame  System

       (1) %--------------------------------------------------------------------
       (2) % Example: System
       (3) %--------------------------------------------------------------------
       (4) RigidBody  A, B
       (5) A.SetMass( mA )
       (6) B.SetMass( mB )
       (7) massSystemAB = System.GetMass()
    -> (8) massSystemAB = mA + mB

       (9) Particle   P, Q
       (10) P.SetMass( mP )
       (11) Q.SetMass( mQ )
       (12) massSystemABPQ = System.GetMass()
    -> (13) massSystemABPQ = mA + mB + mP + mQ

#### SyntaxForms

    Syntactical Forms

     #x>, #y>, #z>  right-handed set of mutually perpendicular unit
                    vectors fixed in RigidFrame or RigidBody #,
                    e.g., Bx>, By>, Bz> are fixed in B.

     #o             name of the point ("origin") fixed on RigidFrame
                    or RigidBody #, e.g., Bo is the origin of B.

     #cm            name of the center of mass (point) fixed on RigidBody #,
                    e.g., Bcm is the center of mass of B.

     #_$            rotation matrix (direction cosine matrix) relating
                    unit vectors #i>  (i = x,y,z)  fixed in # to
                    unit vectors $j>  (j = x,y,z)  fixed in $ where each of
                    # and $ have been declared as a RigidFrame or RigidBody;
                    the element in row i, column j of #_$ is equal
                    to the dot-product of #i> and $j>,
                    e.g., B_A is the rotation matrix relating
                    Bx>, By>, Bz> to Ax>, Ay>, Az>.

     w_#_$>         angular velocity of # in $ where each of # and $
                    have been declared as a RigidFrame or RigidBody,
                    e.g., w_B_A> is the angular velocity of B in A.

     alf_#_$>       angular acceleration of # in $ where each of # and $
                    have been declared as a RigidFrame or RigidBody,
                    e.g., alf_B_A> is the angular acceleration of B in A.

     Torque_#>      torque of external couples on RigidFrame or RigidBody #.
                    For example, Torque_B> is the torque on B.

     Torque_#_$>    torque of couples applied to # from $, where each of # and $
                    have been declared as a RigidFrame or RigidBody.
                    For example, Torque_B_A> is the torque on B from A.

     Force_#>       external contact and distance forces on Point or Particle #.
                    For example, Force_Q> is the force on Q.

     Force_#_$>     action/reaction force applied to # from $, where each of
                    # and $ were declared as a Point or Particle.
                    For example, Force_Q_P> is the force on Q from P.

     p_#_$>         position vector from # to $, where each of # and $
                    have been declared as a Point or Particle,
                    e.g., p_Q_R> is the position vector from Q to R.

     v_#_$>         velocity of # in $, where # is a Point or Particle
                    and # is a RigidFrame or RigidBody, e.g.,
                    v_Q_N> is the velocity of Q in N.

     a_#_$>         acceleration of # in $, where # is a Point or Particle
                    and # is a RigidFrame or RigidBody, e.g.,
                    a_Q_N> is the acceleration of Q in N.

     Zr             rth expression name assigned by a Zee or AutoZee command

     {}             encloses indices, e.g., in declarations

     AUXILIARY[i]   ith constraint function used by the old CONSTRAIN command.
     DEPENDENT[j]   jth constraint function used by the old CONSTRAIN command.

     []             symbols surrounding elements in a matrix, e.g., [1, 2; 3, 4]

     =   or  :=     assignment                  or   overwrite assignment
     +   or  +=     addition                    or   cumulative addition
     -   or  -=     subtraction or unary minus  or   cumulative subtraction
     *   or  *=     multiplication              or   cumulative multiplication
     /   or  /=     division                    or   cumulative division
     ^   or  ^=     exponentiation              or   cumulative exponentiation

     ,              comma separates arguments of a function and
                    separates elements of a row in a matrix

     ;              semicolon separates rows of a matrix; separates commands

     '              prime denotes implicit, ordinary, scalar differentiation
                    with respect to the independent variable t, (e.g., y').

     !              invokes operating system e.g.,  !someOperatingSystemCommand

     &              line continuation symbol (for really long lines)

     %              beginning of a comment.
     %%             beginning of a comment for a MATLAB, C, or Fortran program.

     >              symbol used to denote a vector quantity
     >>             symbol used to denote a dyadic quantity
     >>>            symbol used to denote a triadic quantity
     0>             zero vector
     0>>            zero dyadic
     1>>            unit dyadic
     pi             3.1415926...
     imaginary      default name for the square root of -1
     t              time
     tInitial       Initial value for independent variable t (for ODE command).
     tFinal         Final   value for independent variable t (for ODE command).
     tStep          Numerical integration step for t         (for ODE command).
     absError       Numerical integration absolute error tolerance (for numerics).

#### t

    t

     Purpose:  Default name assigned to the independent variable.
               The program initiates with a declaration of the form:
               IndependentVariable  t

      Syntax:  t

      Remark:  The default name of the independent variable is t.
               t is usually regarded as time.

      Remark:  The prime symbol ' denotes implicit ordinary differentiation
               with respect to the independent variable.  For example, when
               the independent variable t denotes time, x' denotes dx/dt,
               the ordinary time-derivative of x.

     Related:  Constant  ImaginaryNumber  IndependentVariable
               pi  Specified  Variable  t  tInitial  tFinal  tStep  absError

#### tan

    tan and cot

     Purpose:  Returns the tangent or cotangent of a scalar expression.

    Syntax 1:  tan(x)  or  cot(x)
    Syntax 2:  tanDegrees( realNumberDeg )

       Input:  x -- the radian measure of a real or complex scalar expression.
               realNumberDeg -- expression that resolves to a real number.

    Output 1:  tan(x) returns the   tangent of x.
               cot(x) returns the cotangent of x, which is 1/tan(x).
    Output 2:  Returns the tangent of realNumberDeg.

     Related:  ConvertUnits  ImaginaryNumber  MathFunctions
               cos  sin  tan  acos  asin  atan  atan2  cosDegrees  ...

       (1) %--------------------------------------------------------------------
       (2) % Example 1: tan, cot   (real scalar expressions)
       (3) %--------------------------------------------------------------------
       (4) A = tan( pi/4 ) + cot( pi/4 )
    -> (5) A = 2

       (6) B = tanDegrees( 45 )
    -> (7) B = 1

       (8) C = tan(t) + tan( t * ConvertUnits(deg,rad) )
    -> (9) C = tan(t) + tan(0.01745329*t)

       (10) D = tan(0.5+2*t) + cot( t^2 )
    -> (11) D = tan(0.5+2*t) + 1/tan(t^2)

       (12) %--------------------------------------------------------------------
       (13) % Example 2: tan, cot   (complex scalar expressions)
       (14) %--------------------------------------------------------------------
       (15) E = tan( 2 + 3*GetImaginaryNumber() )
    -> (16) E = -0.003764026 + 1.003239*imaginary

       (17) F = tan( 3*GetImaginaryNumber() + t )
    -> (18) F = tan(3*imaginary+t)

       (19) G = cot( GetImaginaryNumber() )
    -> (20) G = -1.313035*imaginary

#### Translate

    Translate

     Purpose:  Sets a point's position from another point.
               Sets a point's velocity in a reference frame.
               Sets a point's acceleration in a reference frame.

    Syntax 1:  Q.Translate( fromPoint, positionVector )
               (Note: positionVector may be differentiated).

    Syntax 2:  Q.Translate( fromPoint, positionVector, BFixed )
               (Note: positionVector will NOT be differentiated).

    Syntax 3:  Q.Translate( fromPoint, positionVector, BFrame, BQ )
               (Note: positionVector may be differentiated).

       Input:  Q -- name of a point.

               fromPoint -- Point whose velocity and acceleration in the
                            NewtonianFrame (or designated frame) is known.

               BFixed -- Rigid frame/body on which fromPoint and Q  are fixed.
               BFrame -- Rigid frame/body on which fromPoint and BQ are fixed.
                         Q is moving on BFrame.

               BQ -- Point of BFrame that is coincident with Q.

      Output:  Sets Q's position vector from fromPoint to positionVector.
               Sets Q's velocity in the NewtonianFrame (or designated frame).
               Sets Q's acceleration in the NewtonianFrame (or designated frame).

    Output 2:  Syntax 2 may also set the following (if not in workspace):
               fromPoint's velocity and acceleration in BFixed to 0>
               Q's         velocity and acceleration in BFixed to 0>

    Output 3:  Syntax 3 may also set the following (if not in workspace):
               fromPoint's velocity and acceleration in BFrame to 0>.
               BQ          may be defined as a physical point of BFrame, with
                           its velocity and acceleration in BFrame set to 0>.
               BQ's        position from fromPoint.
               Q's         velocity in BFrame (derivative of p_fromPoint_Q>).
               Q's         acceleration in BFrame (via differentiation).

      Remark:  To set Q's velocity in a non-NewtonianFrame, insert refFrame (name
               of a RigidFrame or RigidBody) as the optional first argument, e.g.,
    Syntax 1:  Q.Translate( refFrame, fromPoint, positionVector )
    Syntax 2:  Q.Translate( refFrame, fromPoint, positionVector, BFixed )
    Syntax 3:  Q.Translate( refFrame, fromPoint, positionVector, BFrame, BQ )

      Remark:  If Q is welded to rigid frame/body B, declare it:  Point Q(B).
               Alternately, if Q does not move on B (but is not welded or a
               physical point of B), use Q.SetVelocityAcceleration( B, 0> )

     Related:  Translate        SetPositionVelocity   SetVelocityAcceleration
               SetPosition      GetPosition   GetDistance  GetDistanceSquared
               SetVelocity      GetVelocity   GetSpeed     GetElongation
               SetAcceleration  GetAcceleration

       (1) %--------------------------------------------------------------------
       (2) % Example 1: Translate
       (3) % Set Q1's velocity and acceleration in N by differentiation.
       (4) %--------------------------------------------------------------------
       (5) NewtonianFrame N
       (6) Point     Q1
       (7) Variable  x1'', y1''
       (8) Q1.Translate( No,  x1*Nx> + y1*Ny> )
    -> (9) p_No_Q1> = x1*Nx> + y1*Ny>
    -> (10) v_Q1_N> = x1'*Nx> + y1'*Ny>
    -> (11) a_Q1_N> = x1''*Nx> + y1''*Ny>

       (12) %--------------------------------------------------------------------
       (13) % Example 2: Translate
       (14) % Set Q2's velocity and acceleration in N by differentiation.
       (15) %--------------------------------------------------------------------
       (16) Point     Q2
       (17) Variable  x2'', y2''
       (18) Q2.Translate( Q1,  x2*Nx> + y2*Ny> )
    -> (19) p_Q1_Q2> = x2*Nx> + y2*Ny>
    -> (20) v_Q2_N> = (x1'+x2')*Nx> + (y1'+y2')*Ny>
    -> (21) a_Q2_N> = (x1''+x2'')*Nx> + (y1''+y2'')*Ny>

       (22) %--------------------------------------------------------------------
       (23) % Example 3: Translate
       (24) % Set Q3's velocity and acceleration in N via two points fixed on B.
       (25) %--------------------------------------------------------------------
       (26) RigidBody B                  % Body B translates and rotates in N.
       (27) Point     Q3( B )            % Q3 is a point fixed on B.
       (28) Constant  L                  % Distance between Bo and Q3.
       (29) Variable  wB'                % Angular speed and time-derivative.
       (30) B.SetAngularVelocityAcceleration( N,  wB*Bz> )
    -> (31) w_B_N> = wB*Bz>
    -> (32) alf_B_N> = wB'*Bz>

       (33) Bo.Translate( No,  0.5*t^2*Nx> )
    -> (34) p_No_Bo> = 0.5*t^2*Nx>
    -> (35) v_Bo_N> = t*Nx>
    -> (36) a_Bo_N> = Nx>

       (37) Q3.Translate( Bo,  L*Bx>,  B )
    -> (38) p_Bo_Q3> = L*Bx>
    -> (39) v_Q3_N> = L*wB*By> + t*Nx>
    -> (40) a_Q3_N> = -L*wB^2*Bx> + L*wB'*By> + Nx>

       (41) %--------------------------------------------------------------------
       (42) % Example 4: Translate
       (43) % Set Q4's velocity and acceleration in N via one point moving on B.
       (44) %--------------------------------------------------------------------
       (45) Point      Q4,  BQ4( B )     % BQ4 is point of B coincident with Q4.
       (46) Variable   x4''
       (47) Q4.Translate( Bo,  x4*Bx>,  B,  BQ4 )
    -> (48) p_Bo_Q4> = x4*Bx>
    -> (49) p_Bo_BQ4> = x4*Bx>
    -> (50) v_BQ4_N> = wB*x4*By> + t*Nx>
    -> (51) v_Q4_B> = x4'*Bx>
    -> (52) v_Q4_N> = x4'*Bx> + wB*x4*By> + t*Nx>
    -> (53) a_BQ4_N> = -x4*wB^2*Bx> + x4*wB'*By> + Nx>
    -> (54) a_Q4_B> = x4''*Bx>
    -> (55) a_Q4_N> = (x4''-x4*wB^2)*Bx> + (x4*wB'+2*wB*x4')*By> + Nx>

#### TranslateAcrossJoint

    TranslateAcrossJoint

      Syntax:  QB.TranslateAcrossJoint( fromPoint, positionVector )

       Input:  QB -- name of a point welded to a RigidBody or RigidFrame B.

               fromPoint -- Point whose velocity and acceleration in
                            the NewtonianFrame is known.

               positionVector -- QB's position vector fromPoint.

      Output:  Calls   QB.Translate( fromPoint, positionVector )
               Sets the velocity and acceleration of Bo and Bcm
               in the Newtonian reference frame.
               If B is a RigidFrame, skips Bcm calculations.

      Remark:  The position vector to Bo  from fromPoint and
               the position vector to Bcm from Bo are used.

     Related:  Translate         SetPositionVelocity   SetVelocityAcceleration
               SetPosition       GetPosition   GetDistance  GetDistanceSquared
               SetVelocity       GetVelocity   GetSpeed     GetElongation
               SetAcceleration   GetAcceleration
               SetRigidTransform TranslateAcrossJoint
               SetVelocityAccelerationForGetGeometry

#### TrueFalse

    true  false

     Purpose:  Special names that are helpful for true/false logic.

     Syntax 1: true        % true  simplifies to 1 in math expressions.
     Syntax 2: false       % false simplifies to 0 in math expressions.

      Remark:  The multiplication operator * can mimic a logical AND whereas
               the IsPositive command can be used to mimic a logical OR.

     Related:  IsSimplifyEqual  IsSimplifyZero  IsSimplifyTrue
               IsNegative  IsNegativeOr0  IsPositiveOr0  IsPositive

     Builtin:  pi   imaginary   true false   0>   0>>   1>>
               t  tInitial  tFinal  tStep  absError

       (1) %--------------------------------------------------------------------
       (2) % Example 1:  true or false  (operator * can mimic a logical AND)
       (3) %--------------------------------------------------------------------
       (4) isTrue[1] = false * false
    -> (5) isTrue[1] = false

       (6) isTrue[2] = false * true
    -> (7) isTrue[2] = false

       (8) isTrue[3] = true  * false
    -> (9) isTrue[3] = false

       (10) isTrue[4] = true  * true
    -> (11) isTrue[4] = true

       (12) %--------------------------------------------------------------------
       (13) % Example 2:  true or false  (IsPositive can mimic a logical OR)
       (14) %--------------------------------------------------------------------
       (15) isTrue[5] =  IsPositive( false + false )
    -> (16) isTrue[5] = false

       (17) isTrue[6] =  IsPositive( false + true  )
    -> (18) isTrue[6] = true

       (19) isTrue[7] =  IsPositive( true  + false )
    -> (20) isTrue[7] = true

       (21) isTrue[8] =  IsPositive( true  + true  )
    -> (22) isTrue[8] = true

       (23) %--------------------------------------------------------------------
       (24) % Example 3:  true or false
       (25) %--------------------------------------------------------------------
       (26) isSimplifyA = IsSimplifyEqual( 2*t, 9*t )
    -> (27) isSimplifyA = false

       (28) isSimplifyB = IsSimplifyEqual( 2*t, 2*t )
    -> (29) isSimplifyB = true

#### SetVelocityAccelerationForGetGeometry

    SetVelocityAccelerationForGetGeometry

     Purpose:  Sets the velocity and acceleration in the NewtonianFrame
               of the origin and center of mass of a rigid body.

      Syntax:  B.SetVelocityAccelerationForGetGeometry( refFrame, fromPoint )

       Input:  B -- name of a RigidBody or RigidFrame.
               refFrame  -- name of a RigidFrame or RigidBody.
               fromPoint -- Point whose velocity and acceleration
                            in the refFrame is already known.

      Output:  Sets the velocity and acceleration of Bo and Bcm.
               If B is a RigidFrame, skips Bcm calculations.

      Remark:  The position vector to Bo from fromPoint and
               the position vector to Bcm from Bo are used.

     Related:  SetRigidTransform   TranslateAcrossJoint
               SetVelocityAccelerationForGetGeometry

#### Units

    Units      ConvertUnits,  Input,  Output,  Constant,  SetMass,  SetInertia
               GetUnitSystem, SetUnitSystem
               GetMassUnit,  GetLengthUnit, GetTimeUnit, GetAngleUnit

       (1) %--------------------------------------------------------------------
       (2) %Example: Units
       (3) %--------------------------------------------------------------------
       (4) inchToCentimeter = ConvertUnits( inch, cm )
    -> (5) inchToCentimeter = 2.54

       (6) SetUnitSystem( kg, meter,  second)   % Default.
       (7) Constant   a = 20 cm,  b = 0.02 km,  c = 30 inches
       (8) distance = EvaluateToNumber( a + b + c )
    -> (9) distance = 20.962

       (10) Variable   x'' = sin(t),  y'' = t^2
    -> (11) x'' = sin(t)
    -> (12) y'' = t^2

       (13) Input      x  = 2 cm,    y  = 3 noUnits
       (14) Input      x' = 6 cm/s,  y' = 7 noUnits/s
       (15) speed = EvaluateToNumber( x' + y'  +  (x + y)/t )
    -> (16) speed = 7.06 + 3.02/t

       (17) Input   tFinal = 3 seconds, tStep = 0.5 seconds
       (18) Output  t seconds,  x km,  y miles
       (19) ODE() unitTest

#### Variable

    Variable

     Purpose:  Declares the names of variables.

    Syntax 1:  Variable  a,  b,  x+,  y-,  ...
    Syntax 2:  Variable  u', q'',  ...
    Syntax 3:  Variable  (displays all names declared as Variable)
    Syntax 4:  Variable()

       Input:  a -- name that starts with a letter, followed by a reasonable
                    number of alphanumeric characters (similarly for b).
               a, b, ... are regarded as REAL until SetComplex is ON.

               x+ -- declares x as real and non-negative.
               y- -- declares y as real and non-positive.
               Helps simplification such as  abs(x) = x  or  abs(y) = -y.

               u'  -- declares u' and u as Variables.
               q'' -- declares q'', q', and q as Variables.

    Output 4:  Creates an array of all names declared as Variable.

      Remark:  The 1st and 2nd ordinary derivatives of y are denoted y' and y''.
               Dt(y) is permitted if y' was also declared - or y was assigned.

      Remark:  Variable  vs.  Specified ??
               Variable:  Regarded as unknown (to be solved).
                          Partial velocities account for assignment of Variable.
               Specified: Regarded as known   (prescribed).
                          Assigned in program  OR  leave "to be specified" in
                          special functions in MATLAB(R), C, and Fortran codes.
                          Partial velocities ignore assignment of Specified.

      Remark:  The name  a{i}bb    declares a1bb ... aibb  (i is positive integer).
               The name  a{i:j}bb  declares aibb ... ajbb  (i >= 0  and  i <= j).
               The name  a{m,n}bb  declares amnbb     (m, n are integers 0 to 9).
               The name  a{m:x,n:y}  declares amn ... axy    (m <= x and n <= y).

      Remark:  The default name of the independent variable is t.

      Remark:  To both declare and assign a Variable, type e.g.,
               Variable x'' = 2*sin(t)

     Related:  Constant  ImaginaryNumber  Specified  Variable
               SetGeneralizedCoordinate  SetGeneralizedSpeed
               SetDt  SolveDt  SetAutoDifferentiate

       (1) %--------------------------------------------------------------------
       (2) % Example 1: Variable  (variables declarations)
       (3) %--------------------------------------------------------------------
       (4) Variable  w,  x+,  y-,  z'+,   e{0:3}'
       (5) b = sin(t)  +  x  -  abs(x)  +  y  +  abs(y)  +  abs(z)
    -> (6) b = sin(t) + z

       (7) dtExample1 = Dt(b) + Dt(e0)
    -> (8) dtExample1 = cos(t) + e0' + z'

       (9) %--------------------------------------------------------------------
       (10) % Example 2: Variable  (variable declarations and differentiation)
       (11) %--------------------------------------------------------------------
       (12) Variable  q',  u''
       (13) dtExample2 = Dt(q)  +  Dt(u)  + DtDt(u)  +  Dt(u')
    -> (14) dtExample2 = q' + u' + 2*u''

       (15) SetDt( q = sin(t) )
    -> (16) q = sin(t)
    -> (17) q' = cos(t)

       (18) SetDt( u' = t^3 )
    -> (19) u' = t^3
    -> (20) u'' = 3*t^2

       (21) arrayOfVariables = Variable()
    -> (22) arrayOfVariables = [e0;  e0';  e1;  e1';  e2;  e2';  e3;  e3';  q;  q';
            u;  u';  u'';  w;  x;  y;  z;  z']

#### Vector

    Vector

     Purpose:  Constructs a vector or three-element column matrix.

    Syntax 1:  Vector( A,  x, y, z  )
    Syntax 2:  Vector( A,  threeElementMatrix )
    Syntax 3:  Vector( A,  vector>  )

       Input:  A -- the name of a RigidFrame or RigidBody.
               x, y, z -- scalar expressions.
               threeElementMatrix -- 3x1 or 1x3 matrix with scalar elements.
               vector> -- a vector  expression

    Output 1:  Returns the vector x*Ax> + y*Ay> + z*Az>
    Output 2:  Similar to Output 1 (see example)
    Output 3:  3x1 matrix whose elements are the Ax>, Ay>, Az> measures of vector>

     Related:  Cross  Dot  Express  Vector  Dyadic  Matrix >  >>  >>>  0> 0>> 1>>
               GetAngleBetweenVectors  GetAngleBetweenUnitVectors
               GetDistance  GetMagnitude  GetMagnitudeSquared    GetUnitVector

       (1) %--------------------------------------------------------------------
       (2) % Example 1:  Vector( A,  x, y, z )
       (3) %--------------------------------------------------------------------
       (4) RigidFrame A, B
       (5) Constant   x, y, z
       (6) vector1> = Vector( A,  x, y, z )
    -> (7) vector1> = x*Ax> + y*Ay> + z*Az>

       (8) %--------------------------------------------------------------------
       (9) % Example 2:  Vector( A,  threeElementMatrix )
       (10) %--------------------------------------------------------------------
       (11) vector2> = Vector( A,  [x; y; z] )
    -> (12) vector2> = x*Ax> + y*Ay> + z*Az>

       (13) %--------------------------------------------------------------------
       (14) % Example 3:  Vector( A,  vector> )
       (15) %--------------------------------------------------------------------
       (16) B.SetRotationMatrixZ( A, t )
    -> (17) B_A = [cos(t), sin(t), 0;  -sin(t), cos(t), 0;  0, 0, 1]

       (18) matrix1 = Vector( A,  x*Ax> + y*Ay> + z*Az> )
    -> (19) matrix1 = [x;  y;  z]

       (20) matrix2 = Vector( B,  x*Ax> + y*Ay> + z*Az> )
    -> (21) matrix2 = [x*cos(t) + y*sin(t);  y*cos(t) - x*sin(t);  z]

#### Zee

    Zee   ZeeV    ZeeA   ZeeConstants

     Purpose:  Introduces  Z1, Z2, ...  as  names for expressions and
               makes corresponding replacements.

    Syntax 1:  Zee( ExpressionY )
    Syntax 2:  Zee( ExpressionY, X )
    Syntax 3:  ZeeV( ExpressionY )
    Syntax 4:  ZeeA( ExpressionY )
    Syntax 5:  ZeeConstants( expressionY )

       Input:  ExpressionY -- a scalar, vector, or dyadic expression or
               a matrix of scalars, vectors, and/or dyadics.

               X -- The name of a scalar symbol (e.g., a constant or variable)
                    or a comma-separated list of names of scalar symbols,
                    or a matrix of names of scalar symbols,
                    that appear linearly in ExpressionY.

    Output 1:  ExpressionY expressed in a form involving Z1, Z2, ...

    Output 2:  ExpressionY expressed in a form involving Z1, Z2, ... ,
               where Zi do not contain any of the scalar names in X.

    Output 3:  ExpressionY expressed in a form involving Z1, Z2, ... ,
               where Zi do not contain independent generalized speeds
               (generalized speeds are named in the SetGeneralizedSpeed command).

    Output 4:  ExpressionY expressed in a form involving Z1, Z2, ... ,
               where Zi do not contain any 1st-time-derivatives of independent
               generalized speeds.

    Output 5:  ExpressionY expressed in a form involving Z1, Z2, ... ,
               where Zi contain only constants.

      Remark:  Designated names can be excluded from all Zs, provided
               they occur only linearly.  To do this, enter the line
               SetNoZeeSymbol( M ), where M is either a scalar name
               to be excluded or a matrix of scalar names to be excluded.

               ZEE is a dual function; e.g., the command ZEE( F ) can be
               on the right-hand side of an equation or a single expression
               without an equals sign.  In the latter event, an equation
               is created whose left-hand is F.

      Remark:  To be Autolev compatible, use:
               ZeeV( ExpressionY )  instead of  Zee( ExpressionY, U  ),
               ZeeA( ExpressionY )  instead of  Zee( ExpressionY, U' ).

     Related:  Express  SetAutoExpress  SetAutoZee  Zee
               SetNoZeeSymbol  ResetNoZeeSymbol  GetNoZeeSymbol
               FactorLinear  FactorQuadratic

       (1) %--------------------------------------------------------------------
       (2) % Example 1: Zee   (scalar expression)
       (3) %--------------------------------------------------------------------
       (4) Constant   A, B, C
       (5) ScalarExpression = (A-B)*cos(t) + (B-C)*sin(t)
    -> (6) ScalarExpression = (A-B)*cos(t) + (B-C)*sin(t)

       (7) Zee( ScalarExpression )
    -> (8) z1 = cos(t)
    -> (9) z2 = sin(t)
    -> (10) z3 = A - B
    -> (11) z4 = B - C
    -> (12) z5 = z3*z1 + z4*z2
    -> (13) ScalarExpression = z5

       (14) %--------------------------------------------------------------------
       (15) % Example 2: ZeeConstants   (vector expression)
       (16) %--------------------------------------------------------------------
       (17) RigidBody  N
       (18) vector> = (A-B)*cos(t)*Nx> + (B-C)*sin(t)*Ny> + cos(A-B)*sin(B-C)*exp(t)*Nz>
    -> (19) vector> = (A-B)*cos(t)*Nx> + (B-C)*sin(t)*Ny> + sin(B-C)*cos(A-B)*exp(t)*Nz>

       (20) ZeeConstants( vector> )
    -> (21) z6 = sin(B-C)*cos(A-B)
    -> (22) vector> = z3*cos(t)*Nx> + z4*sin(t)*Ny> + z6*exp(t)*Nz>

       (23) %--------------------------------------------------------------------
       (24) % Example 3: Zee   (matrix expression)
       (25) %--------------------------------------------------------------------
       (26) Variable x, y
       (27) matrix[1] = 10 + A + B + C + abs(t)*x + sin(t)*exp(t)*cos(t^2)*y
    -> (28) matrix[1] = 10 + A + B + C + abs(t)*x + sin(t)*exp(t)*cos(t^2)*y

       (29) matrix[2] = 10 + A^2 + cos(B+C)*tan(t)*x
    -> (30) matrix[2] = 10 + A^2 + cos(B+C)*tan(t)*x

       (31) Zee( matrix, x, y )
    -> (32) z7 = abs(t)
    -> (33) z8 = exp(t)
    -> (34) z9 = cos(t^2)
    -> (35) z10 = z2*z8*z9
    -> (36) z11 = 10 + A + B + C
    -> (37) z12 = cos(B+C)
    -> (38) z13 = tan(t)
    -> (39) z14 = z12*z13
    -> (40) z15 = 10 + A^2
    -> (41) matrix = [z11 + z7*x + z10*y;  z15 + z14*x]

#### __Superseded__

     The remaining functions below are or will be superseded by other methods.
    ----------------------------------------------------------------------------

#### Algebraic

    Algebraic  (Also see Solve)

     Purpose:  Writes a MATLAB, C, or Fortran program to solve for Output
               and perhaps to solve coupled LINEAR algebraic equations.

    Syntax 1:  Algebraic()                             Filename.Ext
    Syntax 2:  Algebraic( EqnsToSolve, x1, x2, ... )   Filename.Ext
    Syntax 3:  Algebraic()                             Filename.Ext( Tx, Ty, Tz )
    Syntax 4:  Algebraic() [A = Astart, Astop, Astep]  Filename.Ext
    Note:      The various options in Syntax 1-4 can be used together.

       Input:  Filename -- a valid file name (letters, numbers, or underscores)
               Ext -- .m    (produces MATLAB  code)
                   -- .c    (produces C       code and input file Filename.in)
                   -- .f    (produces FORTRAN code and input file Filename.in)
                   -- .for  (same as .f except 72 character line length)

       Input:  EqnsToSolve -- matrix of (or single) scalar expressions that are
               LINEAR functions of x1, x2, ..., and regarded as equal to zero.
               Treated as:  EqnsToSolve[1] = 0,   EqnsToSolve[2] = 0, ...

               x1, x2 -- the names of scalars or a matrix of scalar names.

               Tx, Ty, Tz -- scalar names (maybe with units) that allow for
               passing command-line arguments to MATLAB or C programs.
               Example:  Filename.m( Tx N*m,  Ty N*cm,  Tz lbf*ft )

               A = Astart, Astop, Astep -- A is the name (maybe with units) of a
               scalar quantity used as a loop index.  Astart, Astop, Astep are
               numerical values.  Example:  [A cm = 0, 100, 2]

    Output 1:  Produces a program that performs all calculations necessary to
               determine values of quantities named in OUTPUT statements.

    Output 2:  Same as Output 1.  Also solves EqnsToSolve for x1, x2, ...

    Output 3:  To run Filename.m, type  Filename( 12, 56, 87 )  at MATLAB prompt.
               To run Filename.c, type  Filename 12 56 87       from OS shell.

    Output 4:  Incorporates Fortran DO-loops or C/MATLAB FOR-loops.
               To have multiple loops inside the program, use, e.g.,
               [ A = Astart, Astop, Astep;   B = Bstart, Bstop, Bstep; ... ]

      Remark:  Input values and units are named in INPUT statements.
               Output quantities and units are named in OUTPUT statements.

      Remark:  SetDigits sets the format of numbers output by programs created by
               the ALGEBRAIC command.  It does not affect calculation accuracy.

      Remark:  Use the  .for  extension for FORTRAN whose line lengths cannot
               exceed 72 characters and which supports all line breaks.
               Use the  .f   extension for FORTRAN with lines less than 120
               characters and which cannot break lines in the middle of names.

     Related:  ODE  Algebraic  Solve  Input  Output  OutputPlot  Plot  Animate
               ConvertUnits  GetUnitSystem  SetUnitSystem  SetDigits  SetLineWidth
               Solve  SolveDt  SolveSetInput  SolveSetInputDt  ...

       (1) %--------------------------------------------------------------------
       (2) % Example 1: CODE Algebraic()  (Fortran for volume of a tetrahedron)
       (3) %--------------------------------------------------------------------
       (4) RigidFrame  N
       (5) Point       A, B, C, D
       (6) Constant    a1 = 0 m,  a2 = 0 m,  a3 = 0 m
       (7) Constant    b1 = 5 m,  b2 = 0 m,  b3 = 0 m
       (8) Constant    c1 = 0 m,  c2 = 5 m,  c3 = 0 m
       (9) Constant    d1 = 2 m,  d2 = 2 m,  d3 = 5 m
       (10) A.SetPosition( No, a1*Nx> + a2*Ny> + a3*Nz> )
    -> (11) p_No_A> = a1*Nx> + a2*Ny> + a3*Nz>

       (12) B.SetPosition( No, b1*Nx> + b2*Ny> + b3*Nz> )
    -> (13) p_No_B> = b1*Nx> + b2*Ny> + b3*Nz>

       (14) C.SetPosition( No, c1*Nx> + c2*Ny> + c3*Nz> )
    -> (15) p_No_C> = c1*Nx> + c2*Ny> + c3*Nz>

       (16) D.SetPosition( No, d1*Nx> + d2*Ny> + d3*Nz> )
    -> (17) p_No_D> = d1*Nx> + d2*Ny> + d3*Nz>

       (18) Side1> = B.GetPosition(A)
    -> (19) Side1> = (b1-a1)*Nx> + (b2-a2)*Ny> + (b3-a3)*Nz>

       (20) Side2> = C.GetPosition(A)
    -> (21) Side2> = (c1-a1)*Nx> + (c2-a2)*Ny> + (c3-a3)*Nz>

       (22) Side3> = D.GetPosition(A)
    -> (23) Side3> = (d1-a1)*Nx> + (d2-a2)*Ny> + (d3-a3)*Nz>

       (24) Volume = abs( Dot( Cross( Side1>, Side2> ), Side3> ) / 6 )
    -> (25) Volume = abs(0.1666667*(a2-d2)*((a1-b1)*(a3-c3)-(a1-c1)*(a3-b3))-0.1666667
            *(a1-d1)*((a2-b2)*(a3-c3)-(a2-c2)*(a3-b3))-0.1666667*(a3-d3)*((a1-b1)*(
            a2-c2)-(a1-c1)*(a2-b2)))

       (26) Output  Volume
       (27) Code Algebraic() Tetra.for

       (28) %--------------------------------------------------------------------
       (29) % Example 2: CODE Algebraic(...)   (.m code for linear equations)
       (30) %--------------------------------------------------------------------
       (31) Variable  x, y
       (32) ZeroMatrix[1] = x + y - sin(t)
    -> (33) ZeroMatrix[1] = x + y - sin(t)

       (34) ZeroMatrix[2] = x - y + t^2
    -> (35) ZeroMatrix[2] = t^2 + x - y

       (36) Output  t, x, y
       (37) Code Algebraic( ZeroMatrix, x, y )  [t=0, 10, 1]  TwoEquations.c

#### Angvel

    Angvel  and  AngvelAccel

     Purpose:  Calculates and sets angular velocity in terms of orientation angles,
               Euler parameters, Rodrigues parameters, or elements of rotation
               matrices (direction cosines) and their time-derivatives.

    Syntax 1:  Angvel(      A, B, TYPE,  q1, q2, q3 )
               AngvelAccel( A, B, TYPE,  q1, q2, q3 )
    Syntax 2:  Angvel(      A, B, Euler, e1, e2, e3, e4 )
               AngvelAccel( A, B, Euler, e1, e2, e3, e4 )
    Syntax 3:  Angvel(      A, B, Rodrigues, rho1, rho2, rho3 )
               AngvelAccel( A, B, Rodrigues, rho1, rho2, rho3 )
    Syntax 4:  Angvel(      A, B )
               AngvelAccel( A, B )

       Input:  A, B -- names of reference frames (RigidFrame or RigidBody).

               TYPE -- BODYx  or  SPACEx, where x is one of 123, 132,
               231, 213, 312, 321, 121, 131, 232, 212, 313, 323

               q1, q2, q3 -- orientation angles characterizing
               the relative orientation of frames A and B.

               e1, e2, e3, e4 -- Euler parameters characterizing
               the relative orientation of frames A and B.

               rho1, rho2, rho3 -- Rodrigues parameters characterizing
               the relative orientation of frames A and B.

    Output 1:  Sets frame B's angular velocity in frame A, expressed in terms of
               q1, q2, q3, q1', q2', q3', and unit vectors fixed in B.
               AngvelAccel also sets B's angular acceleration in A.

    Output 2:  Sets frame B's angular velocity in frame A, expressed in terms of
               e1 ... e4,  e1' ... e4', and unit vectors fixed in B.
               AngvelAccel also sets B's angular acceleration in A.

    Output 3:  Sets frame B's angular velocity in frame A, expressed in terms of
               rho1 ... rho3,  rho1' ... rho3', and unit vectors fixed in B.
               AngvelAccel also sets B's angular acceleration in A.

    Output 4:  Frame B's angular velocity in A, expressed in terms of direction
               cosines, their time-derivatives, and unit vectors fixed in B.
               AngvelAccel also sets B's angular acceleration in A.

      Remark:  Definitions of orientation angles, Euler parameters,
               Rodrigues parameters, and direction cosines are in
               Kane, Likins, Levinson: Spacecraft Dynamics, McGraw-Hill, Ch. 1, and
               Mitiguy, Paul, "Advanced Dynamics & Motion Simulation".

     Related:  Rotate  RotateX  RotateY  RotateZ
               RotateNegativeX  RotateNegativeY  RotateNegativeZ
               SetRotationMatrixX  SetRotationMatrixY  SetRotationMatrixZ
               SetRotationMatrixNegativeX  SetRotationMatrixNegativeY  ...
               SetRotationMatrix  SetAngularVelocity  SetAngularAcceleration
               GetRotationMatrix  GetAngularVelocity  GetAngularAcceleration
               SetRotationMatrixODE  SetEulerParameterODE  SetRodriguesParameterODE
               ANGVEL  KINDIFFS  SetDefaults( AUTOLEV )

       (1) %--------------------------------------------------------------------
       (2) % Example 1: Angvel  (Orientation angles)
       (3) %--------------------------------------------------------------------
       (4) RigidFrame  A, B
       (5) Variable    q1', q2', q3'
       (6) Angvel( A, B, Body123, q1, q2, q3 )
    -> (7) w_B_A> = (sin(q3)*q2'+cos(q2)*cos(q3)*q1')*Bx> + (cos(q3)*q2'-sin(q3)*
           cos(q2)*q1')*By> + (q3'+sin(q2)*q1')*Bz>

       (8) %--------------------------------------------------------------------
       (9) % Example 2: Angvel  (Euler parameters)
       (10) %--------------------------------------------------------------------
       (11) RigidFrame  C
       (12) Variable    e1', e2', e3', e4'
       (13) Angvel( A, C, Euler, e1, e2, e3, e4 )
    -> (14) w_C_A> = (2*e3*e2'+2*e4*e1'-2*e1*e4'-2*e2*e3')*Cx> + (2*e1*e3'+2*e4*e2'
            -2*e2*e4'-2*e3*e1')*Cy> + (2*e2*e1'+2*e4*e3'-2*e1*e2'-2*e3*e4')*Cz>

       (15) %--------------------------------------------------------------------
       (16) % Example 3: Angvel  (Rodrigues parameters)
       (17) %--------------------------------------------------------------------
       (18) RigidFrame  D
       (19) Variable    rho1', rho2', rho3'
       (20) Angvel( A, D, Rodrigues, rho1, rho2, rho3 )
    -> (21) w_D_A> = -2*(rho2*rho3'-rho1'-rho3*rho2')/(1+rho1^2+rho2^2+rho3^2)*Dx>
            + 2*(rho2'+rho1*rho3'-rho3*rho1')/(1+rho1^2+rho2^2+rho3^2)*Dy> - 2*(rh
            o1*rho2'-rho3'-rho2*rho1')/(1+rho1^2+rho2^2+rho3^2)*Dz>

       (22) %--------------------------------------------------------------------
       (23) % Example 4: Angvel  (Direction cosines)
       (24) %--------------------------------------------------------------------
       (25) RigidFrame  F
       (26) Variable    C{1:3,1:3}'
       (27) A_F = [C11, C12, C13; C21, C22, C23; C31, C32, C33]
    -> (28) A_F = [C11, C12, C13;  C21, C22, C23;  C31, C32, C33]

       (29) Angvel( A, F )
    -> (30) w_F_A> = (C13*C12'+C23*C22'+C33*C32')*Fx> + (C11*C13'+C21*C23'+C31*C33')*Fy>
            + (C12*C11'+C22*C21'+C32*C31')*Fz>

       (31) %--------------------------------------------------------------------
       (32) % Example 5: AngvelAccel  (Orientation angles)
       (33) %--------------------------------------------------------------------
       (34) Variable    q1'', q2'', q3''
       (35) AngvelAccel( A, B, Body123, q1, q2, q3 )
    -> (36) w_B_A> = (sin(q3)*q2'+cos(q2)*cos(q3)*q1')*Bx> + (cos(q3)*q2'-sin(q3)*
            cos(q2)*q1')*By> + (q3'+sin(q2)*q1')*Bz>

    -> (37) alf_B_A> = (cos(q3)*q2'*q3'+sin(q3)*q2''+cos(q2)*cos(q3)*q1''-sin(q2)*
            cos(q3)*q1'*q2'-sin(q3)*cos(q2)*q1'*q3')*Bx> + (sin(q2)*sin(q3)*q1'*q2'
            +cos(q3)*q2''-sin(q3)*q2'*q3'-cos(q2)*cos(q3)*q1'*q3'-sin(q3)*cos(q2)*
            q1'')*By> + (cos(q2)*q1'*q2'+q3''+sin(q2)*q1'')*Bz>

       (38) %--------------------------------------------------------------------
       (39) % Example 6: AngvelAccel  (Euler parameters)
       (40) %--------------------------------------------------------------------
       (41) Variable    e1'', e2'', e3'', e4''
       (42) AngvelAccel( A, C, Euler, e1, e2, e3, e4 )
    -> (43) w_C_A> = (2*e3*e2'+2*e4*e1'-2*e1*e4'-2*e2*e3')*Cx> + (2*e1*e3'+2*e4*e2'
            -2*e2*e4'-2*e3*e1')*Cy> + (2*e2*e1'+2*e4*e3'-2*e1*e2'-2*e3*e4')*Cz>

    -> (44) alf_C_A> = (2*e3*e2''+2*e4*e1''-2*e1*e4''-2*e2*e3'')*Cx> + (2*e1*e3''+2
            *e4*e2''-2*e2*e4''-2*e3*e1'')*Cy> + (2*e2*e1''+2*e4*e3''-2*e1*e2''-2*
            e3*e4'')*Cz>

       (45) %--------------------------------------------------------------------
       (46) % Example 7: AngvelAccel  (Rodrigues parameters)
       (47) %--------------------------------------------------------------------
       (48) Variable    rho1'', rho2'', rho3''
       (49) AngvelAccel( A, D, Rodrigues, rho1, rho2, rho3 )
    -> (50) w_D_A> = -2*(rho2*rho3'-rho1'-rho3*rho2')/(1+rho1^2+rho2^2+rho3^2)*Dx>
            + 2*(rho2'+rho1*rho3'-rho3*rho1')/(1+rho1^2+rho2^2+rho3^2)*Dy> - 2*(rh
            o1*rho2'-rho3'-rho2*rho1')/(1+rho1^2+rho2^2+rho3^2)*Dz>

    -> (51) alf_D_A> = 2*(2*(rho1*rho1'+rho2*rho2'+rho3*rho3')*(rho2*rho3'-rho1'-
            rho3*rho2')-(1+rho1^2+rho2^2+rho3^2)*(rho2*rho3''-rho1''-rho3*rho2''))/
            (1+rho1^2+rho2^2+rho3^2)^2*Dx> - 2*(2*(rho1*rho1'+rho2*rho2'+rho3*rho3')
            *(rho2'+rho1*rho3'-rho3*rho1')-(1+rho1^2+rho2^2+rho3^2)*(rho2''+rho1*
            rho3''-rho3*rho1''))/(1+rho1^2+rho2^2+rho3^2)^2*Dy> + 2*(2*(rho1*rho1'+
            rho2*rho2'+rho3*rho3')*(rho1*rho2'-rho3'-rho2*rho1')-(1+rho1^2+rho2^2+rho3^2)
            *(rho1*rho2''-rho3''-rho2*rho1''))/(1+rho1^2+rho2^2+rho3^2)^2*Dz>

       (52) %--------------------------------------------------------------------
       (53) % Example 8: AngvelAccel  (Direction cosines)
       (54) %--------------------------------------------------------------------
       (55) Variable    C{1:3,1:3}''
       (56) AngvelAccel( A, F )
    -> (57) w_F_A> = (C13*C12'+C23*C22'+C33*C32')*Fx> + (C11*C13'+C21*C23'+C31*C33')*Fy>
            + (C12*C11'+C22*C21'+C32*C31')*Fz>

    -> (58) alf_F_A> = (C12'*C13'+C22'*C23'+C32'*C33'+C13*C12''+C23*C22''+C33*C32'')*Fx>
            + (C11'*C13'+C21'*C23'+C31'*C33'+C11*C13''+C21*C23''+C31*C33'')*Fy>
            + (C11'*C12'+C21'*C22'+C31'*C32'+C12*C11''+C22*C21''+C32*C31'')*Fz>

#### Code

    CODE       (Mostly superseded by ODE and Solve)

     Purpose:  Writes a Fortran, C, or MATLAB program or immediately
               executes a program for a variety of purposes.

    Syntax 1:  Code ODE()                               Filename.Ext
               Code ODE( MatrixOfEqns, UNKNOWNS )       Filename.Ext

    Syntax 2:  Code Algebraic()                         Filename.Ext
               Code Algebraic( MatrixOfEqns, UNKNOWNS ) Filename.Ext

    Syntax 3:  Code Nonlinear( MatrixOfEqns, UNKNOWNS ) Filename.Ext

       Input:  Filename -- a valid file name, e.g., one that starts with a
               letter and is followed by letters, numbers, or underscores.

               Ext -- nothing (produces immediate solution)
                   -- .c    (produces C code)
                   -- .f    (produces FORTRAN code)
                   -- .for  (produces FORTRAN code with 72 character line length)
                   -- .m    (produces MATLAB code)

               MatrixOfEqns -- a matrix of scalar expressions (e.g., f1, ..., fn)
               that are functions of the UNKNOWNS and which are regarded to be
               equal to zero, i.e., fi = 0  (i = 1, ..., n).

               UNKNOWNS -- the names of scalars separated by commas or a
               matrix of names of scalars.

    Output 1:  Solves or creates code to solve a set of simultaneous ordinary
               differential equations or coupled differential/algebraic equations
                   *** Type HELP ODE for details. ***

    Output 2:  Creates code to solve a set of coupled or uncoupled
               nonlinear, algebraic (nondifferential) equations
                   *** Type HELP NONLINEAR for details. ***

    Output 3:  Creates code to carry out successive substitutions or to
               solve a set of simultaneous, linear equations
                   *** Type HELP ALGEBRAIC for details. ***

      Remark:  The program's license may limit the type of CODE
               that can be generated (e.g., to a specific Ext).

      Remark:  Use the  .for  extension for FORTRAN whose line lengths cannot
               exceed 72 characters and which supports all line breaks.
               Use the  .f   extension for FORTRAN with lines less than 120
               characters and which cannot break lines in the middle of names.

     Related:  CODE  ALGEBRAIC  NONLINEAR  ODE  Input  Output  Animate
               ConvertUnits  GetUnitSystem  SetUnitSystem  SetDigits  SetLineWidth
               absError  relError  tInitial  tFinal  tStep  printInt
               Solve  SolveDt  SolveSetInput  SolveSetInputDt  ...

       (1) %--------------------------------------------------------------------
       (2) % Example: CODE Nonlinear( ... )      2 equations, 2 unknowns.
       (3) %--------------------------------------------------------------------
       (4) Variable  x, y
       (5) Constant  R = 3 meters       % Radius of circle.
       (6) eqn[1] = x^2 + y^2 - R^2     % Equation for circle of radius R.
    -> (7) eqn[1] = x^2 + y^2 - R^2

       (8) eqn[2] = y - 2*sin(x)        % Equation for sine wave of amplitude 2 m.
    -> (9) eqn[2] = y - 2*sin(x)

       (10) Input  x = 4 m,  y = 2 m     % Guess for solution (in meters).
       (11) Code Nonlinear( eqn = 0,  x, y )  CircleSineWaveIntersection.m

       (12) %--------------------------------------------------------------------
       (13) % Example: CODE Nonlinear( ... )      1 equation, 2 unknowns.
       (14) %--------------------------------------------------------------------
       (15) Code Nonlinear( eqn[1] = 0,  x, y )  CodePointNearCircle.m

       (16) %--------------------------------------------------------------------
       (17) % Example: CODE Algebraic( ... )      2 equations, 2 unknowns.
       (18) %--------------------------------------------------------------------
       (19) linearEqn[1] = x + y - R
    -> (20) linearEqn[1] = x + y - R

       (21) linearEqn[2] = 2*x + 3*y - 4*sin(t)
    -> (22) linearEqn[2] = 2*x + 3*y - 4*sin(t)

       (23) Output t degrees,  x meters,  y meters
       (24) Code Algebraic( linearEqn = 0,  x, y ) [t degrees = 0, 360, 30] CodeTest.m

       (25) %--------------------------------------------------------------------
       (26) % For more examples, type:
       (27) % Help ALGEBRAIC
       (28) % Help NONLINEAR
       (29) % Help ODE
       (30) %--------------------------------------------------------------------

#### Nonlinear

    Nonlinear  (Also see Solve)

     Purpose:  Writes a MATLAB, C, or Fortran program to solve coupled nonlinear
               algebraic equations and calculate Output.

    Syntax 1:  Nonlinear( EqnsToSolve, x1, x2, ... )  Filename.Ext
    Syntax 2:  Nonlinear( EqnsToSolve, x1, x2, ... )  Filename.Ext( Tx, Ty, Tz )
    Syntax 3:  Nonlinear( EqnsToSolve, x1, x2, ... )  [A = Astart, Astop, Astep]

       Input:  Filename -- a valid file name (letters, numbers, or underscores)
               Ext -- .m    (produces MATLAB  code)
                   -- .c    (produces C       code and input file Filename.in)
                   -- .f    (produces FORTRAN code and input file Filename.in)
                   -- .for  (same as .f except 72 character line length)

       Input:  EqnsToSolve -- matrix of (or single) scalar expressions that
               are functions of x1, x2, ..., and regarded as equal to zero.
               Treated as:  EqnsToSolve[1] = 0,   EqnsToSolve[2] = 0, ...

               x1, x2 -- the names of scalars or a matrix of scalar names.

               Tx, Ty, Tz -- scalar names (maybe with units) that allow for
               passing command-line arguments to MATLAB or C programs.
               Example:  Filename.m( Tx N*m,  Ty N*cm,  Tz lbf*ft )

               A = Astart, Astop, Astep -- A is the name (maybe with units) of a
               scalar quantity used as a loop index.  Astart, Astop, Astep are
               numerical values.  Example:  [A cm = 0, 100, 2]

      Output:  Produces a program that solves the nonlinear algebraic equations,
               outputs numerical results for x1, x2, ..., and outputs numerical
               values of quantities named in OUTPUT statements.

    Output 2:  To run Filename.m, type  Filename( 12, 56, 87 )  at MATLAB prompt.
               To run Filename.c, type  Filename 12 56 87       from OS shell.

    Output 3:  Incorporates Fortran DO-loops or C/MATLAB FOR-loops.
               To have multiple loops inside the program, use, e.g.,
               [ A = Astart, Astop, Astep;   B = Bstart, Bstop, Bstep; ... ]

      Remark:  Input values and units are named in INPUT statements.
               Output quantities and units are named in OUTPUT statements.

      Remark:  SetDigits sets the format of numbers output by programs created by
               the ODE command.  It does not affect calculation accuracy.

      Remark:  The solution is approximate and a solution may be reported even
               though one does not exists.  The accuracy of the solution tends
               to improve as the input value assigned to absError gets smaller.
               The default value of absError can be changed via the Input command:
               Input  absError = 1.0E-7 cm

      Remark:  Nonlinear algebraic equations may have 0, 1, 2, 3, ..., solutions.

     Related:  CODE  ALGEBRAIC  NONLINEAR  ODE  Input  Output  Animate
               ConvertUnits  GetUnitSystem  SetUnitSystem  SetDigits  SetLineWidth
               Solve  SolveDt  SolveSetInput  SolveSetInputDt  ...

       (1) %--------------------------------------------------------------------
       (2) % Example:  CODE Nonlinear( ... )
       (3) % Creates C code to find the intersection of a circle and line.
       (4) %--------------------------------------------------------------------
       (5) Variable  x, y
       (6) Constant  R,  m = 1 noUnits,  b = 0 noUnits
       (7) Zero[1] = x^2 + y^2 - R^2
    -> (8) Zero[1] = x^2 + y^2 - R^2

       (9) Zero[2] = y - (m*x + b)
    -> (10) Zero[2] = y - b - m*x

       (11) Input  x = 13,  y = 10      % Guesses for solution
       (12) Code Nonlinear( Zero, x, y ) [R=1,8,1] CircleLineIntersection.c

#### Dircos

    Dircos     (Superseded by SetRotationMatrix)

     Purpose:  Calculates and sets the direction cosine matrix (rotation matrix)
               relating two sets of dextral, orthogonal unit vectors in terms of
               orientation angles, Euler parameters, or Rodrigues parameters.

    Syntax 1:  Dircos( A, B, TYPE,  q1, q2, q3 )
    Syntax 2:  Dircos( A, B, EULER, e1, e2, e3, e4)
    Syntax 3:  Dircos( A, B, RODRIGUES, rho1, rho2, rho3 )

       Input:  A, B -- names of reference frames (RigidFrame or RigidBody).

               TYPE -- BODYx  or  SPACEx, where x is one of 123, 132,
               231, 213, 312, 321, 121, 131, 232, 212, 313, 323

               q1, q2, q3 -- orientation angles characterizing
               the relative orientation of frames A and B.

               e1, e2, e3, e4 -- Euler parameters characterizing
               the relative orientation of frames A and B.

               rho1, rho2, rho3 -- Rodrigues parameters characterizing
               the relative orientation of frames A and B.

    Output 1:  Calculates and sets the direction cosine matrix A_B,
               expressed in terms of q1, q2, q3

    Output 2:  Calculates and sets the direction cosine matrix A_B,
               expressed in terms of e1, e2, e3, e4

    Output 3:  Calculates and sets the direction cosine matrix A_B,
               expressed in terms of rho1, rho2, rho3

      Remark:  Definitions of orientation angles, Euler parameters,
               Rodrigues parameters, and direction cosines are in
               Kane, Likins, Levinson: Spacecraft Dynamics, McGraw-Hill, Ch. 1, and
               Mitiguy, Paul, "Advanced Dynamics & Motion Simulation".

     Related:  Rotate   RotateX   RotateY   RotateZ
               RotateNegativeX  RotateNegativeY  RotateNegativeZ
               SetRotationMatrixX  SetRotationMatrixY  SetRotationMatrixZ
               SetRotationMatrixNegativeX  SetRotationMatrixNegativeY  ...
               SetRotationMatrix  SetAngularVelocity  SetAngularAcceleration
               GetRotationMatrix  GetAngularVelocity  GetAngularAcceleration
               SetRotationMatrixODE  SetEulerParameterODE  SetRodriguesParameterODE
               ANGVEL  DIRCOS  KINDIFFS  SIMPROT  SetDefaults( AUTOLEV )

       (1) %--------------------------------------------------------------------
       (2) % Example 1: DIRCOS  (Orientation angles)
       (3) %--------------------------------------------------------------------
       (4) SetDefaults( AUTOLEV )
       (5) RigidFrame  A, B
       (6) Variable    q1, q2, q3
       (7) DIRCOS( A, B, Body123, q1, q2, q3 )
    -> (8) A_B[1,1] = cos(q2)*cos(q3)
    -> (9) A_B[1,2] = -sin(q3)*cos(q2)
    -> (10) A_B[1,3] = sin(q2)
    -> (11) A_B[2,1] = sin(q3)*cos(q1) + sin(q1)*sin(q2)*cos(q3)
    -> (12) A_B[2,2] = cos(q1)*cos(q3) - sin(q1)*sin(q2)*sin(q3)
    -> (13) A_B[2,3] = -sin(q1)*cos(q2)
    -> (14) A_B[3,1] = sin(q1)*sin(q3) - sin(q2)*cos(q1)*cos(q3)
    -> (15) A_B[3,2] = sin(q1)*cos(q3) + sin(q2)*sin(q3)*cos(q1)
    -> (16) A_B[3,3] = cos(q1)*cos(q2)

       (17) %--------------------------------------------------------------------
       (18) % Example 2: DIRCOS  (Euler parameters)
       (19) %--------------------------------------------------------------------
       (20) RigidFrame  C
       (21) Variable    e1, e2, e3, e4
       (22) DIRCOS( A, C, Euler, e1, e2, e3, e4 )
    -> (23) A_C[1,1] = 1 - 2*e2^2 - 2*e3^2
    -> (24) A_C[1,2] = 2*e1*e2 - 2*e3*e4
    -> (25) A_C[1,3] = 2*e1*e3 + 2*e2*e4
    -> (26) A_C[2,1] = 2*e1*e2 + 2*e3*e4
    -> (27) A_C[2,2] = 1 - 2*e1^2 - 2*e3^2
    -> (28) A_C[2,3] = 2*e2*e3 - 2*e1*e4
    -> (29) A_C[3,1] = 2*e1*e3 - 2*e2*e4
    -> (30) A_C[3,2] = 2*e1*e4 + 2*e2*e3
    -> (31) A_C[3,3] = 1 - 2*e1^2 - 2*e2^2

       (32) %--------------------------------------------------------------------
       (33) % Example 3: DIRCOS  (Rodrigues parameters)
       (34) %--------------------------------------------------------------------
       (35) RigidFrame  D
       (36) Variable    rho1, rho2, rho3
       (37) DIRCOS( A, D, Rodrigues, rho1, rho2, rho3 )
    -> (38) A_D[1,1] = (1+rho1^2-rho2^2-rho3^2)/(1+rho1^2+rho2^2+rho3^2)
    -> (39) A_D[1,2] = -2*(rho3-rho1*rho2)/(1+rho1^2+rho2^2+rho3^2)
    -> (40) A_D[1,3] = 2*(rho2+rho1*rho3)/(1+rho1^2+rho2^2+rho3^2)
    -> (41) A_D[2,1] = 2*(rho3+rho1*rho2)/(1+rho1^2+rho2^2+rho3^2)
    -> (42) A_D[2,2] = (1+rho2^2-rho1^2-rho3^2)/(1+rho1^2+rho2^2+rho3^2)
    -> (43) A_D[2,3] = -2*(rho1-rho2*rho3)/(1+rho1^2+rho2^2+rho3^2)
    -> (44) A_D[3,1] = -2*(rho2-rho1*rho3)/(1+rho1^2+rho2^2+rho3^2)
    -> (45) A_D[3,2] = 2*(rho1+rho2*rho3)/(1+rho1^2+rho2^2+rho3^2)
    -> (46) A_D[3,3] = -(-1+rho1^2+rho2^2-rho3^2)/(1+rho1^2+rho2^2+rho3^2)

#### FrStar

    FrStar     (superseded by the negative of GetGeneralizedEffectiveForce)

     Purpose:  Forms  expressions  for  generalized inertia forces or
               contributions to generalized inertia forces.

    Syntax 1:  FrStar()
    Syntax 2:  FrStar( A1, A2, ... )

       Input:  A1, A2, ... -- a massive object, e.g., a Particle or RigidBody.

    Output 1:  a column matrix, each element of which is the sum of the contri-
               butions of all massive objects to one generalized inertia force.

    Output 2:  a column matrix, each element of which is the sum of the contri-
               butions of A1, A2, ... to one generalized inertia force.

      Remark:  If using the old/deprecated command  SetDefaults( AUTOLEV ),
               the results produced by this command depend on whether
               the command precedes or follows a CONSTRAIN command.

     Related:  GetGeneralizedEffectiveForce  GetGeneralizedForce
               GetGeneralizedMomentum  GetTranslationalMomentum  GetAngularMomentum
               Constrain  MotionVariable  MotionVariable'  SetGeneralizedSpeed
               Gyrostat  SetMass  SetInertia  Rotate  Translate
               GetDynamics  GetDynamicsKane  GetStatics  GetStaticsKane
               FR  FRSTAR  SetDefaults( AUTOLEV )

       (1) %--------------------------------------------------------------------
       (2) % Example 1: FRSTAR
       (3) %--------------------------------------------------------------------
       (4) NewtonianFrame N
       (5) Particle  A
       (6) RigidBody B
       (7) A.SetMass( mA )
       (8) B.SetMass( mB )
       (9) B.SetInertia( Bcm, Ixx, Iyy, Izz )
       (10) Variable   wx',  wy',  wz',  vA'
       (11) SetGeneralizedSpeed(  wx,  wy,  wz,  vA  )
       (12) A.SetVelocity( N, vA*Nx> )
    -> (13) v_A_N> = vA*Nx>

       (14) B.SetAngularVelocity( N, wx*Bx> + wy*By> + wz*Bz> )
    -> (15) w_B_N> = wx*Bx> + wy*By> + wz*Bz>

       (16) Bcm.SetVelocity( N, 0> )
    -> (17) v_Bcm_N> = 0>

       (18) FrStarA = FRSTAR( A )
    -> (19) FrStarA = [0;  0;  0;  -mA*vA']

       (20) FrStarB = FRSTAR( B )
    -> (21) FrStarB[1] = (Iyy-Izz)*wy*wz - Ixx*wx'
    -> (22) FrStarB[2] = -(Ixx-Izz)*wx*wz - Iyy*wy'
    -> (23) FrStarB[3] = (Ixx-Iyy)*wx*wy - Izz*wz'
    -> (24) FrStarB[4] = 0

       (25) FrStarS = FRSTAR()
    -> (26) FrStarS[1] = (Iyy-Izz)*wy*wz - Ixx*wx'
    -> (27) FrStarS[2] = -(Ixx-Izz)*wx*wz - Iyy*wy'
    -> (28) FrStarS[3] = (Ixx-Iyy)*wx*wy - Izz*wz'
    -> (29) FrStarS[4] = -mA*vA'

#### Gyrostat

    Gyrostat   (may be superseded in future versions)

     Purpose:  Calculates expressions related to angular momentum, kinetic energy,
               and generalized inertia forces for systems containing gyrostats.

    Syntax 1:  Gyrostat( Quantity, CYLINDER, Carrier, Rotor, J )
    Syntax 2:  Gyrostat( Quantity, SPHERE,   Carrier, Rotor, K )

       Input:  Quantity -- FrStar, KE, or ANGMOM

               Carrier -- the  name of the carrier portion of a gyro-
               stat, named in a RigidBody declaration

               Rotor -- the  name of a rotor portion of the gyrostat,
               named in a RigidFrame declaration

               J -- the cylindrical Rotor's axial moment of inertia.

               K -- the spherical Rotor's diametral moment of inertia.

      Output:  The Quantity associated with Rotor's motion in Carrier, e.g.,
               when Quantity is KE, the portion of the gyrostat's kinetic energy
               (in NewtonianFrame) attributable to the Rotor's motion in Carrier.

      Remark:  The mass, center of mass, and inertia properties attributed
               to Carrier must be those of the gyrostat.
               The Rotor's angular in Carrier is used by the Gyrostat command.

     Related:  GetAngularMomentum  GetDynamics  GetDynamicsKane  GetKineticEnergy
               GetTranslationalMomentum  GetGeneralizedMomentum
               GetGeneralizedEffectiveForce  SetGeneralizedSpeed
               FRSTAR  MotionVariable  MotionVariable'  SetDefaults( AUTOLEV )

       (1) %--------------------------------------------------------------------
       (2) % Example: Gyrostat
       (3) %--------------------------------------------------------------------
       (4) NewtonianFrame N
       (5) RigidBody      A     % Carrier
       (6) RigidFrame     B     % Spherical   rotor
       (7) RigidFrame     C     % Cylindrical rotor
       (8) Constant       IB    % B's diametral moment of inertia
       (9) Constant       IC    % C's moment of inertia along cylindrical axis
       (10) A.SetMass( mG )      % Attribute the gyrostat's mass and inertia to A.
       (11) A.SetInertia( Acm, IGx, IGy, IGz )
       (12) Variable       wx', wy', wz', w{1:3}', vx', vy', vz'
       (13) Specified      s'
       (14) SetGeneralizedSpeed( wx, wy, wz, w{1:3}, vx, vy, vz )
       (15) A.SetAngularVelocity( N, wx*Ax> + wy*Ay> + wz*Az> )
    -> (16) w_A_N> = wx*Ax> + wy*Ay> + wz*Az>

       (17) B.SetAngularVelocity( A, w1*Ax> + w2*Ay> + w3*Az> )
    -> (18) w_B_A> = w1*Ax> + w2*Ay> + w3*Az>

       (19) C.SetAngularVelocity( A, s*Ax> )
    -> (20) w_C_A> = s*Ax>

       (21) Acm.SetVelocity( N, vx*Ax> + vy*Ay> + vz*Az> )
    -> (22) v_Acm_N> = vx*Ax> + vy*Ay> + vz*Az>

       (23) GyroH> = A.GetAngularMomentum(Acm) + Gyrostat(ANGMOM,CYLINDER,A,C,IC) + Gyrostat(ANGMOM,SPHERE,A,B,IB)
    -> (24) GyroH> = (IC*s+IGx*wx+IB*w1)*Ax> + (IGy*wy+IB*w2)*Ay> + (IGz*wz+IB*w3)*Az>

       (25) GyroKE = A.GetKineticEnergy() + Gyrostat(KE,CYLINDER,A,C,IC) + Gyrostat(KE,SPHERE,A,B,IB)
    -> (26) GyroKE = 0.5*IGx*wx^2 + 0.5*IGy*wy^2 + 0.5*IGz*wz^2 + 0.5*IC*s*(s+2*wx)
            + 0.5*mG*(vx^2+vy^2+vz^2) - 0.5*IB*(wx^2+wy^2+wz^2-(w1+wx)^2-(w2+wy)^2-
            (w3+wz)^2)

       (27) GyroFrStar = FRSTAR(A) + Gyrostat(FRSTAR,CYLINDER,A,C,IC) + Gyrostat(FRSTAR,SPHERE,A,B,IB)
    -> (28) GyroFrStar[1] = (IGy-IGz)*wy*wz + IB*(w2*wz-w3*wy-w1') - IC*s' - IGx*wx'
    -> (29) GyroFrStar[2] = IB*(w3*wx-w1*wz-w2') - IC*s*wz - (IGx-IGz)*wx*wz - IGy*wy'
    -> (30) GyroFrStar[3] = IC*s*wy + (IGx-IGy)*wx*wy + IB*(w1*wy-w2*wx-w3') - IGz*wz'
    -> (31) GyroFrStar[4] = IB*(w2*wz-w3*wy-w1'-wx')
    -> (32) GyroFrStar[5] = IB*(w3*wx-w1*wz-w2'-wy')
    -> (33) GyroFrStar[6] = IB*(w1*wy-w2*wx-w3'-wz')
    -> (34) GyroFrStar[7] = mG*(vy*wz-vz*wy-vx')
    -> (35) GyroFrStar[8] = mG*(vz*wx-vx*wz-vy')
    -> (36) GyroFrStar[9] = mG*(vx*wy-vy*wx-vz')

#### KinDiffs

    KinDiffs  (superseded by  SetRotationMatrixODE,  SetEulerParameterODE,
               SetRodriguesParameterODE  SetPoissonParameterODE)

     Purpose:  Sets the first time-derivatives of orientation angles,
               Euler parameters, Rodrigues parameters, or direction
               cosines in terms of angular velocity measure numbers.

    Syntax 1:  KinDiffs( A, B, SequenceIJK,  q1, q2, q3 )
    Syntax 2:  KinDiffs( A, B, Euler, e1, e2, e3, e4 )
    Syntax 3:  KinDiffs( A, B, Rodrigues, rho1, rho2, rho3 )
    Syntax 4:  KinDiffs( A, B  Poisson, C11,C12,C13,
                               C21,C22,C23, C31,C32,C33 )

       Input:  A, B -- names of reference frames (RigidFrame or RigidBody).

               SequenceIJK -- BodyIJK or SpaceIJK, where IJK is one of:
               123, 132, 231, 213, 312, 321, 121, 131, 232, 212, 313, 323

               q1, q2, q3 -- names of radian measures of orientation angles
               characterizing the relative orientation of frames A and B.

               e1, e2, e3, e4 -- names of Euler parameters
               characterizing the relative orientation of frames A and B.

               rho1, rho2, rho3 -- names of Rodrigues parameters
               characterizing the relative orientation of frames A and B.

               C11, C12, ..., C33 -- names of direction cosines
               characterizing the relative orientation of frames A and B.

    Output 1:  Expresses q1', q2', and q3' in terms of q1, q2, q3,
               and frame B's angular velocity in frame A.

    Output 2:  Expresses e1', e2', e3', and e4' in terms of e1, e2, e3, e4,
               and frame B's angular velocity in frame A.

    Output 3:  Expresses rho1', rho2', and rho3' in terms of rho1, rho2, rho3,
               and frame B's angular velocity in frame A.

    Output 4:  Expresses C11', ... C33' in terms of C11, ... C33,
               and frame B's angular velocity in frame A.

      Remark:  Frame B's angular velocity in frame A or its equivalent must be
               in the workspace before the KinDiffs command is issued.

      Remark:  Definitions of orientation angles, Euler parameters,
               Rodrigues parameters, and direction cosines are in
               Kane, Likins, Levinson: Spacecraft Dynamics, McGraw-Hill, Ch. 1, and
               Mitiguy, Paul, "Advanced Dynamics & Motion Simulation".

     Related:  Rotate  RotateX  RotateY  RotateZ
               RotateNegativeX  RotateNegativeY  RotateNegativeZ
               SetRotationMatrixX  SetRotationMatrixY  SetRotationMatrixZ
               SetRotationMatrixNegativeX  SetRotationMatrixNegativeY  ...
               SetRotationMatrix  SetAngularVelocity  SetAngularAcceleration
               GetRotationMatrix  GetAngularVelocity  GetAngularAcceleration
               SetRotationMatrixODE  SetEulerParameterODE  SetRodriguesParameterODE
               ANGVEL  KINDIFFS  SetDefaults( AUTOLEV )

       (1) %--------------------------------------------------------------------
       (2) % Example 1: KinDiffs  (Orientation angles)
       (3) %--------------------------------------------------------------------
       (4) RigidFrame  A, B
       (5) Variable    q1', q2', q3'
       (6) Variable    wx,  wy,  wz
       (7) B.SetAngularVelocity( A, wx*Bx> + wy*By> + wz*Bz> )
    -> (8) w_B_A> = wx*Bx> + wy*By> + wz*Bz>

       (9) KinDiffs( A, B, Body123, q1, q2, q3 )
    -> (10) q1' = (wx*cos(q3)-wy*sin(q3))/cos(q2)
    -> (11) q2' = wx*sin(q3) + wy*cos(q3)
    -> (12) q3' = wz - tan(q2)*(wx*cos(q3)-wy*sin(q3))

       (13) %--------------------------------------------------------------------
       (14) % Example 2: KinDiffs  (Euler parameters)
       (15) %--------------------------------------------------------------------
       (16) Variable    e1', e2', e3', e4'
       (17) KinDiffs( A, B, Euler, e1, e2, e3, e4 )
    -> (18) e1' = 0.5*e2*wz + 0.5*e4*wx - 0.5*e3*wy
    -> (19) e2' = 0.5*e3*wx + 0.5*e4*wy - 0.5*e1*wz
    -> (20) e3' = 0.5*e1*wy + 0.5*e4*wz - 0.5*e2*wx
    -> (21) e4' = -0.5*e1*wx - 0.5*e2*wy - 0.5*e3*wz

       (22) %--------------------------------------------------------------------
       (23) % Example 3: KinDiffs  (Rodrigues parameters)
       (24) %--------------------------------------------------------------------
       (25) Variable    r1', r2', r3'
       (26) KinDiffs( A, B, Rodrigues, r1, r2, r3 )
    -> (27) r1' = 0.5*wx*(1+r1^2) + 0.5*wz*(r2+r1*r3) - 0.5*wy*(r3-r1*r2)
    -> (28) r2' = 0.5*wx*(r3+r1*r2) + 0.5*wy*(1+r2^2) - 0.5*wz*(r1-r2*r3)
    -> (29) r3' = 0.5*wy*(r1+r2*r3) + 0.5*wz*(1+r3^2) - 0.5*wx*(r2-r1*r3)

       (30) %--------------------------------------------------------------------
       (31) % Example 4: KinDiffs  (Direction cosines)
       (32) %--------------------------------------------------------------------
       (33) Variable    C{1:3,1:3}'
       (34) KinDiffs( A, B, Poisson, C11,C12,C13, C21,C22,C23, C31,C32,C33 )
    -> (35) C11' = C12*wz - C13*wy
    -> (36) C12' = C13*wx - C11*wz
    -> (37) C13' = C11*wy - C12*wx
    -> (38) C21' = C22*wz - C23*wy
    -> (39) C22' = C23*wx - C21*wz
    -> (40) C23' = C21*wy - C22*wx
    -> (41) C31' = C32*wz - C33*wy
    -> (42) C32' = C33*wx - C31*wz
    -> (43) C33' = C31*wy - C32*wx

#### Simprot

    Simprot    (superseded by SetRotationMatrixX, RotateX, etc)

     Purpose:  Forms rotation matrices associated with a simple rotation
               of one reference frame in another reference frame.

    Syntax 1:  Simprot( A, B, Integer, Angle )
    Syntax 2:  Simprot( A, B, Vec,     Angle )

       Input:  A, B -- names of reference frames (RigidFrame or RigidBody).

               Integer -- 1, 2, 3, -1, -2, or -3.

               Angle -- scalar expression.

               Vec -- vector whose orientation in A and B remains unaltered
               during the simple rotation of B in A.

      Output:  Sets the rotation matrix (direction cosine matrix)
               A_B expressed in terms of sines and cosines of Angle.

      Remark:  Simprot is superseded by SetRotationMatrixX, RotateX, etc.

     Related:  Rotate  RotateX  RotateY  RotateZ
               RotateNegativeX  RotateNegativeY  RotateNegativeZ
               SetRotationMatrixX  SetRotationMatrixY  SetRotationMatrixZ
               SetRotationMatrixNegativeX  SetRotationMatrixNegativeY  ...
               SetRotationMatrix  SetAngularVelocity  SetAngularAcceleration
               GetRotationMatrix  GetAngularVelocity  GetAngularAcceleration
               SetRotationMatrixODE  SetEulerParameterODE  SetRodriguesParameterODE
               ANGVEL  DIRCOS  KINDIFFS  SIMPROT  SetDefaults( AUTOLEV )

       (1) %--------------------------------------------------------------------
       (2) % Example: SIMPROT
       (3) %--------------------------------------------------------------------
       (4) SetDefaults( AUTOLEV )
       (5) RigidFrame  A, B, C
       (6) SIMPROT( A, B, 2, t )
    -> (7) A_B = [cos(t), 0, sin(t); 0, 1, 0; -sin(t), 0, cos(t)]

       (8) SIMPROT( B, C, A1> - B2>, t )
    -> (9) B_C[1,1] = 0.5*cos(t)*(2+cos(t)*(1-cos(t)))
    -> (10) B_C[1,2] = -0.7071068*sin(t)^2 - 0.5*cos(t)*(1-cos(t))
    -> (11) B_C[1,3] = 0.5*sin(t)*(-1.414214+cos(t)*(1-cos(t)))
    -> (12) B_C[2,1] = 0.7071068*sin(t)^2 - 0.5*cos(t)*(1-cos(t))
    -> (13) B_C[2,2] = 0.5 + 0.5*cos(t)
    -> (14) B_C[2,3] = -0.2071068*sin(t)*(2.414214+cos(t))
    -> (15) B_C[3,1] = 0.5*sin(t)*(1.414214+cos(t)*(1-cos(t)))
    -> (16) B_C[3,2] = -0.5*sin(t)*(1-2.414214*cos(t))
    -> (17) B_C[3,3] = cos(t) + 0.5*sin(t)^2*(1-cos(t))

#### V1PT

    V1PT       (Superseded by SetVelocity)
    A1PT       (Superseded by SetAcceleration)

     Purpose:  Calculates and sets the velocity (or acceleration) of a point
               moving on a reference frame.

    Syntax 1:  V1PT( N, B, BQ, Q )
    Syntax 2:  A1PT( N, B, BQ, Q )

       Input:  N -- a reference frame (e.g., a RigidFrame or RigidBody).
               B -- a reference frame (e.g., a RigidFrame or RigidBody).
               BQ -- the point fixed on B that is coincident with Q.
               Q -- a point moving on B that is coincident with BQ.

    Output 1:  Calculate and sets V_Q_N>, Q's velocity in N.
    Output 2:  Calculate and sets A_Q_N>, Q's acceleration in N.

      Remark:  The V1PT calculation uses the following quantities:
               --  B's  angular velocity in N
               --  BQ's velocity in N
               --  Q's  velocity in B
      Remark:  The A1PT calculation uses the following quantities:
               --  B's  angular velocity and angular acceleration in N
               --  BQ's acceleration in N
               --  Q's  velocity and acceleration in B

      Remark:  V1PT(N, B, BQ, Q) is superseded by Q.SetVelocity(N, fromPoint, B, BQ)
               A1PT(N, B, BQ, Q) is now Q.SetAcceleration(N, fromPoint, B, BQ)
               where fromPoint is a point fixed on BFrame.

     Related:  Translate        SetPositionVelocity   SetVelocityAcceleration
               SetPosition      GetPosition   GetDistance
               SetVelocity      GetVelocity   GetSpeed   GetElongation
               SetAcceleration  GetAcceleration
               A1PT  A2PTS  V1PT  V2PTS  SetDefaults( AUTOLEV )

       (1) %--------------------------------------------------------------------
       (2) % Example: V1PT  (velocity of a point Q moving on rigid body B)
       (3) %--------------------------------------------------------------------
       (4) RigidFrame N
       (5) RigidBody  B
       (6) Point      BQ(B)   % BQ is the point of B coincident with Q.
       (7) Point      Q       % Q is moving on B.
       (8) Variable   r''     % Relates to Q's position on B.
       (9) Variable   wz'
       (10) B.SetAngularVelocityAcceleration( N,  wz*Bz>  )
    -> (11) w_B_N> = wz*Bz>
    -> (12) alf_B_N> = wz'*Bz>

       (13) Q.SetVelocityAcceleration( B,  r'*Bx>  )
    -> (14) v_Q_B> = r'*Bx>
    -> (15) a_Q_B> = r''*Bx>

       (16) %--------------------------------
       (17) BQ.SetVelocity( N,  r*wz*By>  )
    -> (18) v_BQ_N> = r*wz*By>

       (19) V1PT( N, B, BQ, Q )
    -> (20) V_Q_N> = r'*Bx> + r*wz*By>

       (21) %--------------------------------------------------------------------
       (22) % Example: A1PT  (acceleration of a point Q moving on rigid body B)
       (23) %--------------------------------------------------------------------
       (24) BQ.SetAcceleration( N, r*wz'*By> - r*wz^2*Bx> )
    -> (25) a_BQ_N> = -r*wz^2*Bx> + r*wz'*By>

       (26) A1PT( N, B, BQ, Q )
    -> (27) A_Q_N> = (r''-r*wz^2)*Bx> + (r*wz'+2*wz*r')*By>

#### V2PTS

    V2PTS      (Superseded by SetVelocity)
    A2PTS      (Superseded by SetAcceleration)
    VA2PTS     (Superseded by SetVelocityAcceleration)

     Purpose:  For two points fixed on a reference frame (RigidBody or RigidFrame)
               calculates and sets the velocity (or acceleration) of one point
               from the velocity (or acceleration) of the other.

    Syntax 1:  V2PTS(  N, B, P, Q )
    Syntax 2:  A2PTS(  N, B, P, Q )
    Syntax 3:  VA2PTS( N, B, P, Q )

       Input:  N -- a reference frame (e.g., a RigidFrame or RigidBody).
               B -- a reference frame (e.g., a RigidFrame or RigidBody).
               P -- a point fixed on B, whose velocity (or acceleration)
                   in N is known.
               Q -- a point fixed on B, whose velocity (or acceleration)
                   in N is to be determined.

    Output 1:  Calculate and sets v_Q_N>, Q's velocity in N.
    Output 2:  Calculate and sets a_Q_N>, Q's acceleration in N.
    Output 3:  Calculate and sets v_Q_N> and a_Q_N>.

      Remark:  The V2PTS and VA2PTS calculation uses the following quantities:
               --  B's angular velocity in N
               --  P's velocity in N
               --  Q's position vector from P
               The A2PTS and VA2PTS calculation uses the following quantities:
               --  B's angular velocity and angular acceleration in N
               --  P's acceleration in N
               --  Q's position vector from P

      Remark:  V2PTS( N, B, P, Q ) is superseded by Q.SetVelocity( N, P, B )
               A2PTS( N, B, P, Q ) is superseded by Q.SetAcceleration( N, P, B )
               VA2PTS(N, B, P, Q ) is now Q.SetVelocityAcceleration( N, P, B )

     Related:  Translate        SetPositionVelocity   SetVelocityAcceleration
               SetPosition      GetPosition   GetDistance
               SetVelocity      GetVelocity   GetSpeed   GetElongation
               SetAcceleration  GetAcceleration
               A1PT  A2PTS  V1PT  V2PTS  SetDefaults( AUTOLEV )

       (1) %--------------------------------------------------------------------
       (2) % Example: V2PTS  (velocity of a point Q fixed on rigid body B)
       (3) %--------------------------------------------------------------------
       (4) RigidFrame N
       (5) RigidBody  B      % Points P and Q are both fixed on B.
       (6) Point      P(B)   % P is a point fixed on B.
       (7) Point      Q(B)   % Q is a point fixed on B.
       (8) Constant   r      % Bx> measure of Q's position from P.
       (9) Variable   wz'
       (10) B.SetAngularVelocityAcceleration( N,  wz*Bz> )
    -> (11) w_B_N> = wz*Bz>
    -> (12) alf_B_N> = wz'*Bz>

       (13) Q.SetPosition( P,  r*Bx> )
    -> (14) p_P_Q> = r*Bx>

       (15) P.SetVelocityAcceleration( N,  2*Nx> + 3*t*Ny> )
    -> (16) v_P_N> = 2*Nx> + 3*t*Ny>
    -> (17) a_P_N> = 3*Ny>

       (18) %----------------------------------
       (19) V2PTS( N, B, P, Q )
    -> (20) v_Q_N> = r*wz*By> + 2*Nx> + 3*t*Ny>

       (21) %--------------------------------------------------------------------
       (22) % Example: A2PTS  (acceleration of a point Q fixed on rigid body B)
       (23) %--------------------------------------------------------------------
       (24) A2PTS( N, B, P, Q )
    -> (25) a_Q_N> = -r*wz^2*Bx> + r*wz'*By> + 3*Ny>

       (26) %--------------------------------------------------------------------
       (27) % Example: VA2PTS  (velocity and acceleration of point Q fixed on B)
       (28) %--------------------------------------------------------------------
       (29) VA2PTS( N, B, P, Q )
    -> (30) v_Q_N> = r*wz*By> + 2*Nx> + 3*t*Ny>
    -> (31) a_Q_N> = -r*wz^2*Bx> + r*wz'*By> + 3*Ny>

### Copyright (c) 2009-2026 Motion Genesis LLC. All rights reserved.