anchor.diff:                                  let t  = parameterVector.[3]
                                   b0+b1*((1.-exp(-m/t))/(m/t)) + b2*((1.-exp(-m/t))/(m/t)-exp(-m/t))
   
  -                    // 1.3 Define partial derivatives of the function. 
  -                    //     Take partial derivatives for every unknown parameter and
  -                    //     insert it into the gradient vector sorted by parameterNames.
  -
  +                    // Define partial derivatives of the function.          
                       let getGradientValues =
                           fun (parameterVector:Vector<float>) (gradientVector: Vector<float>) m -> 
                               let b0 = parameterVector.[0]
  
positive.code:                             gradientVector
  
                      let model = createModel parameterNames getFunctionValue getGradientValues
  
                      // 2. define the solver options
                      // 2.1 define the stepwidth of the x value change
                      let deltaX = 0.0001
                      // 2.2 define the stepwidth of the parameter change
                      let deltaP = 0.0001
                      // 2.3 define the number of iterations
                      let k = 5000
  
                      // 2.4 define an initial guess
                      //     For many problems you can set a default value or let the user decide to choose an 
                      //     appropriate guess. 
                      let initialParamGuess =  [|0.01;0.01;0.01;1.0|]
  
                      // 2.5 create the solverOptions
                      let solverOptions = 
                          createSolverOption deltaX deltaP k initialParamGuess
                      
                      // 3. get coefficients
                      let coefficientsExp = LevenbergMarquardt.estimatedParams model solverOptions 0.001 10. xData yData
                      coefficientsExp
  
                  let fit (coefficients : Vector<float>) (xData:Vector<float>) = 
                      // the model
                      let getFunctionValue =                 
                                  fun (parameterVector: Vector<float>) m -> 
                                  let b0 = parameterVector.[0]
  
negative.code:                                 gradientVector.[4] <- (exp(-m/t)*((b2+b1)*t**2.*exp(m/t)+(-b2-b1)*t**2.+(-b2-b1)*m*t-b2*m**2.))/(m*t**2.)
                                  gradientVector.[5] <- b3*(-exp(-m/u)/u-(m*exp(-m/u))/u**2.+(1.-exp(-m/u))/m)
                                  gradientVector
                     
                          let modelNSS = createModel parameterNamesNSS getFunctionValueNSS getGradientValuesNSS
                          
                          let deltaXNSS = 0.0001                       
                          let deltaPNSS = 0.0001                        
                          let kNSS = 5000
                         
                          //For many problems you can set a default value or let the user decide to choose an                       
                          let initialParamGuessNSS =                                                
                              match initialGuess with 
                              |Some initialGuess ->  initialGuess
                              |None -> [|0.01;0.01;0.01;0.01;1.0;1.0|]
       
                          let solverOptionsNSS = createSolverOption deltaXNSS deltaPNSS kNSS initialParamGuessNSS
                          let coefficientsNSS = LevenbergMarquardt.estimatedParams modelNSS solverOptionsNSS 0.001 10. xData yData
                          coefficientsNSS
  
  