Tables
This example shows how to create tables in F#.
Let's first create some data for the purpose of creating example charts:
open Plotly.NET
open Plotly.NET.StyleParam
let table1 =
Chart.Table(
headerValues = [ "<b>RowIndex</b>"; "A"; "simple"; "table" ],
cellsValues = [ [ "0"; "I"; "am"; "a" ]; [ "1"; "little"; "example"; "!" ] ]
)
A little bit of styling:
let table2 =
let header = [ "<b>RowIndex</b>"; "A"; "simple"; "table" ]
let rows = [ [ "0"; "I"; "am"; "a" ]; [ "1"; "little"; "example"; "!" ] ]
Chart.Table(
headerValues = header,
cellsValues = rows,
HeaderAlign = StyleParam.HorizontalAlign.Center,
CellsMultiAlign =
[ StyleParam.HorizontalAlign.Left
StyleParam.HorizontalAlign.Center
StyleParam.HorizontalAlign.Right ],
HeaderFillColor = Color.fromString "#45546a",
CellsFillColor =
Color.fromColors
[ Color.fromString "#deebf7"
Color.fromString "lightgrey"
Color.fromString "#deebf7"
Color.fromString "lightgrey" ],
HeaderHeight = 30,
HeaderOutlineColor = Color.fromString "black",
HeaderOutlineWidth = 2.,
MultiColumnWidth = [ 70.; 50.; 100.; 70. ],
ColumnOrder = [ 1; 2; 3; 4 ]
)
Value dependent cell coloring:
let table3 =
let header2 = [ "Identifier"; "T0"; "T1"; "T2"; "T3" ]
let rowvalues =
[ [ 10001.; 0.2; 2.0; 4.0; 5.0 ]
[ 10002.; 2.1; 2.0; 1.8; 2.1 ]
[ 10003.; 4.5; 3.0; 2.0; 2.5 ]
[ 10004.; 0.0; 0.1; 0.3; 0.2 ]
[ 10005.; 1.0; 1.6; 1.8; 2.2 ]
[ 10006.; 1.0; 0.8; 1.5; 0.7 ]
[ 10007.; 2.0; 2.0; 2.1; 1.9 ] ]
|> Seq.sortBy (fun x -> x.[1])
//map color from value to hex representation
let mapColor min max value =
let proportion = (255. * (value - min) / (max - min)) |> int
Color.fromRGB 255 (255 - proportion) proportion
//Assign a color to every cell seperately. Matrix must be transposed for correct orientation.
let cellcolor =
rowvalues
|> Seq.map (fun row ->
row
|> Seq.mapi (fun index value ->
if index = 0 then
Color.fromString "white"
else
mapColor 0. 5. value))
|> Seq.transpose
|> Seq.map Color.fromColors
|> Color.fromColors
Chart.Table(headerValues = header2, cellsValues = rowvalues, CellsFillColor = cellcolor)
Sequence representation:
let table4 =
let sequence =
[ "ATGAGACGTCGAGACTGATAGACGTCGATAGACGTCGATAGACCG"
"ATAGACTCGTGATAGACGTCGATAGACGTCGATAGAGTATAGACC"
"GTGATAGACGTCGAGAAGACGTCGATAGACGTCGATAGACGTCGA"
"TAGAGATAGACGTCGATAGACCGTATAGAAGACGTCGATAGATAG"
"ACGTCGATAGACCGTAGACGTCGATAGACGTCGATAGACCGT" ]
|> String.concat ""
let elementsPerRow = 60
let headers =
[ 0..elementsPerRow ]
|> Seq.map (fun x -> if x % 10 = 0 && x <> 0 then "|" else "")
let cells =
sequence
|> Seq.chunkBySize elementsPerRow
|> Seq.mapi (fun i x -> Seq.append [ string (i * elementsPerRow) ] (Seq.map string x))
let cellcolors =
cells
|> Seq.map (fun row ->
row
|> Seq.map (fun element ->
match element with
//colors taken from DRuMS
//(http://biomodel.uah.es/en/model4/dna/atgc.htm)
| "A" -> Color.fromString "#5050FF"
| "T" -> Color.fromString "#E6E600"
| "G" -> Color.fromString "#00C000"
| "C" -> Color.fromString "#E00000"
| "U" -> Color.fromString "#B48100"
| _ -> Color.fromString "white"))
|> Seq.transpose
|> Seq.map (fun x -> Seq.append x (seq [ Color.fromString "white" ]))
|> Seq.map Color.fromColors
|> Color.fromColors
let line = Line.init (Width = 0., Color = Color.fromString "white")
let chartwidth = 50 + 10 * elementsPerRow
Chart.Table(
headerValues = headers,
cellsValues = cells,
CellsOutline = line,
HeaderOutline = line,
CellsHeight = 20,
MultiColumnWidth = [ 50.; 10. ],
CellsMultiAlign = [ StyleParam.HorizontalAlign.Right; StyleParam.HorizontalAlign.Center ],
CellsFillColor = cellcolors,
UseDefaults = false
)
|> Chart.withSize (Width = chartwidth)
|> Chart.withTitle "Sequence A"
namespace Plotly
namespace Plotly.NET
module Defaults
from Plotly.NET
<summary> Contains mutable global default values. Changing these values will apply the default values to all consecutive Chart generations. </summary>
<summary> Contains mutable global default values. Changing these values will apply the default values to all consecutive Chart generations. </summary>
val mutable DefaultDisplayOptions: DisplayOptions
Multiple items
type DisplayOptions = inherit DynamicObj new: unit -> DisplayOptions static member addAdditionalHeadTags: additionalHeadTags: XmlNode list -> (DisplayOptions -> DisplayOptions) static member addDescription: description: XmlNode list -> (DisplayOptions -> DisplayOptions) static member combine: first: DisplayOptions -> second: DisplayOptions -> DisplayOptions static member getAdditionalHeadTags: displayOpts: DisplayOptions -> XmlNode list static member getDescription: displayOpts: DisplayOptions -> XmlNode list static member getPlotlyReference: displayOpts: DisplayOptions -> PlotlyJSReference static member init: ?AdditionalHeadTags: XmlNode list * ?Description: XmlNode list * ?PlotlyJSReference: PlotlyJSReference -> DisplayOptions static member initCDNOnly: unit -> DisplayOptions ...
--------------------
new: unit -> DisplayOptions
type DisplayOptions = inherit DynamicObj new: unit -> DisplayOptions static member addAdditionalHeadTags: additionalHeadTags: XmlNode list -> (DisplayOptions -> DisplayOptions) static member addDescription: description: XmlNode list -> (DisplayOptions -> DisplayOptions) static member combine: first: DisplayOptions -> second: DisplayOptions -> DisplayOptions static member getAdditionalHeadTags: displayOpts: DisplayOptions -> XmlNode list static member getDescription: displayOpts: DisplayOptions -> XmlNode list static member getPlotlyReference: displayOpts: DisplayOptions -> PlotlyJSReference static member init: ?AdditionalHeadTags: XmlNode list * ?Description: XmlNode list * ?PlotlyJSReference: PlotlyJSReference -> DisplayOptions static member initCDNOnly: unit -> DisplayOptions ...
--------------------
new: unit -> DisplayOptions
static member DisplayOptions.init: ?AdditionalHeadTags: Giraffe.ViewEngine.HtmlElements.XmlNode list * ?Description: Giraffe.ViewEngine.HtmlElements.XmlNode list * ?PlotlyJSReference: PlotlyJSReference -> DisplayOptions
type PlotlyJSReference =
| CDN of string
| Full
| Require of string
| NoReference
<summary> Sets how plotly is referenced in the head of html docs. </summary>
<summary> Sets how plotly is referenced in the head of html docs. </summary>
union case PlotlyJSReference.NoReference: PlotlyJSReference
module StyleParam
from Plotly.NET
val table1: GenericChart.GenericChart
type Chart =
static member AnnotatedHeatmap: zData: seq<#seq<'a1>> * annotationText: seq<#seq<string>> * ?Name: string * ?ShowLegend: bool * ?Opacity: float * ?X: seq<'a3> * ?MultiX: seq<seq<'a3>> * ?XGap: int * ?Y: seq<'a4> * ?MultiY: seq<seq<'a4>> * ?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 'a3 :> IConvertible and 'a4 :> IConvertible and 'a5 :> IConvertible) + 1 overload
static member Area: x: seq<#IConvertible> * y: seq<#IConvertible> * ?ShowMarkers: bool * ?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 * ?AlignmentGroup: string * ?OffsetGroup: string * ?StackGroup: string * ?Orientation: Orientation * ?GroupNorm: GroupNorm * ?FillColor: Color * ?FillPatternShape: PatternShape * ?FillPattern: Pattern * ?UseWebGL: bool * ?UseDefaults: bool -> GenericChart (requires 'a2 :> IConvertible) + 1 overload
static member Bar: values: seq<#IConvertible> * ?Keys: seq<'a1> * ?MultiKeys: seq<seq<'a1>> * ?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 'a1 :> IConvertible and 'a2 :> IConvertible and 'a4 :> IConvertible) + 1 overload
static member BoxPlot: ?X: seq<'a0> * ?MultiX: seq<seq<'a0>> * ?Y: seq<'a1> * ?MultiY: seq<seq<'a1>> * ?Name: string * ?ShowLegend: bool * ?Text: 'a2 * ?MultiText: seq<'a2> * ?FillColor: Color * ?MarkerColor: Color * ?Marker: Marker * ?Opacity: float * ?WhiskerWidth: float * ?BoxPoints: BoxPoints * ?BoxMean: BoxMean * ?Jitter: float * ?PointPos: float * ?Orientation: Orientation * ?OutlineColor: Color * ?OutlineWidth: float * ?Outline: Line * ?AlignmentGroup: string * ?OffsetGroup: string * ?Notched: bool * ?NotchWidth: float * ?QuartileMethod: QuartileMethod * ?UseDefaults: bool -> GenericChart (requires 'a0 :> IConvertible and 'a1 :> IConvertible and 'a2 :> IConvertible) + 2 overloads
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 * ?AlignmentGroup: string * ?OffsetGroup: string * ?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<'a4> * ?MultiX: seq<seq<'a4>> * ?Name: string * ?ShowLegend: bool * ?Opacity: float * ?Text: 'a5 * ?MultiText: seq<'a5> * ?Line: Line * ?IncreasingColor: Color * ?Increasing: FinanceMarker * ?DecreasingColor: Color * ?Decreasing: FinanceMarker * ?WhiskerWidth: float * ?ShowXAxisRangeSlider: bool * ?UseDefaults: bool -> GenericChart (requires 'a4 :> IConvertible and 'a5 :> IConvertible) + 2 overloads
static member Column: values: seq<#IConvertible> * ?Keys: seq<'a1> * ?MultiKeys: seq<seq<'a1>> * ?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 'a1 :> IConvertible and 'a2 :> IConvertible and 'a4 :> IConvertible) + 1 overload
static member Contour: zData: seq<#seq<'a1>> * ?Name: string * ?ShowLegend: bool * ?Opacity: float * ?X: seq<'a2> * ?MultiX: seq<seq<'a2>> * ?Y: seq<'a3> * ?MultiY: seq<seq<'a3>> * ?Text: 'a4 * ?MultiText: seq<'a4> * ?ColorBar: ColorBar * ?ColorScale: Colorscale * ?ShowScale: bool * ?ReverseScale: bool * ?Transpose: bool * ?ContourLineColor: Color * ?ContourLineDash: DrawingStyle * ?ContourLineSmoothing: float * ?ContourLine: Line * ?ContoursColoring: ContourColoring * ?ContoursOperation: ConstraintOperation * ?ContoursType: ContourType * ?ShowContourLabels: bool * ?ContourLabelFont: Font * ?Contours: Contours * ?FillColor: Color * ?NContours: int * ?UseDefaults: bool -> GenericChart (requires 'a1 :> IConvertible and 'a2 :> IConvertible and 'a3 :> 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>> * ?X: seq<'a2> * ?MultiX: seq<seq<'a2>> * ?Y: seq<'a3> * ?MultiY: seq<seq<'a3>> * ?Name: string * ?ShowLegend: bool * ?Opacity: float * ?XGap: int * ?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 'a2 :> IConvertible and 'a3 :> IConvertible and 'a4 :> IConvertible) + 1 overload
...
static member Chart.Table: header: TraceObjects.TableHeader * cells: TraceObjects.TableCells * ?Name: string * ?ColumnOrder: seq<int> * ?ColumnWidth: float * ?MultiColumnWidth: seq<float> * ?UseDefaults: bool -> GenericChart.GenericChart
static member Chart.Table: headerValues: seq<#seq<'b>> * cellsValues: seq<#seq<'d>> * ?TransposeCells: bool * ?HeaderAlign: HorizontalAlign * ?HeaderMultiAlign: seq<HorizontalAlign> * ?HeaderFillColor: Color * ?HeaderHeight: int * ?HeaderOutlineColor: Color * ?HeaderOutlineWidth: float * ?HeaderOutlineMultiWidth: seq<float> * ?HeaderOutline: Line * ?CellsAlign: HorizontalAlign * ?CellsMultiAlign: seq<HorizontalAlign> * ?CellsFillColor: Color * ?CellsHeight: int * ?CellsOutlineColor: Color * ?CellsOutlineWidth: float * ?CellsOutlineMultiWidth: seq<float> * ?CellsOutline: Line * ?Name: string * ?ColumnOrder: seq<int> * ?ColumnWidth: float * ?MultiColumnWidth: seq<float> * ?UseDefaults: bool -> GenericChart.GenericChart (requires 'b :> System.IConvertible and 'd :> System.IConvertible)
static member Chart.Table: headerValues: seq<#seq<'b>> * cellsValues: seq<#seq<'d>> * ?TransposeCells: bool * ?HeaderAlign: HorizontalAlign * ?HeaderMultiAlign: seq<HorizontalAlign> * ?HeaderFillColor: Color * ?HeaderHeight: int * ?HeaderOutlineColor: Color * ?HeaderOutlineWidth: float * ?HeaderOutlineMultiWidth: seq<float> * ?HeaderOutline: Line * ?CellsAlign: HorizontalAlign * ?CellsMultiAlign: seq<HorizontalAlign> * ?CellsFillColor: Color * ?CellsHeight: int * ?CellsOutlineColor: Color * ?CellsOutlineWidth: float * ?CellsOutlineMultiWidth: seq<float> * ?CellsOutline: Line * ?Name: string * ?ColumnOrder: seq<int> * ?ColumnWidth: float * ?MultiColumnWidth: seq<float> * ?UseDefaults: bool -> GenericChart.GenericChart (requires 'b :> System.IConvertible and 'd :> System.IConvertible)
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
val table2: GenericChart.GenericChart
val header: string list
val rows: string list list
type HorizontalAlign =
| Left
| Center
| Right
member Convert: unit -> obj
override ToString: unit -> string
static member convert: (HorizontalAlign -> obj)
static member toString: (HorizontalAlign -> string)
union case HorizontalAlign.Center: HorizontalAlign
union case HorizontalAlign.Left: HorizontalAlign
union case HorizontalAlign.Right: HorizontalAlign
type Color =
override Equals: other: obj -> bool
override GetHashCode: unit -> int
static member fromARGB: a: int -> r: int -> g: int -> b: int -> Color
static member fromColorScaleValues: c: seq<#IConvertible> -> Color
static member fromColors: c: seq<Color> -> Color
static member fromHex: s: string -> Color
static member fromKeyword: c: ColorKeyword -> Color
static member fromRGB: r: int -> g: int -> b: int -> Color
static member fromString: c: string -> Color
member Value: obj
<summary> Plotly color can be a single color, a sequence of colors, or a sequence of numeric values referencing the color of the colorscale obj </summary>
<summary> Plotly color can be a single color, a sequence of colors, or a sequence of numeric values referencing the color of the colorscale obj </summary>
static member Color.fromString: c: string -> Color
static member Color.fromColors: c: seq<Color> -> Color
val table3: GenericChart.GenericChart
val header2: string list
val rowvalues: seq<float list>
module Seq
from Microsoft.FSharp.Collections
<summary>Contains operations for working with values of type <see cref="T:Microsoft.FSharp.Collections.seq`1" />.</summary>
<summary>Contains operations for working with values of type <see cref="T:Microsoft.FSharp.Collections.seq`1" />.</summary>
val sortBy: projection: ('T -> 'Key) -> source: seq<'T> -> seq<'T> (requires comparison)
<summary>Applies a key-generating function to each element of a sequence and yield a sequence ordered by keys. The keys are compared using generic comparison as implemented by <see cref="M:Microsoft.FSharp.Core.Operators.compare" />.</summary>
<remarks>This function returns a sequence that digests the whole initial sequence as soon as that sequence is iterated. As a result this function should not be used with large or infinite sequences. The function makes no assumption on the ordering of the original sequence and uses a stable sort, that is the original order of equal elements is preserved.</remarks>
<param name="projection">A function to transform items of the input sequence into comparable keys.</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="sortby-1"><code lang="fsharp"> let input = [ "a"; "bbb"; "cccc"; "dd" ] input |> Seq.sortBy (fun s -> s.Length) </code> Evaluates to a sequence yielding the same results as <c>seq { "a"; "dd"; "bbb"; "cccc" }</c>. </example>
<summary>Applies a key-generating function to each element of a sequence and yield a sequence ordered by keys. The keys are compared using generic comparison as implemented by <see cref="M:Microsoft.FSharp.Core.Operators.compare" />.</summary>
<remarks>This function returns a sequence that digests the whole initial sequence as soon as that sequence is iterated. As a result this function should not be used with large or infinite sequences. The function makes no assumption on the ordering of the original sequence and uses a stable sort, that is the original order of equal elements is preserved.</remarks>
<param name="projection">A function to transform items of the input sequence into comparable keys.</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="sortby-1"><code lang="fsharp"> let input = [ "a"; "bbb"; "cccc"; "dd" ] input |> Seq.sortBy (fun s -> s.Length) </code> Evaluates to a sequence yielding the same results as <c>seq { "a"; "dd"; "bbb"; "cccc" }</c>. </example>
val x: float list
val mapColor: (float -> float -> float -> Color)
val min: float
val max: float
val value: float
val proportion: 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>
static member Color.fromRGB: r: int -> g: int -> b: int -> Color
val cellcolor: Color
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 row: float list
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 index: int
val transpose: source: seq<#seq<'T>> -> seq<seq<'T>>
<summary>Returns the transpose of the given sequence of sequences.</summary>
<remarks>This function returns a sequence that digests the whole initial sequence as soon as that sequence is iterated. As a result this function should not be used with large or infinite sequences.</remarks>
<param name="source">The input sequence.</param>
<returns>The transposed sequence.</returns>
<exception cref="T:System.ArgumentNullException">Thrown when the input sequence is null.</exception>
<example id="transpose-1"><code lang="fsharp"> let inputs = [ [ 10; 20; 30 ] [ 11; 21; 31 ] ] inputs |> Seq.transpose </code> Evaluates to a sequence of sequences yielding the same results as <c>[ [10; 11]; [20; 21]; [30; 31] ]</c>. </example>
<summary>Returns the transpose of the given sequence of sequences.</summary>
<remarks>This function returns a sequence that digests the whole initial sequence as soon as that sequence is iterated. As a result this function should not be used with large or infinite sequences.</remarks>
<param name="source">The input sequence.</param>
<returns>The transposed sequence.</returns>
<exception cref="T:System.ArgumentNullException">Thrown when the input sequence is null.</exception>
<example id="transpose-1"><code lang="fsharp"> let inputs = [ [ 10; 20; 30 ] [ 11; 21; 31 ] ] inputs |> Seq.transpose </code> Evaluates to a sequence of sequences yielding the same results as <c>[ [10; 11]; [20; 21]; [30; 31] ]</c>. </example>
val table4: GenericChart.GenericChart
val sequence: string
module String
from Microsoft.FSharp.Core
<summary>Functional programming operators for string processing. Further string operations are available via the member functions on strings and other functionality in <a href="http://msdn2.microsoft.com/en-us/library/system.string.aspx">System.String</a> and <a href="http://msdn2.microsoft.com/library/system.text.regularexpressions.aspx">System.Text.RegularExpressions</a> types. </summary>
<category>Strings and Text</category>
<summary>Functional programming operators for string processing. Further string operations are available via the member functions on strings and other functionality in <a href="http://msdn2.microsoft.com/en-us/library/system.string.aspx">System.String</a> and <a href="http://msdn2.microsoft.com/library/system.text.regularexpressions.aspx">System.Text.RegularExpressions</a> types. </summary>
<category>Strings and Text</category>
val concat: sep: string -> strings: seq<string> -> string
<summary>Returns a new string made by concatenating the given strings with separator <c>sep</c>, that is <c>a1 + sep + ... + sep + aN</c>.</summary>
<param name="sep">The separator string to be inserted between the strings of the input sequence.</param>
<param name="strings">The sequence of strings to be concatenated.</param>
<returns>A new string consisting of the concatenated strings separated by the separation string.</returns>
<exception cref="T:System.ArgumentNullException">Thrown when <c>strings</c> is null.</exception>
<example id="concat-1"><code lang="fsharp"> let input1 = ["Stefan"; "says:"; "Hello"; "there!"] input1 |> String.concat " " // evaluates "Stefan says: Hello there!" let input2 = [0..9] |> List.map string input2 |> String.concat "" // evaluates "0123456789" input2 |> String.concat ", " // evaluates "0, 1, 2, 3, 4, 5, 6, 7, 8, 9" let input3 = ["No comma"] input3 |> String.concat "," // evaluates "No comma" </code></example>
<summary>Returns a new string made by concatenating the given strings with separator <c>sep</c>, that is <c>a1 + sep + ... + sep + aN</c>.</summary>
<param name="sep">The separator string to be inserted between the strings of the input sequence.</param>
<param name="strings">The sequence of strings to be concatenated.</param>
<returns>A new string consisting of the concatenated strings separated by the separation string.</returns>
<exception cref="T:System.ArgumentNullException">Thrown when <c>strings</c> is null.</exception>
<example id="concat-1"><code lang="fsharp"> let input1 = ["Stefan"; "says:"; "Hello"; "there!"] input1 |> String.concat " " // evaluates "Stefan says: Hello there!" let input2 = [0..9] |> List.map string input2 |> String.concat "" // evaluates "0123456789" input2 |> String.concat ", " // evaluates "0, 1, 2, 3, 4, 5, 6, 7, 8, 9" let input3 = ["No comma"] input3 |> String.concat "," // evaluates "No comma" </code></example>
val elementsPerRow: int
val headers: seq<string>
val x: int
val cells: seq<seq<string>>
val chunkBySize: chunkSize: int -> source: seq<'T> -> seq<'T[]>
<summary>Divides the input sequence into chunks of size at most <c>chunkSize</c>.</summary>
<param name="chunkSize">The maximum size of each chunk.</param>
<param name="source">The input sequence.</param>
<returns>The sequence divided into chunks.</returns>
<exception cref="T:System.ArgumentNullException">Thrown when the input sequence is null.</exception>
<exception cref="T:System.ArgumentException">Thrown when <c>chunkSize</c> is not positive.</exception>
<example id="chunk-by-size-1"><code lang="fsharp"> [1; 2; 3] |> Seq.chunkBySize 2 </code> Evaluates to a sequence yielding the same results as <c>seq { [|1; 2|]; [|3|] }</c></example>
<example id="chunk-by-size-2"><code lang="fsharp"> [1; 2; 3] |> Seq.chunkBySize -2 </code> Throws <c>ArgumentException</c></example>
<summary>Divides the input sequence into chunks of size at most <c>chunkSize</c>.</summary>
<param name="chunkSize">The maximum size of each chunk.</param>
<param name="source">The input sequence.</param>
<returns>The sequence divided into chunks.</returns>
<exception cref="T:System.ArgumentNullException">Thrown when the input sequence is null.</exception>
<exception cref="T:System.ArgumentException">Thrown when <c>chunkSize</c> is not positive.</exception>
<example id="chunk-by-size-1"><code lang="fsharp"> [1; 2; 3] |> Seq.chunkBySize 2 </code> Evaluates to a sequence yielding the same results as <c>seq { [|1; 2|]; [|3|] }</c></example>
<example id="chunk-by-size-2"><code lang="fsharp"> [1; 2; 3] |> Seq.chunkBySize -2 </code> Throws <c>ArgumentException</c></example>
val i: int
val x: char[]
val append: source1: seq<'T> -> source2: seq<'T> -> seq<'T>
<summary>Wraps the two given enumerations as a single concatenated enumeration.</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="source1">The first sequence.</param>
<param name="source2">The second sequence.</param>
<returns>The result sequence.</returns>
<exception cref="T:System.ArgumentNullException">Thrown when either of the two provided sequences is null.</exception>
<example id="append-1"><code lang="fsharp"> Seq.append [1; 2] [3; 4] </code> Evaluates to a sequence yielding the same results as <c>seq { 1; 2; 3; 4 }</c></example>
<summary>Wraps the two given enumerations as a single concatenated enumeration.</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="source1">The first sequence.</param>
<param name="source2">The second sequence.</param>
<returns>The result sequence.</returns>
<exception cref="T:System.ArgumentNullException">Thrown when either of the two provided sequences is null.</exception>
<example id="append-1"><code lang="fsharp"> Seq.append [1; 2] [3; 4] </code> Evaluates to a sequence yielding the same results as <c>seq { 1; 2; 3; 4 }</c></example>
Multiple items
val string: value: 'T -> string
<summary>Converts the argument to a string using <c>ToString</c>.</summary>
<remarks>For standard integer and floating point values the and any type that implements <c>IFormattable</c><c>ToString</c> conversion uses <c>CultureInfo.InvariantCulture</c>. </remarks>
<param name="value">The input value.</param>
<returns>The converted string.</returns>
<example id="string-example"><code lang="fsharp"></code></example>
--------------------
type string = System.String
<summary>An abbreviation for the CLI type <see cref="T:System.String" />.</summary>
<category>Basic Types</category>
val string: value: 'T -> string
<summary>Converts the argument to a string using <c>ToString</c>.</summary>
<remarks>For standard integer and floating point values the and any type that implements <c>IFormattable</c><c>ToString</c> conversion uses <c>CultureInfo.InvariantCulture</c>. </remarks>
<param name="value">The input value.</param>
<returns>The converted string.</returns>
<example id="string-example"><code lang="fsharp"></code></example>
--------------------
type string = System.String
<summary>An abbreviation for the CLI type <see cref="T:System.String" />.</summary>
<category>Basic Types</category>
val cellcolors: Color
val row: seq<string>
val element: string
val x: seq<Color>
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 line: Line
Multiple items
type Line = inherit DynamicObj new: unit -> Line static member init: ?BackOff: BackOff * ?AutoColorScale: bool * ?CAuto: bool * ?CMax: float * ?CMid: float * ?CMin: float * ?Color: Color * ?ColorAxis: SubPlotId * ?Colorscale: Colorscale * ?ReverseScale: bool * ?ShowScale: bool * ?ColorBar: ColorBar * ?Dash: DrawingStyle * ?Shape: Shape * ?Simplify: bool * ?Smoothing: float * ?Width: float * ?MultiWidth: seq<float> * ?OutlierColor: Color * ?OutlierWidth: float -> Line static member style: ?BackOff: BackOff * ?AutoColorScale: bool * ?CAuto: bool * ?CMax: float * ?CMid: float * ?CMin: float * ?Color: Color * ?ColorAxis: SubPlotId * ?Colorscale: Colorscale * ?ReverseScale: bool * ?ShowScale: bool * ?ColorBar: ColorBar * ?Dash: DrawingStyle * ?Shape: Shape * ?Simplify: bool * ?Smoothing: float * ?Width: float * ?MultiWidth: seq<float> * ?OutlierColor: Color * ?OutlierWidth: float -> (Line -> Line)
<summary> The line object determines the style of the line in various aspect of plots such as a line connecting datums, outline of layout objects, etc.. </summary>
--------------------
new: unit -> Line
type Line = inherit DynamicObj new: unit -> Line static member init: ?BackOff: BackOff * ?AutoColorScale: bool * ?CAuto: bool * ?CMax: float * ?CMid: float * ?CMin: float * ?Color: Color * ?ColorAxis: SubPlotId * ?Colorscale: Colorscale * ?ReverseScale: bool * ?ShowScale: bool * ?ColorBar: ColorBar * ?Dash: DrawingStyle * ?Shape: Shape * ?Simplify: bool * ?Smoothing: float * ?Width: float * ?MultiWidth: seq<float> * ?OutlierColor: Color * ?OutlierWidth: float -> Line static member style: ?BackOff: BackOff * ?AutoColorScale: bool * ?CAuto: bool * ?CMax: float * ?CMid: float * ?CMin: float * ?Color: Color * ?ColorAxis: SubPlotId * ?Colorscale: Colorscale * ?ReverseScale: bool * ?ShowScale: bool * ?ColorBar: ColorBar * ?Dash: DrawingStyle * ?Shape: Shape * ?Simplify: bool * ?Smoothing: float * ?Width: float * ?MultiWidth: seq<float> * ?OutlierColor: Color * ?OutlierWidth: float -> (Line -> Line)
<summary> The line object determines the style of the line in various aspect of plots such as a line connecting datums, outline of layout objects, etc.. </summary>
--------------------
new: unit -> Line
static member Line.init: ?BackOff: BackOff * ?AutoColorScale: bool * ?CAuto: bool * ?CMax: float * ?CMid: float * ?CMin: float * ?Color: Color * ?ColorAxis: SubPlotId * ?Colorscale: Colorscale * ?ReverseScale: bool * ?ShowScale: bool * ?ColorBar: ColorBar * ?Dash: DrawingStyle * ?Shape: Shape * ?Simplify: bool * ?Smoothing: float * ?Width: float * ?MultiWidth: seq<float> * ?OutlierColor: Color * ?OutlierWidth: float -> Line
val chartwidth: int
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)
static member Chart.withTitle: title: Title -> (GenericChart.GenericChart -> GenericChart.GenericChart)
static member Chart.withTitle: title: string * ?TitleFont: Font -> (GenericChart.GenericChart -> GenericChart.GenericChart)
static member Chart.withTitle: title: string * ?TitleFont: Font -> (GenericChart.GenericChart -> GenericChart.GenericChart)