Growth curve

Binder

Summary: this tutorial demonstrates variou way to model growth curves, a commong task in any (micro)biological lab

Table of contents

Modelling

Growth and other physiological parameters like size/weight/length can be modeled as function of time. Several growth curve models have been proposed. Some of them are covered in this documentation.

For growth curve analysis the cell count data must be considered in log space. The exponential phase (log phase) then becomes linear. After modeling, all growth parameters (maximal cell count, lag phase duration, and growth rate) can be derived from the model, so there is no need for manual labelling of separate growth phases.


Data model


If specific parameters should be constrained to the users choice (like upper or lower asymptote), a constrained version of the Levenberg-Marquardt solver can be used (LevenbergMarquardtConstrained)! Accordingly, minimal and maximal parameter vectors must be provided.

open System
open FSharp.Stats
open FSharp.Stats.Fitting.NonLinearRegression

let time = [|0. .. 0.5 .. 8.|]

let cellCount =
    [|
    17000000.;16500000.;11000000.;14000000.;27000000.;40000000.;120000000.;
    300000000.;450000000.;1200000000.;2700000000.;5000000000.;
    8000000000.;11700000000.;12000000000.;13000000000.;12800000000.
    |]

let cellCountLn = cellCount |> Array.map log

open Plotly.NET

//some axis styling
let myAxis title = Axis.LinearAxis.init(Title=title,Mirror=StyleParam.Mirror.All,Ticks=StyleParam.TickOptions.Inside,Showgrid=false,Showline=true,Zeroline=false)
let styleChart x y chart = chart |> Chart.withX_Axis (myAxis x) |> Chart.withY_Axis (myAxis y)

let chartOrig = 
    Chart.Point(time,cellCount)
    |> Chart.withTraceName "original data"
    |> styleChart "" "cells/ml"

let chartLog =
    Chart.Point(time,cellCountLn)
    |> Chart.withTraceName "log count"
    |> styleChart "time (h)" "ln(cells/ml)"
    
let growthChart = 
    [chartOrig;chartLog]|> Chart.Stack 1

Manual phase selection

If growth phases are labelled manually, the exponential phase can be fitted with a regression line.

To determine the generation time, it is necessary to find the time interval it takes to double the count data. When a log2 transform is used, a doubling of the original counts is achieved, when the log value moves 1 unit. Keeping that in mind, the slope can be used to calculate the time it takes for the log2 data to increase 1 unit.

  • slope * generation time = 1
  • generation time = 1/slope

If a different log transform was used, the correction factor for the numerator is logx(2).

// The exponential phase was defined to be between time point 1.5 and 5.5.
let logPhaseX = vector time.[3..11]
let logPhaseY = vector cellCountLn.[3..11]
// regression coefficients as [intercept;slope]
let regressionCoeffs =
    Fitting.LinearRegression.OrdinaryLeastSquares.Linear.Univariable.coefficient logPhaseX logPhaseY

Here is a pre-evaluated version (to save time during the build process, as the solver takes quite some time.)

// The generation time is calculated by dividing log_x 2. by the regression line slope. 
// The log transform must match the used data transform. 
let slope = regressionCoeffs.[1]
let generationTime = log(2.) / slope


let fittedValues = 
    let f = Fitting.LinearRegression.OrdinaryLeastSquares.Linear.Univariable.fit (vector [|14.03859475; 1.515073487|])
    logPhaseX |> Seq.map (fun x -> x,f x)

let chartLinearRegression =
    [
    Chart.Point(time,cellCountLn)    |> Chart.withTraceName "log counts"
    Chart.Line(fittedValues)            |> Chart.withTraceName "fit"
    ]
    |> Chart.Combine
    |> styleChart "time (h)" "ln(cells/ml)"

let generationTimeManual = sprintf "The generation time (manual selection) is: %.1f min" ((log(2.)/1.5150)* 60.)
No value returned by any evaluator
No value returned by any evaluator

Gompertz model

In the following example the four parameter gompertz function is applied to cell count data (Gibson et al., 1988).

The Gompertz model is fitted using the Levenberg Marquardt solver. Initial parameters are estimated from the original data. The expected generation time has to be approximated as initial guess.

For parameter interpretation the applied log transform is important and must be provided. If other parameters than cell count (e.g. size or length) should be analyzed, use id as value transform.

Gompertz parameters:

  • A: lower asymptote
  • B: relative growth rate (approximated by generation time consideration)
  • C: upper asymptote - lower asymptote
  • M: time point of inflection (maximal growth rate)
// The Levenberg Marquardt algorithm identifies the parameters that leads to the best fit 
// of the gompertz models to the count data. The solver must be provided with initial parameters
// that are estimated in the following:
let solverOptions (xData :float []) (yDataLog :float []) expectedGenerationTime (usedLogTransform: float -> float) =
    // lower asymptote
    let a = Seq.min yDataLog
    // upper asymptote - lower asymptote (y range)
    let c = (Seq.max yDataLog) - a
    // relative growth rate
    let b = usedLogTransform 2. * Math.E / (expectedGenerationTime * c)
    // time point of inflection (in gompertz model at f(x)=36% of the y range)
    let m = 
        let yAtInflection = a + c * 0.36
        Seq.zip xData yDataLog
        |> Seq.minBy (fun (xValue,yValue) ->
            Math.Abs (yValue - yAtInflection)
        )
        |> fst
    createSolverOption 0.001 0.001 10000 [|a;b;c;m|]

// By solving the nonlinear fitting problem, the optimal model parameters are determined
let gompertzParams =
    LevenbergMarquardt.estimatedParams
        Table.GrowthModels.gompertz
        (solverOptions time cellCountLn 1. log)
        0.1
        10.
        time
        cellCountLn

let fittingFunction = 
    Table.GrowthModels.gompertz.GetFunctionValue gompertzParams

    
let fittedValuesGompertz =
    /// The parameter were determined locally for saving time during build processes
    //let f = Table.GrowthModels.gompertz.GetFunctionValue (vector [|16.46850199; 0.7014917539; 7.274139441; 3.3947717|])
    [time.[0] .. 0.1 .. Seq.last time]
    |> Seq.map (fun x -> 
        x,fittingFunction x
        ) 
    |> Chart.Line
    |> Chart.withTraceName "gompertz"

let fittedChartGompertz = 
    [
        Chart.Point(time,cellCountLn)
        |> Chart.withTraceName "log count"
        fittedValuesGompertz
    ]
    |> Chart.Combine
    |> styleChart "time (h)" "ln(cells/ml)"

Generation time calculation

The generation time can be calculated by dividing log(2) by the slope of the inflection point. The used log transform must match the used log transform applied to the count data.

The four parameter Gompertz model allows the determination of generation times from its parameters (Gibson et al., 1988).

let generationtime (parametervector:vector) (logTransform:float -> float) =
    logTransform 2. * Math.E / (parametervector.[1] * parametervector.[2])

let lag (parametervector:vector) =
    (parametervector.[3] - 1.) / parametervector.[1]

let g = sprintf "The generation time (Gompertz) is: %.1f min" (60. * (generationtime gompertzParams log))
let l = sprintf "The lag phase duration is %.2f h" (lag gompertzParams)
"The generation time (Gompertz) is: 22.2 min"
"The lag phase duration is 3.41 h"

Other models

In the following other growth models are applied to the given data set:

  • Richards
  • Weibull
  • Janoschek
  • Exponential
  • Verhulst
  • Morgan-Mercer-Flodin
  • von Bertalanffy

To determine the generation time, the slope at the inflection point must be calculated. As explained above, the generation time can be calculated by: logx(2)/(slope at inflection) where x is the used log transform.

Choose a appropriate growth model according to your needs.

For an overview please scroll down to see a combined diagram of all growth models.

Richards curve

Parameters:

  • l: upper asymptote
  • k: growth rate
  • y: inflection point (x value)
  • d: influences the inflection point on the y axis
let richardsParams =
    LevenbergMarquardt.estimatedParams
        Table.GrowthModels.richards
        (createSolverOption 0.001 0.001 10000 [|23.;1.;3.4;2.|])
        0.1
        10.
        time
        cellCountLn

let fittingFunctionRichards = 
    Table.GrowthModels.richards.GetFunctionValue richardsParams

Here is a pre-evaluated version (to save time during the build process, as the solver takes quite some time.)

let generationtimeRichards (richardParameters:vector) =
    let l = richardParameters.[0]
    let k = richardParameters.[1]
    let y = richardParameters.[2] //x value of inflection point
    let d = richardParameters.[3]
    let gradientFunctionRichards t =
        (k*l*((d-1.)*Math.Exp(-k*(t-y))+1.)**(1./(1.-d)))/(Math.Exp(k*(t-y))+d-1.)
    let maximalSlope =
        gradientFunctionRichards y
    log(2.) / maximalSlope

let fittedValuesRichards =
    /// The parameter were determined locally for saving time during build processes
    let f =  Table.GrowthModels.richards.GetFunctionValue (vector [|23.25211263; 7.053516315; 5.646889803; 111.0132522|])
    [time.[0] .. 0.1 .. Seq.last time]
    |> Seq.map (fun x -> 
        x,f x
        ) 
    |> Chart.Line

let fittedChartRichards = 
    fittedValuesRichards
    |> styleChart "time (h)" "ln(cells/ml)"
    |> Chart.withTraceName "richards"

let fittedChartRichardsS = 
    [
        Chart.Point(time,cellCountLn)
        |> Chart.withTraceName "log count"
        fittedValuesRichards
    ]
    |> Chart.Combine
    |> styleChart "time (h)" "ln(cells/ml)"
    |> Chart.withTitle "richards"

let generationRichards = sprintf "The generation time (Richards) is: %.1f min" (generationtimeRichards (vector [|23.25211263; 7.053516315; 5.646889803; 111.0132522|]) * 60.)
"The generation time (Richards) is: 29.4 min"

Weibull

Parameters:

  • b: lower asymptote
  • l: upper asymptote
  • k: growth rate
  • d: influences the inflection point position
let weibullParams =
    LevenbergMarquardt.estimatedParams
        Table.GrowthModels.weibull
        (createSolverOption 0.001 0.001 10000 [|15.;25.;1.;5.|])
        0.1
        10.
        time
        cellCountLn

let fittingFunctionWeibull = 
    Table.GrowthModels.weibull.GetFunctionValue weibullParams

Here is a pre-evaluated version (to save time during the build process, as the solver takes quite some time.)

let generationtimeWeibull (weibullParameters:vector) =
    let b = weibullParameters.[0]
    let l = weibullParameters.[1]
    let k = weibullParameters.[2]
    let d = weibullParameters.[3]
    let gradientFunctionWeibull t =
        (d*(l-b)*(k*t)**d*Math.Exp(-((k*t)**d)))/t
    let inflectionPointXValue =
        (1./k)*((d-1.)/d)**(1./d)
    let maximalSlope =
        gradientFunctionWeibull inflectionPointXValue
    log(2.) / maximalSlope

let fittedValuesWeibull =
    /// The parameter were determined locally for saving time during build processes
    let f =  Table.GrowthModels.weibull.GetFunctionValue (vector [|16.40632433; 23.35537293; 0.2277752116; 2.900806071|])
    [time.[0] .. 0.1 .. Seq.last time]
    |> Seq.map (fun x -> 
        x,f x
        ) 
    |> Chart.Line

let fittedChartWeibull = 
    fittedValuesWeibull
    |> styleChart "time (h)" "ln(cells/ml)"
    |> Chart.withTraceName "weibull"

let fittedChartWeibullS = 
    [
        Chart.Point(time,cellCountLn)
        |> Chart.withTraceName "log count"
        fittedValuesWeibull
    ]
    |> Chart.Combine
    |> styleChart "time (h)" "ln(cells/ml)"
    |> Chart.withTitle "weibull"

let generationWeibull = 
    sprintf "The generation time (Weibull) is: %.1f min" (generationtimeWeibull (vector [|16.40632433; 23.35537293; 0.2277752116; 2.900806071|]) * 60.)   
"The generation time (Weibull) is: 23.0 min"

Janoschek

Parameters:

  • b: lower asymptote
  • l: upper asymptote
  • k: growth rate
  • d: influences the inflection point position on the x axis
let janoschekParams =
    LevenbergMarquardt.estimatedParams
        Table.GrowthModels.janoschek
        (createSolverOption 0.001 0.001 10000 [|15.;25.;1.;5.|])
        0.1
        10.
        time
        cellCountLn

let fittingFunctionJanoschek = 
    Table.GrowthModels.janoschek.GetFunctionValue janoschekParams

Here is a pre-evaluated version (to save time during the build process, as the solver takes quite some time.)

let generationtimeJanoschek (janoschekParameters:vector) =
    let b = janoschekParameters.[0]
    let l = janoschekParameters.[1]
    let k = janoschekParameters.[2]
    let d = janoschekParameters.[3]
    let gradientFunctionJanoschek t =
        d*k*(l-b)*t**(d-1.)*Math.Exp(-k*t**d)
    //Chart to estimate point of maximal slope (inflection point)
    let slopeChart() =
        [time.[0] .. 0.1 .. 8.] |> List.map (fun x -> x, gradientFunctionJanoschek x) |> Chart.Line
    let inflectionPointXValue =
        3.795
    let maximalSlope =
        gradientFunctionJanoschek inflectionPointXValue
    log(2.) / maximalSlope
    
let fittedValuesJanoschek =
    /// The parameter were determined locally for saving time during build processes
    let f =  Table.GrowthModels.janoschek.GetFunctionValue (vector [|16.40633962; 23.35535182; 0.01368422994; 2.900857027|])
    [time.[0] .. 0.1 .. Seq.last time]
    |> Seq.map (fun x -> 
        x,f x
        ) 
    |> Chart.Line

let fittedChartJanoschek = 
    fittedValuesJanoschek
    |> styleChart "time (h)" "ln(cells/ml)"
    |> Chart.withTraceName "janoschek"

let fittedChartJanoschekS = 
    [
        Chart.Point(time,cellCountLn)
        |> Chart.withTraceName "log count"
        fittedChartJanoschek
    ]
    |> Chart.Combine
    |> styleChart "time (h)" "ln(cells/ml)"
    |> Chart.withTitle "janoschek"

let generationJanoschek = 
    sprintf "The generation time (Janoschek) is: %.1f min" (generationtimeJanoschek (vector [|16.40633962; 23.35535182; 0.01368422994; 2.900857027|]) * 60.)
"The generation time (Janoschek) is: 23.0 min"

Exponential

The exponential model of course can not be applied to the lag phase.

Parameters:

  • b: lower asymptote
  • l: upper asymptote
  • k: growth rate
let exponentialParams =
    LevenbergMarquardt.estimatedParams
        Table.GrowthModels.exponential
        (createSolverOption 0.001 0.001 10000 [|15.;25.;0.5|])
        0.1
        10.
        time.[6..]
        cellCountLn.[6..]

let fittingFunctionExponential = 
    Table.GrowthModels.exponential.GetFunctionValue exponentialParams

Here is a pre-evaluated version (to save time during the build process, as the solver takes quite some time.)

let generationtimeExponential (expParameters:vector) =
    let b = expParameters.[0]
    let l = expParameters.[1]
    let k = expParameters.[2]
    let gradientFunctionExponential t =
        k*(l-b)*Math.Exp(-k*t)
    let maximalSlope =
        gradientFunctionExponential time.[6]
    log(2.) / maximalSlope

let fittedValuesExp =
    /// The parameter were determined locally for saving time during build processes
    let f =  Table.GrowthModels.exponential.GetFunctionValue (vector [|4.813988967; 24.39950361; 0.3939132175|])
    [3.0 .. 0.1 .. Seq.last time]
    |> Seq.map (fun x -> 
        x,f x
        ) 
    |> Chart.Line

let fittedChartExp = 
    fittedValuesExp
    |> styleChart "time (h)" "ln(cells/ml)"
    |> Chart.withTraceName "exponential"

let fittedChartExpS = 
    [
        Chart.Point(time,cellCountLn)
        |> Chart.withTraceName "log count"
        fittedChartExp
    ]
    |> Chart.Combine
    |> styleChart "time (h)" "ln(cells/ml)"
    |> Chart.withTitle "exponential"

let generationExponential = 
    sprintf "The generation time (Exp) is: %.1f min" (generationtimeExponential (vector [|4.813988967; 24.39950361; 0.3939132175|]) * 60.)
    
"The generation time (Exp) is: 17.6 min"

Verhulst

The verhulst growth model is a logistic function with a lower asymptote fixed at y=0. A 4 parameter version allows the lower asymptote to vary from 0.

Note: symmetric with inflection point at 50 % of y axis range

Parameters:

  • l: upper asymptote
  • k: x value at inflection point
  • d: steepness
  • b: lower asymptote

To apply the 3 parameter verhulst model with a fixed lower asymptote = 0 use the 'verhulst' model instead of 'verhulst4Param'.

let verhulstParams =
    LevenbergMarquardt.estimatedParams
        Table.GrowthModels.verhulst4Param
        (createSolverOption 0.001 0.001 10000 [|25.;3.5;1.;15.|])
        0.1
        10.
        time
        cellCountLn

let fittingFunctionVerhulst() = 
    Table.GrowthModels.verhulst.GetFunctionValue verhulstParams

Here is a pre-evaluated version (to save time during the build process, as the solver takes quite some time.)

let generationtimeVerhulst (verhulstParameters:vector) =
    let lmax = verhulstParameters.[0]
    let k    = verhulstParameters.[1]
    let d    = verhulstParameters.[2]
    let lmin = verhulstParameters.[3]
    let gradientFunctionVerhulst t =
        ((lmax-lmin)*Math.Exp((k-t)/d))/(d*(Math.Exp((k-t)/d)+1.)**2.)
    let maximalSlope =
        gradientFunctionVerhulst k
    log(2.) / maximalSlope

let fittedValuesVerhulst =
    /// The parameter were determined locally for saving time during build processes
    let f =  Table.GrowthModels.verhulst4Param.GetFunctionValue (vector [|23.39504328; 3.577488116; 1.072136278; 15.77380824|])
    [time.[0] .. 0.1 .. Seq.last time]
    |> Seq.map (fun x -> 
        x,f x
        ) 
    |> Chart.Line

let fittedChartVerhulst = 
    fittedValuesVerhulst
    |> styleChart "time (h)" "ln(cells/ml)"
    |> Chart.withTraceName "verhulst"

let fittedChartVerhulstS = 
    [
        Chart.Point(time,cellCountLn)
        |> Chart.withTraceName "log count"
        fittedChartVerhulst
    ]
    |> Chart.Combine
    |> styleChart "time (h)" "ln(cells/ml)"
    |> Chart.withTitle "verhulst"

let generationVerhulst = 
    sprintf "The generation time (Verhulst) is: %.1f min" (generationtimeVerhulst (vector [|23.39504328; 3.577488116; 1.072136278; 15.77380824|]) * 60.)
"The generation time (Verhulst) is: 23.4 min"

Morgan-Mercer-Flodin

Parameters:

  • b: count at t0
  • l: upper asymptote
  • k: growth rate
  • d: influences the inflection point position
let morganMercerFlodinParams =
    LevenbergMarquardt.estimatedParams
        Table.GrowthModels.morganMercerFlodin
        (createSolverOption 0.001 0.001 10000 [|15.;25.;0.2;3.|])
        0.1
        10.
        time
        cellCountLn

let fittingFunctionMMF() = 
    Table.GrowthModels.morganMercerFlodin.GetFunctionValue morganMercerFlodinParams

Here is a pre-evaluated version (to save time during the build process, as the solver takes quite some time.)

let generationtimeMmf (mmfParameters:vector) =
    let b = mmfParameters.[0]
    let l = mmfParameters.[1]
    let k = mmfParameters.[2]
    let d = mmfParameters.[3]
    let gradientFunctionMmf t =
        (d*(l-b)*(k*t)**d)/(t*((k*t)**d+1.)**2.)
    //Chart to estimate point of maximal slope (inflection point)
    let slopeChart() =
        [time.[0] .. 0.1 .. 8.] |> List.map (fun x -> x, gradientFunctionMmf x) |> Chart.Line
    let inflectionPointXValue =
        3.45
    let maximalSlope =
        gradientFunctionMmf inflectionPointXValue
    log(2.) / maximalSlope

let generationMmf = 
    sprintf "The generation time (MMF) is: %.1f min" (generationtimeMmf (vector [|16.46099291; 24.00147463; 0.2500698772; 3.741048641|]) * 60.)

let fittedValuesMMF =
    /// The parameter were determined locally for saving time during build processes
    let f =  Table.GrowthModels.morganMercerFlodin.GetFunctionValue (vector [|16.46099291; 24.00147463; 0.2500698772; 3.741048641|])
    [time.[0] .. 0.1 .. Seq.last time]
    |> Seq.map (fun x -> 
        x,f x
        ) 
    |> Chart.Line

let fittedChartMMF = 
    [
        Chart.Point(time,cellCountLn)
        |> Chart.withTraceName "log count"
        fittedValuesMMF |> Chart.withTraceName "morganMercerFlodin"
    ]
    |> Chart.Combine
    |> styleChart "time (h)" "ln(cells/ml)"
    |> Chart.withTitle "morganMercerFlodin"
"The generation time (MMF) is: 21.9 min"

von Bertalanffy

Since this model expects a x axis crossing of the data it cannot be applied to the given data.

Parameters:

  • l: upper asymptote
  • k: growth rate
  • t0: x axis crossing

Comparison between all models

Fit function

let combinedChart =
    [
        
        Chart.Point(time,cellCountLn) |> Chart.withTraceName "log count"
        Chart.Line(fittedValues)|> Chart.withTraceName "regression line"
        fittedValuesGompertz    |> Chart.withTraceName "Gompertz"
        fittedValuesRichards    |> Chart.withTraceName "Richards"
        fittedValuesWeibull     |> Chart.withTraceName "Weibull"
        fittedValuesJanoschek   |> Chart.withTraceName "Janoschek"
        fittedValuesExp         |> Chart.withTraceName "Exponential"
        fittedValuesVerhulst    |> Chart.withTraceName "Verhulst"
        fittedValuesMMF         |> Chart.withTraceName "MorganMercerFlodin"
    ]
    |> Chart.Combine
    |> styleChart "time (h)" "ln(cells/ml)"
No value returned by any evaluator

Generation time

let generationTimeTable =
    let header = ["<b>Model</b>";"<b>Generation time (min)"]
    let rows = 
        [
            ["manual selection (regression line)";      sprintf "%.1f" ((log(2.)/1.5150)* 60.)]    
            ["Gompertz";    sprintf "%.1f" (60. * (generationtime gompertzParams log))]    
            ["Richards";    sprintf "%.1f" (generationtimeRichards (vector [|23.25211263; 7.053516315; 5.646889803; 111.0132522|]) * 60.)]       
            ["Weibull";     sprintf "%.1f" (generationtimeWeibull (vector [|16.40632433; 23.35537293; 0.2277752116; 2.900806071|]) * 60.)  ]       
            ["Janoschek";   sprintf "%.1f" (generationtimeJanoschek (vector [|16.40633962; 23.35535182; 0.01368422994; 2.900857027|]) * 60.)]    
            ["Exponential"; sprintf "%.1f" (generationtimeExponential (vector [|4.813988967; 24.39950361; 0.3939132175|]) * 60.)]
            ["Verhulst";    sprintf "%.1f" (generationtimeVerhulst (vector [|23.39504328; 3.577488116; 1.072136278; 15.77380824|]) * 60.)] 
            ["MMF";         sprintf "%.1f" (generationtimeMmf (vector [|16.46099291; 24.00147463; 0.2500698772; 3.741048641|]) * 60.)] 
        ]
    
    Chart.Table(
        header, 
        rows,
        ColorHeader = "#45546a",
        ColorCells = ["#deebf7";"lightgrey"],
        FontHeader = Font.init(Color="white")
        )

Model examples

namespace System
Multiple items
namespace FSharp

--------------------
namespace Microsoft.FSharp
namespace FSharp.Stats
namespace FSharp.Stats.Fitting
module NonLinearRegression

from FSharp.Stats.Fitting
val time : float []
val cellCount : float []
val cellCountLn : float []
type Array =
  member Clone : unit -> obj
  member CopyTo : array:Array * index:int -> unit + 1 overload
  member GetEnumerator : unit -> IEnumerator
  member GetLength : dimension:int -> int
  member GetLongLength : dimension:int -> int64
  member GetLowerBound : dimension:int -> int
  member GetUpperBound : dimension:int -> int
  member GetValue : index:int -> obj + 7 overloads
  member Initialize : unit -> unit
  member IsFixedSize : bool
  ...
val map : mapping:('T -> 'U) -> array:'T [] -> 'U []
val log : value:'T -> 'T (requires member Log)
namespace Plotly
namespace Plotly.NET
val myAxis : title:string -> Axis.LinearAxis
val title : string
module Axis

from Plotly.NET
Multiple items
type LinearAxis =
  inherit DynamicObj
  new : unit -> LinearAxis
  static member init : ?AxisType:AxisType * ?Title:string * ?Titlefont:Font * ?Autorange:AutoRange * ?Rangemode:RangeMode * ?Range:Range * ?RangeSlider:RangeSlider * ?Fixedrange:'a * ?Tickmode:TickMode * ?nTicks:'b * ?Tick0:'c * ?dTick:'d * ?Tickvals:'e * ?Ticktext:'f * ?Ticks:TickOptions * ?Mirror:Mirror * ?Ticklen:'g * ?Tickwidth:'h * ?Tickcolor:'i * ?Showticklabels:'j * ?Tickfont:Font * ?Tickangle:'k * ?Tickprefix:'l * ?Showtickprefix:ShowTickOption * ?Ticksuffix:'m * ?Showticksuffix:ShowTickOption * ?Showexponent:ShowExponent * ?Exponentformat:ExponentFormat * ?Tickformat:'n * ?Hoverformat:'o * ?Showline:bool * ?Linecolor:'p * ?Linewidth:'q * ?Showgrid:bool * ?Gridcolor:'r * ?Gridwidth:'s * ?Zeroline:bool * ?Zerolinecolor:'t * ?Zerolinewidth:'a1 * ?Anchor:AxisAnchorId * ?Side:Side * ?Overlaying:AxisAnchorId * ?Domain:Range * ?Position:float * ?IsSubplotObj:'a2 * ?Tickvalssrc:'a3 * ?Ticktextsrc:'a4 * ?Showspikes:'a5 * ?Spikesides:'a6 * ?Spikethickness:'a7 * ?Spikecolor:'a8 * ?Showbackground:'a9 * ?Backgroundcolor:'a10 * ?Showaxeslabels:'a11 -> LinearAxis
  static member style : ?AxisType:AxisType * ?Title:string * ?Titlefont:Font * ?Autorange:AutoRange * ?Rangemode:RangeMode * ?Range:Range * ?RangeSlider:RangeSlider * ?Fixedrange:'a * ?Tickmode:TickMode * ?nTicks:'b * ?Tick0:'c * ?dTick:'d * ?Tickvals:'e * ?Ticktext:'f * ?Ticks:TickOptions * ?Mirror:Mirror * ?Ticklen:'g * ?Tickwidth:'h * ?Tickcolor:'i * ?Showticklabels:'j * ?Tickfont:Font * ?Tickangle:'k * ?Tickprefix:'l * ?Showtickprefix:ShowTickOption * ?Ticksuffix:'m * ?Showticksuffix:ShowTickOption * ?Showexponent:ShowExponent * ?Exponentformat:ExponentFormat * ?Tickformat:'n * ?Hoverformat:'o * ?Showline:bool * ?Linecolor:'p * ?Linewidth:'q * ?Showgrid:bool * ?Gridcolor:'r * ?Gridwidth:'s * ?Zeroline:bool * ?Zerolinecolor:'t * ?Zerolinewidth:'a1 * ?Anchor:AxisAnchorId * ?Side:Side * ?Overlaying:AxisAnchorId * ?Domain:Range * ?Position:float * ?IsSubplotObj:'a2 * ?Tickvalssrc:'a3 * ?Ticktextsrc:'a4 * ?Showspikes:'a5 * ?Spikesides:'a6 * ?Spikethickness:'a7 * ?Spikecolor:'a8 * ?Showbackground:'a9 * ?Backgroundcolor:'a10 * ?Showaxeslabels:'a11 -> (LinearAxis -> LinearAxis)

--------------------
new : unit -> Axis.LinearAxis
static member Axis.LinearAxis.init : ?AxisType:StyleParam.AxisType * ?Title:string * ?Titlefont:Font * ?Autorange:StyleParam.AutoRange * ?Rangemode:StyleParam.RangeMode * ?Range:StyleParam.Range * ?RangeSlider:RangeSlider * ?Fixedrange:'a * ?Tickmode:StyleParam.TickMode * ?nTicks:'b * ?Tick0:'c * ?dTick:'d * ?Tickvals:'e * ?Ticktext:'f * ?Ticks:StyleParam.TickOptions * ?Mirror:StyleParam.Mirror * ?Ticklen:'g * ?Tickwidth:'h * ?Tickcolor:'i * ?Showticklabels:'j * ?Tickfont:Font * ?Tickangle:'k * ?Tickprefix:'l * ?Showtickprefix:StyleParam.ShowTickOption * ?Ticksuffix:'m * ?Showticksuffix:StyleParam.ShowTickOption * ?Showexponent:StyleParam.ShowExponent * ?Exponentformat:StyleParam.ExponentFormat * ?Tickformat:'n * ?Hoverformat:'o * ?Showline:bool * ?Linecolor:'p * ?Linewidth:'q * ?Showgrid:bool * ?Gridcolor:'r * ?Gridwidth:'s * ?Zeroline:bool * ?Zerolinecolor:'t * ?Zerolinewidth:'a1 * ?Anchor:StyleParam.AxisAnchorId * ?Side:StyleParam.Side * ?Overlaying:StyleParam.AxisAnchorId * ?Domain:StyleParam.Range * ?Position:float * ?IsSubplotObj:'a2 * ?Tickvalssrc:'a3 * ?Ticktextsrc:'a4 * ?Showspikes:'a5 * ?Spikesides:'a6 * ?Spikethickness:'a7 * ?Spikecolor:'a8 * ?Showbackground:'a9 * ?Backgroundcolor:'a10 * ?Showaxeslabels:'a11 -> Axis.LinearAxis
module StyleParam

from Plotly.NET
type Mirror =
  | True
  | Ticks
  | False
  | All
  | AllTicks
    static member convert : (Mirror -> obj)
    static member toString : (Mirror -> string)
union case StyleParam.Mirror.All: StyleParam.Mirror
type TickOptions =
  | Outside
  | Inside
  | Empty
    static member convert : (TickOptions -> obj)
    static member toString : (TickOptions -> string)
union case StyleParam.TickOptions.Inside: StyleParam.TickOptions
val styleChart : x:string -> y:string -> chart:GenericChart.GenericChart -> GenericChart.GenericChart
val x : string
val y : string
val chart : GenericChart.GenericChart
type Chart =
  static member Area : xy:seq<#IConvertible * #IConvertible> * ?Name:string * ?ShowMarkers:bool * ?Showlegend:bool * ?MarkerSymbol:Symbol * ?Color:string * ?Opacity:float * ?Labels:seq<string> * ?TextPosition:TextPosition * ?TextFont:Font * ?Dash:DrawingStyle * ?Width:'a2 -> GenericChart
  static member Area : x:seq<#IConvertible> * y:seq<#IConvertible> * ?Name:string * ?ShowMarkers:bool * ?Showlegend:bool * ?MarkerSymbol:Symbol * ?Color:string * ?Opacity:float * ?Labels:seq<string> * ?TextPosition:TextPosition * ?TextFont:Font * ?Dash:DrawingStyle * ?Width:'a2 -> GenericChart
  static member Bar : keysvalues:seq<#IConvertible * #IConvertible> * ?Name:string * ?Showlegend:bool * ?Color:'a2 * ?Opacity:float * ?Labels:seq<string> * ?TextPosition:TextPosition * ?TextFont:Font * ?Marker:Marker -> GenericChart
  static member Bar : keys:seq<#IConvertible> * values:seq<#IConvertible> * ?Name:string * ?Showlegend:bool * ?Color:'a2 * ?Opacity:float * ?Labels:seq<string> * ?TextPosition:TextPosition * ?TextFont:Font * ?Marker:Marker -> GenericChart
  static member BoxPlot : xy:seq<'a0 * 'a1> * ?Name:string * ?Showlegend:bool * ?Color:string * ?Fillcolor:'a2 * ?Opacity:float * ?Whiskerwidth:'a3 * ?Boxpoints:Boxpoints * ?Boxmean:BoxMean * ?Jitter:'a4 * ?Pointpos:'a5 * ?Orientation:Orientation * ?Marker:Marker * ?Line:Line * ?Alignmentgroup:'a6 * ?Offsetgroup:'a7 * ?Notched:bool * ?NotchWidth:float * ?QuartileMethod:QuartileMethod -> GenericChart
  static member BoxPlot : ?x:'a0 * ?y:'a1 * ?Name:string * ?Showlegend:bool * ?Color:string * ?Fillcolor:'a2 * ?Opacity:float * ?Whiskerwidth:'a3 * ?Boxpoints:Boxpoints * ?Boxmean:BoxMean * ?Jitter:'a4 * ?Pointpos:'a5 * ?Orientation:Orientation * ?Marker:Marker * ?Line:Line * ?Alignmentgroup:'a6 * ?Offsetgroup:'a7 * ?Notched:bool * ?NotchWidth:float * ?QuartileMethod:QuartileMethod -> GenericChart
  static member Bubble : xysizes:seq<#IConvertible * #IConvertible * #IConvertible> * ?Name:string * ?Showlegend:bool * ?MarkerSymbol:Symbol * ?Color:string * ?Opacity:float * ?Labels:seq<string> * ?TextPosition:TextPosition * ?TextFont:Font * ?StackGroup:string * ?Orientation:Orientation * ?GroupNorm:GroupNorm * ?UseWebGL:bool -> GenericChart
  static member Bubble : x:seq<#IConvertible> * y:seq<#IConvertible> * sizes:seq<#IConvertible> * ?Name:string * ?Showlegend:bool * ?MarkerSymbol:Symbol * ?Color:string * ?Opacity:float * ?Labels:seq<string> * ?TextPosition:TextPosition * ?TextFont:Font * ?StackGroup:string * ?Orientation:Orientation * ?GroupNorm:GroupNorm * ?UseWebGL:bool -> GenericChart
  static member Candlestick : stockTimeSeries:seq<DateTime * StockData> * ?Increasing:Line * ?Decreasing:Line * ?WhiskerWidth:float * ?Line:Line * ?XCalendar:Calendar -> GenericChart
  static member Candlestick : open:seq<#IConvertible> * high:seq<#IConvertible> * low:seq<#IConvertible> * close:seq<#IConvertible> * x:seq<#IConvertible> * ?Increasing:Line * ?Decreasing:Line * ?WhiskerWidth:float * ?Line:Line * ?XCalendar:Calendar -> GenericChart
  ...
static member Chart.withX_Axis : xAxis:Axis.LinearAxis * ?Id:int -> (GenericChart.GenericChart -> GenericChart.GenericChart)
static member Chart.withY_Axis : yAxis:Axis.LinearAxis * ?Id:int -> (GenericChart.GenericChart -> GenericChart.GenericChart)
val chartOrig : GenericChart.GenericChart
static member Chart.Point : xy:seq<#IConvertible * #IConvertible> * ?Name:string * ?Showlegend:bool * ?MarkerSymbol:StyleParam.Symbol * ?Color:string * ?Opacity:float * ?Labels:seq<string> * ?TextPosition:StyleParam.TextPosition * ?TextFont:Font * ?StackGroup:string * ?Orientation:StyleParam.Orientation * ?GroupNorm:StyleParam.GroupNorm * ?UseWebGL:bool -> GenericChart.GenericChart
static member Chart.Point : x:seq<#IConvertible> * y:seq<#IConvertible> * ?Name:string * ?Showlegend:bool * ?MarkerSymbol:StyleParam.Symbol * ?Color:string * ?Opacity:float * ?Labels:seq<string> * ?TextPosition:StyleParam.TextPosition * ?TextFont:Font * ?StackGroup:string * ?Orientation:StyleParam.Orientation * ?GroupNorm:StyleParam.GroupNorm * ?UseWebGL:bool -> GenericChart.GenericChart
static member Chart.withTraceName : ?Name:string * ?Showlegend:bool * ?Legendgroup:string * ?Visible:StyleParam.Visible -> (GenericChart.GenericChart -> GenericChart.GenericChart)
val chartLog : GenericChart.GenericChart
val growthChart : GenericChart.GenericChart
module GenericChart

from Plotly.NET
val toChartHTML : gChart:GenericChart.GenericChart -> string
val logPhaseX : Vector<float>
Multiple items
val vector : l:seq<float> -> Vector<float>

--------------------
type vector = Vector<float>
val logPhaseY : Vector<float>
val regressionCoeffs : Vector<float>
module LinearRegression

from FSharp.Stats.Fitting
module OrdinaryLeastSquares

from FSharp.Stats.Fitting.LinearRegression
module Linear

from FSharp.Stats.Fitting.LinearRegression.OrdinaryLeastSquares
module Univariable

from FSharp.Stats.Fitting.LinearRegression.OrdinaryLeastSquares.Linear
val coefficient : xData:Vector<float> -> yData:Vector<float> -> Vector<float>
val slope : float
val generationTime : float
val fittedValues : seq<float * float>
val f : (float -> float)
val fit : coef:Vector<float> -> x:float -> float
Multiple items
module Seq

from Plotly.NET

--------------------
module Seq

from FSharp.Stats

--------------------
module Seq

from Microsoft.FSharp.Collections
val map : mapping:('T -> 'U) -> source:seq<'T> -> seq<'U>
val x : float
val chartLinearRegression : GenericChart.GenericChart
static member Chart.Line : xy:seq<#IConvertible * #IConvertible> * ?Name:string * ?ShowMarkers:bool * ?Showlegend:bool * ?MarkerSymbol:StyleParam.Symbol * ?Color:string * ?Opacity:float * ?Labels:seq<string> * ?TextPosition:StyleParam.TextPosition * ?TextFont:Font * ?Dash:'c * ?Width:'d * ?StackGroup:string * ?Orientation:StyleParam.Orientation * ?GroupNorm:StyleParam.GroupNorm * ?UseWebGL:bool -> GenericChart.GenericChart
static member Chart.Line : x:seq<#IConvertible> * y:seq<#IConvertible> * ?Name:string * ?ShowMarkers:bool * ?Showlegend:bool * ?MarkerSymbol:StyleParam.Symbol * ?Color:string * ?Opacity:float * ?Labels:seq<string> * ?TextPosition:StyleParam.TextPosition * ?TextFont:Font * ?Dash:'a2 * ?Width:'a3 * ?StackGroup:string * ?Orientation:StyleParam.Orientation * ?GroupNorm:StyleParam.GroupNorm * ?UseWebGL:bool -> GenericChart.GenericChart
static member Chart.Combine : gCharts:seq<GenericChart.GenericChart> -> GenericChart.GenericChart
val generationTimeManual : string
val sprintf : format:Printf.StringFormat<'T> -> 'T
val solverOptions : xData:float [] -> yDataLog:float [] -> expectedGenerationTime:float -> usedLogTransform:(float -> float) -> SolverOptions
val xData : float []
Multiple items
val float : value:'T -> float (requires member op_Explicit)

--------------------
type float = Double

--------------------
type float<'Measure> = float
val yDataLog : float []
val expectedGenerationTime : float
val usedLogTransform : (float -> float)
val a : float
val min : source:seq<'T> -> 'T (requires comparison)
val c : float
val max : source:seq<'T> -> 'T (requires comparison)
val b : float
type Math =
  static val E : float
  static val PI : float
  static val Tau : float
  static member Abs : value:decimal -> decimal + 6 overloads
  static member Acos : d:float -> float
  static member Acosh : d:float -> float
  static member Asin : d:float -> float
  static member Asinh : d:float -> float
  static member Atan : d:float -> float
  static member Atan2 : y:float * x:float -> float
  ...
field Math.E: float = 2.71828182846
val m : float
val yAtInflection : float
val zip : source1:seq<'T1> -> source2:seq<'T2> -> seq<'T1 * 'T2>
val minBy : projection:('T -> 'U) -> source:seq<'T> -> 'T (requires comparison)
val xValue : float
val yValue : float
Math.Abs(value: float32) : float32
Math.Abs(value: sbyte) : sbyte
Math.Abs(value: int64) : int64
Math.Abs(value: int) : int
Math.Abs(value: int16) : int16
Math.Abs(value: float) : float
Math.Abs(value: decimal) : decimal
val fst : tuple:('T1 * 'T2) -> 'T1
val createSolverOption : minimumDeltaValue:float -> minimumDeltaParameters:float -> maximumIterations:int -> initialParamGuess:float [] -> SolverOptions
val gompertzParams : vector
module LevenbergMarquardt

from FSharp.Stats.Fitting.NonLinearRegression
val estimatedParams : model:Model -> solverOptions:SolverOptions -> lambdaInitial:float -> lambdaFactor:float -> xData:float [] -> yData:float [] -> vector
module Table

from FSharp.Stats.Fitting.NonLinearRegression
module GrowthModels

from FSharp.Stats.Fitting.NonLinearRegression.Table
val gompertz : Model
val fittingFunction : (float -> float)
val fittedValuesGompertz : GenericChart.GenericChart
val last : source:seq<'T> -> 'T
val fittedChartGompertz : GenericChart.GenericChart
 The parameter were determined locally for saving time during build processes
val generationtime : parametervector:vector -> logTransform:(float -> float) -> float
val parametervector : vector
val logTransform : (float -> float)
val lag : parametervector:vector -> float
val g : string
val l : string
val richardsParams : vector
val richards : Model
val fittingFunctionRichards : (float -> float)
val generationtimeRichards : richardParameters:vector -> float
val richardParameters : vector
val l : float
val k : float
val y : float
val d : float
val gradientFunctionRichards : (float -> float)
val t : float
Math.Exp(d: float) : float
val maximalSlope : float
val fittedValuesRichards : GenericChart.GenericChart
val f : (float -> float)
 The parameter were determined locally for saving time during build processes
val fittedChartRichards : GenericChart.GenericChart
val fittedChartRichardsS : GenericChart.GenericChart
static member Chart.withTitle : title:string * ?Titlefont:Font -> (GenericChart.GenericChart -> GenericChart.GenericChart)
val generationRichards : string
val weibullParams : vector
val weibull : Model
val fittingFunctionWeibull : (float -> float)
val generationtimeWeibull : weibullParameters:vector -> float
val weibullParameters : vector
val gradientFunctionWeibull : (float -> float)
val inflectionPointXValue : float
val fittedValuesWeibull : GenericChart.GenericChart
val fittedChartWeibull : GenericChart.GenericChart
val fittedChartWeibullS : GenericChart.GenericChart
val generationWeibull : string
val janoschekParams : vector
val janoschek : Model
val fittingFunctionJanoschek : (float -> float)
val generationtimeJanoschek : janoschekParameters:vector -> float
val janoschekParameters : vector
val gradientFunctionJanoschek : (float -> float)
val slopeChart : (unit -> GenericChart.GenericChart)
Multiple items
module List

from FSharp.Stats

--------------------
module List

from Microsoft.FSharp.Collections

--------------------
type List<'T> =
  | ( [] )
  | ( :: ) of Head: 'T * Tail: 'T list
    interface IReadOnlyList<'T>
    interface IReadOnlyCollection<'T>
    interface IEnumerable
    interface IEnumerable<'T>
    member GetReverseIndex : rank:int * offset:int -> int
    member GetSlice : startIndex:int option * endIndex:int option -> 'T list
    member Head : 'T
    member IsEmpty : bool
    member Item : index:int -> 'T with get
    member Length : int
    ...
val map : mapping:('T -> 'U) -> list:'T list -> 'U list
val fittedValuesJanoschek : GenericChart.GenericChart
val fittedChartJanoschek : GenericChart.GenericChart
val fittedChartJanoschekS : GenericChart.GenericChart
val generationJanoschek : string
val exponentialParams : vector
val exponential : Model
val fittingFunctionExponential : (float -> float)
val generationtimeExponential : expParameters:vector -> float
val expParameters : vector
val gradientFunctionExponential : (float -> float)
val fittedValuesExp : GenericChart.GenericChart
val fittedChartExp : GenericChart.GenericChart
val fittedChartExpS : GenericChart.GenericChart
val generationExponential : string
val verhulstParams : vector
val verhulst4Param : Model
val fittingFunctionVerhulst : unit -> (float -> float)
val verhulst : Model
val generationtimeVerhulst : verhulstParameters:vector -> float
val verhulstParameters : vector
val lmax : float
val lmin : float
val gradientFunctionVerhulst : (float -> float)
val fittedValuesVerhulst : GenericChart.GenericChart
val fittedChartVerhulst : GenericChart.GenericChart
val fittedChartVerhulstS : GenericChart.GenericChart
val generationVerhulst : string
val morganMercerFlodinParams : vector
val morganMercerFlodin : Model
val fittingFunctionMMF : unit -> (float -> float)
val generationtimeMmf : mmfParameters:vector -> float
val mmfParameters : vector
val gradientFunctionMmf : (float -> float)
val generationMmf : string
val fittedValuesMMF : GenericChart.GenericChart
val fittedChartMMF : GenericChart.GenericChart
val combinedChart : GenericChart.GenericChart
val generationTimeTable : GenericChart.GenericChart
val header : string list
val rows : string list list
static member Chart.Table : headerValues:seq<#seq<'b>> * cellValues:seq<#seq<'d>> * ?AlignHeader:seq<StyleParam.HorizontalAlign> * ?AlignCells:seq<StyleParam.HorizontalAlign> * ?ColumnWidth:seq<int> * ?ColumnOrder:seq<int> * ?ColorHeader:'e * ?ColorCells:'f * ?FontHeader:Font * ?FontCells:Font * ?HeightHeader:'g * ?HeightCells:'h * ?LineHeader:Line * ?LineCells:Line -> GenericChart.GenericChart (requires 'b :> IConvertible and 'd :> IConvertible)
Multiple items
type Font =
  inherit DynamicObj
  new : unit -> Font
  static member init : ?Family:FontFamily * ?Size:'a * ?Color:'b * ?Familysrc:'c * ?Sizesrc:'d * ?Colorsrc:'e -> Font
  static member style : ?Family:FontFamily * ?Size:'a0 * ?Color:'a1 * ?Familysrc:'a2 * ?Sizesrc:'a3 * ?Colorsrc:'a4 -> (Font -> Font)

--------------------
new : unit -> Font
static member Font.init : ?Family:StyleParam.FontFamily * ?Size:'a * ?Color:'b * ?Familysrc:'c * ?Sizesrc:'d * ?Colorsrc:'e -> Font
val explGompertz : model:Model -> coefs:Vector<float> -> GenericChart.GenericChart
val model : Model
type Model =
  { ParameterNames: string []
    GetFunctionValue: Vector<float> -> float -> float
    GetGradientValue: Vector<float> -> Vector<float> -> float -> Vector<float> }
val coefs : Vector<float>
val ff : (float -> float)
Model.GetFunctionValue: Vector<float> -> float -> float
val gom : GenericChart.GenericChart
val rich : GenericChart.GenericChart
val wei : GenericChart.GenericChart
val jan : GenericChart.GenericChart
val exp : GenericChart.GenericChart
val ver : GenericChart.GenericChart
val ver4 : GenericChart.GenericChart
val mmf : GenericChart.GenericChart
val vonB : GenericChart.GenericChart
val vonBertalanffy : Model