anchor.diff:  
                       let fittingFunction =  getFunctionValue coefficients 
                       //let n =  Array.length xData |> float
  -                    let interpoletedYields = Vector.map(fun x -> fittingFunction x)xData
  +                    let interpoletedYields = Vector.map(fun x -> fittingFunction x)xFit
                       interpoletedYields
   
               module NelsonSigelSevvensson = 
   
  -                let coefficients(xData : array<float>) (yData : array<float>)  = 
  +                let coefficients(xData : array<float>) (yData : array<float>) (initialGuess: float array option)  = 
   
                           if Array.length xData = 0 || Array.length yData = 0 then
                                raise (ArgumentException("Empty Inputs are invalid"))
   
                           if  xData.Length <> yData.Length then 
                                raise(ArgumentException("Inputs have unequal length - Both inputs must have the same length."))
  -                                             
  -                        // 1.1 define parameter names
  +                                         
                           let parameterNamesNSS = [|"b0";"b1";"b2";"b3";"t";"u"|]
  -
  -                        // 1.2 define the function that gets a parameter vector containing the 
  -                        // parameters and the x value and gives the corresponding y value
  +                        
                           let getFunctionValueNSS =                 
                               fun (parameterVector: Vector<float>) m -> 
                                   let b0 = parameterVector.[0]
  
positive.code:                     if  xData.Length <> yData.Length then 
                           raise(ArgumentException("Inputs have unequal length - Both inputs must have the same length."))
  
                      // 1.1 define parameter names
                      let parameterNames = [|"b0";"b1";"b2";"t"|]
                      //function defining the model
                      let getFunctionValue =                 
                                  fun (parameterVector: Vector<float>) m -> 
  
negative.code:                             gradientVector
  
                      let model = createModel parameterNames getFunctionValue getGradientValues
                     
                      // the stepwidth of the x value change
                      let deltaX = 0.0001
                      // the stepwidth of the parameter change
                      let deltaP = 0.0001
                      //number of iterations
                      let k = 5000
  
                      // The initial guess
                      let initialParamGuess = 
                          match initialGuess with 
                          |Some initialGuess ->  initialGuess
                          |None -> [|0.01;0.01;0.01;1.0|]
                     
                      let solverOptions = 
                          createSolverOption deltaX deltaP k initialParamGuess
                      
                      //get the coefficients
                      let coefficientsExp = LevenbergMarquardt.estimatedParams model solverOptions 0.001 10. xData yData
                      coefficientsExp
  
                  let fit (coefficients : Vector<float>) (xFit:Vector<float>) = 
                      
                      let getFunctionValue =                 
                                  fun (parameterVector: Vector<float>) m -> 
                                  let b0 = parameterVector.[0]
  