anchor.diff:      /// <param name="value1">The first Quaternion rotation in the series.</param>
       /// <param name="value2">The second Quaternion rotation in the series.</param>
       /// <returns>A new Quaternion representing the concatenation of the value1 rotation followed by the value2 rotation.</returns>
  -    let concat (q:Quaternion) (q':Quaternion) = q' * q //concat rotation is actually q' * q instead of q * q'.
  +    [<System.Obsolete("Semantic Version Opt-Out: this routine has not been finalized yet and may change in breaking ways within minor versions.")>]
  +    let concat (q:Quaternion) (q':Quaternion) =
  +         //concat rotation is q' * q instead of q * q'.
  +        q' * q
  
positive.code:     } with
  
      static member (+) (r: Quaternion, q: Quaternion) =
          {w=r.w+q.w;x=r.x+q.x;y=r.y+q.y;z=r.z+q.z}
  
      static member (-) (r: Quaternion, q: Quaternion) =
          {w=r.w-q.w;x=r.x-q.x;y=r.y-q.y;z=r.z-q.z}
  
      static member (*) (r: Quaternion, q: Quaternion) =
          let w = r.w*q.w - r.x*q.x - r.y*q.y - r.z*q.z
          let x = r.w*q.x + r.x*q.w - r.y*q.z + r.z*q.y
          let y = r.w*q.y + r.x*q.z + r.y*q.w - r.z*q.x
          let z = r.w*q.z - r.x*q.y + r.y*q.x + r.z*q.w
          {w=w;x=x;y=y;z=z}
  
      static member (/) (r: Quaternion, q: Quaternion) =
          let d = (r.w**2.0 + r.x**2.0 + r.y**2.0 + r.z**2.0)
  
          let w = (r.w*q.w + r.x*q.x + r.y*q.y + r.z*q.z) / d
          let x = (r.w*q.x - r.x*q.w - r.y*q.z + r.z*q.y) / d
          let y = (r.w*q.y + r.x*q.z - r.y*q.w - r.z*q.x) / d
          let z = (r.w*q.z - r.x*q.y + r.y*q.x - r.z*q.w) / d
          {w=w;x=x;y=y;z=z}
  
      static member (/) (q:Quaternion, a) =
          {w=q.w/a; x=q.x/a;y=q.y/a;z=q.z/a}
  
  
  [<RequireQualifiedAccess; CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix)>]
  module Quaternion =
  
      //Reference:
  
negative.code:     //https://en.wikipedia.org/wiki/Quaternions_and_spatial_rotation#The_conjugation_operation
  
      let normSquared q =
          q.w*q.w + q.x*q.x + q.y*q.y + q.z*q.z
  
      /// Euclidean Norm
      let norm q =
          normSquared q |> sqrt
  
      /// Normalize a quaternion to unit quaternion with norm 1.
      let normalize q =
          let invNorm = 1.0 / (norm q)
          { w=q.w*invNorm; x=q.x*invNorm; y=q.y*invNorm; z=q.z*invNorm }
  
      let conjugate q =
          { w=q.w; x= -q.x; y= -q.y; z= -q.z }
  
      let inverse q =
          conjugate q / normSquared q
  
      /// Dot product
      let dot q1 q2 =
          q1.w*q2.w + q1.x*q2.x + q1.y*q2.y + q1.z*q2.z
  
      //create a new quaternion
      //angle in radians
  