Clustering
Summary: this tutorial demonstrates several clustering methods in FSharp.Stats and how to visualize the results with Plotly.NET.
Table of contents
- Iterative Clustering
- Density based clustering
- Hierarchical clustering
- Determining the optimal number of clusters
Clustering methods can be used to group elements of a huge data set based on their similarity. Elements sharing similar properties cluster together and can be reported as coherent group. For demonstration of several clustering methods, the classic iris data set is used, which consists of 150 records, each of which contains four measurements and a species identifier. Since the species identifier occur several times (Iris-virginica, Iris-versicolor, and Iris-setosa), the first step is to generate unique labels:
- The data is shuffled and an index is appended to the data label, such that each label is unique.
open FSharp.Stats
let fromFileWithSep (separator:char) (filePath) =
// The function is implemented using a sequence expression
seq { let sr = System.IO.File.OpenText(filePath)
while not sr.EndOfStream do
let line = sr.ReadLine()
let words = line.Split separator//[|',';' ';'\t'|]
yield words }
let lables,data =
fromFileWithSep ',' (__SOURCE_DIRECTORY__ + "/data/irisData.csv")
|> Seq.skip 1
|> Seq.map (fun arr -> arr.[4], [| float arr.[0]; float arr.[1]; float arr.[2]; float arr.[3]; |])
|> Seq.toArray
|> Array.shuffleFisherYates
|> Array.mapi (fun i (lable,data) -> sprintf "%s_%i" lable i, data)
|> Array.unzip
let's first take a look at the dataset with Plotly.NET:
open Plotly.NET
let colnames = ["Sepal length";"Sepal width";"Petal length";"Petal width"]
let colorscaleValue =
StyleParam.Colorscale.Electric //Custom [(0.0,"#3D9970");(1.0,"#001f3f")]
let dataChart =
Chart.Heatmap(data,colNames=colnames,rowNames=(lables |> Seq.mapi (fun i s -> sprintf "%s%i" s i )),ColorScale=colorscaleValue,ShowScale=true)
|> Chart.withMarginSize(Left=250.)
|> Chart.withTitle "raw iris data"
Iterative Clustering
k-means clustering
In k-means clustering a cluster number has to be specified prior to clustering the data. K centroids are randomly chosen. After all data points are assigned to their nearest centroid, the algorithm iteratively approaches a centroid position configuration, that minimizes the dispersion of every of the k clusters. For cluster number determination see below (Determining the optimal number of clusters).
Further information can be found here.
open FSharp.Stats.ML
open FSharp.Stats.ML.Unsupervised
open FSharp.Stats.ML.Unsupervised.HierarchicalClustering
// Kmeans clustering
// For random cluster inititalization use randomInitFactory:
let rnd = new System.Random()
let randomInitFactory : IterativeClustering.CentroidsFactory<float []> =
IterativeClustering.randomCentroids<float []> rnd
//let cvmaxFactory : IterativeClustering.CentroidsFactory<float []> =
// IterativeClustering.initCVMAX
let kmeansResult =
IterativeClustering.kmeans <| DistanceMetrics.euclidean <| randomInitFactory
<| data <| 4
let clusteredIrisData =
Array.zip lables data
|> Array.sortBy (fun (l,dataPoint) -> fst (kmeansResult.Classifier dataPoint))
|> Array.unzip
|> fun (labels,d) ->
Chart.Heatmap(d,colNames=colnames,rowNames=labels,ColorScale=colorscaleValue,ShowScale=true)
|> Chart.withMarginSize(Left=250.)
|> Chart.withTitle "clustered iris data (k-means clustering)"
// To get the best kMeans clustering result in terms of the average squared distance of each point
// to its centroid, perform the clustering b times and minimize the dispersion.
let getBestkMeansClustering data k bootstraps =
[1..bootstraps]
|> List.mapi (fun i x ->
IterativeClustering.kmeans <| DistanceMetrics.euclidean <| randomInitFactory <| data <| k
)
|> List.minBy (fun clusteringResult -> IterativeClustering.DispersionOfClusterResult clusteringResult)
Density based clustering
DBSCAN
Further information can be found here.
//four dimensional clustering with sepal length, petal length, sepal width and petal width
let t = DbScan.compute DistanceMetrics.Array.euclideanNaN 5 1.0 data
//extract petal length and petal width
let petLpetW = data |> Array.map (fun x -> [|x.[2];x.[3]|])
//extract petal width, petal length and sepal length
let petWpetLsepL = data |> Array.map (fun x -> [|x.[3];x.[2];x.[0]|])
//to create a chart with two dimensional data use the following function
let dbscanPlot =
if (petLpetW |> Seq.head |> Seq.length) <> 2 then failwithf "create2dChart only can handle 2 coordinates"
let result = DbScan.compute DistanceMetrics.Array.euclidean 20 0.5 petLpetW
let chartCluster =
if result.Clusterlist |> Seq.length > 0 then
result.Clusterlist
|> Array.ofSeq
|> Array.mapi (fun i l ->
l
|> Array.ofSeq
|> Array.map (fun x ->
x.[0],x.[1])
|> Array.distinct //more efficient visualization; no difference in plot but in point numbers
|> Chart.Point
|> Chart.withTraceName (sprintf "Cluster %i" i)
)
|> Chart.combine
else Chart.Point []
let chartNoise =
if result.Noisepoints |> Seq.length > 0 then
result.Noisepoints
|> Seq.map (fun x -> x.[0],x.[1])
|> Seq.distinct //more efficient visualization; no difference in plot but in point numbers
|> Chart.Point
|> Chart.withTraceName "Noise"
else Chart.Point []
let chartname =
let noiseCount = result.Noisepoints |> Seq.length
let clusterCount = result.Clusterlist |> Seq.length
let clPtsCount = result.Clusterlist |> Seq.sumBy Seq.length
sprintf "eps:%.1f minPts:%i pts:%i cluster:%i noisePts:%i"
0.5 20 (noiseCount + clPtsCount) clusterCount noiseCount
[chartNoise;chartCluster]
|> Chart.combine
|> Chart.withTitle chartname
|> Chart.withAxisTitles "Petal width" "Petal length"
//to create a chart with three dimensional data use the following function
let create3dChart (dfu:array<'a> -> array<'a> -> float) (minPts:int) (eps:float) (input:seq<#seq<'a>>) =
if (input |> Seq.head |> Seq.length) <> 3 then failwithf "create3dChart only can handle 3 coordinates"
let result = DbScan.compute dfu minPts eps input
let chartCluster =
if result.Clusterlist |> Seq.length > 0 then
result.Clusterlist
|> Seq.mapi (fun i l ->
l
|> Seq.map (fun x -> x.[0],x.[1],x.[2])
|> Seq.distinct //faster visualization; no difference in plot but in point number
|> fun x -> Chart.Scatter3D (x,StyleParam.Mode.Markers)
|> Chart.withTraceName (sprintf "Cluster_%i" i))
|> Chart.combine
else Chart.Scatter3D ([],StyleParam.Mode.Markers)
let chartNoise =
if result.Noisepoints |> Seq.length > 0 then
result.Noisepoints
|> Seq.map (fun x -> x.[0],x.[1],x.[2])
|> Seq.distinct //faster visualization; no difference in plot but in point number
|> fun x -> Chart.Scatter3D (x,StyleParam.Mode.Markers)
|> Chart.withTraceName "Noise"
else Chart.Scatter3D ([],StyleParam.Mode.Markers)
let chartname =
let noiseCount = result.Noisepoints |> Seq.length
let clusterCount = result.Clusterlist |> Seq.length
let clPtsCount = result.Clusterlist |> Seq.sumBy Seq.length
sprintf "eps:%.1f minPts:%i n:%i Cluster:%i NoisePts:%i"
eps minPts (noiseCount + clPtsCount) clusterCount noiseCount
[chartNoise;chartCluster]
|> Chart.combine
|> Chart.withTitle chartname
|> Chart.withAxisTitles "Petal width" "Petal length"
|> Chart.withZAxis (Chart.myAxis "Sepal length")
//for faster computation you can use the squaredEuclidean distance and set your eps to its square
let clusteredChart3D = create3dChart DistanceMetrics.Array.euclideanNaNSquared 20 (0.7**2.) petWpetLsepL
Hierarchical clustering
Hierarchical clustering results in a tree structure, that has a single cluster (node) on its root and recursively splits up into clusters of elements that are more similar to each other than to elements of other clusters. For generating multiple cluster results with different number of clusters, the clustering has to performed only once. Subsequently a threshold can be determined which will result in the desired number of clusters.
Further information can be found here. For network visualization follow this tutorial.
Distance measures
There are several distance metrics, that can be used as distance function. The commonly used one probably is Euclidean distance.
Linker
When the distance between two clusters is calculated, there are several linkage types to choose from:
complete linkage: maximal pairwise distance between the clusters (prone to break large clusters)
single linkage: minimal pairwise distance between the clusters (sensitive to outliers)
centroid linkage: distance between the two cluster centroids
average linkage: average pairwise distance between the clusters (sensitive to cluster shape and size)
median linkage: median pairwise distance between the clusters
open FSharp.Stats.ML.Unsupervised.HierarchicalClustering
// calculates the clustering and reports a single root cluster (node),
// that may recursively contains further nodes
let clusterResultH =
HierarchicalClustering.generate DistanceMetrics.euclideanNaNSquared Linker.wardLwLinker data
// If a desired cluster number is specified, the following function cuts the cluster according
// to the depth, that results in the respective number of clusters (here 3). Only leaves are reported.
let threeClustersH = HierarchicalClustering.cutHClust 3 clusterResultH
Every cluster leaf contains its raw values and an index that indicates the position of the respective data point in the raw data. The index can be retrieved from leaves by HierarchicalClustering.getClusterId.
let inspectThreeClusters =
threeClustersH
|> List.map (fun cluster ->
cluster
|> List.map (fun leaf ->
lables.[HierarchicalClustering.getClusterId leaf]
)
)
|> fun clusteredLabels ->
sprintf "Detailed information for %i clusters is given:" clusteredLabels.Length,clusteredLabels
|
// To recursevely flatten the cluster tree into leaves only, use flattenHClust.
// A leaf list is reported, that does not contain any cluster membership,
// but is sorted by the clustering result.
let hLeaves =
clusterResultH
|> HierarchicalClustering.flattenHClust
// takes the sorted cluster result and reports a tuple of lable and data value.
let dataSortedByClustering =
hLeaves
|> Seq.choose (fun c ->
let lable = lables.[HierarchicalClustering.getClusterId c]
let values = HierarchicalClustering.tryGetLeafValue c
match values with
| None -> None
| Some x -> Some (lable,x)
)
let hierClusteredDataHeatmap =
let (hlable,hdata) =
dataSortedByClustering
|> Seq.unzip
Chart.Heatmap(hdata,colNames=colnames,rowNames=hlable,ColorScale=colorscaleValue,ShowScale=true)
|> Chart.withMarginSize(Left=250.)
|> Chart.withTitle "Clustered iris data (hierarchical clustering)"
Determining the optimal number of clusters
Rule of thumb
The rule of thumb is a very crude cluster number estimation only based on the number of data points.
Reference: 'Review on Determining of Cluster in K-means Clustering'; Kodinariya et al; January 2013
//optimal k for iris data set by using rule-of-thumb
let ruleOfThumb = ClusterNumber.kRuleOfThumb data
|
Elbow criterion
The elbow criterion is a visual method to determine the optimal cluster number. The cluster dispersion is measured as the sum of all average (squared) euclidean distance of each point to its associated centroid. The point at which the dispersion drops drastically and further increase in k does not lead to a strong decrease in dispersion is the optimal k.
Reference: 'Review on Determining of Cluster in K-means Clustering'; Kodinariya et al; January 2013
open IterativeClustering
open DistanceMetrics
let kElbow = 10
let iterations = 10
let dispersionOfK =
[|1..kElbow|]
|> Array.map (fun k ->
let (dispersion,std) =
[|1..iterations|]
|> Array.map (fun i ->
kmeans euclideanNaNSquared (randomCentroids rnd) data k
|> DispersionOfClusterResult)
|> fun dispersions ->
Seq.mean dispersions, Seq.stDev dispersions
k,dispersion,std
)
let elbowChart =
Chart.Line (dispersionOfK |> Array.map (fun (k,dispersion,std) -> k,dispersion))
|> Chart.withYErrorStyle (dispersionOfK |> Array.map (fun (k,dispersion,std) -> std))
|> Chart.withAxisTitles "k" "dispersion"
|> Chart.withTitle "Iris data set dispersion"
AIC
The Akaike information criterion (AIC) balances the information gain (with raising k) against parameter necessity (number of k). The k that minimizes the AIC is assumed to be the optimal one.
let aicBootstraps = 10
//optimal k for iris data set by using aic
let (aicK,aicMeans,aicStd) =
//perform 10 iterations and take the mean and standard deviation of the aic
let aic =
[|1..aicBootstraps|]
|> Array.map (fun b -> ClusterNumber.calcAIC 10 (kmeans euclideanNaNSquared (randomCentroids rnd) data) 15)
aic
|> Array.map (fun iteration -> Array.map snd iteration)
|> JaggedArray.transpose
|> Array.mapi (fun i aics ->
i+1,Seq.mean aics,Seq.stDev aics)
|> Array.unzip3
let aicChart =
Chart.Line (aicK,aicMeans)
|> Chart.withAxisTitles "k" "AIC"
|> Chart.withYErrorStyle aicStd
Silhouette coefficient
The silhouette index ranges from -1 to 1, where -1 indicates a misclassified point, and 1 indicates a perfect fit. It can be calculated for every point by comparing the mean intra cluster distance with the nearest mean inter cluster distance. The mean of all indices can be visualized, where a maximal value indicates the optimal k.
Reference: 'Review on Determining of Cluster in K-means Clustering'; Kodinariya et al; January 2013
// The following example expects the raw data to be clustered by k means clustering.
// If you already have clustered data use the 'silhouetteIndex' function instead.
let silhouetteData =
System.IO.File.ReadAllLines(__SOURCE_DIRECTORY__ + "/data/silhouetteIndexData.txt")
|> Array.map (fun x ->
let tmp = x.Split '\t'
[|float tmp.[0]; float tmp.[1]|])
let sI =
ML.Unsupervised.ClusterNumber.silhouetteIndexKMeans
50 // number of bootstraps
(kmeans euclideanNaNSquared (randomCentroids rnd) silhouetteData)
silhouetteData // input data
15 // maximal number of allowed k
let rawDataChart =
silhouetteData
|> Array.map (fun x -> x.[0],x.[1])
|> Chart.Point
let silhouetteIndicesChart =
Chart.Line (sI |> Array.map (fun x -> x.ClusterNumber,x.SilhouetteIndex))
|> Chart.withYErrorStyle (sI |> Array.map (fun x -> x.SilhouetteIndexStDev))
let combinedSilhouette =
[
rawDataChart |> Chart.withAxisTitles "" "" |> Chart.withTraceName "raw data"
silhouetteIndicesChart |> Chart.withAxisTitles "k" "silhouette index" |> Chart.withTraceName "silhouette"
]
|> Chart.Grid(1,2)
GapStatistics
Reference: 'Estimating the number of clusters in a data set via the gap statistic'; J. R. Statist. Soc. B (2001); Tibshirani, Walther, and Hastie
Gap statistics allows to determine the optimal cluster number by comparing the cluster dispersion (intra-cluster variation) of a reference dataset to the original data cluster dispersion. For each k both dispersions are calculated, while for the reference dataset multiple iterations are performed for each k. The difference of the log(dispersionOriginal) and the log(dispersionReference) is called 'gap'. The maximal gap points to the optimal cluster number.
Two ways to generate a reference data set are implemented.
- a uniform coverage within the range of the original data set
- a PCA based point coverage, that considers the density/shape of the original data
let gapStatisticsData =
System.IO.File.ReadAllLines(__SOURCE_DIRECTORY__ + "/data/gapStatisticsData.txt")
|> Array.map (fun x ->
let tmp = x.Split '\t'
tmp |> Array.map float)
let gapDataChart =
[
gapStatisticsData|> Array.map (fun x -> x.[0],x.[1]) |> Chart.Point |> Chart.withTraceName "original" |> Chart.withXAxis (Chart.myAxisRange "" (-4.,10.)) |> Chart.withYAxis (Chart.myAxisRange "" (-2.5,9.))
(GapStatistics.PointGenerators.generateUniformPoints rnd gapStatisticsData) |> Array.map (fun x -> x.[0],x.[1]) |> Chart.Point |> Chart.withTraceName "uniform" |> Chart.withXAxis (Chart.myAxisRange "" (-4.,10.)) |> Chart.withYAxis (Chart.myAxisRange "" (-2.5,9.))
(GapStatistics.PointGenerators.generateUniformPointsPCA rnd gapStatisticsData) |> Array.map (fun x -> x.[0],x.[1]) |> Chart.Point |> Chart.withTraceName "uniform PCA" |> Chart.withXAxis (Chart.myAxisRange "" (-4.,10.)) |> Chart.withYAxis (Chart.myAxisRange "" (-2.5,9.))
]
|> Chart.Grid(1,3)
|> Chart.withSize(800.,400.)
The log(dispersionReference) should decrease with rising k, but - if clusters are present in the data - should be greater than the log(dispersionOriginal).
open GapStatistics
//create gap statistics
let gaps =
GapStatistics.calculate
(PointGenerators.generateUniformPointsPCA rnd) //uniform point distribution
100// no gain above 500 //number of bootstraps samples
ClusterDispersionMetric.logDispersionKMeansInitRandom //dispersion metric of clustering algorithm
10 //maximal number of allowed clusters
gapStatisticsData //float [] [] data of coordinates
//number of clusters
let k = gaps |> Array.map (fun x -> x.ClusterIndex)
//log(dispersion) of the original data (with rising k)
let disp = gaps |> Array.map (fun x -> x.Dispersion)
//log(dispersion) of the reference data (with rising k)
let dispRef = gaps |> Array.map (fun x -> x.ReferenceDispersion)
//log(dispersionRef) - log(dispersionOriginal)
let gap = gaps |> Array.map (fun x -> x.Gaps)
//standard deviation of reference data set dispersion
let std = gaps |> Array.map (fun x -> x.RefDispersionStDev)
let gapStatisticsChart =
let dispersions =
[
Chart.Line (k,disp) |> Chart.withTraceName "disp"
Chart.Line (k,dispRef)|> Chart.withTraceName "dispRef" |> Chart.withYErrorStyle(std)
]
|> Chart.combine
|> Chart.withAxisTitles "" "log(disp)"
let gaps =
Chart.Line (k,gap)|> Chart.withTraceName "gaps"
|> Chart.withAxisTitles "k" "gaps"
[dispersions; gaps]
|> Chart.Grid(2,1)
The maximal gap points to the optimal cluster number with the following condition:
- kopt = smallest k such that Gap(k)>= Gap(k+1)-sk+1
- where sk = std * sqrt(1+1/bootstraps)
//calculate s(k) out of std(k) and the number of performed iterations for the refernce data set
let sK = std |> Array.map (fun sd -> sd * sqrt(1. + 1./500.)) //bootstraps = 500
let gapChart =
Chart.Line (k,gap)
|> Chart.withYErrorStyle(sK)
|> Chart.withAxisTitles "k" "gaps"
//choose kOpt = smallest k such that Gap(k)>= Gap(k+1)-sk+1, where sk = sdk * sqrt(1+1/bootstraps)
let kOpt =
Array.init (gap.Length - 2) (fun i -> gap.[i] >= gap.[i+1] - sK.[i+1])
|> Array.findIndex id
|> fun x -> sprintf "The optimal cluster number is: %i" (x + 1)
|
namespace Plotly
namespace Plotly.NET
module StyleParam
from Plotly.NET
namespace Plotly.NET.LayoutObjects
type Chart =
static member AnnotatedHeatmap: zData: seq<#seq<'a1>> * annotationText: seq<#seq<string>> * ?Name: string * ?ShowLegend: bool * ?Opacity: float * ?X: seq<#IConvertible> * ?XGap: int * ?Y: seq<#IConvertible> * ?YGap: int * ?Text: 'a5 * ?MultiText: seq<'a5> * ?ColorBar: ColorBar * ?ColorScale: Colorscale * ?ShowScale: bool * ?ReverseScale: bool * ?ZSmooth: SmoothAlg * ?Transpose: bool * ?UseWebGL: bool * ?ReverseYAxis: bool * ?UseDefaults: bool -> GenericChart (requires 'a1 :> IConvertible and 'a5 :> IConvertible)
static member Area: x: seq<#IConvertible> * y: seq<#IConvertible> * ?Name: string * ?ShowMarkers: bool * ?ShowLegend: bool * ?MarkerSymbol: MarkerSymbol * ?Color: Color * ?Opacity: float * ?Labels: seq<#IConvertible> * ?TextPosition: TextPosition * ?TextFont: Font * ?Dash: DrawingStyle * ?Width: float * ?UseDefaults: bool -> GenericChart + 1 overload
static member Bar: values: seq<#IConvertible> * ?Keys: seq<#IConvertible> * ?Name: string * ?ShowLegend: bool * ?Opacity: float * ?MultiOpacity: seq<float> * ?Text: 'a2 * ?MultiText: seq<'a2> * ?MarkerColor: Color * ?MarkerColorScale: Colorscale * ?MarkerOutline: Line * ?MarkerPatternShape: PatternShape * ?MultiMarkerPatternShape: seq<PatternShape> * ?MarkerPattern: Pattern * ?Marker: Marker * ?Base: #IConvertible * ?Width: 'a4 * ?MultiWidth: seq<'a4> * ?TextPosition: TextPosition * ?MultiTextPosition: seq<TextPosition> * ?UseDefaults: bool -> GenericChart (requires 'a2 :> IConvertible and 'a4 :> IConvertible) + 1 overload
static member BoxPlot: ?x: seq<#IConvertible> * ?y: seq<#IConvertible> * ?Name: string * ?ShowLegend: bool * ?Text: 'a2 * ?MultiText: seq<'a2> * ?Fillcolor: Color * ?MarkerColor: Color * ?OutlierColor: Color * ?OutlierWidth: int * ?Opacity: float * ?WhiskerWidth: float * ?BoxPoints: BoxPoints * ?BoxMean: BoxMean * ?Jitter: float * ?PointPos: float * ?Orientation: Orientation * ?Marker: Marker * ?Line: Line * ?AlignmentGroup: string * ?Offsetgroup: string * ?Notched: bool * ?NotchWidth: float * ?QuartileMethod: QuartileMethod * ?UseDefaults: bool -> GenericChart (requires 'a2 :> IConvertible) + 1 overload
static member Bubble: x: seq<#IConvertible> * y: seq<#IConvertible> * sizes: seq<int> * ?Name: string * ?ShowLegend: bool * ?Opacity: float * ?MultiOpacity: seq<float> * ?Text: 'a2 * ?MultiText: seq<'a2> * ?TextPosition: TextPosition * ?MultiTextPosition: seq<TextPosition> * ?MarkerColor: Color * ?MarkerColorScale: Colorscale * ?MarkerOutline: Line * ?MarkerSymbol: MarkerSymbol * ?MultiMarkerSymbol: seq<MarkerSymbol> * ?Marker: Marker * ?LineColor: Color * ?LineColorScale: Colorscale * ?LineWidth: float * ?LineDash: DrawingStyle * ?Line: Line * ?StackGroup: string * ?Orientation: Orientation * ?GroupNorm: GroupNorm * ?UseWebGL: bool * ?UseDefaults: bool -> GenericChart (requires 'a2 :> IConvertible) + 1 overload
static member Candlestick: ``open`` : seq<#IConvertible> * high: seq<#IConvertible> * low: seq<#IConvertible> * close: seq<#IConvertible> * x: seq<#IConvertible> * ?Name: string * ?ShowLegend: bool * ?Opacity: float * ?Text: 'a5 * ?MultiText: seq<'a5> * ?Line: Line * ?IncreasingColor: Color * ?Increasing: FinanceMarker * ?DecreasingColor: Color * ?Decreasing: FinanceMarker * ?WhiskerWidth: float * ?UseDefaults: bool -> GenericChart (requires 'a5 :> IConvertible) + 1 overload
static member Column: values: seq<#IConvertible> * ?Keys: seq<#IConvertible> * ?Name: string * ?ShowLegend: bool * ?Opacity: float * ?MultiOpacity: seq<float> * ?Text: 'a2 * ?MultiText: seq<'a2> * ?MarkerColor: Color * ?MarkerColorScale: Colorscale * ?MarkerOutline: Line * ?MarkerPatternShape: PatternShape * ?MultiMarkerPatternShape: seq<PatternShape> * ?MarkerPattern: Pattern * ?Marker: Marker * ?Base: #IConvertible * ?Width: 'a4 * ?MultiWidth: seq<'a4> * ?TextPosition: TextPosition * ?MultiTextPosition: seq<TextPosition> * ?UseDefaults: bool -> GenericChart (requires 'a2 :> IConvertible and 'a4 :> IConvertible) + 1 overload
static member Contour: zData: seq<#seq<'a1>> * ?Name: string * ?ShowLegend: bool * ?Opacity: float * ?X: seq<#IConvertible> * ?Y: seq<#IConvertible> * ?Text: 'a4 * ?MultiText: seq<'a4> * ?ColorBar: ColorBar * ?ColorScale: Colorscale * ?ShowScale: bool * ?ReverseScale: bool * ?Transpose: bool * ?LineColor: Color * ?LineDash: DrawingStyle * ?Line: Line * ?ContoursColoring: ContourColoring * ?ContoursOperation: ConstraintOperation * ?ContoursType: ContourType * ?ShowContourLabels: bool * ?ContourLabelFont: Font * ?Contours: Contours * ?FillColor: Color * ?NContours: int * ?UseDefaults: bool -> GenericChart (requires 'a1 :> IConvertible and 'a4 :> IConvertible)
static member Funnel: x: seq<#IConvertible> * y: seq<#IConvertible> * ?Name: string * ?ShowLegend: bool * ?Opacity: float * ?Width: float * ?Offset: float * ?Text: 'a2 * ?MultiText: seq<'a2> * ?TextPosition: TextPosition * ?MultiTextPosition: seq<TextPosition> * ?Orientation: Orientation * ?AlignmentGroup: string * ?OffsetGroup: string * ?MarkerColor: Color * ?MarkerOutline: Line * ?Marker: Marker * ?TextInfo: TextInfo * ?ConnectorLineColor: Color * ?ConnectorLineStyle: DrawingStyle * ?ConnectorFillColor: Color * ?ConnectorLine: Line * ?Connector: FunnelConnector * ?InsideTextFont: Font * ?OutsideTextFont: Font * ?UseDefaults: bool -> GenericChart (requires 'a2 :> IConvertible)
static member Heatmap: zData: seq<#seq<'a1>> * ?Name: string * ?ShowLegend: bool * ?Opacity: float * ?X: seq<#IConvertible> * ?XGap: int * ?Y: seq<#IConvertible> * ?YGap: int * ?Text: 'a4 * ?MultiText: seq<'a4> * ?ColorBar: ColorBar * ?ColorScale: Colorscale * ?ShowScale: bool * ?ReverseScale: bool * ?ZSmooth: SmoothAlg * ?Transpose: bool * ?UseWebGL: bool * ?ReverseYAxis: bool * ?UseDefaults: bool -> GenericChart (requires 'a1 :> IConvertible and 'a4 :> IConvertible) + 1 overload
...
val myAxis: name: string -> LinearAxis
val name: string
Multiple items
type LinearAxis = inherit DynamicObj new: unit -> LinearAxis static member init: ?Visible: bool * ?Color: Color * ?Title: Title * ?AxisType: AxisType * ?AutoTypeNumbers: AutoTypeNumbers * ?AutoRange: AutoRange * ?RangeMode: RangeMode * ?Range: Range * ?FixedRange: bool * ?ScaleAnchor: LinearAxisId * ?ScaleRatio: float * ?Constrain: AxisConstraint * ?ConstrainToward: AxisConstraintDirection * ?Matches: LinearAxisId * ?Rangebreaks: seq<Rangebreak> * ?TickMode: TickMode * ?NTicks: int * ?Tick0: #IConvertible * ?DTick: #IConvertible * ?TickVals: seq<#IConvertible> * ?TickText: seq<#IConvertible> * ?Ticks: TickOptions * ?TicksOn: CategoryTickAnchor * ?TickLabelMode: TickLabelMode * ?TickLabelPosition: TickLabelPosition * ?TickLabelOverflow: TickLabelOverflow * ?Mirror: Mirror * ?TickLen: int * ?TickWidth: int * ?TickColor: Color * ?ShowTickLabels: bool * ?AutoMargin: bool * ?ShowSpikes: bool * ?SpikeColor: Color * ?SpikeThickness: int * ?SpikeDash: DrawingStyle * ?SpikeMode: SpikeMode * ?SpikeSnap: SpikeSnap * ?TickFont: Font * ?TickAngle: int * ?ShowTickPrefix: ShowTickOption * ?TickPrefix: string * ?ShowTickSuffix: ShowTickOption * ?TickSuffix: string * ?ShowExponent: ShowExponent * ?ExponentFormat: ExponentFormat * ?MinExponent: float * ?SeparateThousands: bool * ?TickFormat: string * ?TickFormatStops: seq<TickFormatStop> * ?HoverFormat: string * ?ShowLine: bool * ?LineColor: Color * ?LineWidth: float * ?ShowGrid: bool * ?GridColor: Color * ?GridWidth: float * ?ZeroLine: bool * ?ZeroLineColor: Color * ?ZeroLineWidth: float * ?ShowDividers: bool * ?DividerColor: Color * ?DividerWidth: int * ?Anchor: LinearAxisId * ?Side: Side * ?Overlaying: LinearAxisId * ?Layer: Layer * ?Domain: Range * ?Position: float * ?CategoryOrder: CategoryOrder * ?CategoryArray: seq<#IConvertible> * ?UIRevision: #IConvertible * ?RangeSlider: RangeSlider * ?RangeSelector: RangeSelector * ?Calendar: Calendar * ?BackgroundColor: Color * ?ShowBackground: bool -> LinearAxis static member initCarpet: ?Color: Color * ?Title: Title * ?AxisType: AxisType * ?AutoTypeNumbers: AutoTypeNumbers * ?AutoRange: AutoRange * ?RangeMode: RangeMode * ?Range: Range * ?FixedRange: bool * ?TickMode: TickMode * ?NTicks: int * ?Tick0: #IConvertible * ?DTick: #IConvertible * ?TickVals: seq<#IConvertible> * ?TickText: seq<#IConvertible> * ?Ticks: TickOptions * ?ShowTickLabels: bool * ?TickFont: Font * ?TickAngle: int * ?ShowTickPrefix: ShowTickOption * ?TickPrefix: string * ?ShowTickSuffix: ShowTickOption * ?TickSuffix: string * ?ShowExponent: ShowExponent * ?ExponentFormat: ExponentFormat * ?MinExponent: float * ?SeparateThousands: bool * ?TickFormat: string * ?TickFormatStops: seq<TickFormatStop> * ?ShowLine: bool * ?LineColor: Color * ?LineWidth: float * ?ShowGrid: bool * ?GridColor: Color * ?GridWidth: float * ?CategoryOrder: CategoryOrder * ?CategoryArray: seq<#IConvertible> * ?ArrayDTick: int * ?ArrayTick0: int * ?CheaterType: CheaterType * ?EndLine: bool * ?EndLineColor: Color * ?EndLineWidth: int * ?LabelPadding: int * ?LabelPrefix: string * ?LabelSuffix: string * ?MinorGridColor: Color * ?MinorGridCount: int * ?MinorGridWidth: int * ?Smoothing: float * ?StartLine: bool * ?StartLineColor: Color * ?StartLineWidth: int -> LinearAxis static member initCategorical: categoryOrder: CategoryOrder * ?Visible: bool * ?Color: Color * ?Title: Title * ?AutoTypeNumbers: AutoTypeNumbers * ?AutoRange: AutoRange * ?RangeMode: RangeMode * ?Range: Range * ?FixedRange: bool * ?ScaleAnchor: LinearAxisId * ?ScaleRatio: float * ?Constrain: AxisConstraint * ?ConstrainToward: AxisConstraintDirection * ?Matches: LinearAxisId * ?Rangebreaks: seq<Rangebreak> * ?TickMode: TickMode * ?NTicks: int * ?Tick0: #IConvertible * ?DTick: #IConvertible * ?TickVals: seq<#IConvertible> * ?TickText: seq<#IConvertible> * ?Ticks: TickOptions * ?TicksOn: CategoryTickAnchor * ?TickLabelMode: TickLabelMode * ?TickLabelPosition: TickLabelPosition * ?TickLabelOverflow: TickLabelOverflow * ?Mirror: Mirror * ?TickLen: int * ?TickWidth: int * ?TickColor: Color * ?ShowTickLabels: bool * ?AutoMargin: bool * ?ShowSpikes: bool * ?SpikeColor: Color * ?SpikeThickness: int * ?SpikeDash: DrawingStyle * ?SpikeMode: SpikeMode * ?SpikeSnap: SpikeSnap * ?TickFont: Font * ?TickAngle: int * ?ShowTickPrefix: ShowTickOption * ?TickPrefix: string * ?ShowTickSuffix: ShowTickOption * ?TickSuffix: string * ?ShowExponent: ShowExponent * ?ExponentFormat: ExponentFormat * ?MinExponent: float * ?SeparateThousands: bool * ?TickFormat: string * ?TickFormatStops: seq<TickFormatStop> * ?HoverFormat: string * ?ShowLine: bool * ?LineColor: Color * ?LineWidth: float * ?ShowGrid: bool * ?GridColor: Color * ?GridWidth: float * ?ZeroLine: bool * ?ZeroLineColor: Color * ?ZeroLineWidth: float * ?ShowDividers: bool * ?DividerColor: Color * ?DividerWidth: int * ?Anchor: LinearAxisId * ?Side: Side * ?Overlaying: LinearAxisId * ?Layer: Layer * ?Domain: Range * ?Position: float * ?CategoryArray: seq<#IConvertible> * ?UIRevision: #IConvertible * ?RangeSlider: RangeSlider * ?RangeSelector: RangeSelector * ?Calendar: Calendar -> LinearAxis static member initIndicatorGauge: ?DTick: #IConvertible * ?ExponentFormat: ExponentFormat * ?MinExponent: float * ?NTicks: int * ?Range: Range * ?SeparateThousands: bool * ?ShowExponent: ShowExponent * ?ShowTickLabels: bool * ?ShowTickPrefix: ShowTickOption * ?ShowTickSuffix: ShowTickOption * ?Tick0: #IConvertible * ?TickAngle: int * ?TickColor: Color * ?TickFont: Font * ?TickFormat: string * ?TickFormatStops: seq<TickFormatStop> * ?TickLen: int * ?TickMode: TickMode * ?TickPrefix: string * ?Ticks: TickOptions * ?TickSuffix: string * ?TickText: seq<#IConvertible> * ?TickVals: seq<#IConvertible> * ?TickWidth: int * ?Visible: bool -> LinearAxis static member style: ?Visible: bool * ?Color: Color * ?Title: Title * ?AxisType: AxisType * ?AutoTypeNumbers: AutoTypeNumbers * ?AutoRange: AutoRange * ?RangeMode: RangeMode * ?Range: Range * ?FixedRange: bool * ?ScaleAnchor: LinearAxisId * ?ScaleRatio: float * ?Constrain: AxisConstraint * ?ConstrainToward: AxisConstraintDirection * ?Matches: LinearAxisId * ?Rangebreaks: seq<Rangebreak> * ?TickMode: TickMode * ?NTicks: int * ?Tick0: #IConvertible * ?DTick: #IConvertible * ?TickVals: seq<#IConvertible> * ?TickText: seq<#IConvertible> * ?Ticks: TickOptions * ?TicksOn: CategoryTickAnchor * ?TickLabelMode: TickLabelMode * ?TickLabelPosition: TickLabelPosition * ?TickLabelOverflow: TickLabelOverflow * ?Mirror: Mirror * ?TickLen: int * ?TickWidth: int * ?TickColor: Color * ?ShowTickLabels: bool * ?AutoMargin: bool * ?ShowSpikes: bool * ?SpikeColor: Color * ?SpikeThickness: int * ?SpikeDash: DrawingStyle * ?SpikeMode: SpikeMode * ?SpikeSnap: SpikeSnap * ?TickFont: Font * ?TickAngle: int * ?ShowTickPrefix: ShowTickOption * ?TickPrefix: string * ?ShowTickSuffix: ShowTickOption * ?TickSuffix: string * ?ShowExponent: ShowExponent * ?ExponentFormat: ExponentFormat * ?MinExponent: float * ?SeparateThousands: bool * ?TickFormat: string * ?TickFormatStops: seq<TickFormatStop> * ?HoverFormat: string * ?ShowLine: bool * ?LineColor: Color * ?LineWidth: float * ?ShowGrid: bool * ?GridColor: Color * ?GridWidth: float * ?ZeroLine: bool * ?ZeroLineColor: Color * ?ZeroLineWidth: float * ?ShowDividers: bool * ?DividerColor: Color * ?DividerWidth: int * ?Anchor: LinearAxisId * ?Side: Side * ?Overlaying: LinearAxisId * ?Layer: Layer * ?Domain: Range * ?Position: float * ?CategoryOrder: CategoryOrder * ?CategoryArray: seq<#IConvertible> * ?UIRevision: #IConvertible * ?RangeSlider: RangeSlider * ?RangeSelector: RangeSelector * ?Calendar: Calendar * ?ArrayDTick: int * ?ArrayTick0: int * ?CheaterType: CheaterType * ?EndLine: bool * ?EndLineColor: Color * ?EndLineWidth: int * ?LabelPadding: int * ?LabelPrefix: string * ?LabelSuffix: string * ?MinorGridColor: Color * ?MinorGridCount: int * ?MinorGridWidth: int * ?Smoothing: float * ?StartLine: bool * ?StartLineColor: Color * ?StartLineWidth: int * ?BackgroundColor: Color * ?ShowBackground: bool -> (LinearAxis -> LinearAxis)
<summary>Linear axes can be used as x and y scales on 2D plots, and as x,y, and z scales on 3D plots.</summary>
--------------------
new: unit -> LinearAxis
type LinearAxis = inherit DynamicObj new: unit -> LinearAxis static member init: ?Visible: bool * ?Color: Color * ?Title: Title * ?AxisType: AxisType * ?AutoTypeNumbers: AutoTypeNumbers * ?AutoRange: AutoRange * ?RangeMode: RangeMode * ?Range: Range * ?FixedRange: bool * ?ScaleAnchor: LinearAxisId * ?ScaleRatio: float * ?Constrain: AxisConstraint * ?ConstrainToward: AxisConstraintDirection * ?Matches: LinearAxisId * ?Rangebreaks: seq<Rangebreak> * ?TickMode: TickMode * ?NTicks: int * ?Tick0: #IConvertible * ?DTick: #IConvertible * ?TickVals: seq<#IConvertible> * ?TickText: seq<#IConvertible> * ?Ticks: TickOptions * ?TicksOn: CategoryTickAnchor * ?TickLabelMode: TickLabelMode * ?TickLabelPosition: TickLabelPosition * ?TickLabelOverflow: TickLabelOverflow * ?Mirror: Mirror * ?TickLen: int * ?TickWidth: int * ?TickColor: Color * ?ShowTickLabels: bool * ?AutoMargin: bool * ?ShowSpikes: bool * ?SpikeColor: Color * ?SpikeThickness: int * ?SpikeDash: DrawingStyle * ?SpikeMode: SpikeMode * ?SpikeSnap: SpikeSnap * ?TickFont: Font * ?TickAngle: int * ?ShowTickPrefix: ShowTickOption * ?TickPrefix: string * ?ShowTickSuffix: ShowTickOption * ?TickSuffix: string * ?ShowExponent: ShowExponent * ?ExponentFormat: ExponentFormat * ?MinExponent: float * ?SeparateThousands: bool * ?TickFormat: string * ?TickFormatStops: seq<TickFormatStop> * ?HoverFormat: string * ?ShowLine: bool * ?LineColor: Color * ?LineWidth: float * ?ShowGrid: bool * ?GridColor: Color * ?GridWidth: float * ?ZeroLine: bool * ?ZeroLineColor: Color * ?ZeroLineWidth: float * ?ShowDividers: bool * ?DividerColor: Color * ?DividerWidth: int * ?Anchor: LinearAxisId * ?Side: Side * ?Overlaying: LinearAxisId * ?Layer: Layer * ?Domain: Range * ?Position: float * ?CategoryOrder: CategoryOrder * ?CategoryArray: seq<#IConvertible> * ?UIRevision: #IConvertible * ?RangeSlider: RangeSlider * ?RangeSelector: RangeSelector * ?Calendar: Calendar * ?BackgroundColor: Color * ?ShowBackground: bool -> LinearAxis static member initCarpet: ?Color: Color * ?Title: Title * ?AxisType: AxisType * ?AutoTypeNumbers: AutoTypeNumbers * ?AutoRange: AutoRange * ?RangeMode: RangeMode * ?Range: Range * ?FixedRange: bool * ?TickMode: TickMode * ?NTicks: int * ?Tick0: #IConvertible * ?DTick: #IConvertible * ?TickVals: seq<#IConvertible> * ?TickText: seq<#IConvertible> * ?Ticks: TickOptions * ?ShowTickLabels: bool * ?TickFont: Font * ?TickAngle: int * ?ShowTickPrefix: ShowTickOption * ?TickPrefix: string * ?ShowTickSuffix: ShowTickOption * ?TickSuffix: string * ?ShowExponent: ShowExponent * ?ExponentFormat: ExponentFormat * ?MinExponent: float * ?SeparateThousands: bool * ?TickFormat: string * ?TickFormatStops: seq<TickFormatStop> * ?ShowLine: bool * ?LineColor: Color * ?LineWidth: float * ?ShowGrid: bool * ?GridColor: Color * ?GridWidth: float * ?CategoryOrder: CategoryOrder * ?CategoryArray: seq<#IConvertible> * ?ArrayDTick: int * ?ArrayTick0: int * ?CheaterType: CheaterType * ?EndLine: bool * ?EndLineColor: Color * ?EndLineWidth: int * ?LabelPadding: int * ?LabelPrefix: string * ?LabelSuffix: string * ?MinorGridColor: Color * ?MinorGridCount: int * ?MinorGridWidth: int * ?Smoothing: float * ?StartLine: bool * ?StartLineColor: Color * ?StartLineWidth: int -> LinearAxis static member initCategorical: categoryOrder: CategoryOrder * ?Visible: bool * ?Color: Color * ?Title: Title * ?AutoTypeNumbers: AutoTypeNumbers * ?AutoRange: AutoRange * ?RangeMode: RangeMode * ?Range: Range * ?FixedRange: bool * ?ScaleAnchor: LinearAxisId * ?ScaleRatio: float * ?Constrain: AxisConstraint * ?ConstrainToward: AxisConstraintDirection * ?Matches: LinearAxisId * ?Rangebreaks: seq<Rangebreak> * ?TickMode: TickMode * ?NTicks: int * ?Tick0: #IConvertible * ?DTick: #IConvertible * ?TickVals: seq<#IConvertible> * ?TickText: seq<#IConvertible> * ?Ticks: TickOptions * ?TicksOn: CategoryTickAnchor * ?TickLabelMode: TickLabelMode * ?TickLabelPosition: TickLabelPosition * ?TickLabelOverflow: TickLabelOverflow * ?Mirror: Mirror * ?TickLen: int * ?TickWidth: int * ?TickColor: Color * ?ShowTickLabels: bool * ?AutoMargin: bool * ?ShowSpikes: bool * ?SpikeColor: Color * ?SpikeThickness: int * ?SpikeDash: DrawingStyle * ?SpikeMode: SpikeMode * ?SpikeSnap: SpikeSnap * ?TickFont: Font * ?TickAngle: int * ?ShowTickPrefix: ShowTickOption * ?TickPrefix: string * ?ShowTickSuffix: ShowTickOption * ?TickSuffix: string * ?ShowExponent: ShowExponent * ?ExponentFormat: ExponentFormat * ?MinExponent: float * ?SeparateThousands: bool * ?TickFormat: string * ?TickFormatStops: seq<TickFormatStop> * ?HoverFormat: string * ?ShowLine: bool * ?LineColor: Color * ?LineWidth: float * ?ShowGrid: bool * ?GridColor: Color * ?GridWidth: float * ?ZeroLine: bool * ?ZeroLineColor: Color * ?ZeroLineWidth: float * ?ShowDividers: bool * ?DividerColor: Color * ?DividerWidth: int * ?Anchor: LinearAxisId * ?Side: Side * ?Overlaying: LinearAxisId * ?Layer: Layer * ?Domain: Range * ?Position: float * ?CategoryArray: seq<#IConvertible> * ?UIRevision: #IConvertible * ?RangeSlider: RangeSlider * ?RangeSelector: RangeSelector * ?Calendar: Calendar -> LinearAxis static member initIndicatorGauge: ?DTick: #IConvertible * ?ExponentFormat: ExponentFormat * ?MinExponent: float * ?NTicks: int * ?Range: Range * ?SeparateThousands: bool * ?ShowExponent: ShowExponent * ?ShowTickLabels: bool * ?ShowTickPrefix: ShowTickOption * ?ShowTickSuffix: ShowTickOption * ?Tick0: #IConvertible * ?TickAngle: int * ?TickColor: Color * ?TickFont: Font * ?TickFormat: string * ?TickFormatStops: seq<TickFormatStop> * ?TickLen: int * ?TickMode: TickMode * ?TickPrefix: string * ?Ticks: TickOptions * ?TickSuffix: string * ?TickText: seq<#IConvertible> * ?TickVals: seq<#IConvertible> * ?TickWidth: int * ?Visible: bool -> LinearAxis static member style: ?Visible: bool * ?Color: Color * ?Title: Title * ?AxisType: AxisType * ?AutoTypeNumbers: AutoTypeNumbers * ?AutoRange: AutoRange * ?RangeMode: RangeMode * ?Range: Range * ?FixedRange: bool * ?ScaleAnchor: LinearAxisId * ?ScaleRatio: float * ?Constrain: AxisConstraint * ?ConstrainToward: AxisConstraintDirection * ?Matches: LinearAxisId * ?Rangebreaks: seq<Rangebreak> * ?TickMode: TickMode * ?NTicks: int * ?Tick0: #IConvertible * ?DTick: #IConvertible * ?TickVals: seq<#IConvertible> * ?TickText: seq<#IConvertible> * ?Ticks: TickOptions * ?TicksOn: CategoryTickAnchor * ?TickLabelMode: TickLabelMode * ?TickLabelPosition: TickLabelPosition * ?TickLabelOverflow: TickLabelOverflow * ?Mirror: Mirror * ?TickLen: int * ?TickWidth: int * ?TickColor: Color * ?ShowTickLabels: bool * ?AutoMargin: bool * ?ShowSpikes: bool * ?SpikeColor: Color * ?SpikeThickness: int * ?SpikeDash: DrawingStyle * ?SpikeMode: SpikeMode * ?SpikeSnap: SpikeSnap * ?TickFont: Font * ?TickAngle: int * ?ShowTickPrefix: ShowTickOption * ?TickPrefix: string * ?ShowTickSuffix: ShowTickOption * ?TickSuffix: string * ?ShowExponent: ShowExponent * ?ExponentFormat: ExponentFormat * ?MinExponent: float * ?SeparateThousands: bool * ?TickFormat: string * ?TickFormatStops: seq<TickFormatStop> * ?HoverFormat: string * ?ShowLine: bool * ?LineColor: Color * ?LineWidth: float * ?ShowGrid: bool * ?GridColor: Color * ?GridWidth: float * ?ZeroLine: bool * ?ZeroLineColor: Color * ?ZeroLineWidth: float * ?ShowDividers: bool * ?DividerColor: Color * ?DividerWidth: int * ?Anchor: LinearAxisId * ?Side: Side * ?Overlaying: LinearAxisId * ?Layer: Layer * ?Domain: Range * ?Position: float * ?CategoryOrder: CategoryOrder * ?CategoryArray: seq<#IConvertible> * ?UIRevision: #IConvertible * ?RangeSlider: RangeSlider * ?RangeSelector: RangeSelector * ?Calendar: Calendar * ?ArrayDTick: int * ?ArrayTick0: int * ?CheaterType: CheaterType * ?EndLine: bool * ?EndLineColor: Color * ?EndLineWidth: int * ?LabelPadding: int * ?LabelPrefix: string * ?LabelSuffix: string * ?MinorGridColor: Color * ?MinorGridCount: int * ?MinorGridWidth: int * ?Smoothing: float * ?StartLine: bool * ?StartLineColor: Color * ?StartLineWidth: int * ?BackgroundColor: Color * ?ShowBackground: bool -> (LinearAxis -> LinearAxis)
<summary>Linear axes can be used as x and y scales on 2D plots, and as x,y, and z scales on 3D plots.</summary>
--------------------
new: unit -> LinearAxis
static member LinearAxis.init: ?Visible: bool * ?Color: Color * ?Title: Title * ?AxisType: AxisType * ?AutoTypeNumbers: AutoTypeNumbers * ?AutoRange: AutoRange * ?RangeMode: RangeMode * ?Range: Range * ?FixedRange: bool * ?ScaleAnchor: LinearAxisId * ?ScaleRatio: float * ?Constrain: AxisConstraint * ?ConstrainToward: AxisConstraintDirection * ?Matches: LinearAxisId * ?Rangebreaks: seq<Rangebreak> * ?TickMode: TickMode * ?NTicks: int * ?Tick0: #System.IConvertible * ?DTick: #System.IConvertible * ?TickVals: seq<#System.IConvertible> * ?TickText: seq<#System.IConvertible> * ?Ticks: TickOptions * ?TicksOn: CategoryTickAnchor * ?TickLabelMode: TickLabelMode * ?TickLabelPosition: TickLabelPosition * ?TickLabelOverflow: TickLabelOverflow * ?Mirror: Mirror * ?TickLen: int * ?TickWidth: int * ?TickColor: Color * ?ShowTickLabels: bool * ?AutoMargin: bool * ?ShowSpikes: bool * ?SpikeColor: Color * ?SpikeThickness: int * ?SpikeDash: DrawingStyle * ?SpikeMode: SpikeMode * ?SpikeSnap: SpikeSnap * ?TickFont: Font * ?TickAngle: int * ?ShowTickPrefix: ShowTickOption * ?TickPrefix: string * ?ShowTickSuffix: ShowTickOption * ?TickSuffix: string * ?ShowExponent: ShowExponent * ?ExponentFormat: ExponentFormat * ?MinExponent: float * ?SeparateThousands: bool * ?TickFormat: string * ?TickFormatStops: seq<TickFormatStop> * ?HoverFormat: string * ?ShowLine: bool * ?LineColor: Color * ?LineWidth: float * ?ShowGrid: bool * ?GridColor: Color * ?GridWidth: float * ?ZeroLine: bool * ?ZeroLineColor: Color * ?ZeroLineWidth: float * ?ShowDividers: bool * ?DividerColor: Color * ?DividerWidth: int * ?Anchor: LinearAxisId * ?Side: Side * ?Overlaying: LinearAxisId * ?Layer: Layer * ?Domain: Range * ?Position: float * ?CategoryOrder: CategoryOrder * ?CategoryArray: seq<#System.IConvertible> * ?UIRevision: #System.IConvertible * ?RangeSlider: RangeSlider * ?RangeSelector: RangeSelector * ?Calendar: Calendar * ?BackgroundColor: Color * ?ShowBackground: bool -> LinearAxis
Multiple items
type Title = inherit DynamicObj new: unit -> Title static member init: ?Text: string * ?Font: Font * ?Standoff: int * ?Side: Side * ?X: float * ?Y: float -> Title static member style: ?Text: string * ?Font: Font * ?Standoff: int * ?Side: Side * ?X: float * ?Y: float -> (Title -> Title)
--------------------
new: unit -> Title
type Title = inherit DynamicObj new: unit -> Title static member init: ?Text: string * ?Font: Font * ?Standoff: int * ?Side: Side * ?X: float * ?Y: float -> Title static member style: ?Text: string * ?Font: Font * ?Standoff: int * ?Side: Side * ?X: float * ?Y: float -> (Title -> Title)
--------------------
new: unit -> Title
static member Title.init: ?Text: string * ?Font: Font * ?Standoff: int * ?Side: Side * ?X: float * ?Y: float -> Title
type Mirror =
| True
| Ticks
| False
| All
| AllTicks
member Convert: unit -> obj
override ToString: unit -> string
static member convert: (Mirror -> obj)
static member toString: (Mirror -> string)
<summary> Determines if the axis lines or/and ticks are mirrored to the opposite side of the plotting area. If "true", the axis lines are mirrored. If "ticks", the axis lines and ticks are mirrored. If "false", mirroring is disable. If "all", axis lines are mirrored on all shared-axes subplots. If "allticks", axis lines and ticks are mirrored on all shared-axes subplots. </summary>
<summary> Determines if the axis lines or/and ticks are mirrored to the opposite side of the plotting area. If "true", the axis lines are mirrored. If "ticks", the axis lines and ticks are mirrored. If "false", mirroring is disable. If "all", axis lines are mirrored on all shared-axes subplots. If "allticks", axis lines and ticks are mirrored on all shared-axes subplots. </summary>
union case Mirror.All: Mirror
type TickOptions =
| Outside
| Inside
| Empty
member Convert: unit -> obj
override ToString: unit -> string
static member convert: (TickOptions -> obj)
static member toString: (TickOptions -> string)
<summary> Determines whether ticks are drawn or not. If "", this axis' ticks are not drawn. If "outside" ("inside"), this axis' are drawn outside (inside) the axis lines. </summary>
<summary> Determines whether ticks are drawn or not. If "", this axis' ticks are not drawn. If "outside" ("inside"), this axis' are drawn outside (inside) the axis lines. </summary>
union case TickOptions.Inside: TickOptions
val myAxisRange: name: string -> min: float * max: float -> LinearAxis
val min: float
val max: float
type Range =
| MinMax of float * float
| Values of float array
member Convert: unit -> obj
static member convert: (Range -> obj)
<summary> Defines a Range between min and max value </summary>
<summary> Defines a Range between min and max value </summary>
union case Range.MinMax: float * float -> Range
val withAxisTitles: x: string -> y: string -> chart: GenericChart.GenericChart -> GenericChart.GenericChart
val x: string
val y: string
val chart: GenericChart.GenericChart
static member Chart.withTemplate: template: Template -> (GenericChart.GenericChart -> GenericChart.GenericChart)
module ChartTemplates
from Plotly.NET
val lightMirrored: Template
static member Chart.withXAxis: xAxis: LinearAxis * ?Id: SubPlotId -> (GenericChart.GenericChart -> GenericChart.GenericChart)
static member Chart.withYAxis: yAxis: LinearAxis * ?Id: SubPlotId -> (GenericChart.GenericChart -> GenericChart.GenericChart)
Multiple items
namespace FSharp
--------------------
namespace Microsoft.FSharp
namespace FSharp
--------------------
namespace Microsoft.FSharp
namespace FSharp.Stats
val fromFileWithSep: separator: char -> filePath: string -> seq<string[]>
val separator: char
Multiple items
val char: value: 'T -> char (requires member op_Explicit)
<summary>Converts the argument to character. Numeric inputs are converted according to the UTF-16 encoding for characters. String inputs must be exactly one character long. For other input types the operation requires an appropriate static conversion method on the input type.</summary>
<param name="value">The input value.</param>
<returns>The converted char.</returns>
<example id="char-example"><code lang="fsharp"></code></example>
--------------------
[<Struct>] type char = System.Char
<summary>An abbreviation for the CLI type <see cref="T:System.Char" />.</summary>
<category>Basic Types</category>
val char: value: 'T -> char (requires member op_Explicit)
<summary>Converts the argument to character. Numeric inputs are converted according to the UTF-16 encoding for characters. String inputs must be exactly one character long. For other input types the operation requires an appropriate static conversion method on the input type.</summary>
<param name="value">The input value.</param>
<returns>The converted char.</returns>
<example id="char-example"><code lang="fsharp"></code></example>
--------------------
[<Struct>] type char = System.Char
<summary>An abbreviation for the CLI type <see cref="T:System.Char" />.</summary>
<category>Basic Types</category>
val filePath: string
Multiple items
val seq: sequence: seq<'T> -> seq<'T>
<summary>Builds a sequence using sequence expression syntax</summary>
<param name="sequence">The input sequence.</param>
<returns>The result sequence.</returns>
<example id="seq-cast-example"><code lang="fsharp"> seq { for i in 0..10 do yield (i, i*i) } </code></example>
--------------------
type seq<'T> = System.Collections.Generic.IEnumerable<'T>
<summary>An abbreviation for the CLI type <see cref="T:System.Collections.Generic.IEnumerable`1" /></summary>
<remarks> See the <see cref="T:Microsoft.FSharp.Collections.SeqModule" /> module for further operations related to sequences. See also <a href="https://docs.microsoft.com/dotnet/fsharp/language-reference/sequences">F# Language Guide - Sequences</a>. </remarks>
val seq: sequence: seq<'T> -> seq<'T>
<summary>Builds a sequence using sequence expression syntax</summary>
<param name="sequence">The input sequence.</param>
<returns>The result sequence.</returns>
<example id="seq-cast-example"><code lang="fsharp"> seq { for i in 0..10 do yield (i, i*i) } </code></example>
--------------------
type seq<'T> = System.Collections.Generic.IEnumerable<'T>
<summary>An abbreviation for the CLI type <see cref="T:System.Collections.Generic.IEnumerable`1" /></summary>
<remarks> See the <see cref="T:Microsoft.FSharp.Collections.SeqModule" /> module for further operations related to sequences. See also <a href="https://docs.microsoft.com/dotnet/fsharp/language-reference/sequences">F# Language Guide - Sequences</a>. </remarks>
val sr: System.IO.StreamReader
namespace System
namespace System.IO
type File =
static member AppendAllLines: path: string * contents: IEnumerable<string> -> unit + 1 overload
static member AppendAllLinesAsync: path: string * contents: IEnumerable<string> * encoding: Encoding * ?cancellationToken: CancellationToken -> Task + 1 overload
static member AppendAllText: path: string * contents: string -> unit + 1 overload
static member AppendAllTextAsync: path: string * contents: string * encoding: Encoding * ?cancellationToken: CancellationToken -> Task + 1 overload
static member AppendText: path: string -> StreamWriter
static member Copy: sourceFileName: string * destFileName: string -> unit + 1 overload
static member Create: path: string -> FileStream + 2 overloads
static member CreateSymbolicLink: path: string * pathToTarget: string -> FileSystemInfo
static member CreateText: path: string -> StreamWriter
static member Decrypt: path: string -> unit
...
<summary>Provides static methods for the creation, copying, deletion, moving, and opening of a single file, and aids in the creation of <see cref="T:System.IO.FileStream" /> objects.</summary>
<summary>Provides static methods for the creation, copying, deletion, moving, and opening of a single file, and aids in the creation of <see cref="T:System.IO.FileStream" /> objects.</summary>
System.IO.File.OpenText(path: string) : System.IO.StreamReader
property System.IO.StreamReader.EndOfStream: bool with get
<summary>Gets a value that indicates whether the current stream position is at the end of the stream.</summary>
<exception cref="T:System.ObjectDisposedException">The underlying stream has been disposed.</exception>
<returns><see langword="true" /> if the current stream position is at the end of the stream; otherwise <see langword="false" />.</returns>
<summary>Gets a value that indicates whether the current stream position is at the end of the stream.</summary>
<exception cref="T:System.ObjectDisposedException">The underlying stream has been disposed.</exception>
<returns><see langword="true" /> if the current stream position is at the end of the stream; otherwise <see langword="false" />.</returns>
val line: string
System.IO.StreamReader.ReadLine() : string
val words: string[]
System.String.Split([<System.ParamArray>] separator: char[]) : string[]
System.String.Split(separator: string[], options: System.StringSplitOptions) : string[]
System.String.Split(separator: string, ?options: System.StringSplitOptions) : string[]
System.String.Split(separator: char[], options: System.StringSplitOptions) : string[]
System.String.Split(separator: char[], count: int) : string[]
System.String.Split(separator: char, ?options: System.StringSplitOptions) : string[]
System.String.Split(separator: string[], count: int, options: System.StringSplitOptions) : string[]
System.String.Split(separator: string, count: int, ?options: System.StringSplitOptions) : string[]
System.String.Split(separator: char[], count: int, options: System.StringSplitOptions) : string[]
System.String.Split(separator: char, count: int, ?options: System.StringSplitOptions) : string[]
System.String.Split(separator: string[], options: System.StringSplitOptions) : string[]
System.String.Split(separator: string, ?options: System.StringSplitOptions) : string[]
System.String.Split(separator: char[], options: System.StringSplitOptions) : string[]
System.String.Split(separator: char[], count: int) : string[]
System.String.Split(separator: char, ?options: System.StringSplitOptions) : string[]
System.String.Split(separator: string[], count: int, options: System.StringSplitOptions) : string[]
System.String.Split(separator: string, count: int, ?options: System.StringSplitOptions) : string[]
System.String.Split(separator: char[], count: int, options: System.StringSplitOptions) : string[]
System.String.Split(separator: char, count: int, ?options: System.StringSplitOptions) : string[]
val lables: string[]
val data: float[][]
Multiple items
module Seq from FSharp.Stats
<summary> Module to compute common statistical measure </summary>
--------------------
module Seq from Plotly.NET
--------------------
module Seq from Microsoft.FSharp.Collections
<summary>Contains operations for working with values of type <see cref="T:Microsoft.FSharp.Collections.seq`1" />.</summary>
module Seq from FSharp.Stats
<summary> Module to compute common statistical measure </summary>
--------------------
module Seq from Plotly.NET
--------------------
module Seq from Microsoft.FSharp.Collections
<summary>Contains operations for working with values of type <see cref="T:Microsoft.FSharp.Collections.seq`1" />.</summary>
val skip: count: int -> source: seq<'T> -> seq<'T>
<summary>Returns a sequence that skips N elements of the underlying sequence and then yields the remaining elements of the sequence.</summary>
<param name="count">The number of items to skip.</param>
<param name="source">The input sequence.</param>
<returns>The result sequence.</returns>
<exception cref="T:System.ArgumentNullException">Thrown when the input sequence is null.</exception>
<exception cref="T:System.InvalidOperationException">Thrown when count exceeds the number of elements in the sequence.</exception>
<example id="skip-1"><code lang="fsharp"> let inputs = ["a"; "b"; "c"; "d"] inputs |> Seq.skip 2 </code> Evaluates a sequence yielding the same results as <c>seq { "c"; "d" }</c></example>
<example id="skip-2"><code lang="fsharp"> let inputs = ["a"; "b"; "c"; "d"] inputs |> Seq.skip 5 </code> Throws <c>ArgumentException</c>. </example>
<example id="skip-3"><code lang="fsharp"> let inputs = ["a"; "b"; "c"; "d"] inputs |> Seq.skip -1 </code> Evaluates a sequence yielding the same results as <c>seq { "a"; "b"; "c"; "d" }</c>. </example>
<summary>Returns a sequence that skips N elements of the underlying sequence and then yields the remaining elements of the sequence.</summary>
<param name="count">The number of items to skip.</param>
<param name="source">The input sequence.</param>
<returns>The result sequence.</returns>
<exception cref="T:System.ArgumentNullException">Thrown when the input sequence is null.</exception>
<exception cref="T:System.InvalidOperationException">Thrown when count exceeds the number of elements in the sequence.</exception>
<example id="skip-1"><code lang="fsharp"> let inputs = ["a"; "b"; "c"; "d"] inputs |> Seq.skip 2 </code> Evaluates a sequence yielding the same results as <c>seq { "c"; "d" }</c></example>
<example id="skip-2"><code lang="fsharp"> let inputs = ["a"; "b"; "c"; "d"] inputs |> Seq.skip 5 </code> Throws <c>ArgumentException</c>. </example>
<example id="skip-3"><code lang="fsharp"> let inputs = ["a"; "b"; "c"; "d"] inputs |> Seq.skip -1 </code> Evaluates a sequence yielding the same results as <c>seq { "a"; "b"; "c"; "d" }</c>. </example>
val map: mapping: ('T -> 'U) -> source: seq<'T> -> seq<'U>
<summary>Builds a new collection whose elements are the results of applying the given function to each of the elements of the collection. The given function will be applied as elements are demanded using the <c>MoveNext</c> method on enumerators retrieved from the object.</summary>
<remarks>The returned sequence may be passed between threads safely. However, individual IEnumerator values generated from the returned sequence should not be accessed concurrently.</remarks>
<param name="mapping">A function to transform items from the input sequence.</param>
<param name="source">The input sequence.</param>
<returns>The result sequence.</returns>
<exception cref="T:System.ArgumentNullException">Thrown when the input sequence is null.</exception>
<example id="item-1"><code lang="fsharp"> let inputs = ["a"; "bbb"; "cc"] inputs |> Seq.map (fun x -> x.Length) </code> Evaluates to a sequence yielding the same results as <c>seq { 1; 3; 2 }</c></example>
<summary>Builds a new collection whose elements are the results of applying the given function to each of the elements of the collection. The given function will be applied as elements are demanded using the <c>MoveNext</c> method on enumerators retrieved from the object.</summary>
<remarks>The returned sequence may be passed between threads safely. However, individual IEnumerator values generated from the returned sequence should not be accessed concurrently.</remarks>
<param name="mapping">A function to transform items from the input sequence.</param>
<param name="source">The input sequence.</param>
<returns>The result sequence.</returns>
<exception cref="T:System.ArgumentNullException">Thrown when the input sequence is null.</exception>
<example id="item-1"><code lang="fsharp"> let inputs = ["a"; "bbb"; "cc"] inputs |> Seq.map (fun x -> x.Length) </code> Evaluates to a sequence yielding the same results as <c>seq { 1; 3; 2 }</c></example>
val arr: string[]
Multiple items
val float: value: 'T -> float (requires member op_Explicit)
<summary>Converts the argument to 64-bit float. This is a direct conversion for all primitive numeric types. For strings, the input is converted using <c>Double.Parse()</c> with InvariantCulture settings. Otherwise the operation requires an appropriate static conversion method on the input type.</summary>
<param name="value">The input value.</param>
<returns>The converted float</returns>
<example id="float-example"><code lang="fsharp"></code></example>
--------------------
[<Struct>] type float = System.Double
<summary>An abbreviation for the CLI type <see cref="T:System.Double" />.</summary>
<category>Basic Types</category>
--------------------
type float<'Measure> = float
<summary>The type of double-precision floating point numbers, annotated with a unit of measure. The unit of measure is erased in compiled code and when values of this type are analyzed using reflection. The type is representationally equivalent to <see cref="T:System.Double" />.</summary>
<category index="6">Basic Types with Units of Measure</category>
val float: value: 'T -> float (requires member op_Explicit)
<summary>Converts the argument to 64-bit float. This is a direct conversion for all primitive numeric types. For strings, the input is converted using <c>Double.Parse()</c> with InvariantCulture settings. Otherwise the operation requires an appropriate static conversion method on the input type.</summary>
<param name="value">The input value.</param>
<returns>The converted float</returns>
<example id="float-example"><code lang="fsharp"></code></example>
--------------------
[<Struct>] type float = System.Double
<summary>An abbreviation for the CLI type <see cref="T:System.Double" />.</summary>
<category>Basic Types</category>
--------------------
type float<'Measure> = float
<summary>The type of double-precision floating point numbers, annotated with a unit of measure. The unit of measure is erased in compiled code and when values of this type are analyzed using reflection. The type is representationally equivalent to <see cref="T:System.Double" />.</summary>
<category index="6">Basic Types with Units of Measure</category>
val toArray: source: seq<'T> -> 'T[]
<summary>Builds an array from the given collection.</summary>
<param name="source">The input sequence.</param>
<returns>The result array.</returns>
<exception cref="T:System.ArgumentNullException">Thrown when the input sequence is null.</exception>
<example id="toarray-1"><code lang="fsharp"> let inputs = seq { 1; 2; 5 } inputs |> Seq.toArray </code> Evaluates to <c>[| 1; 2; 5 |]</c>. </example>
<summary>Builds an array from the given collection.</summary>
<param name="source">The input sequence.</param>
<returns>The result array.</returns>
<exception cref="T:System.ArgumentNullException">Thrown when the input sequence is null.</exception>
<example id="toarray-1"><code lang="fsharp"> let inputs = seq { 1; 2; 5 } inputs |> Seq.toArray </code> Evaluates to <c>[| 1; 2; 5 |]</c>. </example>
Multiple items
module Array from FSharp.Stats
<summary> Module to compute common statistical measure on array </summary>
--------------------
module Array from Microsoft.FSharp.Collections
<summary>Contains operations for working with arrays.</summary>
<remarks> See also <a href="https://docs.microsoft.com/dotnet/fsharp/language-reference/arrays">F# Language Guide - Arrays</a>. </remarks>
module Array from FSharp.Stats
<summary> Module to compute common statistical measure on array </summary>
--------------------
module Array from Microsoft.FSharp.Collections
<summary>Contains operations for working with arrays.</summary>
<remarks> See also <a href="https://docs.microsoft.com/dotnet/fsharp/language-reference/arrays">F# Language Guide - Arrays</a>. </remarks>
val shuffleFisherYates: arr: 'b[] -> 'b[]
<summary> Shuffels the input array (method: Fisher-Yates) </summary>
<summary> Shuffels the input array (method: Fisher-Yates) </summary>
val mapi: mapping: (int -> 'T -> 'U) -> array: 'T[] -> 'U[]
<summary>Builds a new array whose elements are the results of applying the given function to each of the elements of the array. The integer index passed to the function indicates the index of element being transformed, starting at zero.</summary>
<param name="mapping">The function to transform elements and their indices.</param>
<param name="array">The input array.</param>
<returns>The array of transformed elements.</returns>
<exception cref="T:System.ArgumentNullException">Thrown when the input array is null.</exception>
<example id="mapi-1"><code lang="fsharp"> let inputs = [| 10; 10; 10 |] inputs |> Array.mapi (fun i x -> i + x) </code> Evaluates to <c>[| 10; 11; 12 |]</c></example>
<summary>Builds a new array whose elements are the results of applying the given function to each of the elements of the array. The integer index passed to the function indicates the index of element being transformed, starting at zero.</summary>
<param name="mapping">The function to transform elements and their indices.</param>
<param name="array">The input array.</param>
<returns>The array of transformed elements.</returns>
<exception cref="T:System.ArgumentNullException">Thrown when the input array is null.</exception>
<example id="mapi-1"><code lang="fsharp"> let inputs = [| 10; 10; 10 |] inputs |> Array.mapi (fun i x -> i + x) </code> Evaluates to <c>[| 10; 11; 12 |]</c></example>
val i: int
val lable: string
val data: float[]
val sprintf: format: Printf.StringFormat<'T> -> 'T
<summary>Print to a string using the given format.</summary>
<param name="format">The formatter.</param>
<returns>The formatted result.</returns>
<example>See <c>Printf.sprintf</c> (link: <see cref="M:Microsoft.FSharp.Core.PrintfModule.PrintFormatToStringThen``1" />) for examples.</example>
<summary>Print to a string using the given format.</summary>
<param name="format">The formatter.</param>
<returns>The formatted result.</returns>
<example>See <c>Printf.sprintf</c> (link: <see cref="M:Microsoft.FSharp.Core.PrintfModule.PrintFormatToStringThen``1" />) for examples.</example>
val unzip: array: ('T1 * 'T2)[] -> 'T1[] * 'T2[]
<summary>Splits an array of pairs into two arrays.</summary>
<param name="array">The input array.</param>
<returns>The two arrays.</returns>
<exception cref="T:System.ArgumentNullException">Thrown when the input array is null.</exception>
<example id="unzip-1"><code lang="fsharp"> let inputs = [| (1, "one"); (2, "two") |] let numbers, names = inputs |> Array.unzip </code> Evaluates <c>numbers</c> to <c>[|1; 2|]</c> and <c>names</c> to <c>[|"one"; "two"|]</c>. </example>
<summary>Splits an array of pairs into two arrays.</summary>
<param name="array">The input array.</param>
<returns>The two arrays.</returns>
<exception cref="T:System.ArgumentNullException">Thrown when the input array is null.</exception>
<example id="unzip-1"><code lang="fsharp"> let inputs = [| (1, "one"); (2, "two") |] let numbers, names = inputs |> Array.unzip </code> Evaluates <c>numbers</c> to <c>[|1; 2|]</c> and <c>names</c> to <c>[|"one"; "two"|]</c>. </example>
val colnames: string list
val colorscaleValue: Colorscale
type Colorscale =
| Custom of seq<float * string>
| RdBu
| Earth
| Blackbody
| YIOrRd
| YIGnBu
| Bluered
| Portland
| Electric
| Jet
...
member Convert: unit -> obj
static member convert: (Colorscale -> obj)
<summary> The colorscale must be a collection containing a mapping of a normalized value (between 0.0 and 1.0) to it's color. At minimum, a mapping for the lowest (0.0) and highest (1.0) values are required. </summary>
<summary> The colorscale must be a collection containing a mapping of a normalized value (between 0.0 and 1.0) to it's color. At minimum, a mapping for the lowest (0.0) and highest (1.0) values are required. </summary>
union case Colorscale.Electric: Colorscale
val dataChart: GenericChart.GenericChart
Multiple items
module Chart from Clustering
--------------------
type Chart = static member AnnotatedHeatmap: zData: seq<#seq<'a1>> * annotationText: seq<#seq<string>> * ?Name: string * ?ShowLegend: bool * ?Opacity: float * ?X: seq<#IConvertible> * ?XGap: int * ?Y: seq<#IConvertible> * ?YGap: int * ?Text: 'a5 * ?MultiText: seq<'a5> * ?ColorBar: ColorBar * ?ColorScale: Colorscale * ?ShowScale: bool * ?ReverseScale: bool * ?ZSmooth: SmoothAlg * ?Transpose: bool * ?UseWebGL: bool * ?ReverseYAxis: bool * ?UseDefaults: bool -> GenericChart (requires 'a1 :> IConvertible and 'a5 :> IConvertible) static member Area: x: seq<#IConvertible> * y: seq<#IConvertible> * ?Name: string * ?ShowMarkers: bool * ?ShowLegend: bool * ?MarkerSymbol: MarkerSymbol * ?Color: Color * ?Opacity: float * ?Labels: seq<#IConvertible> * ?TextPosition: TextPosition * ?TextFont: Font * ?Dash: DrawingStyle * ?Width: float * ?UseDefaults: bool -> GenericChart + 1 overload static member Bar: values: seq<#IConvertible> * ?Keys: seq<#IConvertible> * ?Name: string * ?ShowLegend: bool * ?Opacity: float * ?MultiOpacity: seq<float> * ?Text: 'a2 * ?MultiText: seq<'a2> * ?MarkerColor: Color * ?MarkerColorScale: Colorscale * ?MarkerOutline: Line * ?MarkerPatternShape: PatternShape * ?MultiMarkerPatternShape: seq<PatternShape> * ?MarkerPattern: Pattern * ?Marker: Marker * ?Base: #IConvertible * ?Width: 'a4 * ?MultiWidth: seq<'a4> * ?TextPosition: TextPosition * ?MultiTextPosition: seq<TextPosition> * ?UseDefaults: bool -> GenericChart (requires 'a2 :> IConvertible and 'a4 :> IConvertible) + 1 overload static member BoxPlot: ?x: seq<#IConvertible> * ?y: seq<#IConvertible> * ?Name: string * ?ShowLegend: bool * ?Text: 'a2 * ?MultiText: seq<'a2> * ?Fillcolor: Color * ?MarkerColor: Color * ?OutlierColor: Color * ?OutlierWidth: int * ?Opacity: float * ?WhiskerWidth: float * ?BoxPoints: BoxPoints * ?BoxMean: BoxMean * ?Jitter: float * ?PointPos: float * ?Orientation: Orientation * ?Marker: Marker * ?Line: Line * ?AlignmentGroup: string * ?Offsetgroup: string * ?Notched: bool * ?NotchWidth: float * ?QuartileMethod: QuartileMethod * ?UseDefaults: bool -> GenericChart (requires 'a2 :> IConvertible) + 1 overload static member Bubble: x: seq<#IConvertible> * y: seq<#IConvertible> * sizes: seq<int> * ?Name: string * ?ShowLegend: bool * ?Opacity: float * ?MultiOpacity: seq<float> * ?Text: 'a2 * ?MultiText: seq<'a2> * ?TextPosition: TextPosition * ?MultiTextPosition: seq<TextPosition> * ?MarkerColor: Color * ?MarkerColorScale: Colorscale * ?MarkerOutline: Line * ?MarkerSymbol: MarkerSymbol * ?MultiMarkerSymbol: seq<MarkerSymbol> * ?Marker: Marker * ?LineColor: Color * ?LineColorScale: Colorscale * ?LineWidth: float * ?LineDash: DrawingStyle * ?Line: Line * ?StackGroup: string * ?Orientation: Orientation * ?GroupNorm: GroupNorm * ?UseWebGL: bool * ?UseDefaults: bool -> GenericChart (requires 'a2 :> IConvertible) + 1 overload static member Candlestick: ``open`` : seq<#IConvertible> * high: seq<#IConvertible> * low: seq<#IConvertible> * close: seq<#IConvertible> * x: seq<#IConvertible> * ?Name: string * ?ShowLegend: bool * ?Opacity: float * ?Text: 'a5 * ?MultiText: seq<'a5> * ?Line: Line * ?IncreasingColor: Color * ?Increasing: FinanceMarker * ?DecreasingColor: Color * ?Decreasing: FinanceMarker * ?WhiskerWidth: float * ?UseDefaults: bool -> GenericChart (requires 'a5 :> IConvertible) + 1 overload static member Column: values: seq<#IConvertible> * ?Keys: seq<#IConvertible> * ?Name: string * ?ShowLegend: bool * ?Opacity: float * ?MultiOpacity: seq<float> * ?Text: 'a2 * ?MultiText: seq<'a2> * ?MarkerColor: Color * ?MarkerColorScale: Colorscale * ?MarkerOutline: Line * ?MarkerPatternShape: PatternShape * ?MultiMarkerPatternShape: seq<PatternShape> * ?MarkerPattern: Pattern * ?Marker: Marker * ?Base: #IConvertible * ?Width: 'a4 * ?MultiWidth: seq<'a4> * ?TextPosition: TextPosition * ?MultiTextPosition: seq<TextPosition> * ?UseDefaults: bool -> GenericChart (requires 'a2 :> IConvertible and 'a4 :> IConvertible) + 1 overload static member Contour: zData: seq<#seq<'a1>> * ?Name: string * ?ShowLegend: bool * ?Opacity: float * ?X: seq<#IConvertible> * ?Y: seq<#IConvertible> * ?Text: 'a4 * ?MultiText: seq<'a4> * ?ColorBar: ColorBar * ?ColorScale: Colorscale * ?ShowScale: bool * ?ReverseScale: bool * ?Transpose: bool * ?LineColor: Color * ?LineDash: DrawingStyle * ?Line: Line * ?ContoursColoring: ContourColoring * ?ContoursOperation: ConstraintOperation * ?ContoursType: ContourType * ?ShowContourLabels: bool * ?ContourLabelFont: Font * ?Contours: Contours * ?FillColor: Color * ?NContours: int * ?UseDefaults: bool -> GenericChart (requires 'a1 :> IConvertible and 'a4 :> IConvertible) static member Funnel: x: seq<#IConvertible> * y: seq<#IConvertible> * ?Name: string * ?ShowLegend: bool * ?Opacity: float * ?Width: float * ?Offset: float * ?Text: 'a2 * ?MultiText: seq<'a2> * ?TextPosition: TextPosition * ?MultiTextPosition: seq<TextPosition> * ?Orientation: Orientation * ?AlignmentGroup: string * ?OffsetGroup: string * ?MarkerColor: Color * ?MarkerOutline: Line * ?Marker: Marker * ?TextInfo: TextInfo * ?ConnectorLineColor: Color * ?ConnectorLineStyle: DrawingStyle * ?ConnectorFillColor: Color * ?ConnectorLine: Line * ?Connector: FunnelConnector * ?InsideTextFont: Font * ?OutsideTextFont: Font * ?UseDefaults: bool -> GenericChart (requires 'a2 :> IConvertible) static member Heatmap: zData: seq<#seq<'a1>> * ?Name: string * ?ShowLegend: bool * ?Opacity: float * ?X: seq<#IConvertible> * ?XGap: int * ?Y: seq<#IConvertible> * ?YGap: int * ?Text: 'a4 * ?MultiText: seq<'a4> * ?ColorBar: ColorBar * ?ColorScale: Colorscale * ?ShowScale: bool * ?ReverseScale: bool * ?ZSmooth: SmoothAlg * ?Transpose: bool * ?UseWebGL: bool * ?ReverseYAxis: bool * ?UseDefaults: bool -> GenericChart (requires 'a1 :> IConvertible and 'a4 :> IConvertible) + 1 overload ...
module Chart from Clustering
--------------------
type Chart = static member AnnotatedHeatmap: zData: seq<#seq<'a1>> * annotationText: seq<#seq<string>> * ?Name: string * ?ShowLegend: bool * ?Opacity: float * ?X: seq<#IConvertible> * ?XGap: int * ?Y: seq<#IConvertible> * ?YGap: int * ?Text: 'a5 * ?MultiText: seq<'a5> * ?ColorBar: ColorBar * ?ColorScale: Colorscale * ?ShowScale: bool * ?ReverseScale: bool * ?ZSmooth: SmoothAlg * ?Transpose: bool * ?UseWebGL: bool * ?ReverseYAxis: bool * ?UseDefaults: bool -> GenericChart (requires 'a1 :> IConvertible and 'a5 :> IConvertible) static member Area: x: seq<#IConvertible> * y: seq<#IConvertible> * ?Name: string * ?ShowMarkers: bool * ?ShowLegend: bool * ?MarkerSymbol: MarkerSymbol * ?Color: Color * ?Opacity: float * ?Labels: seq<#IConvertible> * ?TextPosition: TextPosition * ?TextFont: Font * ?Dash: DrawingStyle * ?Width: float * ?UseDefaults: bool -> GenericChart + 1 overload static member Bar: values: seq<#IConvertible> * ?Keys: seq<#IConvertible> * ?Name: string * ?ShowLegend: bool * ?Opacity: float * ?MultiOpacity: seq<float> * ?Text: 'a2 * ?MultiText: seq<'a2> * ?MarkerColor: Color * ?MarkerColorScale: Colorscale * ?MarkerOutline: Line * ?MarkerPatternShape: PatternShape * ?MultiMarkerPatternShape: seq<PatternShape> * ?MarkerPattern: Pattern * ?Marker: Marker * ?Base: #IConvertible * ?Width: 'a4 * ?MultiWidth: seq<'a4> * ?TextPosition: TextPosition * ?MultiTextPosition: seq<TextPosition> * ?UseDefaults: bool -> GenericChart (requires 'a2 :> IConvertible and 'a4 :> IConvertible) + 1 overload static member BoxPlot: ?x: seq<#IConvertible> * ?y: seq<#IConvertible> * ?Name: string * ?ShowLegend: bool * ?Text: 'a2 * ?MultiText: seq<'a2> * ?Fillcolor: Color * ?MarkerColor: Color * ?OutlierColor: Color * ?OutlierWidth: int * ?Opacity: float * ?WhiskerWidth: float * ?BoxPoints: BoxPoints * ?BoxMean: BoxMean * ?Jitter: float * ?PointPos: float * ?Orientation: Orientation * ?Marker: Marker * ?Line: Line * ?AlignmentGroup: string * ?Offsetgroup: string * ?Notched: bool * ?NotchWidth: float * ?QuartileMethod: QuartileMethod * ?UseDefaults: bool -> GenericChart (requires 'a2 :> IConvertible) + 1 overload static member Bubble: x: seq<#IConvertible> * y: seq<#IConvertible> * sizes: seq<int> * ?Name: string * ?ShowLegend: bool * ?Opacity: float * ?MultiOpacity: seq<float> * ?Text: 'a2 * ?MultiText: seq<'a2> * ?TextPosition: TextPosition * ?MultiTextPosition: seq<TextPosition> * ?MarkerColor: Color * ?MarkerColorScale: Colorscale * ?MarkerOutline: Line * ?MarkerSymbol: MarkerSymbol * ?MultiMarkerSymbol: seq<MarkerSymbol> * ?Marker: Marker * ?LineColor: Color * ?LineColorScale: Colorscale * ?LineWidth: float * ?LineDash: DrawingStyle * ?Line: Line * ?StackGroup: string * ?Orientation: Orientation * ?GroupNorm: GroupNorm * ?UseWebGL: bool * ?UseDefaults: bool -> GenericChart (requires 'a2 :> IConvertible) + 1 overload static member Candlestick: ``open`` : seq<#IConvertible> * high: seq<#IConvertible> * low: seq<#IConvertible> * close: seq<#IConvertible> * x: seq<#IConvertible> * ?Name: string * ?ShowLegend: bool * ?Opacity: float * ?Text: 'a5 * ?MultiText: seq<'a5> * ?Line: Line * ?IncreasingColor: Color * ?Increasing: FinanceMarker * ?DecreasingColor: Color * ?Decreasing: FinanceMarker * ?WhiskerWidth: float * ?UseDefaults: bool -> GenericChart (requires 'a5 :> IConvertible) + 1 overload static member Column: values: seq<#IConvertible> * ?Keys: seq<#IConvertible> * ?Name: string * ?ShowLegend: bool * ?Opacity: float * ?MultiOpacity: seq<float> * ?Text: 'a2 * ?MultiText: seq<'a2> * ?MarkerColor: Color * ?MarkerColorScale: Colorscale * ?MarkerOutline: Line * ?MarkerPatternShape: PatternShape * ?MultiMarkerPatternShape: seq<PatternShape> * ?MarkerPattern: Pattern * ?Marker: Marker * ?Base: #IConvertible * ?Width: 'a4 * ?MultiWidth: seq<'a4> * ?TextPosition: TextPosition * ?MultiTextPosition: seq<TextPosition> * ?UseDefaults: bool -> GenericChart (requires 'a2 :> IConvertible and 'a4 :> IConvertible) + 1 overload static member Contour: zData: seq<#seq<'a1>> * ?Name: string * ?ShowLegend: bool * ?Opacity: float * ?X: seq<#IConvertible> * ?Y: seq<#IConvertible> * ?Text: 'a4 * ?MultiText: seq<'a4> * ?ColorBar: ColorBar * ?ColorScale: Colorscale * ?ShowScale: bool * ?ReverseScale: bool * ?Transpose: bool * ?LineColor: Color * ?LineDash: DrawingStyle * ?Line: Line * ?ContoursColoring: ContourColoring * ?ContoursOperation: ConstraintOperation * ?ContoursType: ContourType * ?ShowContourLabels: bool * ?ContourLabelFont: Font * ?Contours: Contours * ?FillColor: Color * ?NContours: int * ?UseDefaults: bool -> GenericChart (requires 'a1 :> IConvertible and 'a4 :> IConvertible) static member Funnel: x: seq<#IConvertible> * y: seq<#IConvertible> * ?Name: string * ?ShowLegend: bool * ?Opacity: float * ?Width: float * ?Offset: float * ?Text: 'a2 * ?MultiText: seq<'a2> * ?TextPosition: TextPosition * ?MultiTextPosition: seq<TextPosition> * ?Orientation: Orientation * ?AlignmentGroup: string * ?OffsetGroup: string * ?MarkerColor: Color * ?MarkerOutline: Line * ?Marker: Marker * ?TextInfo: TextInfo * ?ConnectorLineColor: Color * ?ConnectorLineStyle: DrawingStyle * ?ConnectorFillColor: Color * ?ConnectorLine: Line * ?Connector: FunnelConnector * ?InsideTextFont: Font * ?OutsideTextFont: Font * ?UseDefaults: bool -> GenericChart (requires 'a2 :> IConvertible) static member Heatmap: zData: seq<#seq<'a1>> * ?Name: string * ?ShowLegend: bool * ?Opacity: float * ?X: seq<#IConvertible> * ?XGap: int * ?Y: seq<#IConvertible> * ?YGap: int * ?Text: 'a4 * ?MultiText: seq<'a4> * ?ColorBar: ColorBar * ?ColorScale: Colorscale * ?ShowScale: bool * ?ReverseScale: bool * ?ZSmooth: SmoothAlg * ?Transpose: bool * ?UseWebGL: bool * ?ReverseYAxis: bool * ?UseDefaults: bool -> GenericChart (requires 'a1 :> IConvertible and 'a4 :> IConvertible) + 1 overload ...
static member Chart.Heatmap: zData: seq<#seq<'b>> * colNames: seq<string> * rowNames: seq<string> * ?Name: string * ?ShowLegend: bool * ?Opacity: float * ?XGap: int * ?YGap: int * ?Text: 'c * ?MultiText: seq<'c> * ?ColorBar: ColorBar * ?ColorScale: Colorscale * ?ShowScale: bool * ?ReverseScale: bool * ?ZSmooth: SmoothAlg * ?Transpose: bool * ?UseWebGL: bool * ?ReverseYAxis: bool * ?UseDefaults: bool -> GenericChart.GenericChart (requires 'b :> System.IConvertible and 'c :> System.IConvertible)
static member Chart.Heatmap: zData: seq<#seq<'a1>> * ?Name: string * ?ShowLegend: bool * ?Opacity: float * ?X: seq<#System.IConvertible> * ?XGap: int * ?Y: seq<#System.IConvertible> * ?YGap: int * ?Text: 'a4 * ?MultiText: seq<'a4> * ?ColorBar: ColorBar * ?ColorScale: Colorscale * ?ShowScale: bool * ?ReverseScale: bool * ?ZSmooth: SmoothAlg * ?Transpose: bool * ?UseWebGL: bool * ?ReverseYAxis: bool * ?UseDefaults: bool -> GenericChart.GenericChart (requires 'a1 :> System.IConvertible and 'a4 :> System.IConvertible)
static member Chart.Heatmap: zData: seq<#seq<'a1>> * ?Name: string * ?ShowLegend: bool * ?Opacity: float * ?X: seq<#System.IConvertible> * ?XGap: int * ?Y: seq<#System.IConvertible> * ?YGap: int * ?Text: 'a4 * ?MultiText: seq<'a4> * ?ColorBar: ColorBar * ?ColorScale: Colorscale * ?ShowScale: bool * ?ReverseScale: bool * ?ZSmooth: SmoothAlg * ?Transpose: bool * ?UseWebGL: bool * ?ReverseYAxis: bool * ?UseDefaults: bool -> GenericChart.GenericChart (requires 'a1 :> System.IConvertible and 'a4 :> System.IConvertible)
Multiple items
module Seq from Plotly.NET
--------------------
module Seq from FSharp.Stats
<summary> Module to compute common statistical measure </summary>
--------------------
module Seq from Microsoft.FSharp.Collections
<summary>Contains operations for working with values of type <see cref="T:Microsoft.FSharp.Collections.seq`1" />.</summary>
module Seq from Plotly.NET
--------------------
module Seq from FSharp.Stats
<summary> Module to compute common statistical measure </summary>
--------------------
module Seq from Microsoft.FSharp.Collections
<summary>Contains operations for working with values of type <see cref="T:Microsoft.FSharp.Collections.seq`1" />.</summary>
val mapi: mapping: (int -> 'T -> 'U) -> source: seq<'T> -> seq<'U>
<summary>Builds a new collection whose elements are the results of applying the given function to each of the elements of the collection. The integer index passed to the function indicates the index (from 0) of element being transformed.</summary>
<param name="mapping">A function to transform items from the input sequence that also supplies the current index.</param>
<param name="source">The input sequence.</param>
<returns>The result sequence.</returns>
<exception cref="T:System.ArgumentNullException">Thrown when the input sequence is null.</exception>
<example id="item-1"><code lang="fsharp"> let inputs = [ 10; 10; 10 ] inputs |> Seq.mapi (fun i x -> i + x) </code> Evaluates to a sequence yielding the same results as <c>seq { 10; 11; 12 }</c></example>
<summary>Builds a new collection whose elements are the results of applying the given function to each of the elements of the collection. The integer index passed to the function indicates the index (from 0) of element being transformed.</summary>
<param name="mapping">A function to transform items from the input sequence that also supplies the current index.</param>
<param name="source">The input sequence.</param>
<returns>The result sequence.</returns>
<exception cref="T:System.ArgumentNullException">Thrown when the input sequence is null.</exception>
<example id="item-1"><code lang="fsharp"> let inputs = [ 10; 10; 10 ] inputs |> Seq.mapi (fun i x -> i + x) </code> Evaluates to a sequence yielding the same results as <c>seq { 10; 11; 12 }</c></example>
val s: string
static member Chart.withMarginSize: ?Left: 'a * ?Right: 'b * ?Top: 'c * ?Bottom: 'd * ?Pad: 'e * ?Autoexpand: 'f -> (GenericChart.GenericChart -> GenericChart.GenericChart)
static member Chart.withTitle: title: string * ?TitleFont: Font -> (GenericChart.GenericChart -> GenericChart.GenericChart)
module GenericChart
from Plotly.NET
<summary> Module to represent a GenericChart </summary>
<summary> Module to represent a GenericChart </summary>
val toChartHTML: gChart: GenericChart.GenericChart -> string
<summary> Converts a GenericChart to it HTML representation. The div layer has a default size of 600 if not specified otherwise. </summary>
<summary> Converts a GenericChart to it HTML representation. The div layer has a default size of 600 if not specified otherwise. </summary>
namespace FSharp.Stats.ML
namespace FSharp.Stats.ML.Unsupervised
module HierarchicalClustering
from FSharp.Stats.ML.Unsupervised
<summary> Agglomerative hierarchical clustering </summary>
<summary> Agglomerative hierarchical clustering </summary>
val rnd: System.Random
Multiple items
type Random = new: unit -> unit + 1 overload member Next: unit -> int + 2 overloads member NextBytes: buffer: byte[] -> unit + 1 overload member NextDouble: unit -> float member NextInt64: unit -> int64 + 2 overloads member NextSingle: unit -> float32 static member Shared: Random
<summary>Represents a pseudo-random number generator, which is an algorithm that produces a sequence of numbers that meet certain statistical requirements for randomness.</summary>
--------------------
System.Random() : System.Random
System.Random(Seed: int) : System.Random
type Random = new: unit -> unit + 1 overload member Next: unit -> int + 2 overloads member NextBytes: buffer: byte[] -> unit + 1 overload member NextDouble: unit -> float member NextInt64: unit -> int64 + 2 overloads member NextSingle: unit -> float32 static member Shared: Random
<summary>Represents a pseudo-random number generator, which is an algorithm that produces a sequence of numbers that meet certain statistical requirements for randomness.</summary>
--------------------
System.Random() : System.Random
System.Random(Seed: int) : System.Random
val randomInitFactory: IterativeClustering.CentroidsFactory<float[]>
module IterativeClustering
from FSharp.Stats.ML.Unsupervised
type CentroidsFactory<'a> = 'a array -> int -> 'a array
val randomCentroids: rng: System.Random -> sample: 'a array -> k: int -> 'a[]
val kmeansResult: IterativeClustering.KClusteringResult<float[]>
val kmeans: dist: DistanceMetrics.Distance<float[]> -> factory: IterativeClustering.CentroidsFactory<float[]> -> dataset: float[] array -> k: int -> IterativeClustering.KClusteringResult<float[]>
module DistanceMetrics
from FSharp.Stats.ML
<summary> Functions for computing distances of elements or sets </summary>
<summary> Functions for computing distances of elements or sets </summary>
val euclidean: s1: seq<'a> -> s2: seq<'a> -> 'c (requires member (-) and member get_Zero and member (+) and member Sqrt and member ( * ))
<summary> Euclidean distance of two coordinate sequences </summary>
<summary> Euclidean distance of two coordinate sequences </summary>
val clusteredIrisData: GenericChart.GenericChart
val zip: array1: 'T1[] -> array2: 'T2[] -> ('T1 * 'T2)[]
<summary>Combines the two arrays into an array of pairs. The two arrays must have equal lengths, otherwise an <c>ArgumentException</c> is raised.</summary>
<param name="array1">The first input array.</param>
<param name="array2">The second input array.</param>
<exception cref="T:System.ArgumentNullException">Thrown when either of the input arrays is null.</exception>
<exception cref="T:System.ArgumentException">Thrown when the input arrays differ in length.</exception>
<returns>The array of tupled elements.</returns>
<example id="zip-1"><code lang="fsharp"> let numbers = [|1; 2|] let names = [|"one"; "two"|] Array.zip numbers names </code> Evaluates to <c>[| (1, "one"); (2, "two") |]</c>. </example>
<summary>Combines the two arrays into an array of pairs. The two arrays must have equal lengths, otherwise an <c>ArgumentException</c> is raised.</summary>
<param name="array1">The first input array.</param>
<param name="array2">The second input array.</param>
<exception cref="T:System.ArgumentNullException">Thrown when either of the input arrays is null.</exception>
<exception cref="T:System.ArgumentException">Thrown when the input arrays differ in length.</exception>
<returns>The array of tupled elements.</returns>
<example id="zip-1"><code lang="fsharp"> let numbers = [|1; 2|] let names = [|"one"; "two"|] Array.zip numbers names </code> Evaluates to <c>[| (1, "one"); (2, "two") |]</c>. </example>
val sortBy: projection: ('T -> 'Key) -> array: 'T[] -> 'T[] (requires comparison)
<summary>Sorts the elements of an array, using the given projection for the keys and returning a new array. Elements are compared using <see cref="M:Microsoft.FSharp.Core.Operators.compare" />.</summary>
<remarks>This is not a stable sort, i.e. the original order of equal elements is not necessarily preserved. For a stable sort, consider using <see cref="M:Microsoft.FSharp.Collections.SeqModule.Sort" />.</remarks>
<param name="projection">The function to transform array elements into the type that is compared.</param>
<param name="array">The input array.</param>
<returns>The sorted array.</returns>
<exception cref="T:System.ArgumentNullException">Thrown when the input array is null.</exception>
<example id="sortby-1"><code lang="fsharp"> let input = [| "a"; "bbb"; "cccc"; "dd" |] input |> Array.sortBy (fun s -> s.Length) </code> Evaluates to <c>[|"a"; "dd"; "bbb"; "cccc"|]</c>. </example>
<summary>Sorts the elements of an array, using the given projection for the keys and returning a new array. Elements are compared using <see cref="M:Microsoft.FSharp.Core.Operators.compare" />.</summary>
<remarks>This is not a stable sort, i.e. the original order of equal elements is not necessarily preserved. For a stable sort, consider using <see cref="M:Microsoft.FSharp.Collections.SeqModule.Sort" />.</remarks>
<param name="projection">The function to transform array elements into the type that is compared.</param>
<param name="array">The input array.</param>
<returns>The sorted array.</returns>
<exception cref="T:System.ArgumentNullException">Thrown when the input array is null.</exception>
<example id="sortby-1"><code lang="fsharp"> let input = [| "a"; "bbb"; "cccc"; "dd" |] input |> Array.sortBy (fun s -> s.Length) </code> Evaluates to <c>[|"a"; "dd"; "bbb"; "cccc"|]</c>. </example>
val l: string
val dataPoint: float[]
val fst: tuple: ('T1 * 'T2) -> 'T1
<summary>Return the first element of a tuple, <c>fst (a,b) = a</c>.</summary>
<param name="tuple">The input tuple.</param>
<returns>The first value.</returns>
<example id="fst-example"><code lang="fsharp"> fst ("first", 2) // Evaluates to "first" </code></example>
<summary>Return the first element of a tuple, <c>fst (a,b) = a</c>.</summary>
<param name="tuple">The input tuple.</param>
<returns>The first value.</returns>
<example id="fst-example"><code lang="fsharp"> fst ("first", 2) // Evaluates to "first" </code></example>
IterativeClustering.KClusteringResult.Classifier: float[] -> int * float[]
<summary> Classifier function returns cluster index and centroid </summary>
<summary> Classifier function returns cluster index and centroid </summary>
val labels: string[]
val d: float[][]
val getBestkMeansClustering: data: float[] array -> k: int -> bootstraps: int -> IterativeClustering.KClusteringResult<float[]>
val data: float[] array
val k: int
val bootstraps: int
Multiple items
module List from FSharp.Stats
<summary> Module to compute common statistical measure on list </summary>
--------------------
module List from Microsoft.FSharp.Collections
<summary>Contains operations for working with values of type <see cref="T:Microsoft.FSharp.Collections.list`1" />.</summary>
<namespacedoc><summary>Operations for collections such as lists, arrays, sets, maps and sequences. See also <a href="https://docs.microsoft.com/dotnet/fsharp/language-reference/fsharp-collection-types">F# Collection Types</a> in the F# Language Guide. </summary></namespacedoc>
--------------------
type List<'T> = | op_Nil | op_ColonColon 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 static member Cons: head: 'T * tail: 'T list -> 'T list member Head: 'T member IsEmpty: bool member Item: index: int -> 'T with get ...
<summary>The type of immutable singly-linked lists.</summary>
<remarks>Use the constructors <c>[]</c> and <c>::</c> (infix) to create values of this type, or the notation <c>[1;2;3]</c>. Use the values in the <c>List</c> module to manipulate values of this type, or pattern match against the values directly. </remarks>
<exclude />
module List from FSharp.Stats
<summary> Module to compute common statistical measure on list </summary>
--------------------
module List from Microsoft.FSharp.Collections
<summary>Contains operations for working with values of type <see cref="T:Microsoft.FSharp.Collections.list`1" />.</summary>
<namespacedoc><summary>Operations for collections such as lists, arrays, sets, maps and sequences. See also <a href="https://docs.microsoft.com/dotnet/fsharp/language-reference/fsharp-collection-types">F# Collection Types</a> in the F# Language Guide. </summary></namespacedoc>
--------------------
type List<'T> = | op_Nil | op_ColonColon 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 static member Cons: head: 'T * tail: 'T list -> 'T list member Head: 'T member IsEmpty: bool member Item: index: int -> 'T with get ...
<summary>The type of immutable singly-linked lists.</summary>
<remarks>Use the constructors <c>[]</c> and <c>::</c> (infix) to create values of this type, or the notation <c>[1;2;3]</c>. Use the values in the <c>List</c> module to manipulate values of this type, or pattern match against the values directly. </remarks>
<exclude />
val mapi: mapping: (int -> 'T -> 'U) -> list: 'T list -> 'U list
<summary>Builds a new collection whose elements are the results of applying the given function to each of the elements of the collection. The integer index passed to the function indicates the index (from 0) of element being transformed.</summary>
<param name="mapping">The function to transform elements and their indices.</param>
<param name="list">The input list.</param>
<returns>The list of transformed elements.</returns>
<example id="item-1"><code lang="fsharp"> let inputs = [ 10; 10; 10 ] inputs |> List.mapi (fun i x -> i + x) </code> Evaluates to <c>[ 10; 11; 12 ]</c></example>
<summary>Builds a new collection whose elements are the results of applying the given function to each of the elements of the collection. The integer index passed to the function indicates the index (from 0) of element being transformed.</summary>
<param name="mapping">The function to transform elements and their indices.</param>
<param name="list">The input list.</param>
<returns>The list of transformed elements.</returns>
<example id="item-1"><code lang="fsharp"> let inputs = [ 10; 10; 10 ] inputs |> List.mapi (fun i x -> i + x) </code> Evaluates to <c>[ 10; 11; 12 ]</c></example>
val x: int
val minBy: projection: ('T -> 'U) -> list: 'T list -> 'T (requires comparison)
<summary>Returns the lowest of all elements of the list, compared via Operators.min on the function result</summary>
<remarks>Raises <see cref="T:System.ArgumentException" /> if <c>list</c> is empty.</remarks>
<param name="projection">The function to transform list elements into the type to be compared.</param>
<param name="list">The input list.</param>
<exception cref="T:System.ArgumentException">Thrown when the list is empty.</exception>
<returns>The minimum value.</returns>
<example id="minby-1"><code lang="fsharp"> let inputs = ["aaa"; "b"; "cccc"] inputs |> List.minBy (fun s -> s.Length) </code> Evaluates to <c>"b"</c></example>
<example id="minby-2"><code lang="fsharp"> let inputs = [] inputs |> List.minBy (fun (s: string) -> s.Length) </code> Throws <c>System.ArgumentException</c>. </example>
<summary>Returns the lowest of all elements of the list, compared via Operators.min on the function result</summary>
<remarks>Raises <see cref="T:System.ArgumentException" /> if <c>list</c> is empty.</remarks>
<param name="projection">The function to transform list elements into the type to be compared.</param>
<param name="list">The input list.</param>
<exception cref="T:System.ArgumentException">Thrown when the list is empty.</exception>
<returns>The minimum value.</returns>
<example id="minby-1"><code lang="fsharp"> let inputs = ["aaa"; "b"; "cccc"] inputs |> List.minBy (fun s -> s.Length) </code> Evaluates to <c>"b"</c></example>
<example id="minby-2"><code lang="fsharp"> let inputs = [] inputs |> List.minBy (fun (s: string) -> s.Length) </code> Throws <c>System.ArgumentException</c>. </example>
val clusteringResult: IterativeClustering.KClusteringResult<float[]>
val DispersionOfClusterResult: kmeansResult: IterativeClustering.KClusteringResult<'a> -> float
<summary> Calculates the average squared distance from the data points to the cluster centroid (also refered to as error) </summary>
<summary> Calculates the average squared distance from the data points to the cluster centroid (also refered to as error) </summary>
val t: DbScan.DbscanResult<float array>
module DbScan
from FSharp.Stats.ML.Unsupervised
val compute: dfu: ('a array -> 'a array -> float) -> minPts: int -> eps: float -> input: seq<#seq<'a>> -> DbScan.DbscanResult<'a array>
module Array
from FSharp.Stats.ML.DistanceMetrics
val euclideanNaN: a1: float array -> a2: float array -> float
<summary> Euclidean distance of two coordinate float arrays (ignores nan) </summary>
<summary> Euclidean distance of two coordinate float arrays (ignores nan) </summary>
val petLpetW: float[][]
val map: mapping: ('T -> 'U) -> array: 'T[] -> 'U[]
<summary>Builds a new array whose elements are the results of applying the given function to each of the elements of the array.</summary>
<param name="mapping">The function to transform elements of the array.</param>
<param name="array">The input array.</param>
<returns>The array of transformed elements.</returns>
<exception cref="T:System.ArgumentNullException">Thrown when the input array is null.</exception>
<example id="map-1"><code lang="fsharp"> let inputs = [| "a"; "bbb"; "cc" |] inputs |> Array.map (fun x -> x.Length) </code> Evaluates to <c>[| 1; 3; 2 |]</c></example>
<summary>Builds a new array whose elements are the results of applying the given function to each of the elements of the array.</summary>
<param name="mapping">The function to transform elements of the array.</param>
<param name="array">The input array.</param>
<returns>The array of transformed elements.</returns>
<exception cref="T:System.ArgumentNullException">Thrown when the input array is null.</exception>
<example id="map-1"><code lang="fsharp"> let inputs = [| "a"; "bbb"; "cc" |] inputs |> Array.map (fun x -> x.Length) </code> Evaluates to <c>[| 1; 3; 2 |]</c></example>
val x: float[]
val petWpetLsepL: float[][]
val dbscanPlot: GenericChart.GenericChart
val head: source: seq<'T> -> 'T
<summary>Returns the first element of the sequence.</summary>
<param name="source">The input sequence.</param>
<returns>The first element of the sequence.</returns>
<exception cref="T:System.ArgumentNullException">Thrown when the input sequence is null.</exception>
<exception cref="T:System.ArgumentException">Thrown when the input does not have any elements.</exception>
<example id="head-1"><code lang="fsharp"> let inputs = ["banana"; "pear"] inputs |> Seq.head </code> Evaluates to <c>banana</c></example>
<example id="head-2"><code lang="fsharp"> [] |> Seq.head </code> Throws <c>ArgumentException</c></example>
<summary>Returns the first element of the sequence.</summary>
<param name="source">The input sequence.</param>
<returns>The first element of the sequence.</returns>
<exception cref="T:System.ArgumentNullException">Thrown when the input sequence is null.</exception>
<exception cref="T:System.ArgumentException">Thrown when the input does not have any elements.</exception>
<example id="head-1"><code lang="fsharp"> let inputs = ["banana"; "pear"] inputs |> Seq.head </code> Evaluates to <c>banana</c></example>
<example id="head-2"><code lang="fsharp"> [] |> Seq.head </code> Throws <c>ArgumentException</c></example>
val length: source: seq<'T> -> int
<summary>Returns the length of the sequence</summary>
<param name="source">The input sequence.</param>
<returns>The length of the sequence.</returns>
<exception cref="T:System.ArgumentNullException">Thrown when the input sequence is null.</exception>
<example id="item-1"><code lang="fsharp"> let inputs = ["a"; "b"; "c"] inputs |> Seq.length </code> Evaluates to <c>3</c></example>
<summary>Returns the length of the sequence</summary>
<param name="source">The input sequence.</param>
<returns>The length of the sequence.</returns>
<exception cref="T:System.ArgumentNullException">Thrown when the input sequence is null.</exception>
<example id="item-1"><code lang="fsharp"> let inputs = ["a"; "b"; "c"] inputs |> Seq.length </code> Evaluates to <c>3</c></example>
val failwithf: format: Printf.StringFormat<'T,'Result> -> 'T
<summary>Print to a string buffer and raise an exception with the given result. Helper printers must return strings.</summary>
<param name="format">The formatter.</param>
<returns>The formatted result.</returns>
<example>See <c>Printf.failwithf</c> (link: <see cref="M:Microsoft.FSharp.Core.PrintfModule.PrintFormatToStringThenFail``2" />) for examples.</example>
<summary>Print to a string buffer and raise an exception with the given result. Helper printers must return strings.</summary>
<param name="format">The formatter.</param>
<returns>The formatted result.</returns>
<example>See <c>Printf.failwithf</c> (link: <see cref="M:Microsoft.FSharp.Core.PrintfModule.PrintFormatToStringThenFail``2" />) for examples.</example>
val result: DbScan.DbscanResult<float array>
val euclidean: a1: 'a array -> a2: 'a array -> float (requires member get_Zero and member (-) and member (+) and member op_Explicit and member ( * ))
<summary> Euclidean distance of two coordinate arrays </summary>
<summary> Euclidean distance of two coordinate arrays </summary>
val chartCluster: GenericChart.GenericChart
DbScan.DbscanResult.Clusterlist: seq<seq<float array>>
val ofSeq: source: seq<'T> -> 'T[]
<summary>Builds a new array from the given enumerable object.</summary>
<param name="source">The input sequence.</param>
<returns>The array of elements from the sequence.</returns>
<exception cref="T:System.ArgumentNullException">Thrown when the input sequence is null.</exception>
<example id="ofseq-1"><code lang="fsharp"> let inputs = seq { 1; 2; 5 } inputs |> Array.ofSeq </code> Evaluates to <c>[| 1; 2; 5 |]</c>. </example>
<summary>Builds a new array from the given enumerable object.</summary>
<param name="source">The input sequence.</param>
<returns>The array of elements from the sequence.</returns>
<exception cref="T:System.ArgumentNullException">Thrown when the input sequence is null.</exception>
<example id="ofseq-1"><code lang="fsharp"> let inputs = seq { 1; 2; 5 } inputs |> Array.ofSeq </code> Evaluates to <c>[| 1; 2; 5 |]</c>. </example>
val l: seq<float array>
val x: float array
val distinct: array: 'T[] -> 'T[] (requires equality)
<summary>Returns an array that contains no duplicate entries according to generic hash and equality comparisons on the entries. If an element occurs multiple times in the array then the later occurrences are discarded.</summary>
<param name="array">The input array.</param>
<returns>The result array.</returns>
<exception cref="T:System.ArgumentNullException">Thrown when the input array is null.</exception>
<example id="distinct-1"><code lang="fsharp"> let input = [| 1; 1; 2; 3 |] input |> Array.distinct </code> Evaluates to <c>[| 1; 2; 3 |]</c></example>
<summary>Returns an array that contains no duplicate entries according to generic hash and equality comparisons on the entries. If an element occurs multiple times in the array then the later occurrences are discarded.</summary>
<param name="array">The input array.</param>
<returns>The result array.</returns>
<exception cref="T:System.ArgumentNullException">Thrown when the input array is null.</exception>
<example id="distinct-1"><code lang="fsharp"> let input = [| 1; 1; 2; 3 |] input |> Array.distinct </code> Evaluates to <c>[| 1; 2; 3 |]</c></example>
static member Chart.Point: xy: seq<#System.IConvertible * #System.IConvertible> * ?Name: string * ?ShowLegend: bool * ?Opacity: float * ?MultiOpacity: seq<float> * ?Text: 'c * ?MultiText: seq<'c> * ?TextPosition: TextPosition * ?MultiTextPosition: seq<TextPosition> * ?MarkerColor: Color * ?MarkerColorScale: Colorscale * ?MarkerOutline: Line * ?MarkerSymbol: MarkerSymbol * ?MultiMarkerSymbol: seq<MarkerSymbol> * ?Marker: TraceObjects.Marker * ?StackGroup: string * ?Orientation: Orientation * ?GroupNorm: GroupNorm * ?UseWebGL: bool * ?UseDefaults: bool -> GenericChart.GenericChart (requires 'c :> System.IConvertible)
static member Chart.Point: x: seq<#System.IConvertible> * y: seq<#System.IConvertible> * ?Name: string * ?ShowLegend: bool * ?Opacity: float * ?MultiOpacity: seq<float> * ?Text: 'a2 * ?MultiText: seq<'a2> * ?TextPosition: TextPosition * ?MultiTextPosition: seq<TextPosition> * ?MarkerColor: Color * ?MarkerColorScale: Colorscale * ?MarkerOutline: Line * ?MarkerSymbol: MarkerSymbol * ?MultiMarkerSymbol: seq<MarkerSymbol> * ?Marker: TraceObjects.Marker * ?StackGroup: string * ?Orientation: Orientation * ?GroupNorm: GroupNorm * ?UseWebGL: bool * ?UseDefaults: bool -> GenericChart.GenericChart (requires 'a2 :> System.IConvertible)
static member Chart.Point: x: seq<#System.IConvertible> * y: seq<#System.IConvertible> * ?Name: string * ?ShowLegend: bool * ?Opacity: float * ?MultiOpacity: seq<float> * ?Text: 'a2 * ?MultiText: seq<'a2> * ?TextPosition: TextPosition * ?MultiTextPosition: seq<TextPosition> * ?MarkerColor: Color * ?MarkerColorScale: Colorscale * ?MarkerOutline: Line * ?MarkerSymbol: MarkerSymbol * ?MultiMarkerSymbol: seq<MarkerSymbol> * ?Marker: TraceObjects.Marker * ?StackGroup: string * ?Orientation: Orientation * ?GroupNorm: GroupNorm * ?UseWebGL: bool * ?UseDefaults: bool -> GenericChart.GenericChart (requires 'a2 :> System.IConvertible)
static member Chart.withTraceName: ?Name: string * ?ShowLegend: bool * ?LegendGroup: string * ?Visible: Visible -> (GenericChart.GenericChart -> GenericChart.GenericChart)
static member Chart.combine: gCharts: seq<GenericChart.GenericChart> -> GenericChart.GenericChart
val chartNoise: GenericChart.GenericChart
DbScan.DbscanResult.Noisepoints: seq<float array>
val distinct: source: seq<'T> -> seq<'T> (requires equality)
<summary>Returns a sequence that contains no duplicate entries according to generic hash and equality comparisons on the entries. If an element occurs multiple times in the sequence then the later occurrences are discarded.</summary>
<param name="source">The input sequence.</param>
<returns>The result sequence.</returns>
<exception cref="T:System.ArgumentNullException">Thrown when the input sequence is null.</exception>
<example id="distinct-1"><code lang="fsharp"> [1; 1; 2; 3] |> Seq.distinct </code> Evaluates to a sequence yielding the same results as <c>seq { 1; 2; 3 }</c></example>
<summary>Returns a sequence that contains no duplicate entries according to generic hash and equality comparisons on the entries. If an element occurs multiple times in the sequence then the later occurrences are discarded.</summary>
<param name="source">The input sequence.</param>
<returns>The result sequence.</returns>
<exception cref="T:System.ArgumentNullException">Thrown when the input sequence is null.</exception>
<example id="distinct-1"><code lang="fsharp"> [1; 1; 2; 3] |> Seq.distinct </code> Evaluates to a sequence yielding the same results as <c>seq { 1; 2; 3 }</c></example>
val chartname: string
val noiseCount: int
val clusterCount: int
val clPtsCount: int
val sumBy: projection: ('T -> 'U) -> source: seq<'T> -> 'U (requires member (+) and member get_Zero)
<summary>Returns the sum of the results generated by applying the function to each element of the sequence.</summary>
<remarks>The generated elements are summed using the <c>+</c> operator and <c>Zero</c> property associated with the generated type.</remarks>
<param name="projection">A function to transform items from the input sequence into the type that will be summed.</param>
<param name="source">The input sequence.</param>
<returns>The computed sum.</returns>
<example id="sumby-1"><code lang="fsharp"> let input = [ "aa"; "bbb"; "cc" ] input |> Seq.sumBy (fun s -> s.Length) </code> Evaluates to <c>7</c>. </example>
<summary>Returns the sum of the results generated by applying the function to each element of the sequence.</summary>
<remarks>The generated elements are summed using the <c>+</c> operator and <c>Zero</c> property associated with the generated type.</remarks>
<param name="projection">A function to transform items from the input sequence into the type that will be summed.</param>
<param name="source">The input sequence.</param>
<returns>The computed sum.</returns>
<example id="sumby-1"><code lang="fsharp"> let input = [ "aa"; "bbb"; "cc" ] input |> Seq.sumBy (fun s -> s.Length) </code> Evaluates to <c>7</c>. </example>
val create3dChart: dfu: ('a array -> 'a array -> float) -> minPts: int -> eps: float -> input: seq<#seq<'a>> -> GenericChart.GenericChart (requires equality and 'a :> System.IConvertible)
val dfu: ('a array -> 'a array -> float) (requires equality and 'a :> System.IConvertible)
type 'T array = 'T[]
<summary>Single dimensional, zero-based arrays, written <c>int[]</c>, <c>string[]</c> etc.</summary>
<remarks>Use the values in the <see cref="T:Microsoft.FSharp.Collections.ArrayModule" /> module to manipulate values of this type, or the notation <c>arr.[x]</c> to get/set array values.</remarks>
<category>Basic Types</category>
<summary>Single dimensional, zero-based arrays, written <c>int[]</c>, <c>string[]</c> etc.</summary>
<remarks>Use the values in the <see cref="T:Microsoft.FSharp.Collections.ArrayModule" /> module to manipulate values of this type, or the notation <c>arr.[x]</c> to get/set array values.</remarks>
<category>Basic Types</category>
val minPts: int
Multiple items
val int: value: 'T -> int (requires member op_Explicit)
<summary>Converts the argument to signed 32-bit integer. This is a direct conversion for all primitive numeric types. For strings, the input is converted using <c>Int32.Parse()</c> with InvariantCulture settings. Otherwise the operation requires an appropriate static conversion method on the input type.</summary>
<param name="value">The input value.</param>
<returns>The converted int</returns>
<example id="int-example"><code lang="fsharp"></code></example>
--------------------
[<Struct>] type int = int32
<summary>An abbreviation for the CLI type <see cref="T:System.Int32" />.</summary>
<category>Basic Types</category>
--------------------
type int<'Measure> = int
<summary>The type of 32-bit signed integer numbers, annotated with a unit of measure. The unit of measure is erased in compiled code and when values of this type are analyzed using reflection. The type is representationally equivalent to <see cref="T:System.Int32" />.</summary>
<category>Basic Types with Units of Measure</category>
val int: value: 'T -> int (requires member op_Explicit)
<summary>Converts the argument to signed 32-bit integer. This is a direct conversion for all primitive numeric types. For strings, the input is converted using <c>Int32.Parse()</c> with InvariantCulture settings. Otherwise the operation requires an appropriate static conversion method on the input type.</summary>
<param name="value">The input value.</param>
<returns>The converted int</returns>
<example id="int-example"><code lang="fsharp"></code></example>
--------------------
[<Struct>] type int = int32
<summary>An abbreviation for the CLI type <see cref="T:System.Int32" />.</summary>
<category>Basic Types</category>
--------------------
type int<'Measure> = int
<summary>The type of 32-bit signed integer numbers, annotated with a unit of measure. The unit of measure is erased in compiled code and when values of this type are analyzed using reflection. The type is representationally equivalent to <see cref="T:System.Int32" />.</summary>
<category>Basic Types with Units of Measure</category>
val eps: float
val input: seq<#seq<'a0>> (requires equality and 'a0 :> System.IConvertible)
val result: DbScan.DbscanResult<'a array> (requires equality and 'a :> System.IConvertible)
DbScan.DbscanResult.Clusterlist: seq<seq<'a array>>
val l: seq<'a array> (requires equality and 'a :> System.IConvertible)
val x: 'a array (requires equality and 'a :> System.IConvertible)
val x: seq<'a * 'a * 'a> (requires equality and 'a :> System.IConvertible)
static member Chart.Scatter3D: xyz: seq<#System.IConvertible * #System.IConvertible * #System.IConvertible> * mode: Mode * ?Name: string * ?ShowLegend: bool * ?Opacity: float * ?Text: 'e * ?MultiText: seq<'e> * ?TextPosition: TextPosition * ?MultiTextPosition: seq<TextPosition> * ?MarkerColor: Color * ?MarkerColorScale: Colorscale * ?MarkerOutline: Line * ?MarkerSymbol: MarkerSymbol3D * ?MultiMarkerSymbol: seq<MarkerSymbol3D> * ?Marker: TraceObjects.Marker * ?LineColor: Color * ?LineColorScale: Colorscale * ?LineWidth: float * ?LineDash: DrawingStyle * ?Line: Line * ?Projection: TraceObjects.Projection * ?UseDefaults: bool -> GenericChart.GenericChart (requires 'e :> System.IConvertible)
static member Chart.Scatter3D: x: seq<#System.IConvertible> * y: seq<#System.IConvertible> * z: seq<#System.IConvertible> * mode: Mode * ?Name: string * ?ShowLegend: bool * ?Opacity: float * ?Text: 'a3 * ?MultiText: seq<'a3> * ?TextPosition: TextPosition * ?MultiTextPosition: seq<TextPosition> * ?MarkerColor: Color * ?MarkerColorScale: Colorscale * ?MarkerOutline: Line * ?MarkerSymbol: MarkerSymbol3D * ?MultiMarkerSymbol: seq<MarkerSymbol3D> * ?Marker: TraceObjects.Marker * ?LineColor: Color * ?LineColorScale: Colorscale * ?LineWidth: float * ?LineDash: DrawingStyle * ?Line: Line * ?Projection: TraceObjects.Projection * ?UseDefaults: bool -> GenericChart.GenericChart (requires 'a3 :> System.IConvertible)
static member Chart.Scatter3D: x: seq<#System.IConvertible> * y: seq<#System.IConvertible> * z: seq<#System.IConvertible> * mode: Mode * ?Name: string * ?ShowLegend: bool * ?Opacity: float * ?Text: 'a3 * ?MultiText: seq<'a3> * ?TextPosition: TextPosition * ?MultiTextPosition: seq<TextPosition> * ?MarkerColor: Color * ?MarkerColorScale: Colorscale * ?MarkerOutline: Line * ?MarkerSymbol: MarkerSymbol3D * ?MultiMarkerSymbol: seq<MarkerSymbol3D> * ?Marker: TraceObjects.Marker * ?LineColor: Color * ?LineColorScale: Colorscale * ?LineWidth: float * ?LineDash: DrawingStyle * ?Line: Line * ?Projection: TraceObjects.Projection * ?UseDefaults: bool -> GenericChart.GenericChart (requires 'a3 :> System.IConvertible)
type Mode =
| None
| Lines
| Lines_Markers
| Lines_Text
| Lines_Markers_Text
| Markers
| Markers_Text
| Text
member Convert: unit -> obj
override ToString: unit -> string
static member convert: (Mode -> obj)
static member toString: (Mode -> string)
union case Mode.Markers: Mode
DbScan.DbscanResult.Noisepoints: seq<'a array>
static member Chart.withZAxis: zAxis: LinearAxis * ?Id: SubPlotId -> (GenericChart.GenericChart -> GenericChart.GenericChart)
val clusteredChart3D: GenericChart.GenericChart
val euclideanNaNSquared: a1: float array -> a2: float array -> float
<summary> Squared Euclidean distance of two coordinate float arrays (ignores nan) </summary>
<summary> Squared Euclidean distance of two coordinate float arrays (ignores nan) </summary>
val clusterResultH: Cluster<float[]>
val generate: distance: DistanceMetrics.Distance<'T> -> linker: Linker.LancWilliamsLinker -> data: seq<'T> -> Cluster<'T>
<summary> Builds a hierarchy of clusters of data containing cluster labels </summary>
<summary> Builds a hierarchy of clusters of data containing cluster labels </summary>
val euclideanNaNSquared: s1: seq<float> -> s2: seq<float> -> float
<summary> Squared Euclidean distance of two coordinate float sequences (ignores nan) </summary>
<summary> Squared Euclidean distance of two coordinate float sequences (ignores nan) </summary>
module Linker
from FSharp.Stats.ML.Unsupervised.HierarchicalClustering
<summary> The linkage criterion determines the distance between sets of observations as a function of the pairwise distances between observations </summary>
<summary> The linkage criterion determines the distance between sets of observations as a function of the pairwise distances between observations </summary>
val wardLwLinker: int * int * int -> dAB: float -> dAC: float -> dBC: float -> float
<summary> Ward linkage criterion (UPGMA) Calculates the d(A u B, C) </summary>
<summary> Ward linkage criterion (UPGMA) Calculates the d(A u B, C) </summary>
val threeClustersH: Cluster<float[]> list list
val cutHClust: desiredNumber: int -> clusterTree: Cluster<'T> -> Cluster<'T> list list
<summary> Cuts a tree, as resulting from hclust, into several groups by specifying the desired number(s). If the desired number is odd the function cut the cluster with maximal distance </summary>
<summary> Cuts a tree, as resulting from hclust, into several groups by specifying the desired number(s). If the desired number is odd the function cut the cluster with maximal distance </summary>
val inspectThreeClusters: string * string list list
val map: mapping: ('T -> 'U) -> list: 'T list -> 'U list
<summary>Builds a new collection whose elements are the results of applying the given function to each of the elements of the collection.</summary>
<param name="mapping">The function to transform elements from the input list.</param>
<param name="list">The input list.</param>
<returns>The list of transformed elements.</returns>
<example id="map-1"><code lang="fsharp"> let inputs = [ "a"; "bbb"; "cc" ] inputs |> List.map (fun x -> x.Length) </code> Evaluates to <c>[ 1; 3; 2 ]</c></example>
<summary>Builds a new collection whose elements are the results of applying the given function to each of the elements of the collection.</summary>
<param name="mapping">The function to transform elements from the input list.</param>
<param name="list">The input list.</param>
<returns>The list of transformed elements.</returns>
<example id="map-1"><code lang="fsharp"> let inputs = [ "a"; "bbb"; "cc" ] inputs |> List.map (fun x -> x.Length) </code> Evaluates to <c>[ 1; 3; 2 ]</c></example>
val cluster: Cluster<float[]> list
val leaf: Cluster<float[]>
val getClusterId: c: Cluster<'T> -> int
val clusteredLabels: string list list
property List.Length: int with get
<summary>Gets the number of items contained in the list</summary>
<summary>Gets the number of items contained in the list</summary>
val hLeaves: Cluster<float[]> list
val flattenHClust: clusterTree: Cluster<'T> -> Cluster<'T> list
<summary> Returns a flatten list containing Leafs </summary>
<summary> Returns a flatten list containing Leafs </summary>
val dataSortedByClustering: seq<string * float[]>
val choose: chooser: ('T -> 'U option) -> source: seq<'T> -> seq<'U>
<summary>Applies the given function to each element of the sequence. Returns a sequence comprised of the results "x" for each element where the function returns Some(x).</summary>
<remarks>The returned sequence may be passed between threads safely. However, individual IEnumerator values generated from the returned sequence should not be accessed concurrently.</remarks>
<param name="chooser">A function to transform items of type T into options of type U.</param>
<param name="source">The input sequence of type T.</param>
<returns>The result sequence.</returns>
<exception cref="T:System.ArgumentNullException">Thrown when the input sequence is null.</exception>
<example id="choose-1"><code lang="fsharp"> [Some 1; None; Some 2] |> Seq.choose id </code> Evaluates to a sequence yielding the same results as <c>seq { 1; 2 }</c></example>
<example id="choose-2"><code lang="fsharp"> [1; 2; 3] |> Seq.choose (fun n -> if n % 2 = 0 then Some n else None) </code> Evaluates to a sequence yielding the same results as <c>seq { 2 }</c></example>
<summary>Applies the given function to each element of the sequence. Returns a sequence comprised of the results "x" for each element where the function returns Some(x).</summary>
<remarks>The returned sequence may be passed between threads safely. However, individual IEnumerator values generated from the returned sequence should not be accessed concurrently.</remarks>
<param name="chooser">A function to transform items of type T into options of type U.</param>
<param name="source">The input sequence of type T.</param>
<returns>The result sequence.</returns>
<exception cref="T:System.ArgumentNullException">Thrown when the input sequence is null.</exception>
<example id="choose-1"><code lang="fsharp"> [Some 1; None; Some 2] |> Seq.choose id </code> Evaluates to a sequence yielding the same results as <c>seq { 1; 2 }</c></example>
<example id="choose-2"><code lang="fsharp"> [1; 2; 3] |> Seq.choose (fun n -> if n % 2 = 0 then Some n else None) </code> Evaluates to a sequence yielding the same results as <c>seq { 2 }</c></example>
val c: Cluster<float[]>
val values: float[] option
val tryGetLeafValue: c: Cluster<'T> -> 'T option
union case Option.None: Option<'T>
<summary>The representation of "No value"</summary>
<summary>The representation of "No value"</summary>
union case Option.Some: Value: 'T -> Option<'T>
<summary>The representation of "Value of type 'T"</summary>
<param name="Value">The input value.</param>
<returns>An option representing the value.</returns>
<summary>The representation of "Value of type 'T"</summary>
<param name="Value">The input value.</param>
<returns>An option representing the value.</returns>
val hierClusteredDataHeatmap: GenericChart.GenericChart
val hlable: seq<string>
val hdata: seq<float[]>
val unzip: input: seq<'a * 'b> -> seq<'a> * seq<'b>
<summary> Splits a sequence of pairs into two sequences </summary>
<summary> Splits a sequence of pairs into two sequences </summary>
val ruleOfThumb: float
module ClusterNumber
from FSharp.Stats.ML.Unsupervised
val kRuleOfThumb: observations: seq<'a> -> float
<summary> Simple estimator for number of cluster (k) // can be used as the upper bound for other methods </summary>
<summary> Simple estimator for number of cluster (k) // can be used as the upper bound for other methods </summary>
val kElbow: int
val iterations: int
val dispersionOfK: (int * float * float)[]
Multiple items
module Array from FSharp.Stats.ML.DistanceMetrics
--------------------
module Array from FSharp.Stats
<summary> Module to compute common statistical measure on array </summary>
--------------------
module Array from Microsoft.FSharp.Collections
<summary>Contains operations for working with arrays.</summary>
<remarks> See also <a href="https://docs.microsoft.com/dotnet/fsharp/language-reference/arrays">F# Language Guide - Arrays</a>. </remarks>
module Array from FSharp.Stats.ML.DistanceMetrics
--------------------
module Array from FSharp.Stats
<summary> Module to compute common statistical measure on array </summary>
--------------------
module Array from Microsoft.FSharp.Collections
<summary>Contains operations for working with arrays.</summary>
<remarks> See also <a href="https://docs.microsoft.com/dotnet/fsharp/language-reference/arrays">F# Language Guide - Arrays</a>. </remarks>
val dispersion: float
val std: float
val kmeans: dist: Distance<float[]> -> factory: CentroidsFactory<float[]> -> dataset: float[] array -> k: int -> KClusteringResult<float[]>
val DispersionOfClusterResult: kmeansResult: KClusteringResult<'a> -> float
<summary> Calculates the average squared distance from the data points to the cluster centroid (also refered to as error) </summary>
<summary> Calculates the average squared distance from the data points to the cluster centroid (also refered to as error) </summary>
val dispersions: float[]
val mean: items: seq<'T> -> 'U (requires member (+) and member get_Zero and member DivideByInt and member (/))
<summary> Computes the population mean (Normalized by N) </summary>
<param name="items">The input sequence.</param>
<remarks>Returns default value if data is empty or if any entry is NaN.</remarks>
<returns>population mean (Normalized by N)</returns>
<summary> Computes the population mean (Normalized by N) </summary>
<param name="items">The input sequence.</param>
<remarks>Returns default value if data is empty or if any entry is NaN.</remarks>
<returns>population mean (Normalized by N)</returns>
val stDev: items: seq<'T> -> 'U (requires member (-) and member get_Zero and member DivideByInt and member (+) and member ( * ) and member (+) and member (/) and member Sqrt)
<summary> Computes the sample standard deviation </summary>
<param name="items">The input sequence.</param>
<remarks>Returns NaN if data is empty or if any entry is NaN.</remarks>
<returns>standard deviation of a sample (Bessel's correction by N-1)</returns>
<summary> Computes the sample standard deviation </summary>
<param name="items">The input sequence.</param>
<remarks>Returns NaN if data is empty or if any entry is NaN.</remarks>
<returns>standard deviation of a sample (Bessel's correction by N-1)</returns>
val elbowChart: GenericChart.GenericChart
static member Chart.Line: xy: seq<#System.IConvertible * #System.IConvertible> * ?ShowMarkers: bool * ?Name: string * ?ShowLegend: bool * ?Opacity: float * ?MultiOpacity: seq<float> * ?Text: 'c * ?MultiText: seq<'c> * ?TextPosition: TextPosition * ?MultiTextPosition: seq<TextPosition> * ?MarkerColor: Color * ?MarkerColorScale: Colorscale * ?MarkerOutline: Line * ?MarkerSymbol: MarkerSymbol * ?MultiMarkerSymbol: seq<MarkerSymbol> * ?Marker: TraceObjects.Marker * ?LineColor: Color * ?LineColorScale: Colorscale * ?LineWidth: float * ?LineDash: DrawingStyle * ?Line: Line * ?StackGroup: string * ?Orientation: Orientation * ?GroupNorm: GroupNorm * ?UseWebGL: bool * ?UseDefaults: bool -> GenericChart.GenericChart (requires 'c :> System.IConvertible)
static member Chart.Line: x: seq<#System.IConvertible> * y: seq<#System.IConvertible> * ?ShowMarkers: bool * ?Name: string * ?ShowLegend: bool * ?Opacity: float * ?MultiOpacity: seq<float> * ?Text: 'c * ?MultiText: seq<'c> * ?TextPosition: TextPosition * ?MultiTextPosition: seq<TextPosition> * ?MarkerColor: Color * ?MarkerColorScale: Colorscale * ?MarkerOutline: Line * ?MarkerSymbol: MarkerSymbol * ?MultiMarkerSymbol: seq<MarkerSymbol> * ?Marker: TraceObjects.Marker * ?LineColor: Color * ?LineColorScale: Colorscale * ?LineWidth: float * ?LineDash: DrawingStyle * ?Line: Line * ?StackGroup: string * ?Orientation: Orientation * ?GroupNorm: GroupNorm * ?UseWebGL: bool * ?UseDefaults: bool -> GenericChart.GenericChart (requires 'c :> System.IConvertible)
static member Chart.Line: x: seq<#System.IConvertible> * y: seq<#System.IConvertible> * ?ShowMarkers: bool * ?Name: string * ?ShowLegend: bool * ?Opacity: float * ?MultiOpacity: seq<float> * ?Text: 'c * ?MultiText: seq<'c> * ?TextPosition: TextPosition * ?MultiTextPosition: seq<TextPosition> * ?MarkerColor: Color * ?MarkerColorScale: Colorscale * ?MarkerOutline: Line * ?MarkerSymbol: MarkerSymbol * ?MultiMarkerSymbol: seq<MarkerSymbol> * ?Marker: TraceObjects.Marker * ?LineColor: Color * ?LineColorScale: Colorscale * ?LineWidth: float * ?LineDash: DrawingStyle * ?Line: Line * ?StackGroup: string * ?Orientation: Orientation * ?GroupNorm: GroupNorm * ?UseWebGL: bool * ?UseDefaults: bool -> GenericChart.GenericChart (requires 'c :> System.IConvertible)
static member Chart.withYErrorStyle: ?Array: seq<#System.IConvertible> * ?Arrayminus: seq<#System.IConvertible> * ?Symmetric: bool * ?Color: Color * ?Thickness: float * ?Width: float -> (GenericChart.GenericChart -> GenericChart.GenericChart)
val aicBootstraps: int
val aicK: int[]
val aicMeans: float[]
val aicStd: float[]
val aic: (int * float)[][]
val b: int
val calcAIC: bootstraps: int -> iClustering: (int -> KClusteringResult<float[]>) -> maxK: int -> (int * float)[]
<summary> Akaike Information Criterion (AIC) </summary>
<summary> Akaike Information Criterion (AIC) </summary>
val iteration: (int * float)[]
val snd: tuple: ('T1 * 'T2) -> 'T2
<summary>Return the second element of a tuple, <c>snd (a,b) = b</c>.</summary>
<param name="tuple">The input tuple.</param>
<returns>The second value.</returns>
<example id="snd-example"><code lang="fsharp"> snd ("first", 2) // Evaluates to 2 </code></example>
<summary>Return the second element of a tuple, <c>snd (a,b) = b</c>.</summary>
<param name="tuple">The input tuple.</param>
<returns>The second value.</returns>
<example id="snd-example"><code lang="fsharp"> snd ("first", 2) // Evaluates to 2 </code></example>
module JaggedArray
from FSharp.Stats
val transpose: arr: 'T[][] -> 'T[][]
<summary> Transposes a jagged array </summary>
<summary> Transposes a jagged array </summary>
val aics: float[]
val unzip3: array: ('T1 * 'T2 * 'T3)[] -> 'T1[] * 'T2[] * 'T3[]
<summary>Splits an array of triples into three arrays.</summary>
<param name="array">The input array.</param>
<returns>The tuple of three arrays.</returns>
<exception cref="T:System.ArgumentNullException">Thrown when the input array is null.</exception>
<example id="unzip3-1"><code lang="fsharp"> let inputs = [| (1, "one", "I"); (2, "two", "II") |] let numbers, names, roman = inputs |> Array.unzip3 </code> Evaluates <c>numbers</c> to <c>[|1; 2|]</c>, <c>names</c> to <c>[|"one"; "two"|]</c> and <c>roman</c> to <c>[|"I"; "II"|]</c>. </example>
<summary>Splits an array of triples into three arrays.</summary>
<param name="array">The input array.</param>
<returns>The tuple of three arrays.</returns>
<exception cref="T:System.ArgumentNullException">Thrown when the input array is null.</exception>
<example id="unzip3-1"><code lang="fsharp"> let inputs = [| (1, "one", "I"); (2, "two", "II") |] let numbers, names, roman = inputs |> Array.unzip3 </code> Evaluates <c>numbers</c> to <c>[|1; 2|]</c>, <c>names</c> to <c>[|"one"; "two"|]</c> and <c>roman</c> to <c>[|"I"; "II"|]</c>. </example>
val aicChart: GenericChart.GenericChart
val silhouetteData: float[][]
System.IO.File.ReadAllLines(path: string) : string[]
System.IO.File.ReadAllLines(path: string, encoding: System.Text.Encoding) : string[]
System.IO.File.ReadAllLines(path: string, encoding: System.Text.Encoding) : string[]
val tmp: string[]
val sI: ClusterNumber.SilhouetteResult[]
val silhouetteIndexKMeans: bootstraps: int -> iClustering: (int -> KClusteringResult<float[]>) -> data: float[][] -> maxK: int -> ClusterNumber.SilhouetteResult[]
<summary> The silhouette index can be used to determine the optimal cluster number in k means clustering. bootstraps indicates the number the k means clustering is performed for each k and maxK indicated the maximal cluster number. </summary>
<summary> The silhouette index can be used to determine the optimal cluster number in k means clustering. bootstraps indicates the number the k means clustering is performed for each k and maxK indicated the maximal cluster number. </summary>
val rawDataChart: GenericChart.GenericChart
val silhouetteIndicesChart: GenericChart.GenericChart
val x: ClusterNumber.SilhouetteResult
ClusterNumber.SilhouetteResult.ClusterNumber: int
ClusterNumber.SilhouetteResult.SilhouetteIndex: float
ClusterNumber.SilhouetteResult.SilhouetteIndexStDev: float
val combinedSilhouette: GenericChart.GenericChart
static member Chart.Grid: ?SubPlots: (LinearAxisId * LinearAxisId)[][] * ?XAxes: LinearAxisId[] * ?YAxes: LinearAxisId[] * ?RowOrder: LayoutGridRowOrder * ?Pattern: LayoutGridPattern * ?XGap: float * ?YGap: float * ?Domain: Domain * ?XSide: LayoutGridXSide * ?YSide: LayoutGridYSide -> (#seq<'a1> -> GenericChart.GenericChart) (requires 'a1 :> seq<GenericChart.GenericChart>)
static member Chart.Grid: nRows: int * nCols: int * ?SubPlots: (LinearAxisId * LinearAxisId)[][] * ?XAxes: LinearAxisId[] * ?YAxes: LinearAxisId[] * ?RowOrder: LayoutGridRowOrder * ?Pattern: LayoutGridPattern * ?XGap: float * ?YGap: float * ?Domain: Domain * ?XSide: LayoutGridXSide * ?YSide: LayoutGridYSide -> (#seq<GenericChart.GenericChart> -> GenericChart.GenericChart)
static member Chart.Grid: nRows: int * nCols: int * ?SubPlots: (LinearAxisId * LinearAxisId)[][] * ?XAxes: LinearAxisId[] * ?YAxes: LinearAxisId[] * ?RowOrder: LayoutGridRowOrder * ?Pattern: LayoutGridPattern * ?XGap: float * ?YGap: float * ?Domain: Domain * ?XSide: LayoutGridXSide * ?YSide: LayoutGridYSide -> (#seq<GenericChart.GenericChart> -> GenericChart.GenericChart)
val gapStatisticsData: float[][]
val gapDataChart: GenericChart.GenericChart
module GapStatistics
from FSharp.Stats.ML.Unsupervised
module PointGenerators
from FSharp.Stats.ML.Unsupervised.GapStatistics
val generateUniformPoints: rnd: System.Random -> data: float[] array -> float[][]
<summary> Generate uniform points within the range of `data`. </summary>
<summary> Generate uniform points within the range of `data`. </summary>
val generateUniformPointsPCA: rnd: System.Random -> data: float[] array -> float[][]
static member Chart.withSize: width: float * height: float -> (GenericChart.GenericChart -> GenericChart.GenericChart)
static member Chart.withSize: ?Width: int * ?Height: int -> (GenericChart.GenericChart -> GenericChart.GenericChart)
static member Chart.withSize: ?Width: int * ?Height: int -> (GenericChart.GenericChart -> GenericChart.GenericChart)
val gaps: GapStatisticResult[]
val calculate: rndPointGenerator: GenericPointGenerator<'a> -> bootstraps: int -> calcDispersion: GenericClusterDispersion<'a> -> maxK: int -> data: 'a array -> GapStatisticResult[]
module ClusterDispersionMetric
from FSharp.Stats.ML.Unsupervised.GapStatistics
val logDispersionKMeansInitRandom: (float[] array -> int -> float)
val k: int[]
val x: GapStatisticResult
GapStatisticResult.ClusterIndex: int
val disp: float[]
GapStatisticResult.Dispersion: float
val dispRef: float[]
GapStatisticResult.ReferenceDispersion: float
val gap: float[]
GapStatisticResult.Gaps: float
val std: float[]
GapStatisticResult.RefDispersionStDev: float
val gapStatisticsChart: GenericChart.GenericChart
val dispersions: GenericChart.GenericChart
val gaps: GenericChart.GenericChart
val sK: float[]
val sd: float
val sqrt: value: 'T -> 'U (requires member Sqrt)
<summary>Square root of the given number</summary>
<param name="value">The input value.</param>
<returns>The square root of the input.</returns>
<example id="log-example"><code lang="fsharp"> sqrt 2.0 // Evaluates to 1.414213562 sqrt 100.0 // Evaluates to 10.0 </code></example>
<summary>Square root of the given number</summary>
<param name="value">The input value.</param>
<returns>The square root of the input.</returns>
<example id="log-example"><code lang="fsharp"> sqrt 2.0 // Evaluates to 1.414213562 sqrt 100.0 // Evaluates to 10.0 </code></example>
val gapChart: GenericChart.GenericChart
val kOpt: string
val init: count: int -> initializer: (int -> 'T) -> 'T[]
<summary>Creates an array given the dimension and a generator function to compute the elements.</summary>
<param name="count">The number of elements to initialize.</param>
<param name="initializer">The function to generate the initial values for each index.</param>
<returns>The created array.</returns>
<exception cref="T:System.ArgumentException">Thrown when count is negative.</exception>
<example id="init-1"><code lang="fsharp"> Array.init 4 (fun v -> v + 5) </code> Evaluates to <c>[| 5; 6; 7; 8 |]</c></example>
<example id="init-2"><code lang="fsharp"> Array.init -5 (fun v -> v + 5) </code> Throws <c>ArgumentException</c></example>
<summary>Creates an array given the dimension and a generator function to compute the elements.</summary>
<param name="count">The number of elements to initialize.</param>
<param name="initializer">The function to generate the initial values for each index.</param>
<returns>The created array.</returns>
<exception cref="T:System.ArgumentException">Thrown when count is negative.</exception>
<example id="init-1"><code lang="fsharp"> Array.init 4 (fun v -> v + 5) </code> Evaluates to <c>[| 5; 6; 7; 8 |]</c></example>
<example id="init-2"><code lang="fsharp"> Array.init -5 (fun v -> v + 5) </code> Throws <c>ArgumentException</c></example>
property System.Array.Length: int with get
<summary>Gets the total number of elements in all the dimensions of the <see cref="T:System.Array" />.</summary>
<exception cref="T:System.OverflowException">The array is multidimensional and contains more than <see cref="F:System.Int32.MaxValue" /> elements.</exception>
<returns>The total number of elements in all the dimensions of the <see cref="T:System.Array" />; zero if there are no elements in the array.</returns>
<summary>Gets the total number of elements in all the dimensions of the <see cref="T:System.Array" />.</summary>
<exception cref="T:System.OverflowException">The array is multidimensional and contains more than <see cref="F:System.Int32.MaxValue" /> elements.</exception>
<returns>The total number of elements in all the dimensions of the <see cref="T:System.Array" />; zero if there are no elements in the array.</returns>
val findIndex: predicate: ('T -> bool) -> array: 'T[] -> int
<summary>Returns the index of the first element in the array that satisfies the given predicate. Raise <see cref="T:System.Collections.Generic.KeyNotFoundException" /> if none of the elements satisfy the predicate.</summary>
<param name="predicate">The function to test the input elements.</param>
<param name="array">The input array.</param>
<exception cref="T:System.Collections.Generic.KeyNotFoundException">Thrown if <c>predicate</c> never returns true.</exception>
<exception cref="T:System.ArgumentNullException">Thrown when the input array is null.</exception>
<returns>The index of the first element in the array that satisfies the given predicate.</returns>
<example id="findindex-1"><code lang="fsharp"> let inputs = [| 1; 2; 3; 4; 5 |] inputs |> Array.findIndex (fun elm -> elm % 2 = 0) </code> Evaluates to <c>1</c></example>
<example id="findindex-2"><code lang="fsharp"> let inputs = [| 1; 2; 3; 4; 5 |] inputs |> Array.findIndex (fun elm -> elm % 6 = 0) </code> Throws <c>KeyNotFoundException</c></example>
<summary>Returns the index of the first element in the array that satisfies the given predicate. Raise <see cref="T:System.Collections.Generic.KeyNotFoundException" /> if none of the elements satisfy the predicate.</summary>
<param name="predicate">The function to test the input elements.</param>
<param name="array">The input array.</param>
<exception cref="T:System.Collections.Generic.KeyNotFoundException">Thrown if <c>predicate</c> never returns true.</exception>
<exception cref="T:System.ArgumentNullException">Thrown when the input array is null.</exception>
<returns>The index of the first element in the array that satisfies the given predicate.</returns>
<example id="findindex-1"><code lang="fsharp"> let inputs = [| 1; 2; 3; 4; 5 |] inputs |> Array.findIndex (fun elm -> elm % 2 = 0) </code> Evaluates to <c>1</c></example>
<example id="findindex-2"><code lang="fsharp"> let inputs = [| 1; 2; 3; 4; 5 |] inputs |> Array.findIndex (fun elm -> elm % 6 = 0) </code> Throws <c>KeyNotFoundException</c></example>
val id: x: 'T -> 'T
<summary>The identity function</summary>
<param name="x">The input value.</param>
<returns>The same value.</returns>
<example id="id-example"><code lang="fsharp"> id 12 // Evaulates to 12 id "abc" // Evaulates to "abc" </code></example>
<summary>The identity function</summary>
<param name="x">The input value.</param>
<returns>The same value.</returns>
<example id="id-example"><code lang="fsharp"> id 12 // Evaulates to 12 id "abc" // Evaulates to "abc" </code></example>