Deedle


Interoperating between R and Deedle

The R type provider enables smooth interoperation between R and F#. The type provider automatically discovers installed packages and makes them accessible via the RProvider namespace.

R type provider for F# automatically converts standard data structures betwene R and F# (such as numerical values, arrays, etc.). However, the conversion mechanism is extensible and so it is possible to support conversion between other F# types.

The Deedle library comes with extension that automatically converts between Deedle Frame<R, C> and R data.frame and also between Deedle Series<K, V> and the zoo package (Z's ordered observations).

This page is a quick overview showing how to pass data between R and Deedle. You can also get this page as an F# script file from GitHub and run the samples interactively.

Getting started

To use Deedle and R provider together, all you need to do is to install the Deedle.RPlugin package, which installes both as dependencies. Alternatively, you can use the FsLab package, which also includes additional data access, data science and visualization libraries.

In a typical project ("F# Tutorial"), the NuGet packages are installed in the ../packages directory. To use R provider and Deedle, you need to write something like this:

1: 
2: 
3: 
4: 
5: 
6: 
#load "RProvider.fsx"
#load "Deedle.fsx"

open RProvider
open RDotNet
open Deedle

If you're not using NuGet from Visual Studio, then you'll need to manually copy the file Deedle.RProvider.Plugin.dll from the package Deedle.RPlugin to the directory where RProvider.dll is located (in RProvider/lib). Once that's done, the R provider will automatically find the plugin.

Passing data frames to and from R

From R to Deedle

Let's start by looking at passing data frames from R to Deedle. To test this, we can use some of the sample data sets available in the datasets package. The R makes all packages available under the RProvider namespace, so we can just open datasets and access the mtcars data set using R.mtcars (when typing the code, you'll get automatic completion when you type R followed by dot):

1: 
2: 
3: 
4: 
5: 
6: 
7: 
open RProvider.datasets

// Get mtcars as an untyped object
R.mtcars.Value

// Get mtcars as a typed Deedle frame
let mtcars : Frame<string, string> = R.mtcars.GetValue()

mpg

cyl

disp

...

am

gear

carb

Mazda RX4

21

6

160

...

1

4

4

Mazda RX4 Wag

21

6

160

...

1

4

4

Datsun 710

22.8

4

108

...

1

4

1

Hornet 4 Drive

21.4

6

258

...

3

1

Hornet Sportabout

18.7

8

360

...

3

2

Valiant

18.1

6

225

...

3

1

Duster 360

14.3

8

360

...

3

4

Merc 240D

24.4

4

146.7

...

4

2

...

...

...

...

...

...

...

...

Ford Pantera L

15.8

8

351

...

1

5

4

Ferrari Dino

19.7

6

145

...

1

5

6

Maserati Bora

15

8

301

...

1

5

8

Volvo 142E

21.4

4

121

...

1

4

2

The first sample uses the Value property to convert the data set to a boxed Deedle frame of type obj. This is a great way to explore the data, but when you want to do some further processing, you need to specify the type of the data frame that you want to get. This is done on line 7 where we get mtcars as a Deedle frame with both rows and columns indexed by string.

To see that this is a standard Deedle data frame, let's group the cars by the number of gears and calculate the average "miles per galon" value based on the gear. To visualize the data, we use the F# Charting library:

1: 
2: 
3: 
4: 
5: 
6: 
7: 
8: 
#load "FSharp.Charting.fsx"
open FSharp.Charting

mtcars
|> Frame.groupRowsByInt "gear"
|> Frame.getCol "mpg"
|> Stats.levelMean fst
|> Series.observations |> Chart.Column

From Deedle to R

So far, we looked how to turn R data frame into Deedle Frame<R, C>, so let's look at the opposite direction. The following snippet first reads Deedle data frame from a CSV file (file name is in the airQuality variable). We can then use the data frame as argument to standard R functions that expect data frame.

1: 
let air = Frame.ReadCsv(airQuality, separators=";")

Ozone

Solar.R

Wind

Temp

Month

Day

0

N/A

190

7.4

67

5

1

1

36

118

8

72

5

2

2

12

149

12.6

74

5

3

3

18

313

11.5

62

5

4

4

N/A

N/A

14.3

56

5

5

5

28

N/A

14.9

66

5

6

6

23

299

8.6

65

5

7

7

19

99

13.8

59

5

8

...

...

...

...

...

...

...

149

N/A

145

13.2

77

9

27

150

14

191

14.3

75

9

28

151

18

131

8

76

9

29

152

20

223

11.5

68

9

30

Let's first try passing the air frame to the R as.data.frame function (which will not do anything, aside from importing the data into R). To do something slightly more interesting, we then use the colMeans R function to calculate averages for each column (to do this, we need to open the base package):

 1: 
 2: 
 3: 
 4: 
 5: 
 6: 
 7: 
 8: 
 9: 
10: 
open RProvider.``base``

// Pass air data to R and print the R output
R.as_data_frame(air)

// Pass air data to R and get column means
R.colMeans(air)
val it : SymbolicExpression =
  Ozone  Solar.R  Wind  Temp  Month   Day 
    NaN      NaN  9.96 77.88   6.99  15.8

As a final example, let's look at the handling of missing values. Unlike R, Deedle does not distinguish between missing data (NA) and not a number (NaN). For example, in the following simple frame, the Floats column has missing value for keys 2 and 3 while Names has missing value for the row 2:

1: 
2: 
3: 
4: 
5: 
// Create sample data frame with missing values
let df = 
  [ "Floats" =?> series [ 1 => 10.0; 2 => nan; 4 => 15.0]
    "Names"  =?> series [ 1 => "one"; 3 => "three"; 4 => "four" ] ] 
  |> frame

When we pass the data frame to R, missing values in numeric columns are turned into NaN and missing data for other columns are turned into NA. Here, we use R.assign which stores the data frame in a varaible available in the current R environment:

1: 
2: 
3: 
4: 
5: 
6: 
7: 
R.assign("x",  df)
val it : SymbolicExpression = 
     Floats   Names 
 1       10     one 
 2      NaN    <NA> 
 4       15    four 
 3      NaN   three 

Passing time series to and from R

For working with time series data, the Deedle plugin uses the zoo package (Z's ordered observations). If you do not have the package installed, you can do that by using the install.packages("zoo") command from R or using R.install_packages("zoo") from F# after opening RProvider.utils. When running the code from F#, you'll need to restart your editor and F# interactive after it is installed.

From R to Deedle

Let's start by looking at getting time series data from R. We can again use the datasets package with samples. For example, the austres data set gives us access to quarterly time series of the number of australian residents:

1: 
2: 
3: 
4: 
5: 
6: 
7: 
8: 
9: 
R.austres.Value
val it : obj =
    1971.25 -> 13067.3 
    1971.5  -> 13130.5 
    1971.75 -> 13198.4 
    ...     -> ...     
    1992.75 -> 17568.7 
    1993    -> 17627.1 
    1993.25 -> 17661.5 

As with data frames, when we want to do any further processing with the time series, we need to use the generic GetValue method and specify a type annotation to that tells the F# compiler that we expect a series where both keys and values are of type float:

 1: 
 2: 
 3: 
 4: 
 5: 
 6: 
 7: 
 8: 
 9: 
10: 
11: 
// Get series with numbers of australian residents
let austres : Series<float, float> = R.austres.GetValue()

// Get TimeSpan representing (roughly..) two years
let twoYears = TimeSpan.FromDays(2.0 * 365.0)

// Calculate means of sliding windows of 2 year size 
austres 
|> Series.mapKeys (fun y -> 
    DateTime(int y, 1 + int (12.0 * (y - floor y)), 1))
|> Series.windowDistInto twoYears Stats.mean

The current version of the Deedle plugin supports only time series with single column. To access, for example, the EU stock market data, we need to write a short R inline code to extract the column we are interested in. The following gets the FTSE time series from EuStockMarkets:

1: 
2: 
let ftseStr = R.parse(text="""EuStockMarkets[,"FTSE"]""")
let ftse : Series<float, float> = R.eval(ftseStr).GetValue()

From Deedle to R

The opposite direction is equally easy. To demonstrate this, we'll generate a simple time series with 3 days of randomly generated values starting today:

1: 
2: 
3: 
4: 
5: 
let rnd = Random()
let ts = 
  [ for i in 0.0 .. 100.0 -> 
      DateTime.Today.AddHours(i), rnd.NextDouble() ] 
  |> series

Now that we have a time series, we can pass it to R using the R.as_zoo function or using R.assign to store it in an R variable. As previously, the R provider automatically shows the output that R prints for the value:

1: 
2: 
3: 
4: 
5: 
6: 
7: 
8: 
9: 
open RProvider.zoo

// Just convert time series to R
R.as_zoo(ts)
// Convert and assing to a variable 'ts'
R.assign("ts", ts)
// [fsi:val it : string =
 2013-11-07 05:00:00 2013-11-07 06:00:00 2013-11-07 07:00:00 ...
 0.749946652         0.580584353         0.523962789         ...

Typically, you will not need to assign time series to an R variable, because you can use it directly as an argument to functions that expect time series. For example, the following snippet applies the rolling mean function with a window size 20 to the time series.

1: 
2: 
// Rolling mean with window size 20
R.rollmean(ts, 20)

This is a simple example - in practice, you can achieve the same thing with Series.window function from Deedle - but it demonstrates how easy it is to use R packages with time series (and data frames) from Deedle. As a final example, we create a data frame that contains the original time series together with the rolling mean (in a separate column) and then draws a chart showing the results:

 1: 
 2: 
 3: 
 4: 
 5: 
 6: 
 7: 
 8: 
 9: 
10: 
11: 
12: 
13: 
// Use 'rollmean' to calculate mean and 'GetValue' to 
// turn the result into a Deedle time series
let tf = 
  [ "Input" => ts 
    "Means5" => R.rollmean(ts, 5).GetValue<Series<_, float>>()
    "Means20" => R.rollmean(ts, 20).GetValue<Series<_, float>>() ]
  |> frame

// Chart original input and the two rolling means
Chart.Combine
  [ Chart.Line(Series.observations tf?Input)
    Chart.Line(Series.observations tf?Means5)
    Chart.Line(Series.observations tf?Means20) ]

Depending on your random number generator, the resulting chart looks something like this:

namespace System
val airQuality : string

Full name: Rinterop.airQuality
namespace RProvider
namespace RDotNet
namespace Deedle
namespace RProvider.datasets
type R =
  static member AirPassengers : SymbolicExpression
  static member BJsales : SymbolicExpression
  static member BJsales_lead : SymbolicExpression
  static member BOD : SymbolicExpression
  static member CO2 : SymbolicExpression
  static member ChickWeight : SymbolicExpression
  static member DNase : SymbolicExpression
  static member EuStockMarkets : SymbolicExpression
  static member Formaldehyde : SymbolicExpression
  static member HairEyeColor : SymbolicExpression
  ...

Full name: RProvider.datasets.R


Base R datasets
property R.mtcars: SymbolicExpression
property SymbolicExpression.Value: obj
val mtcars : Frame<string,string>

Full name: Rinterop.mtcars
Multiple items
module Frame

from Deedle

--------------------
type Frame =
  static member CreateEmpty : unit -> Frame<'R,'C> (requires equality and equality)
  static member FromArray2D : array:'T [,] -> Frame<int,int>
  static member FromColumns : cols:Series<'TColKey,Series<'TRowKey,'V>> -> Frame<'TRowKey,'TColKey> (requires equality and equality)
  static member FromColumns : cols:Series<'TColKey,ObjectSeries<'TRowKey>> -> Frame<'TRowKey,'TColKey> (requires equality and equality)
  static member FromColumns : columns:seq<KeyValuePair<'ColKey,ObjectSeries<'RowKey>>> -> Frame<'RowKey,'ColKey> (requires equality and equality)
  static member FromColumns : columns:seq<KeyValuePair<'ColKey,Series<'RowKey,'V>>> -> Frame<'RowKey,'ColKey> (requires equality and equality)
  static member FromColumns : cols:seq<Series<'ColKey,'V>> -> Frame<'ColKey,int> (requires equality)
  static member FromRecords : values:seq<'T> -> Frame<int,string>
  static member FromRecords : series:Series<'K,'R> -> Frame<'K,string> (requires equality)
  static member FromRowKeys : keys:seq<'K> -> Frame<'K,string> (requires equality)
  ...

Full name: Deedle.Frame

--------------------
type Frame<'TRowKey,'TColumnKey (requires equality and equality)> =
  interface IDynamicMetaObjectProvider
  interface INotifyCollectionChanged
  interface IFsiFormattable
  interface IFrame
  new : names:seq<'TColumnKey> * columns:seq<ISeries<'TRowKey>> -> Frame<'TRowKey,'TColumnKey>
  new : rowIndex:IIndex<'TRowKey> * columnIndex:IIndex<'TColumnKey> * data:IVector<IVector> * indexBuilder:IIndexBuilder * vectorBuilder:IVectorBuilder -> Frame<'TRowKey,'TColumnKey>
  member AddColumn : column:'TColumnKey * series:ISeries<'TRowKey> -> unit
  member AddColumn : column:'TColumnKey * series:seq<'V> -> unit
  member AddColumn : column:'TColumnKey * series:ISeries<'TRowKey> * lookup:Lookup -> unit
  member AddColumn : column:'TColumnKey * series:seq<'V> * lookup:Lookup -> unit
  ...

Full name: Deedle.Frame<_,_>

--------------------
new : names:seq<'TColumnKey> * columns:seq<ISeries<'TRowKey>> -> Frame<'TRowKey,'TColumnKey>
new : rowIndex:Indices.IIndex<'TRowKey> * columnIndex:Indices.IIndex<'TColumnKey> * data:IVector<IVector> * indexBuilder:Indices.IIndexBuilder * vectorBuilder:Vectors.IVectorBuilder -> Frame<'TRowKey,'TColumnKey>
Multiple items
val string : value:'T -> string

Full name: Microsoft.FSharp.Core.Operators.string

--------------------
type string = String

Full name: Microsoft.FSharp.Core.string
member SymbolicExpression.GetValue : unit -> 'a
namespace FSharp
namespace FSharp.Charting
val groupRowsByInt : column:'C -> frame:Frame<'R,'C> -> Frame<(int * 'R),'C> (requires equality and equality)

Full name: Deedle.Frame.groupRowsByInt
val getCol : column:'C -> frame:Frame<'R,'C> -> Series<'R,'V> (requires equality and equality)

Full name: Deedle.Frame.getCol
type Stats =
  static member count : frame:Frame<'R,'C> -> Series<'C,int> (requires equality and equality)
  static member count : series:Series<'K,'V> -> int (requires equality)
  static member expandingCount : series:Series<'K,float> -> Series<'K,float> (requires equality)
  static member expandingKurt : series:Series<'K,float> -> Series<'K,float> (requires equality)
  static member expandingMax : series:Series<'K,float> -> Series<'K,float> (requires equality)
  static member expandingMean : series:Series<'K,float> -> Series<'K,float> (requires equality)
  static member expandingMin : series:Series<'K,float> -> Series<'K,float> (requires equality)
  static member expandingSkew : series:Series<'K,float> -> Series<'K,float> (requires equality)
  static member expandingStdDev : series:Series<'K,float> -> Series<'K,float> (requires equality)
  static member expandingSum : series:Series<'K,float> -> Series<'K,float> (requires equality)
  ...

Full name: Deedle.Stats
static member Stats.levelMean : level:('K -> 'L) -> series:Series<'K,float> -> Series<'L,float> (requires equality and equality)
val fst : tuple:('T1 * 'T2) -> 'T1

Full name: Microsoft.FSharp.Core.Operators.fst
Multiple items
module Series

from Deedle

--------------------
type Series =
  static member ofNullables : values:seq<Nullable<'a0>> -> Series<int,'a0> (requires default constructor and value type and 'a0 :> ValueType)
  static member ofObservations : observations:seq<'c * 'd> -> Series<'c,'d> (requires equality)
  static member ofOptionalObservations : observations:seq<'K * 'a1 option> -> Series<'K,'a1> (requires equality)
  static member ofValues : values:seq<'a> -> Series<int,'a>

Full name: Deedle.F# Series extensions.Series

--------------------
type Series<'K,'V (requires equality)> =
  interface IFsiFormattable
  interface ISeries<'K>
  new : pairs:seq<KeyValuePair<'K,'V>> -> Series<'K,'V>
  new : keys:'K [] * values:'V [] -> Series<'K,'V>
  new : keys:seq<'K> * values:seq<'V> -> Series<'K,'V>
  new : index:IIndex<'K> * vector:IVector<'V> * vectorBuilder:IVectorBuilder * indexBuilder:IIndexBuilder -> Series<'K,'V>
  member After : lowerExclusive:'K -> Series<'K,'V>
  member Aggregate : aggregation:Aggregation<'K> * observationSelector:Func<DataSegment<Series<'K,'V>>,KeyValuePair<'TNewKey,OptionalValue<'R>>> -> Series<'TNewKey,'R> (requires equality)
  member Aggregate : aggregation:Aggregation<'K> * keySelector:Func<DataSegment<Series<'K,'V>>,'TNewKey> * valueSelector:Func<DataSegment<Series<'K,'V>>,OptionalValue<'R>> -> Series<'TNewKey,'R> (requires equality)
  member AsyncMaterialize : unit -> Async<Series<'K,'V>>
  ...

Full name: Deedle.Series<_,_>

--------------------
new : pairs:seq<Collections.Generic.KeyValuePair<'K,'V>> -> Series<'K,'V>
new : keys:seq<'K> * values:seq<'V> -> Series<'K,'V>
new : keys:'K [] * values:'V [] -> Series<'K,'V>
new : index:Indices.IIndex<'K> * vector:IVector<'V> * vectorBuilder:Vectors.IVectorBuilder * indexBuilder:Indices.IIndexBuilder -> Series<'K,'V>
val observations : series:Series<'K,'T> -> seq<'K * 'T> (requires equality)

Full name: Deedle.Series.observations
type Chart =
  static member Area : data:seq<#value> * ?Name:string * ?Title:string * ?Labels:#seq<string> * ?Color:Color * ?XTitle:string * ?YTitle:string -> GenericChart
  static member Area : data:seq<#key * #value> * ?Name:string * ?Title:string * ?Labels:#seq<string> * ?Color:Color * ?XTitle:string * ?YTitle:string -> GenericChart
  static member Bar : data:seq<#value> * ?Name:string * ?Title:string * ?Labels:#seq<string> * ?Color:Color * ?XTitle:string * ?YTitle:string -> GenericChart
  static member Bar : data:seq<#key * #value> * ?Name:string * ?Title:string * ?Labels:#seq<string> * ?Color:Color * ?XTitle:string * ?YTitle:string -> GenericChart
  static member BoxPlotFromData : data:seq<#key * #seq<'a2>> * ?Name:string * ?Title:string * ?Color:Color * ?XTitle:string * ?YTitle:string * ?Percentile:int * ?ShowAverage:bool * ?ShowMedian:bool * ?ShowUnusualValues:bool * ?WhiskerPercentile:int -> GenericChart (requires 'a2 :> value)
  static member BoxPlotFromStatistics : data:seq<#key * #value * #value * #value * #value * #value * #value> * ?Name:string * ?Title:string * ?Labels:#seq<string> * ?Color:Color * ?XTitle:string * ?YTitle:string * ?Percentile:int * ?ShowAverage:bool * ?ShowMedian:bool * ?ShowUnusualValues:bool * ?WhiskerPercentile:int -> GenericChart
  static member Bubble : data:seq<#value * #value> * ?Name:string * ?Title:string * ?Labels:#seq<string> * ?Color:Color * ?XTitle:string * ?YTitle:string * ?BubbleMaxSize:int * ?BubbleMinSize:int * ?BubbleScaleMax:float * ?BubbleScaleMin:float * ?UseSizeForLabel:bool -> GenericChart
  static member Bubble : data:seq<#key * #value * #value> * ?Name:string * ?Title:string * ?Labels:#seq<string> * ?Color:Color * ?XTitle:string * ?YTitle:string * ?BubbleMaxSize:int * ?BubbleMinSize:int * ?BubbleScaleMax:float * ?BubbleScaleMin:float * ?UseSizeForLabel:bool -> GenericChart
  static member Candlestick : data:seq<#value * #value * #value * #value> * ?Name:string * ?Title:string * ?Labels:#seq<string> * ?Color:Color * ?XTitle:string * ?YTitle:string -> CandlestickChart
  static member Candlestick : data:seq<#key * #value * #value * #value * #value> * ?Name:string * ?Title:string * ?Labels:#seq<string> * ?Color:Color * ?XTitle:string * ?YTitle:string -> CandlestickChart
  ...

Full name: FSharp.Charting.Chart
static member Chart.Column : data:seq<#value> * ?Name:string * ?Title:string * ?Labels:#seq<string> * ?Color:Drawing.Color * ?XTitle:string * ?YTitle:string -> ChartTypes.GenericChart
static member Chart.Column : data:seq<#key * #value> * ?Name:string * ?Title:string * ?Labels:#seq<string> * ?Color:Drawing.Color * ?XTitle:string * ?YTitle:string -> ChartTypes.GenericChart
val air : Frame<int,string>

Full name: Rinterop.air
static member Frame.ReadCsv : path:string * ?hasHeaders:bool * ?inferTypes:bool * ?inferRows:int * ?schema:string * ?separators:string * ?culture:string * ?maxRows:int * ?missingValues:string [] -> Frame<int,string>
static member Frame.ReadCsv : stream:IO.Stream * ?hasHeaders:bool * ?inferTypes:bool * ?inferRows:int * ?schema:string * ?separators:string * ?culture:string * ?maxRows:int * ?missingValues:string [] -> Frame<int,string>
static member Frame.ReadCsv : reader:IO.TextReader * ?hasHeaders:bool * ?inferTypes:bool * ?inferRows:int * ?schema:string * ?separators:string * ?culture:string * ?maxRows:int * ?missingValues:string [] -> Frame<int,string>
static member Frame.ReadCsv : path:string * indexCol:string * ?hasHeaders:bool * ?inferTypes:bool * ?inferRows:int * ?schema:string * ?separators:string * ?culture:string * ?maxRows:int * ?missingValues:string [] -> Frame<'R,string> (requires equality)
type R =
  static member ! : ?paramArray: obj [] -> SymbolicExpression + 1 overload
  static member != : ?paramArray: obj [] -> SymbolicExpression + 1 overload
  static member !_hexmode : ?a: obj -> SymbolicExpression + 1 overload
  static member !_octmode : ?a: obj -> SymbolicExpression + 1 overload
  static member $ : ?paramArray: obj [] -> SymbolicExpression + 1 overload
  static member $<- : ?paramArray: obj [] -> SymbolicExpression + 1 overload
  static member $<-_data_frame : ?x: obj * ?name: obj * ?value: obj -> SymbolicExpression + 1 overload
  static member $_DLLInfo : ?x: obj * ?name: obj -> SymbolicExpression + 1 overload
  static member $_package__version : ?x: obj * ?name: obj -> SymbolicExpression + 1 overload
  static member %% : ?paramArray: obj [] -> SymbolicExpression + 1 overload
  ...

Full name: RProvider.base.R


Base R functions
Multiple items
R.as_data_frame(paramsByName: Collections.Generic.IDictionary<string,obj>) : SymbolicExpression
R.as_data_frame(?x: obj, ?row_names: obj, ?optional: obj, ?___: obj, ?paramArray: obj []) : SymbolicExpression


Coerce to a Data Frame


--------------------
R.as_data_frame(paramsByName: Collections.Generic.IDictionary<string,obj>) : SymbolicExpression
R.as_data_frame(?x: obj, ?row_names: obj, ?optional: obj, ?___: obj, ?paramArray: obj []) : SymbolicExpression


Coerce to a Data Frame
Multiple items
R.colMeans(paramsByName: Collections.Generic.IDictionary<string,obj>) : SymbolicExpression
R.colMeans(?x: obj, ?na_rm: obj, ?dims: obj) : SymbolicExpression


No documentation available


--------------------
R.colMeans(paramsByName: Collections.Generic.IDictionary<string,obj>) : SymbolicExpression
R.colMeans(?x: obj, ?na_rm: obj, ?dims: obj) : SymbolicExpression


No documentation available
val df : Frame<int,string>

Full name: Rinterop.df
val series : observations:seq<'a * 'b> -> Series<'a,'b> (requires equality)

Full name: Deedle.F# Series extensions.series
val nan : float

Full name: Microsoft.FSharp.Core.Operators.nan
val frame : columns:seq<'a * #ISeries<'c>> -> Frame<'c,'a> (requires equality and equality)

Full name: Deedle.F# Frame extensions.frame
Multiple items
R.assign(paramsByName: Collections.Generic.IDictionary<string,obj>) : SymbolicExpression
R.assign(?x: obj, ?value: obj, ?pos: obj, ?envir: obj, ?inherits: obj, ?immediate: obj) : SymbolicExpression


Assign a Value to a Name


--------------------
R.assign(paramsByName: Collections.Generic.IDictionary<string,obj>) : SymbolicExpression
R.assign(?x: obj, ?value: obj, ?pos: obj, ?envir: obj, ?inherits: obj, ?immediate: obj) : SymbolicExpression


Assign a Value to a Name
property R.austres: SymbolicExpression
val austres : Series<float,float>

Full name: Rinterop.austres
Multiple items
val float : value:'T -> float (requires member op_Explicit)

Full name: Microsoft.FSharp.Core.Operators.float

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

Full name: Microsoft.FSharp.Core.float

--------------------
type float<'Measure> = float

Full name: Microsoft.FSharp.Core.float<_>
val twoYears : TimeSpan

Full name: Rinterop.twoYears
Multiple items
type TimeSpan =
  struct
    new : ticks:int64 -> TimeSpan + 3 overloads
    member Add : ts:TimeSpan -> TimeSpan
    member CompareTo : value:obj -> int + 1 overload
    member Days : int
    member Duration : unit -> TimeSpan
    member Equals : value:obj -> bool + 1 overload
    member GetHashCode : unit -> int
    member Hours : int
    member Milliseconds : int
    member Minutes : int
    ...
  end

Full name: System.TimeSpan

--------------------
TimeSpan()
TimeSpan(ticks: int64) : unit
TimeSpan(hours: int, minutes: int, seconds: int) : unit
TimeSpan(days: int, hours: int, minutes: int, seconds: int) : unit
TimeSpan(days: int, hours: int, minutes: int, seconds: int, milliseconds: int) : unit
TimeSpan.FromDays(value: float) : TimeSpan
val mapKeys : f:('K -> 'R) -> series:Series<'K,'T> -> Series<'R,'T> (requires equality and equality)

Full name: Deedle.Series.mapKeys
val y : float
Multiple items
type DateTime =
  struct
    new : ticks:int64 -> DateTime + 10 overloads
    member Add : value:TimeSpan -> DateTime
    member AddDays : value:float -> DateTime
    member AddHours : value:float -> DateTime
    member AddMilliseconds : value:float -> DateTime
    member AddMinutes : value:float -> DateTime
    member AddMonths : months:int -> DateTime
    member AddSeconds : value:float -> DateTime
    member AddTicks : value:int64 -> DateTime
    member AddYears : value:int -> DateTime
    ...
  end

Full name: System.DateTime

--------------------
DateTime()
   (+0 other overloads)
DateTime(ticks: int64) : unit
   (+0 other overloads)
DateTime(ticks: int64, kind: DateTimeKind) : unit
   (+0 other overloads)
DateTime(year: int, month: int, day: int) : unit
   (+0 other overloads)
DateTime(year: int, month: int, day: int, calendar: Globalization.Calendar) : unit
   (+0 other overloads)
DateTime(year: int, month: int, day: int, hour: int, minute: int, second: int) : unit
   (+0 other overloads)
DateTime(year: int, month: int, day: int, hour: int, minute: int, second: int, kind: DateTimeKind) : unit
   (+0 other overloads)
DateTime(year: int, month: int, day: int, hour: int, minute: int, second: int, calendar: Globalization.Calendar) : unit
   (+0 other overloads)
DateTime(year: int, month: int, day: int, hour: int, minute: int, second: int, millisecond: int) : unit
   (+0 other overloads)
DateTime(year: int, month: int, day: int, hour: int, minute: int, second: int, millisecond: int, kind: DateTimeKind) : unit
   (+0 other overloads)
Multiple items
val int : value:'T -> int (requires member op_Explicit)

Full name: Microsoft.FSharp.Core.Operators.int

--------------------
type int = int32

Full name: Microsoft.FSharp.Core.int

--------------------
type int<'Measure> = int

Full name: Microsoft.FSharp.Core.int<_>
val floor : value:'T -> 'T (requires member Floor)

Full name: Microsoft.FSharp.Core.Operators.floor
val windowDistInto : distance:'a -> f:(Series<'K,'T> -> 'b) -> series:Series<'K,'T> -> Series<'K,'b> (requires comparison and equality and member ( - ))

Full name: Deedle.Series.windowDistInto
static member Stats.mean : frame:Frame<'R,'C> -> Series<'C,float> (requires equality and equality)
static member Stats.mean : series:Series<'K,float> -> float (requires equality)
val ftseStr : SymbolicExpression

Full name: Rinterop.ftseStr
Multiple items
R.parse(paramsByName: Collections.Generic.IDictionary<string,obj>) : SymbolicExpression
R.parse(?file: obj, ?n: obj, ?text: obj, ?prompt: obj, ?srcfile: obj, ?encoding: obj) : SymbolicExpression


Parse Expressions


--------------------
R.parse(paramsByName: Collections.Generic.IDictionary<string,obj>) : SymbolicExpression
R.parse(?file: obj, ?n: obj, ?text: obj, ?prompt: obj, ?srcfile: obj, ?encoding: obj) : SymbolicExpression


Parse Expressions
val ftse : Series<float,float>

Full name: Rinterop.ftse
Multiple items
R.eval(paramsByName: Collections.Generic.IDictionary<string,obj>) : SymbolicExpression
R.eval(?expr: obj, ?envir: obj, ?enclos: obj) : SymbolicExpression


Evaluate an (Unevaluated) Expression


--------------------
R.eval(paramsByName: Collections.Generic.IDictionary<string,obj>) : SymbolicExpression
R.eval(?expr: obj, ?envir: obj, ?enclos: obj) : SymbolicExpression


Evaluate an (Unevaluated) Expression
val rnd : Random

Full name: Rinterop.rnd
Multiple items
type Random =
  new : unit -> Random + 1 overload
  member Next : unit -> int + 2 overloads
  member NextBytes : buffer:byte[] -> unit
  member NextDouble : unit -> float

Full name: System.Random

--------------------
Random() : unit
Random(Seed: int) : unit
val ts : Series<DateTime,float>

Full name: Rinterop.ts
val i : float
property DateTime.Today: DateTime
DateTime.AddHours(value: float) : DateTime
Random.NextDouble() : float
namespace RProvider.zoo
type R =
  static member MATCH : ?x: obj * ?table: obj * ?nomatch: obj * ?___: obj * ?paramArray: obj [] -> SymbolicExpression + 1 overload
  static member MATCH_default : ?x: obj * ?table: obj * ?nomatch: obj * ?___: obj * ?paramArray: obj [] -> SymbolicExpression + 1 overload
  static member MATCH_times : ?x: obj * ?table: obj * ?nomatch: obj * ?units: obj * ?eps: obj * ?___: obj * ?paramArray: obj [] -> SymbolicExpression + 1 overload
  static member ORDER : ?x: obj * ?___: obj * ?paramArray: obj [] -> SymbolicExpression + 1 overload
  static member ORDER_default : ?x: obj * ?___: obj * ?na_last: obj * ?decreasing: obj * ?paramArray: obj [] -> SymbolicExpression + 1 overload
  static member Sys_yearmon : ?NULL: obj -> SymbolicExpression + 1 overload
  static member Sys_yearqtr : ?NULL: obj -> SymbolicExpression + 1 overload
  static member as_Date : ?x: obj * ?___: obj * ?paramArray: obj [] -> SymbolicExpression + 1 overload
  static member as_Date_numeric : ?x: obj * ?origin: obj * ?___: obj * ?paramArray: obj [] -> SymbolicExpression + 1 overload
  static member as_Date_ts : ?x: obj * ?offset: obj * ?___: obj * ?paramArray: obj [] -> SymbolicExpression + 1 overload
  ...

Full name: RProvider.zoo.R


An S3 class with methods for totally ordered indexed
        observations. It is particularly aimed at irregular time series
        of numeric vectors/matrices and factors. zoo's key design goals
        are independence of a particular index/date/time class and
        consistency with ts and base R by providing methods to extend
        standard generics.
R.as_zoo(paramsByName: Collections.Generic.IDictionary<string,obj>) : SymbolicExpression
R.as_zoo(?x: obj, ?___: obj, ?paramArray: obj []) : SymbolicExpression


Coercion from and to zoo
R.rollmean(paramsByName: Collections.Generic.IDictionary<string,obj>) : SymbolicExpression
R.rollmean(?x: obj, ?k: obj, ?fill: obj, ?na_pad: obj, ?align: obj, ?___: obj, ?paramArray: obj []) : SymbolicExpression


Rolling Means/Maximums/Medians
val tf : Frame<DateTime,string>

Full name: Rinterop.tf
static member Chart.Combine : charts:seq<ChartTypes.GenericChart> -> ChartTypes.GenericChart
static member Chart.Line : data:seq<#value> * ?Name:string * ?Title:string * ?Labels:#seq<string> * ?Color:Drawing.Color * ?XTitle:string * ?YTitle:string -> ChartTypes.GenericChart
static member Chart.Line : data:seq<#key * #value> * ?Name:string * ?Title:string * ?Labels:#seq<string> * ?Color:Drawing.Color * ?XTitle:string * ?YTitle:string -> ChartTypes.GenericChart
Fork me on GitHub