anchor.diff:          Array.foldBack (fun (a,b,c,d) (accA,accB,accC,accD) -> a::accA, b::accB, c::accC, d::accD) arr ([],[],[],[])
           |> fun (ra,rb,rc,rd) -> Array.ofList ra,Array.ofList rb,Array.ofList rc,Array.ofList rd
       
  -    let private unzip4List li =
  +    let private unzip4 li =
           let length = Seq.length li
           let la = Array.zeroCreate length
           let lb = Array.zeroCreate length
  
positive.code:         let variance = var_ny lambda
          (gcv,variance)
  
      let private spline operator (x:Vector<float>) (y:Vector<float>) (W:Matrix<float>) lambd con=
  
          /// Sets the diagonal to value inplace
          let setDiagonalInplace value (m:Matrix<_>) =
  
negative.code:             let cfinal = cfin.[eminIndex]
              createHermiteResultSimple afinal cfinal gcvfinal efinal lambdafinal ctemp nan
  
      let splineIncreasing (x:Vector<float>) (y:Vector<float>) (W:Matrix<float>) con= 
          spline (~-) x y W con
  
      let splineDecreasing (x:Vector<float>) (y:Vector<float>) (W:Matrix<float>) con= 
          spline (~+) x y W con
          
      
      let getBestFitOfWeighting arr wMat xVal=
          let getinitialestimate = getInitialEstimateOfWXY wMat (vector arr) xVal 
          let initial = getinitialestimate |> fun (a,b,c,d) -> b
          
          let fst1 =(1,splineIncreasing xVal (vector arr) wMat 0 )  |> fun (cl,x) -> (cl, createHermiteResultSimple x.TraceA x.TraceC x.Error (x.GCV*1.04) x.Lambda x.Ctemp x.Variance)
          let fst2 =(-1,splineDecreasing xVal (vector arr) wMat 0)  |> fun (cl,x) -> (cl, createHermiteResultSimple x.TraceA x.TraceC x.Error (x.GCV*1.04) x.Lambda x.Ctemp x.Variance)
          let bestfst = [fst1;fst2] |> List.minBy (fun (cl,x) -> x.Error)                                                                                                    
                                                                                                                                                                              
          let snd1 =(2,splineIncreasing xVal (vector arr) wMat 1; ) |> fun (cl,x) -> (cl, createHermiteResultSimple x.TraceA x.TraceC x.Error (x.GCV*1.06) x.Lambda x.Ctemp x.Variance)
          let snd2 =( 2,splineDecreasing xVal (vector arr) wMat 1;) |> fun (cl,x) -> (cl, createHermiteResultSimple x.TraceA x.TraceC x.Error (x.GCV*1.06) x.Lambda x.Ctemp x.Variance)
          let bestsnd = [snd1;snd2] |> List.minBy (fun (cl,x) -> x.Error)                                                                                                    
                                                                                                                                                                               
          let trd1 =(3,splineIncreasing xVal (vector arr) wMat 2; ) |> fun (cl,x) -> (cl, createHermiteResultSimple x.TraceA x.TraceC x.Error (x.GCV*1.08) x.Lambda x.Ctemp x.Variance)
          let trd2 =(-3,splineDecreasing xVal (vector arr) wMat 2;) |> fun (cl,x) -> (cl, createHermiteResultSimple x.TraceA x.TraceC x.Error (x.GCV*1.08) x.Lambda x.Ctemp x.Variance)
          let besttrd = [trd1;trd2] |> List.minBy (fun (cl,x) -> x.Error)
          
          [bestfst;bestsnd;besttrd]
  