anchor.diff:  
               let rhs = l._rhs - r._rhs
               let count = l._count - r._count
  -
  -            SphereRegression3d(l._reference, lhs, rhs, count)
  +            let sum = l._sum - r._sum
  +
  +            SphereRegression3d(l._reference, lhs, sum, rhs, count)
   
       static member (+) (l : SphereRegression3d, r : V3d) = l.Add r
       static member (+) (l : V3d, r : SphereRegression3d) = r.Add l
  
positive.code:     member x.Remove(pt : V3d) =
          if x._count <= 1 then
              SphereRegression3d.Empty
          else
              let pt = pt - x._reference
              let pt2 = sqr pt
  
              let mutable lhs = x._lhs
              let mutable rhs = x._rhs
              let v = V4d(pt, 1.0)
              lhs.SubOuterProduct v
              rhs <- rhs + v * (pt2.X + pt2.Y + pt2.Z)
              SphereRegression3d(x._reference, lhs, rhs, x._count - 1)
              
      /// Removes the given point from the regression assuming that it has previously been added.
      /// NOTE: when removing non-added points the regression will produce inconsistent results.
      member x.RemoveInPlace(pt : V3d) =
          if x._count <= 1 then
              x._reference <- V3d.Zero
              x._lhs <- SymmetricM44d.Zero
              x._rhs <- V4d.Zero
              x._count <- 0
          else
              let pt = pt - x._reference
              let pt2 = sqr pt
              let v = V4d(pt, 1.0)
              x._lhs.SubOuterProduct v
              x._rhs <- x._rhs + v * (pt2.X + pt2.Y + pt2.Z)
     
      /// Gets the least-squares sphere.
      member x.GetSphere() =
          if x._count < 4 then   
              Sphere3d(V3d.Zero, 0.0)
          else
              let u = x._lhs.Inverse * x._rhs
              let center = -u.XYZ / 2.0
              let r = sqrt (center.LengthSquared - u.W)
              Sphere3d(x._reference + center, r)
  
negative.code:         if x._count < 2 then
              V3d.Zero
          else
              let sum = x._sum
              let off = V3d(x._lhs.M12, x._lhs.M02, x._lhs.M01)
              let n = float x._count
              let avg = sum / n
  