Intervals

open FSharp.Stats
open Plotly.NET

let myInterval = Interval.CreateLeftOpen (-3.,2.)

let loi = sprintf "myInterval is: %s" (myInterval.ToString())

"myInterval is: (-3.0,2.0]"

let collection = [3.0; -2.0; 5.0; 1.0; -6.0; 100.0]
let interval = Interval.ofSeq collection

Closed (-6.0, 100.0)

open Plotly.NET
open Plotly.NET.LayoutObjects
open Plotly.NET.StyleParam

let interval01 = 
    Chart.Point([])
    |> Chart.withShape (Shape.init(ShapeType=ShapeType.Rectangle,X0=Interval.getStart interval,X1=Interval.getEnd interval,Y0=1,Y1=2,FillColor=Color.fromHex "#1f77b4"))
    |> Chart.withTemplate ChartTemplates.lightMirrored
    |> Chart.withXAxisStyle ("",MinMax=(-10.,120.))
    |> Chart.withYAxisStyle ("",MinMax=(0.,5.))

let collectionBy = [("a",3.0); ("b",-2.0); ("c",5.0); ("d",1.0); ("e",-6.0); ("f",100.0)]
let intervalByFst = Interval.ofSeqBy fst collectionBy
let intervalBySnd = Interval.ofSeqBy snd collectionBy

Closed (("a", 3.0), ("f", 100.0))

Closed (("e", -6.0), ("f", 100.0))

i=[a,b]
j=[c,d]

i + j = [a+b,c+d]

let i02 = Interval.CreateClosed<float> (6.,8.)
let i03 = Interval.CreateClosed<float> (5.,10.)
let addedInterval = Interval.add i02 i03

i=[a,b]
j=[c,d]

i - j = [a-d,b-c]

let subInterval = Interval.subtract i02 i03

let i04 = Interval.CreateClosed<float> (2.,8.)
let i05 = Interval.CreateClosed<float> (5.,10.)
let intInterval = Interval.intersect i04 i05

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>

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

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>

union case PlotlyJSReference.NoReference: PlotlyJSReference

Multiple items
namespace FSharp

--------------------
namespace Microsoft.FSharp

namespace FSharp.Stats

val myInterval: Interval<float>

Multiple items
module Interval from FSharp.Stats

--------------------
type Interval<'a (requires comparison)> = | Closed of 'a * 'a | LeftOpen of 'a * 'a | RightOpen of 'a * 'a | Open of 'a * 'a | Empty member GetEnd: unit -> 'a member GetStart: unit -> 'a override ToString: unit -> string member ToTuple: unit -> 'a * 'a member liesInInterval: value: 'a -> bool static member CreateClosed: min: 'b * max: 'b -> Interval<'b> (requires comparison) static member CreateLeftOpen: min: 'a0 * max: 'a0 -> Interval<'a0> (requires comparison) static member CreateOpen: min: 'c * max: 'c -> Interval<'c> (requires comparison) static member CreateRightOpen: min: 'a0 * max: 'a0 -> Interval<'a0> (requires comparison) static member ofSeq: source: seq<'a> -> Interval<'a> ...
<summary> Closed interval [Start,End] </summary>

static member Interval.CreateLeftOpen: min: 'a0 * max: 'a0 -> Interval<'a0> (requires comparison)

val loi: string

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>

override Interval.ToString: unit -> string

val collection: float list

val interval: Interval<float>

static member Interval.ofSeq: source: seq<'a> -> Interval<'a>

namespace Plotly.NET.LayoutObjects

module StyleParam from Plotly.NET

val interval01: 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.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 * ?AlignmentGroup: string * ?OffsetGroup: string * ?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 * ?AlignmentGroup: string * ?OffsetGroup: string * ?StackGroup: string * ?Orientation: Orientation * ?GroupNorm: GroupNorm * ?UseWebGL: bool * ?UseDefaults: bool -> GenericChart.GenericChart (requires 'a2 :> System.IConvertible)

static member Chart.withShape: shape: Shape * ?Append: bool -> (GenericChart.GenericChart -> GenericChart.GenericChart)

type Shape = | Linear | Spline | Hv | Vh | Hvh | Vhv member Convert: unit -> obj override ToString: unit -> string static member convert: (Shape -> obj) static member toString: (Shape -> string)
<summary> Determines the line shape. With "spline" the lines are drawn using spline interpolation. The other available values correspond to step-wise line shapes. </summary>

static member Shape.init: ?Editable: bool * ?FillColor: Color * ?FillRule: FillRule * ?Layer: Layer * ?Line: Line * ?Name: string * ?Opacity: float * ?Path: string * ?TemplateItemName: string * ?ShapeType: ShapeType * ?Visible: bool * ?X0: #System.IConvertible * ?X1: #System.IConvertible * ?XAnchor: LinearAxisId * ?Xref: string * ?XSizeMode: ShapeSizeMode * ?Y0: #System.IConvertible * ?Y1: #System.IConvertible * ?YAnchor: LinearAxisId * ?Yref: string * ?YSizeMode: ShapeSizeMode -> Shape

type ShapeType = | Circle | Rectangle | SvgPath | Line member Convert: unit -> obj override ToString: unit -> string static member convert: (ShapeType -> obj) static member toString: (ShapeType -> string)
<summary> Specifies the shape type to be drawn. If "line", a line is drawn from (`x0`,`y0`) to (`x1`,`y1`) If "circle", a circle is drawn from ((`x0`+`x1`)/2, (`y0`+`y1`)/2)) with radius (|(`x0`+`x1`)/2 - `x0`|, |(`y0`+`y1`)/2 -`y0`)|) If "rect", a rectangle is drawn linking (`x0`,`y0`), (`x1`,`y0`), (`x1`,`y1`), (`x0`,`y1`), (`x0`,`y0`) If "path", draw a custom SVG path using `path`. </summary>

union case ShapeType.Rectangle: ShapeType

val getStart: interval: Interval<'a> -> 'a (requires comparison)

val getEnd: interval: Interval<'a> -> 'a (requires comparison)

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>

static member Color.fromHex: s: string -> Color

static member Chart.withTemplate: template: Template -> (GenericChart.GenericChart -> GenericChart.GenericChart)

module ChartTemplates from Plotly.NET

val lightMirrored: Template

static member Chart.withXAxisStyle: ?TitleText: string * ?TitleFont: Font * ?TitleStandoff: int * ?Title: Title * ?Color: Color * ?AxisType: AxisType * ?MinMax: (#System.IConvertible * #System.IConvertible) * ?Mirror: Mirror * ?ShowSpikes: bool * ?SpikeColor: Color * ?SpikeThickness: int * ?ShowLine: bool * ?LineColor: Color * ?ShowGrid: bool * ?GridColor: Color * ?GridDash: DrawingStyle * ?ZeroLine: bool * ?ZeroLineColor: Color * ?Anchor: LinearAxisId * ?Side: Side * ?Overlaying: LinearAxisId * ?Domain: (float * float) * ?Position: float * ?CategoryOrder: CategoryOrder * ?CategoryArray: seq<#System.IConvertible> * ?RangeSlider: RangeSlider * ?RangeSelector: RangeSelector * ?BackgroundColor: Color * ?ShowBackground: bool * ?Id: SubPlotId -> (GenericChart.GenericChart -> GenericChart.GenericChart)

static member Chart.withYAxisStyle: ?TitleText: string * ?TitleFont: Font * ?TitleStandoff: int * ?Title: Title * ?Color: Color * ?AxisType: AxisType * ?MinMax: (#System.IConvertible * #System.IConvertible) * ?Mirror: Mirror * ?ShowSpikes: bool * ?SpikeColor: Color * ?SpikeThickness: int * ?ShowLine: bool * ?LineColor: Color * ?ShowGrid: bool * ?GridColor: Color * ?GridDash: DrawingStyle * ?ZeroLine: bool * ?ZeroLineColor: Color * ?Anchor: LinearAxisId * ?Side: Side * ?Overlaying: LinearAxisId * ?AutoShift: bool * ?Shift: int * ?Domain: (float * float) * ?Position: float * ?CategoryOrder: CategoryOrder * ?CategoryArray: seq<#System.IConvertible> * ?RangeSlider: RangeSlider * ?RangeSelector: RangeSelector * ?BackgroundColor: Color * ?ShowBackground: bool * ?Id: SubPlotId -> (GenericChart.GenericChart -> GenericChart.GenericChart)

module GenericChart from Plotly.NET
<summary> Module to represent a GenericChart </summary>

val toChartHTML: gChart: GenericChart.GenericChart -> string

val collectionBy: (string * float) list

val intervalByFst: Interval<string * float>

static member Interval.ofSeqBy: projection: ('a -> 'b) -> source: seq<'a> -> Interval<'a> (requires comparison)

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>

val intervalBySnd: Interval<string * 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>

val i02: Interval<float>

static member Interval.CreateClosed: min: 'b * max: 'b -> Interval<'b> (requires comparison)

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 i03: Interval<float>

val addedInterval: Interval<float>

val add: a: Interval<'a> -> b: Interval<'a> -> Interval<'a> (requires comparison and member (+))
<summary>Add two given intervals. </summary>
<remarks></remarks>
<param name="a"></param>
<param name="b"></param>
<returns></returns>
<example><code></code></example>

val interval02: GenericChart.GenericChart

val i1: Shape

val i2: Shape

val re: Shape

static member Chart.withShapes: shapes: seq<Shape> * ?Append: bool -> (GenericChart.GenericChart -> GenericChart.GenericChart)

val subInterval: Interval<float>

val subtract: a: Interval<'a> -> b: Interval<'a> -> Interval<'a> (requires comparison and member (-))
<summary>Subtract a given interval from the other interval.</summary>
<remarks></remarks>
<param name="a"></param>
<param name="b"></param>
<returns></returns>
<example><code></code></example>

val interval03: GenericChart.GenericChart

val i04: Interval<float>

val i05: Interval<float>

val intInterval: Interval<float>

val intersect: a: Interval<'a> -> b: Interval<'a> -> Interval<'a> (requires comparison)
<summary>Returns the intersection of this interval with another.</summary>
<remarks></remarks>
<param name="a"></param>
<param name="b"></param>
<returns></returns>
<example><code></code></example>

val interval04: GenericChart.GenericChart