anchor.diff:                  let y = this.Evaluate x;
                   let derivative = this.EvaluateDerivative2 x y
                   (y, derivative)
  -            let signal (Range y, Gradient d) =
  -                Signal (y, Some d)
  -            vector |> Array.map (fun x -> Domain x |> valueAndDerivative |> signal) |> Signals
  +            let hiddenUnit (Range y, Gradient d) =
  +                HiddenUnit (y, d)
  +            vector |> Array.map (fun x -> Domain x |> valueAndDerivative |> hiddenUnit) |> HiddenUnits
   
       let prepend value (Vector vector) = value :: List.ofArray vector |> Array.ofList |> Vector
   
  
positive.code:     let width = Array2D.length2
  
      type [<ReflectedDefinition>] Vector = Vector of float32[] with
          static member (.*) (Vector lhs, Vector rhs) =
              Array.map2 (*) lhs rhs |> Vector
          static member (-) (Vector lhs, Vector rhs) =
              Array.map2 (-) lhs rhs |> Vector
  
  
negative.code: 
      type Errors = Errors of Error[]
  
      type HiddenUnit = HiddenUnit of (float32 * float32) with
          static member (-) (target : float32, HiddenUnit hiddenUnit) = target - fst hiddenUnit
  
      type HiddenUnits = HiddenUnits of HiddenUnit[] with
          static member (-) (Vector target, HiddenUnits hiddenUnits) =
              hiddenUnits |> Array.map (fun (HiddenUnit hiddenUnit) -> fst hiddenUnit) |> Array.map2 (-) target |> Array.map Error |> Errors
  
      type Errors with
          static member (.*) (HiddenUnits lhs, Errors rhs) =
              let derivative (HiddenUnit (x, x')) = x'
              let error (Error e) = e
              Array.map2 (*) (lhs |> Array.map derivative) (rhs |> Array.map error) |> Array.map ErrorSignal |> ErrorSignals
          member this.ToErrorSignals hiddenUnits = hiddenUnits .* this 
  
      type WeightsAndBiases = WeightsAndBiases of Matrix with
          static member (*) (WeightsAndBiases weightsAndBiases, HiddenUnits hiddenUnitsArray) =
              let prependedSignals = 1.0f :: List.ofArray (Array.map (fun (HiddenUnit (x, d)) -> x) hiddenUnitsArray) |> Array.ofList |> Vector
              weightsAndBiases * prependedSignals
  
      type DifferentiableFunction with
  