anchor.diff:      let inline log10Val<'T>              = log10ValFloat32
   
   
  -/// A constraint used to ensure the evaluation stack is only over D, DV or DM
  -type dobj = interface end
  -let bxd (x : dobj) = x
   
   /// Scalar numeric type keeping dual numbers for forward mode and adjoints and tapes for reverse mode AD, 
   /// with nesting capability, using tags to avoid perturbation confusion
  
positive.code:     member internal __.SetDV(uniq:int, v:DV) = dict.[uniq] <- v
      member internal __.GetDM(uniq: int) = dict.[uniq] :?> DM
      member internal __.SetDM(uniq:int, v:DM) = dict.[uniq] <- v
  
      /// Lookup the adjoint for a value
      member this.Item 
  
negative.code:     /// Element-wise addition of `a` and `b`
      static member (+) (a:DV, b:DV) =
          let inline ff(a, b) = Backend.Add_V_V(a, b)
          let inline fd(a, b) = a + b
          let inline df_da(cp, ap, at) = at
          let inline df_db(cp, bp, bt) = bt
          let inline df_dab(cp, ap, at, bp, bt) = at + bt
          let inline r_d_d(a, b) = Add_DV_DV(a, b)
          let inline r_d_c(a, b) = Add_DV_DVCons(a)
          let inline r_c_d(a, b) = Add_DV_DVCons(b)
          DV.Op_DV_DV_DV (a, b, ff, fd, df_da, df_db, df_dab, r_d_d, r_d_c, r_c_d)
  
      /// Element-wise addition of `a` and `b`, potentially destructive of the storage of raw matrices in 'b'
      static member Add_V_V_Inplace (a:DV, b:DV) =
          let inline ff(a:number[], b:number[]) = Backend.Add_V_V_Inplace(a, b); b
          let inline fd(a, b) = a + b
          let inline df_da(cp, ap, at) = at
          let inline df_db(cp, bp, bt) = bt
  