Deedle in 10 minutes

This quick-start gets you productive with Deedle fast. We use the classic Titanic passenger data set to show the most important features — loading data, exploring columns, filtering, grouping, handling missing values, and basic statistics.

Setup

Install from NuGet and open the namespace:

dotnet add package Deedle

#r "nuget: Deedle"
open Deedle

Loading data

The fastest way to get data into Deedle is Frame.ReadCsv:

let titanic = Frame.ReadCsv(root + "titanic.csv")

Let's see what we have:

titanic.RowCount

val it: int = 891

titanic.ColumnCount

val it: int = 12

titanic.ColumnKeys |> Seq.toList

val it: string list =
  ["PassengerId"; "Survived"; "Pclass"; "Name"; "Sex"; "Age"; "SibSp"; "Parch";
   "Ticket"; "Fare"; "Cabin"; "Embarked"]

Print the first few rows:

titanic |> Frame.take 5

val it: Frame<int,string> =
  
     PassengerId Survived Pclass Name                                               Sex    Age SibSp Parch Ticket           Fare    Cabin Embarked 
0 -> 1           False    3      Braund, Mr. Owen Harris                            male   22  1     0     A/5 21171        7.25          S        
1 -> 2           True     1      Cumings, Mrs. John Bradley (Florence Briggs Tha... female 38  1     0     PC 17599         71.2833 C85   C        
2 -> 3           True     3      Heikkinen, Miss. Laina                             female 26  0     0     STON/O2. 3101282 7.925         S        
3 -> 4           True     1      Futrelle, Mrs. Jacques Heath (Lily May Peel)       female 35  1     0     113803           53.1    C123  S        
4 -> 5           False    3      Allen, Mr. William Henry                           male   35  0     0     373450           8.05          S

Accessing columns

Use ? to grab a column as a Series. Deedle reads numeric columns as float and text columns as string:

// A numeric column
titanic?Age

val it: Series<int,float> =
  
0   -> 22        
1   -> 38        
2   -> 26        
3   -> 35        
4   -> 35        
5   -> <missing> 
6   -> 54        
7   -> 2         
8   -> 27        
9   -> 14        
10  -> 4         
11  -> 58        
12  -> 20        
13  -> 39        
14  -> 14        
... -> ...       
876 -> 20        
877 -> 19        
878 -> <missing> 
879 -> 56        
880 -> 25        
881 -> 33        
882 -> 22        
883 -> 28        
884 -> 25        
885 -> 39        
886 -> 27        
887 -> 19        
888 -> <missing> 
889 -> 26        
890 -> 32

// A text column
titanic.GetColumn<string>("Name") |> Series.take 3

val it: Series<int,string> =
  
0 -> Braund, Mr. Owen Harris                            
1 -> Cumings, Mrs. John Bradley (Florence Briggs Tha... 
2 -> Heikkinen, Miss. Laina

Basic statistics

Compute summary statistics on any numeric series:

titanic?Age |> Stats.mean

val it: float = 29.69911765

titanic?Fare |> Stats.mean

val it: float = 32.20420797

titanic?Age |> Stats.median

val it: float = 28.0

titanic?Age |> Stats.stdDev

val it: float = 14.52649733

Missing values (like missing Age entries in the Titanic data) are automatically skipped by all statistical functions.

Filtering rows

Use Frame.filterRowValues to keep only rows matching a condition:

// Passengers who survived
let survived = titanic |> Frame.filterRowValues (fun row ->
  row.GetAs<bool>("Survived"))

survived.RowCount

val survived: Frame<int,string> =
  
       PassengerId Survived Pclass Name                                               Sex    Age       SibSp Parch Ticket           Fare     Cabin Embarked 
1   -> 2           True     1      Cumings, Mrs. John Bradley (Florence Briggs Tha... female 38        1     0     PC 17599         71.2833  C85   C        
2   -> 3           True     3      Heikkinen, Miss. Laina                             female 26        0     0     STON/O2. 3101282 7.925          S        
3   -> 4           True     1      Futrelle, Mrs. Jacques Heath (Lily May Peel)       female 35        1     0     113803           53.1     C123  S        
8   -> 9           True     3      Johnson, Mrs. Oscar W (Elisabeth Vilhelmina Berg)  female 27        0     2     347742           11.1333        S        
9   -> 10          True     2      Nasser, Mrs. Nicholas (Adele Achem)                female 14        1     0     237736           30.0708        C        
10  -> 11          True     3      Sandstrom, Miss. Marguerite Rut                    female 4         1     1     PP 9549          16.7     G6    S        
11  -> 12          True     1      Bonnell, Miss. Elizabeth                           female 58        0     0     113783           26.55    C103  S        
15  -> 16          True     2      Hewlett, Mrs. (Mary D Kingcome)                    female 55        0     0     248706           16             S        
17  -> 18          True     2      Williams, Mr. Charles Eugene                       male   <missing> 0     0     244373           13             S        
19  -> 20          True     3      Masselmani, Mrs. Fatima                            female <missing> 0     0     2649             7.225          C        
21  -> 22          True     2      Beesley, Mr. Lawrence                              male   34        0     0     248698           13       D56   S        
22  -> 23          True     3      McGowan, Miss. Anna "Annie"                        female 15        0     0     330923           8.0292         Q        
23  -> 24          True     1      Sloper, Mr. William Thompson                       male   28        0     0     113788           35.5     A6    S        
25  -> 26          True     3      Asplund, Mrs. Carl Oscar (Selma Augusta Emilia ... female 38        1     5     347077           31.3875        S        
28  -> 29          True     3      O'Dwyer, Miss. Ellen "Nellie"                      female <missing> 0     0     330959           7.8792         Q        
:      ...         ...      ...    ...                                                ...    ...       ...   ...   ...              ...      ...   ...      
855 -> 856         True     3      Aks, Mrs. Sam (Leah Rosen)                         female 18        0     1     392091           9.35           S        
856 -> 857         True     1      Wick, Mrs. George Dennick (Mary Hitchcock)         female 45        1     1     36928            164.8667       S        
857 -> 858         True     1      Daly, Mr. Peter Denis                              male   51        0     0     113055           26.55    E17   S        
858 -> 859         True     3      Baclini, Mrs. Solomon (Latifa Qurban)              female 24        0     3     2666             19.2583        C        
862 -> 863         True     1      Swift, Mrs. Frederick Joel (Margaret Welles Bar... female 48        0     0     17466            25.9292  D17   S        
865 -> 866         True     2      Bystrom, Mrs. (Karolina)                           female 42        0     0     236852           13             S        
866 -> 867         True     2      Duran y More, Miss. Asuncion                       female 27        1     0     SC/PARIS 2149    13.8583        C        
869 -> 870         True     3      Johnson, Master. Harold Theodor                    male   4         1     1     347742           11.1333        S        
871 -> 872         True     1      Beckwith, Mrs. Richard Leonard (Sallie Monypeny)   female 47        1     1     11751            52.5542  D35   S        
874 -> 875         True     2      Abelson, Mrs. Samuel (Hannah Wizosky)              female 28        1     0     P/PP 3381        24             C        
875 -> 876         True     3      Najib, Miss. Adele Kiamie "Jane"                   female 15        0     0     2667             7.225          C        
879 -> 880         True     1      Potter, Mrs. Thomas Jr (Lily Alexenia Wilson)      female 56        0     1     11767            83.1583  C50   C        
880 -> 881         True     2      Shelley, Mrs. William (Imanita Parrish Hall)       female 25        0     1     230433           26             S        
887 -> 888         True     1      Graham, Miss. Margaret Edith                       female 19        0     0     112053           30       B42   S        
889 -> 890         True     1      Behr, Mr. Karl Howell                              male   26        0     0     111369           30       C148  C        

val it: int = 342

// First-class passengers
let firstClass = titanic |> Frame.filterRowValues (fun row ->
  row.GetAs<int>("Pclass") = 1)

firstClass.RowCount

val firstClass: Frame<int,string> =
  
       PassengerId Survived Pclass Name                                               Sex    Age       SibSp Parch Ticket   Fare     Cabin       Embarked 
1   -> 2           True     1      Cumings, Mrs. John Bradley (Florence Briggs Tha... female 38        1     0     PC 17599 71.2833  C85         C        
3   -> 4           True     1      Futrelle, Mrs. Jacques Heath (Lily May Peel)       female 35        1     0     113803   53.1     C123        S        
6   -> 7           False    1      McCarthy, Mr. Timothy J                            male   54        0     0     17463    51.8625  E46         S        
11  -> 12          True     1      Bonnell, Miss. Elizabeth                           female 58        0     0     113783   26.55    C103        S        
23  -> 24          True     1      Sloper, Mr. William Thompson                       male   28        0     0     113788   35.5     A6          S        
27  -> 28          False    1      Fortune, Mr. Charles Alexander                     male   19        3     2     19950    263      C23 C25 C27 S        
30  -> 31          False    1      Uruchurtu, Don. Manuel E                           male   40        0     0     PC 17601 27.7208              C        
31  -> 32          True     1      Spencer, Mrs. William Augustus (Marie Eugenie)     female <missing> 1     0     PC 17569 146.5208 B78         C        
34  -> 35          False    1      Meyer, Mr. Edgar Joseph                            male   28        1     0     PC 17604 82.1708              C        
35  -> 36          False    1      Holverson, Mr. Alexander Oskar                     male   42        1     0     113789   52                   S        
52  -> 53          True     1      Harper, Mrs. Henry Sleeper (Myna Haxtun)           female 49        1     0     PC 17572 76.7292  D33         C        
54  -> 55          False    1      Ostby, Mr. Engelhart Cornelius                     male   65        0     1     113509   61.9792  B30         C        
55  -> 56          True     1      Woolner, Mr. Hugh                                  male   <missing> 0     0     19947    35.5     C52         S        
61  -> 62          True     1      Icard, Miss. Amelie                                female 38        0     0     113572   80       B28                  
62  -> 63          False    1      Harris, Mr. Henry Birkhardt                        male   45        1     0     36973    83.475   C83         S        
:      ...         ...      ...    ...                                                ...    ...       ...   ...   ...      ...      ...         ...      
829 -> 830         True     1      Stone, Mrs. George Nelson (Martha Evelyn)          female 62        0     0     113572   80       B28                  
835 -> 836         True     1      Compton, Miss. Sara Rebecca                        female 39        1     1     PC 17756 83.1583  E49         C        
839 -> 840         True     1      Marechal, Mr. Pierre                               male   <missing> 0     0     11774    29.7     C47         C        
842 -> 843         True     1      Serepeca, Miss. Augusta                            female 30        0     0     113798   31                   C        
849 -> 850         True     1      Goldenberg, Mrs. Samuel L (Edwiga Grabowska)       female <missing> 1     0     17453    89.1042  C92         C        
853 -> 854         True     1      Lines, Miss. Mary Conover                          female 16        0     1     PC 17592 39.4     D28         S        
856 -> 857         True     1      Wick, Mrs. George Dennick (Mary Hitchcock)         female 45        1     1     36928    164.8667             S        
857 -> 858         True     1      Daly, Mr. Peter Denis                              male   51        0     0     113055   26.55    E17         S        
862 -> 863         True     1      Swift, Mrs. Frederick Joel (Margaret Welles Bar... female 48        0     0     17466    25.9292  D17         S        
867 -> 868         False    1      Roebling, Mr. Washington Augustus II               male   31        0     0     PC 17590 50.4958  A24         S        
871 -> 872         True     1      Beckwith, Mrs. Richard Leonard (Sallie Monypeny)   female 47        1     1     11751    52.5542  D35         S        
872 -> 873         False    1      Carlsson, Mr. Frans Olof                           male   33        0     0     695      5        B51 B53 B55 S        
879 -> 880         True     1      Potter, Mrs. Thomas Jr (Lily Alexenia Wilson)      female 56        0     1     11767    83.1583  C50         C        
887 -> 888         True     1      Graham, Miss. Margaret Edith                       female 19        0     0     112053   30       B42         S        
889 -> 890         True     1      Behr, Mr. Karl Howell                              male   26        0     0     111369   30       C148        C        

val it: int = 216

Adding computed columns

The ?<- operator adds or replaces a column. Let's add a HasCabin flag:

titanic?HasCabin <- titanic.GetColumn<string>("Cabin")
  |> Series.mapAll (fun _ v -> Some(v.IsSome))

titanic.Columns.[ ["Name"; "Pclass"; "HasCabin"] ] |> Frame.take 5

val it: Frame<int,string> =
  
     Name                                               Pclass HasCabin 
0 -> Braund, Mr. Owen Harris                            3      True     
1 -> Cumings, Mrs. John Bradley (Florence Briggs Tha... 1      True     
2 -> Heikkinen, Miss. Laina                             3      True     
3 -> Futrelle, Mrs. Jacques Heath (Lily May Peel)       1      True     
4 -> Allen, Mr. William Henry                           3      True

Grouping and aggregation

Group rows by a column and aggregate — one of Deedle's most powerful features.

Survival rate by passenger class

titanic
|> Frame.aggregateRowsBy ["Pclass"] ["Fare"] Stats.mean

val it: Frame<int,string> =
  
     Pclass Fare               
0 -> 3      13.675550101832997 
1 -> 1      84.15468749999992  
2 -> 2      20.66218315217391

Survival counts by class and sex

let byClassAndSex = 
  titanic
  |> Frame.groupRowsByInt "Pclass"
  |> Frame.groupRowsByString "Sex"
  |> Frame.mapRowKeys Pair.flatten3

byClassAndSex.GetColumn<bool>("Survived")
|> Series.applyLevel Pair.get1And2Of3 (fun s ->
    series (Seq.countBy id s.Values))
|> Frame.ofRows

val byClassAndSex: Frame<(string * int * int),string> =
  
                PassengerId Survived Pclass Name                                          Sex    Age       SibSp Parch Ticket          Fare    Cabin Embarked HasCabin 
male   3 0   -> 1           False    3      Braund, Mr. Owen Harris                       male   22        1     0     A/5 21171       7.25          S        True     
male   3 4   -> 5           False    3      Allen, Mr. William Henry                      male   35        0     0     373450          8.05          S        True     
male   3 5   -> 6           False    3      Moran, Mr. James                              male   <missing> 0     0     330877          8.4583        Q        True     
male   3 7   -> 8           False    3      Palsson, Master. Gosta Leonard                male   2         3     1     349909          21.075        S        True     
male   3 12  -> 13          False    3      Saundercock, Mr. William Henry                male   20        0     0     A/5. 2151       8.05          S        True     
male   3 13  -> 14          False    3      Andersson, Mr. Anders Johan                   male   39        1     5     347082          31.275        S        True     
male   3 16  -> 17          False    3      Rice, Master. Eugene                          male   2         4     1     382652          29.125        Q        True     
male   3 26  -> 27          False    3      Emir, Mr. Farred Chehab                       male   <missing> 0     0     2631            7.225         C        True     
male   3 29  -> 30          False    3      Todoroff, Mr. Lalio                           male   <missing> 0     0     349216          7.8958        S        True     
male   3 36  -> 37          True     3      Mamee, Mr. Hanna                              male   <missing> 0     0     2677            7.2292        C        True     
male   3 37  -> 38          False    3      Cann, Mr. Ernest Charles                      male   21        0     0     A./5. 2152      8.05          S        True     
male   3 42  -> 43          False    3      Kraeff, Mr. Theodor                           male   <missing> 0     0     349253          7.8958        C        True     
male   3 45  -> 46          False    3      Rogers, Mr. William John                      male   <missing> 0     0     S.C./A.4. 23567 8.05          S        True     
male   3 46  -> 47          False    3      Lennon, Mr. Denis                             male   <missing> 1     0     370371          15.5          Q        True     
male   3 48  -> 49          False    3      Samaan, Mr. Youssef                           male   <missing> 2     0     2662            21.6792       C        True     
:      : :      ...         ...      ...    ...                                           ...    ...       ...   ...   ...             ...     ...   ...      ...      
female 2 706 -> 707         True     2      Kelly, Mrs. Florence "Fannie"                 female 45        0     0     223596          13.5          S        True     
female 2 717 -> 718         True     2      Troutt, Miss. Edwina Celia "Winnie"           female 27        0     0     34218           10.5    E101  S        True     
female 2 720 -> 721         True     2      Harper, Miss. Annie Jessie "Nina"             female 6         0     1     248727          33            S        True     
female 2 726 -> 727         True     2      Renouf, Mrs. Peter Henry (Lillian Jefferys)   female 30        3     0     31027           21            S        True     
female 2 747 -> 748         True     2      Sinkkonen, Miss. Anna                         female 30        0     0     250648          13            S        True     
female 2 750 -> 751         True     2      Wells, Miss. Joan                             female 4         1     1     29103           23            S        True     
female 2 754 -> 755         True     2      Herman, Mrs. Samuel (Jane Laver)              female 48        1     2     220845          65            S        True     
female 2 772 -> 773         False    2      Mack, Mrs. (Mary)                             female 57        0     0     S.O./P.P. 3     10.5    E77   S        True     
female 2 774 -> 775         True     2      Hocking, Mrs. Elizabeth (Eliza Needs)         female 54        1     3     29105           23            S        True     
female 2 801 -> 802         True     2      Collyer, Mrs. Harvey (Charlotte Annie Tate)   female 31        1     1     C.A. 31921      26.25         S        True     
female 2 854 -> 855         False    2      Carter, Mrs. Ernest Courtenay (Lilian Hughes) female 44        1     0     244252          26            S        True     
female 2 865 -> 866         True     2      Bystrom, Mrs. (Karolina)                      female 42        0     0     236852          13            S        True     
female 2 866 -> 867         True     2      Duran y More, Miss. Asuncion                  female 27        1     0     SC/PARIS 2149   13.8583       C        True     
female 2 874 -> 875         True     2      Abelson, Mrs. Samuel (Hannah Wizosky)         female 28        1     0     P/PP 3381       24            C        True     
female 2 880 -> 881         True     2      Shelley, Mrs. William (Imanita Parrish Hall)  female 25        0     1     230433          26            S        True     

val it: Frame<(string * int),bool> =
  
            False True 
male   3 -> 300   47   
male   1 -> 77    45   
male   2 -> 91    17   
female 3 -> 72    72   
female 1 -> 3     91   
female 2 -> 6     70

Average age by class

titanic
|> Frame.aggregateRowsBy ["Pclass"] ["Age"] Stats.mean

val it: Frame<int,string> =
  
     Pclass Age                
0 -> 3      25.14061971830986  
1 -> 1      38.233440860215055 
2 -> 2      29.87763005780347

Pivot tables

Pivot tables cross-tabulate two categorical variables with an aggregation:

titanic 
|> Frame.pivotTable 
    (fun k r -> r.GetAs<string>("Sex"))
    (fun k r -> r.GetAs<int>("Pclass"))
    Frame.countRows

val it: Frame<string,int> =
  
          3   1   2   
male   -> 347 122 108 
female -> 144 94  76

Handling missing values

Real data has gaps. The Titanic Age and Cabin columns both contain missing entries. Deedle makes this explicit — missing values show as <missing> and are automatically skipped by statistics:

// How many ages are missing?
let ageCol = titanic?Age
let total = ageCol |> Series.countKeys
let present = ageCol |> Series.countValues

val ageCol: Series<int,float> =
  
0   -> 22        
1   -> 38        
2   -> 26        
3   -> 35        
4   -> 35        
5   -> <missing> 
6   -> 54        
7   -> 2         
8   -> 27        
9   -> 14        
10  -> 4         
11  -> 58        
12  -> 20        
13  -> 39        
14  -> 14        
... -> ...       
876 -> 20        
877 -> 19        
878 -> <missing> 
879 -> 56        
880 -> 25        
881 -> 33        
882 -> 22        
883 -> 28        
884 -> 25        
885 -> 39        
886 -> 27        
887 -> 19        
888 -> <missing> 
889 -> 26        
890 -> 32        

val total: int = 891
val present: int = 714

Fill strategies let you choose how to handle the gaps:

// Replace missing ages with a constant
ageCol |> Series.fillMissingWith 0.0 |> Series.take 5

val it: Series<int,float> = 
0 -> 22 
1 -> 38 
2 -> 26 
3 -> 35 
4 -> 35

// Fill forward (propagate last known value)
ageCol |> Series.fillMissing Direction.Forward |> Series.take 5

val it: Series<int,float> = 
0 -> 22 
1 -> 38 
2 -> 26 
3 -> 35 
4 -> 35

// Drop rows with missing values
ageCol |> Series.dropMissing |> Series.countKeys

val it: int = 714

Creating frames and series from scratch

You can also build data frames from scratch rather than loading CSV.

// A simple series
let ages = series [ "Alice" => 30.0; "Bob" => 25.0; "Carol" => 35.0 ]
ages

val ages: Series<string,float> = 
Alice -> 30 
Bob   -> 25 
Carol -> 35 

val it: Series<string,float> = 
Alice -> 30 
Bob   -> 25 
Carol -> 35

// Build a frame from columns
let people = 
  Frame.ofColumns [
    "Age" => ages
    "Score" => series [ "Alice" => 90.0; "Bob" => 85.0; "Carol" => 92.0 ]
  ]
people

val people: Frame<string,string> =
  
         Age Score 
Alice -> 30  90    
Bob   -> 25  85    
Carol -> 35  92    

val it: Frame<string,string> =
  
         Age Score 
Alice -> 30  90    
Bob   -> 25  85    
Carol -> 35  92

// Build a frame from records
type Person = { Name: string; Age: int }
let records = 
  [ { Name = "Alice"; Age = 30 }
    { Name = "Bob"; Age = 25 } ]
Frame.ofRecords records

type Person =
  {
    Name: string
    Age: int
  }
val records: Person list = [{ Name = "Alice"
                              Age = 30 }; { Name = "Bob"
                                            Age = 25 }]
val it: Frame<int,string> = 
     Name  Age 
0 -> Alice 30  
1 -> Bob   25

Selecting columns and rows

Pick specific columns with Frame.sliceCols or the indexer:

titanic.Columns.[ ["Name"; "Age"; "Fare"] ] |> Frame.take 3

val it: Frame<int,string> =
  
     Name                                               Age Fare    
0 -> Braund, Mr. Owen Harris                            22  7.25    
1 -> Cumings, Mrs. John Bradley (Florence Briggs Tha... 38  71.2833 
2 -> Heikkinen, Miss. Laina                             26  7.925

titanic |> Frame.sliceCols ["Pclass"; "Survived"] |> Frame.take 3

val it: Frame<int,string> =
  
     Pclass Survived 
0 -> 3      False    
1 -> 1      True     
2 -> 3      True

Sorting

Sort a frame by column values:

titanic |> Frame.sortRowsBy "Fare" (fun (v: float) -> -v) |> Frame.take 5

val it: Frame<int,string> =
  
       PassengerId Survived Pclass Name                               Sex    Age SibSp Parch Ticket   Fare     Cabin       Embarked HasCabin 
737 -> 738         True     1      Lesurer, Mr. Gustave J             male   35  0     0     PC 17755 512.3292 B101        C        True     
258 -> 259         True     1      Ward, Miss. Anna                   female 35  0     0     PC 17755 512.3292             C        True     
679 -> 680         True     1      Cardeza, Mr. Thomas Drake Martinez male   36  0     1     PC 17755 512.3292 B51 B53 B55 C        True     
88  -> 89          True     1      Fortune, Miss. Mabel Helen         female 23  3     2     19950    263      C23 C25 C27 S        True     
341 -> 342         True     1      Fortune, Miss. Alice Elizabeth     female 24  3     2     19950    263      C23 C25 C27 S        True

Data frame features — full coverage of frame construction, slicing, grouping, aggregation with Frame.aggregateRowsBy, pivot tables, and more.
Series features — windowing, chunking, resampling, and time-series alignment.
Statistics — moving and expanding window statistics, multi-level aggregation.
Handling missing values — sentinel types, all fill strategies, and how missing values interact with joins.
Joining and merging — inner, outer, left, and right joins.
Apache Arrow / Feather — zero-copy columnar I/O.
Deedle.MathNetNumerics — linear algebra, correlation matrices, EWM statistics, PCA, and linear regression via the Deedle.MathNetNumerics package.

namespace System

namespace Deedle

val root: string

val fsi: FSharp.Compiler.Interactive.InteractiveSession

member FSharp.Compiler.Interactive.InteractiveSession.AddPrinter: ('T -> string) -> unit

val o: obj

type obj = Object

val iface: Type

Object.GetType() : Type

val fmt: Reflection.MethodInfo

Type.GetMethod(name: string) : Reflection.MethodInfo
   (+0 other overloads)
Type.GetMethod(name: string, types: Type array) : Reflection.MethodInfo
   (+0 other overloads)
Type.GetMethod(name: string, bindingAttr: Reflection.BindingFlags) : Reflection.MethodInfo
   (+0 other overloads)
Type.GetMethod(name: string, types: Type array, modifiers: Reflection.ParameterModifier array) : Reflection.MethodInfo
   (+0 other overloads)
Type.GetMethod(name: string, bindingAttr: Reflection.BindingFlags, types: Type array) : Reflection.MethodInfo
   (+0 other overloads)
Type.GetMethod(name: string, genericParameterCount: int, types: Type array) : Reflection.MethodInfo
   (+0 other overloads)
Type.GetMethod(name: string, genericParameterCount: int, types: Type array, modifiers: Reflection.ParameterModifier array) : Reflection.MethodInfo
   (+0 other overloads)
Type.GetMethod(name: string, genericParameterCount: int, bindingAttr: Reflection.BindingFlags, types: Type array) : Reflection.MethodInfo
   (+0 other overloads)
Type.GetMethod(name: string, bindingAttr: Reflection.BindingFlags, binder: Reflection.Binder, types: Type array, modifiers: Reflection.ParameterModifier array) : Reflection.MethodInfo
   (+0 other overloads)
Type.GetMethod(name: string, bindingAttr: Reflection.BindingFlags, binder: Reflection.Binder, callConvention: Reflection.CallingConventions, types: Type array, modifiers: Reflection.ParameterModifier array) : Reflection.MethodInfo
   (+0 other overloads)

Reflection.MethodBase.Invoke(obj: obj, parameters: obj array) : obj
Reflection.MethodBase.Invoke(obj: obj, invokeAttr: Reflection.BindingFlags, binder: Reflection.Binder, parameters: obj array, culture: Globalization.CultureInfo) : obj

Multiple items
val string: value: 'T -> string

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

val titanic: Frame<int,string>

Multiple items
module Frame from Deedle
<summary> The `Frame` module provides an F#-friendly API for working with data frames. The module follows the usual desing for collection-processing in F#, so the functions work well with the pipelining operator (`|>`). For example, given a frame with two columns representing prices, we can use `Frame.pctChange` to calculate daily returns like this: let df = frame [ "MSFT" => prices1; "AAPL" => prices2 ] let rets = df |> Frame.pctChange 1 rets |> Stats.mean Note that the `Stats.mean` operation is overloaded and works both on series (returning a number) and on frames (returning a series). You can also use `Frame.diff` if you need absolute differences rather than relative changes. The functions in this module are designed to be used from F#. For a C#-friendly API, see the `FrameExtensions` type. For working with individual series, see the `Series` module. The functions in the `Frame` module are grouped in a number of categories and documented below. Accessing frame data and lookup ------------------------------- Functions in this category provide access to the values in the fame. You can also add and remove columns from a frame (which both return a new value). - `addCol`, `replaceCol` and `dropCol` can be used to create a new data frame with a new column, by replacing an existing column with a new one, or by dropping an existing column - `cols` and `rows` return the columns or rows of a frame as a series containing objects; `getCols` and `getRows` return a generic series and cast the values to the type inferred from the context (columns or rows of incompatible types are skipped); `getNumericCols` returns columns of a type convertible to `float` for convenience. - You can get a specific row or column using `get[Col|Row]` or `lookup[Col|Row]` functions. The `lookup` variant lets you specify lookup behavior for key matching (e.g. find the nearest smaller key than the specified value). There are also `[try]get` and `[try]Lookup` functions that return optional values and functions returning entire observations (key together with the series). - `sliceCols` and `sliceRows` return a sub-frame containing only the specified columns or rows. Finally, `toArray2D` returns the frame data as a 2D array. Grouping, windowing and chunking -------------------------------- The basic grouping functions in this category can be used to group the rows of a data frame by a specified projection or column to create a frame with hierarchical index such as <c>Frame<'K1 * 'K2, 'C></c>. The functions always aggregate rows, so if you want to group columns, you need to use `Frame.transpose` first. The function `groupRowsBy` groups rows by the value of a specified column. Use `groupRowsBy[Int|Float|String...]` if you want to specify the type of the column in an easier way than using type inference; `groupRowsUsing` groups rows using the specified _projection function_ and `groupRowsByIndex` projects the grouping key just from the row index. More advanced functions include: `aggregateRowsBy` which groups the rows by a specified sequence of columns and aggregates each group into a single value; `pivotTable` implements the pivoting operation [as documented in the tutorials](../frame.html#pivot). The `melt` and `unmelt` functions turn the data frame into a single data frame containing columns `Row`, `Column` and `Value` containing the data of the original frame; `unmelt` can be used to turn this representation back into an original frame. The `stack` and `unstack` functions implement pandas-style reshape operations. `stack` converts `Frame<'R,'C>` to a long-format `Frame<'R*'C, string>` where each cell becomes a row keyed by `(rowKey, colKey)` with a single `"Value"` column. `unstack` promotes the inner row-key level to column keys, producing `Frame<'R1, 'C*'R2>` from `Frame<'R1*'R2,'C>`. A simple windowing functions that are exposed for an entire frame operations are `window` and `windowInto`. For more complex windowing operations, you currently have to use `mapRows` or `mapCols` and apply windowing on individual series. Sorting and index manipulation ------------------------------ A frame is indexed by row keys and column keys. Both of these indices can be sorted (by the keys). A frame that is sorted allows a number of additional operations (such as lookup using the `Lookp.ExactOrSmaller` lookup behavior). The functions in this category provide ways for manipulating the indices. It is expected that most operations are done on rows and so more functions are available in a row-wise way. A frame can alwyas be transposed using `Frame.transpose`. Index operations: The existing row/column keys can be replaced by a sequence of new keys using the `indexColsWith` and `indexRowsWith` functions. Row keys can also be replaced by ordinal numbers using `indexRowsOrdinally`. The function `indexRows` uses the specified column of the original frame as the index. It removes the column from the resulting frame (to avoid this, use overloaded `IndexRows` method). This function infers the type of row keys from the context, so it is usually more convenient to use `indexRows[Date|String|Int|...]` functions. Finally, if you want to calculate the index value based on multiple columns of the row, you can use `indexRowsUsing`. Sorting frame rows: Frame rows can be sorted according to the value of a specified column using the `sortRows` function; `sortRowsBy` takes a projection function which lets you transform the value of a column (e.g. to project a part of the value). The functions `sortRowsByKey` and `sortColsByKey` sort the rows or columns using the default ordering on the key values. The result is a frame with ordered index. Expanding columns: When the frame contains a series with complex .NET objects such as F# records or C# classes, it can be useful to "expand" the column. This operation looks at the type of the objects, gets all properties of the objects (recursively) and generates multiple series representing the properties as columns. The function `expandCols` expands the specified columns while `expandAllCols` applies the expansion to all columns of the data frame. Frame transformations --------------------- Functions in this category perform standard transformations on data frames including projections, filtering, taking some sub-frame of the frame, aggregating values using scanning and so on. Projection and filtering functions such as `[map|filter][Cols|Rows]` call the specified function with the column or row key and an <c>ObjectSeries<'K></c> representing the column or row. You can use functions ending with `Values` (such as `mapRowValues`) when you do not require the row key, but only the row series; `mapRowKeys` and `mapColKeys` can be used to transform the keys. You can use `reduceValues` to apply a custom reduction to values of columns. Other aggregations are available in the `Stats` module. You can also get a row with the greaterst or smallest value of a given column using `[min|max]RowBy`. The functions `take[Last]` and `skip[Last]` can be used to take a sub-frame of the original source frame by skipping a specified number of rows. Note that this does not require an ordered frame and it ignores the index - for index-based lookup use slicing, such as `df.Rows.[lo .. hi]`, instead. Finally the `shift` function can be used to obtain a frame with values shifted by the specified offset. This can be used e.g. to get previous value for each key using `Frame.shift 1 df`. The `diff` function calculates difference from previous value using `df - (Frame.shift offs df)`. Processing frames with exceptions --------------------------------- The functions in this group can be used to write computations over frames that may fail. They use the type <c>tryval<'T></c> which is defined as a discriminated union with two cases: Success containing a value, or Error containing an exception. Using <c>tryval<'T></c> as a value in a data frame is not generally recommended, because the type of values cannot be tracked in the type. For this reason, it is better to use <c>tryval<'T></c> with individual series. However, `tryValues` and `fillErrorsWith` functions can be used to get values, or fill failed values inside an entire data frame. The `tryMapRows` function is more useful. It can be used to write a transformation that applies a computation (which may fail) to each row of a data frame. The resulting series is of type <c>Series<'R, tryval<'T>></c> and can be processed using the <c>Series</c> module functions. Missing values -------------- This group of functions provides a way of working with missing values in a data frame. The category provides the following functions that can be used to fill missing values: * `fillMissingWith` fills missing values with a specified constant * `fillMissingUsing` calls a specified function for every missing value * `fillMissing` and variants propagates values from previous/later keys We use the terms _sparse_ and _dense_ to denote series that contain some missing values or do not contain any missing values, respectively. The functions `denseCols` and `denseRows` return a series that contains only dense columns or rows and all sparse rows or columns are replaced with a missing value. The `dropSparseCols` and `dropSparseRows` functions drop these missing values and return a frame with no missing values. Joining, merging and zipping ---------------------------- The simplest way to join two frames is to use the `join` operation which can be used to perform left, right, outer or inner join of two frames. When the row keys of the frames do not match exactly, you can use `joinAlign` which takes an additional parameter that specifies how to find matching key in left/right join (e.g. by taking the nearest smaller available key). Frames that do not contian overlapping values can be combined using `merge` (when combining just two frames) or using `mergeAll` (for larger number of frames). Tha latter is optimized to work well for a large number of data frames. Finally, frames with overlapping values can be combined using `zip`. It takes a function that is used to combine the overlapping values. A `zipAlign` function provides a variant with more flexible row key matching (as in `joinAlign`) Hierarchical index operations ----------------------------- A data frame has a hierarchical row index if the row index is formed by a tuple, such as <c>Frame<'R1 * 'R2, 'C></c>. Frames of this kind are returned, for example, by the grouping functions such as <c>Frame.groupRowsBy</c>. The functions in this category provide ways for working with data frames that have hierarchical row keys. The functions <c>applyLevel</c> and <c>reduceLevel</c> can be used to reduce values according to one of the levels. The <c>applyLevel</c> function takes a reduction of type <c>Series<'K, 'T> -> 'T</c> while <c>reduceLevel</c> reduces individual values using a function of type <c>'T -> 'T -> 'T</c>. The functions <c>nest</c> and <c>unnest</c> can be used to convert between frames with hierarchical indices (<c>Frame<'K1 * 'K2, 'C></c>) and series of frames that represent individual groups (<c>Series<'K1, Frame<'K2, 'C>></c>). The <c>nestBy</c> function can be used to perform group by operation and return the result as a series of frems. </summary>
<category>Frame and series operations</category>

--------------------
type Frame = static member ReadCsv: location: string * hasHeaders: Nullable<bool> * inferTypes: Nullable<bool> * inferRows: Nullable<int> * schema: string * separators: string * culture: string * maxRows: Nullable<int> * missingValues: string array * preferOptions: bool * encoding: Encoding -> Frame<int,string> + 1 overload static member ReadReader: reader: IDataReader -> Frame<int,string> static member CustomExpanders: Dictionary<Type,Func<obj,(string * Type * obj) seq>> static member NonExpandableInterfaces: ResizeArray<Type> static member NonExpandableTypes: HashSet<Type>
<summary> Provides static methods for creating frames, reading frame data from CSV files and database (via IDataReader). The type also provides global configuration for reflection-based expansion. </summary>
<category>Frame and series operations</category>

--------------------
type Frame<'TRowKey,'TColumnKey (requires equality and equality)> = interface IDynamicMetaObjectProvider interface INotifyCollectionChanged interface IFrameFormattable interface IFsiFormattable interface IFrame new: rowIndex: IIndex<'TRowKey> * columnIndex: IIndex<'TColumnKey> * data: IVector<IVector> * indexBuilder: IIndexBuilder * vectorBuilder: IVectorBuilder -> Frame<'TRowKey,'TColumnKey> + 1 overload member AddColumn: column: 'TColumnKey * series: 'V seq -> unit + 3 overloads member AggregateRowsBy: groupBy: 'TColumnKey seq * aggBy: 'TColumnKey seq * aggFunc: Func<Series<'TRowKey,'a>,'b> -> Frame<int,'TColumnKey> member Clone: unit -> Frame<'TRowKey,'TColumnKey> member ColumnApply: f: Func<Series<'TRowKey,'T>,ISeries<'TRowKey>> -> Frame<'TRowKey,'TColumnKey> + 1 overload ...
<summary> A frame is the key Deedle data structure (together with series). It represents a data table (think spreadsheet or CSV file) with multiple rows and columns. The frame consists of row index, column index and data. The indices are used for efficient lookup when accessing data by the row key `'TRowKey` or by the column key `'TColumnKey`. Deedle frames are optimized for the scenario when all values in a given column are of the same type (but types of different columns can differ). </summary>
<remarks><para>Joining, zipping and appending:</para><para> More info </para></remarks>
<category>Core frame and series types</category>

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

static member Frame.ReadCsv: reader: IO.TextReader * ?hasHeaders: bool * ?inferTypes: bool * ?inferRows: int * ?schema: string * ?separators: string * ?culture: string * ?maxRows: int * ?missingValues: string array * ?preferOptions: bool * ?typeResolver: (string -> string option) -> Frame<int,string>
static member Frame.ReadCsv: stream: IO.Stream * hasHeaders: Nullable<bool> * inferTypes: Nullable<bool> * inferRows: Nullable<int> * schema: string * separators: string * culture: string * maxRows: Nullable<int> * missingValues: string array * preferOptions: Nullable<bool> * encoding: Text.Encoding -> Frame<int,string>
static member Frame.ReadCsv: location: string * hasHeaders: Nullable<bool> * inferTypes: Nullable<bool> * inferRows: Nullable<int> * schema: string * separators: string * culture: string * maxRows: Nullable<int> * missingValues: string array * preferOptions: bool * encoding: Text.Encoding -> Frame<int,string>
static member Frame.ReadCsv: path: string * ?hasHeaders: bool * ?inferTypes: bool * ?inferRows: int * ?schema: string * ?separators: string * ?culture: string * ?maxRows: int * ?missingValues: string array * ?preferOptions: bool * ?typeResolver: (string -> string option) * ?encoding: Text.Encoding -> 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 array * ?preferOptions: bool * ?typeResolver: (string -> string option) * ?encoding: Text.Encoding -> 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 array * ?preferOptions: bool * ?typeResolver: (string -> string option) * ?encoding: Text.Encoding -> Frame<'R,string> (requires equality)

property Frame.RowCount: int with get

property Frame.ColumnCount: int with get

property Frame.ColumnKeys: string seq with get
<category>Accessors and slicing</category>

module Seq from Microsoft.FSharp.Collections

val toList: source: 'T seq -> 'T list

val take: count: int -> frame: Frame<'R,'C> -> Frame<'R,'C> (requires equality and equality)
<summary> Returns a frame that contains the specified `count` of rows from the original frame; `count` must be smaller or equal to the original number of rows. <category>Frame transformations</category> </summary>

member Frame.GetColumn<'R> : column: 'TColumnKey -> Series<'TRowKey,'R>
member Frame.GetColumn<'R> : column: 'TColumnKey * lookup: Lookup -> Series<'TRowKey,'R>

Multiple items
module Series from Deedle
<summary> The `Series` module provides an F#-friendly API for working with data and time series. The API follows the usual design for collection-processing in F#, so the functions work well with the pipelining (<c>|></c>) operator. For example, given a series with ages, we can use `Series.filterValues` to filter outliers and then `Stats.mean` to calculate the mean: ages |> Series.filterValues (fun v -> v > 0.0 && v < 120.0) |> Stats.mean The module provides comprehensive set of functions for working with series. The same API is also exposed using C#-friendly extension methods. In C#, the above snippet could be written as: [lang=csharp] ages .Where(kvp => kvp.Value > 0.0 && kvp.Value < 120.0) .Mean() For more information about similar frame-manipulation functions, see the `Frame` module. For more information about C#-friendly extensions, see `SeriesExtensions`. The functions in the `Series` module are grouped in a number of categories and documented below. Accessing series data and lookup -------------------------------- Functions in this category provide access to the values in the series. - The term _observation_ is used for a key value pair in the series. - When working with a sorted series, it is possible to perform lookup using keys that are not present in the series - you can specify to search for the previous or next available value using _lookup behavior_. - Functions such as `get` and `getAll` have their counterparts `lookup` and `lookupAll` that let you specify lookup behavior. - For most of the functions that may fail, there is a `try[Foo]` variant that returns `None` instead of failing. - Functions with a name ending with `At` perform lookup based on the absolute integer offset (and ignore the keys of the series) Series transformations ---------------------- Functions in this category perform standard transformations on series including projections, filtering, taking some sub-series of the series, aggregating values using scanning and so on. Projection and filtering functions generally skip over missing values, but there are variants `filterAll` and `mapAll` that let you handle missing values explicitly. Keys can be transformed using `mapKeys`. When you do not need to consider the keys, and only care about values, use `filterValues` and `mapValues` (which is also aliased as the `$` operator). Series supports standard set of folding functions including `reduce` and `fold` (to reduce series values into a single value) as well as the `scan[All]` function, which can be used to fold values of a series into a series of intermeidate folding results. The functions `take[Last]` and `skip[Last]` can be used to take a sub-series of the original source series by skipping a specified number of elements. Note that this does not require an ordered series and it ignores the index - for index-based lookup use slicing, such as `series.[lo .. hi]`, instead. Finally the `shift` function can be used to obtain a series with values shifted by the specified offset. This can be used e.g. to get previous value for each key using `Series.shift 1 ts`. The `diff` function calculates difference from previous value using `ts - (Series.shift offs ts)`. Processing series with exceptions --------------------------------- The functions in this group can be used to write computations over series that may fail. They use the type <c>tryval<'T></c> which is defined as a discriminated union with two cases: Success containing a value, or Error containing an exception. The function `tryMap` lets you create <c>Series<'K, tryval<'T>></c> by mapping over values of an original series. You can then extract values using `tryValues`, which throws `AggregateException` if there were any errors. Functions `tryErrors` and `trySuccesses` give series containing only errors and successes. You can fill failed values with a constant using `fillErrorsWith`. Hierarchical index operations ----------------------------- When the key of a series is tuple, the elements of the tuple can be treated as multiple levels of a index. For example <c>Series<'K1 * 'K2, 'V></c> has two levels with keys of types <c>'K1</c> and <c>'K2</c> respectively. The functions in this cateogry provide a way for aggregating values in the series at one of the levels. For example, given a series `input` indexed by two-element tuple, you can calculate mean for different first-level values as follows: input |> applyLevel fst Stats.mean Note that the `Stats` module provides helpers for typical statistical operations, so the above could be written just as `input |> Stats.levelMean fst`. Grouping, windowing and chunking -------------------------------- This category includes functions that group data from a series in some way. Two key concepts here are _window_ and _chunk_. Window refers to (overlapping) sliding windows over the input series while chunk refers to non-overlapping blocks of the series. The boundary behavior can be specified using the `Boundary` flags. The value `Skip` means that boundaries (incomplete windows or chunks) should be skipped. The value `AtBeginning` and `AtEnding` can be used to define at which side should the boundary be returned (or skipped). For chunking, `AtBeginning ||| Skip` makes sense and it means that the incomplete chunk at the beginning should be skipped (aligning the last chunk with the end). The behavior may be specified in a number of ways (which is reflected in the name): - `dist` - using an absolute distance between the keys - `while` - using a condition on the first and last key - `size` - by specifying the absolute size of the window/chunk The functions ending with `Into` take a function to be applied to the window/chunk. The functions `window`, `windowInto` and `chunk`, `chunkInto` are simplified versions that take a size. There is also `pairwise` function for sliding window of size two. Missing values -------------- This group of functions provides a way of working with missing values in a series. The `dropMissing` function drops all keys for which there are no values in the series. The `withMissingFrom` function lets you copy missing values from another series. The remaining functions provide different mechanism for filling the missing values. * `fillMissingWith` fills missing values with a specified constant * `fillMissingUsing` calls a specified function for every missing value * `fillMissing` and variants propagates values from previous/later keys Sorting and index manipulation ------------------------------ A series that is sorted by keys allows a number of additional operations (such as lookup using the `Lookp.ExactOrSmaller` lookup behavior). However, it is also possible to sort series based on the values - although the functions for manipulation with series do not guarantee that the order will be preserved. To sort series by keys, use `sortByKey`. Other sorting functions let you sort the series using a specified comparer function (`sortWith`), using a projection function (`sortBy`) and using the default comparison (`sort`). In addition, you can also replace the keys of a series with other keys using `indexWith` or with integers using `indexOrdinally`. To pick and reorder series values using to match a list of keys use `realign`. Sampling, resampling and advanced lookup ---------------------------------------- Given a (typically) time series sampling or resampling makes it possible to get time series with representative values at lower or uniform frequency. We use the following terminology: - `lookup` and `sample` functions find values at specified key; if a key is not available, they can look for value associated with the nearest smaller or the nearest greater key. - `resample` function aggregate values values into chunks based on a specified collection of keys (e.g. explicitly provided times), or based on some relation between keys (e.g. date times having the same date). - `resampleUniform` is similar to resampling, but we specify keys by providing functions that generate a uniform sequence of keys (e.g. days), the operation also fills value for days that have no corresponding observations in the input sequence. Joining, merging and zipping ---------------------------- Given two series, there are two ways to combine the values. If the keys in the series are not overlapping (or you want to throw away values from one or the other series), then you can use `merge` or `mergeUsing`. To merge more than 2 series efficiently, use the `mergeAll` function, which has been optimized for large number of series. If you want to align two series, you can use the _zipping_ operation. This aligns two series based on their keys and gives you tuples of values. The default behavior (`zip`) uses outer join and exact matching. For ordered series, you can specify other forms of key lookups (e.g. find the greatest smaller key) using `zipAlign`. functions ending with `Into` are generally easier to use as they call a specified function to turn the tuple (of possibly missing values) into a new value. For more complicated behaviors, it is often convenient to use joins on frames instead of working with series. Create two frames with single columns and then use the join operation. The result will be a frame with two columns (which is easier to use than series of tuples). </summary>
<category>Frame and series operations</category>

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

--------------------
type Series<'K,'V (requires equality)> = interface ISeriesFormattable interface IFsiFormattable interface ISeries<'K> new: index: IIndex<'K> * vector: IVector<'V> * vectorBuilder: IVectorBuilder * indexBuilder: IIndexBuilder -> Series<'K,'V> + 3 overloads member After: lowerExclusive: 'K -> Series<'K,'V> 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) + 1 overload member AsyncMaterialize: unit -> Async<Series<'K,'V>> member Before: upperExclusive: 'K -> Series<'K,'V> member Between: lowerInclusive: 'K * upperInclusive: 'K -> Series<'K,'V> member Compare: another: Series<'K,'V> -> Series<'K,Diff<'V>> ...
<summary> The type <c>Series<K, V></c> represents a data series consisting of values `V` indexed by keys `K`. The keys of a series may or may not be ordered </summary>
<category>Core frame and series types</category>

--------------------
new: pairs: Collections.Generic.KeyValuePair<'K,'V> seq -> Series<'K,'V>
new: keys: 'K seq * values: 'V seq -> Series<'K,'V>
new: keys: 'K array * values: 'V array -> Series<'K,'V>
new: index: Indices.IIndex<'K> * vector: IVector<'V> * vectorBuilder: Vectors.IVectorBuilder * indexBuilder: Indices.IIndexBuilder -> Series<'K,'V>

val take: count: int -> series: Series<'K,'T> -> Series<'K,'T> (requires equality)
<summary> Returns a series that contains the specified number of keys from the original series. </summary>
<param name="count">Number of keys to take; must be smaller or equal to the original number of keys</param>
<param name="series">Input series from which the keys are taken</param>
<category>Series transformations</category>

type Stats = static member corr: series1: Series<'K,'V1> -> series2: Series<'K,'V2> -> float (requires equality) static member corrFrame: frame: Frame<'R,'C> -> Frame<'C,'C> (requires equality and equality) static member count: series: Series<'K,'V> -> int (requires equality) + 1 overload static member cov: series1: Series<'K,'V1> -> series2: Series<'K,'V2> -> float (requires equality) static member covFrame: frame: Frame<'R,'C> -> Frame<'C,'C> (requires equality and equality) static member describe: series: Series<'K,'V> -> Series<string,float> (requires equality and equality) + 1 overload static member expandingCount: series: Series<'K,'V> -> Series<'K,float> (requires equality) static member expandingKurt: series: Series<'K,'V> -> Series<'K,float> (requires equality) static member expandingMax: series: Series<'K,'V> -> Series<'K,float> (requires equality) static member expandingMean: series: Series<'K,'V> -> Series<'K,float> (requires equality) ...

static member Stats.mean: frame: Frame<'R,'C> -> Series<'C,float> (requires equality and equality)
static member Stats.mean: series: Series<'K,'V> -> float (requires equality)

static member Stats.median: frame: Frame<'R,'C> -> Series<'C,float> (requires equality and equality)
static member Stats.median: series: Series<'K,'V> -> float (requires equality)

static member Stats.stdDev: frame: Frame<'R,'C> -> Series<'C,float> (requires equality and equality)
static member Stats.stdDev: series: Series<'K,'V> -> float (requires equality)

val survived: Frame<int,string>

val filterRowValues: f: (ObjectSeries<'C> -> bool) -> frame: Frame<'R,'C> -> Frame<'R,'C> (requires equality and equality)
<summary> Returns a new data frame containing only the rows of the input frame for which the specified predicate returns `true`. The predicate is called with an object series that represents the row data (use `filterRows` if you need to access the row key). </summary>
<param name="frame">Input data frame to be transformed</param>
<param name="f">Function of one argument that defines the predicate</param>
<category>Frame transformations</category>

val row: ObjectSeries<string>

member ObjectSeries.GetAs<'R> : column: 'K -> 'R
member ObjectSeries.GetAs: column: 'K * fallback: 'R -> 'R

type bool = Boolean

val firstClass: Frame<int,string>

Multiple items
val int: value: 'T -> int (requires member op_Explicit)

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

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

val mapAll: f: ('K -> 'T option -> 'R option) -> series: Series<'K,'T> -> Series<'K,'R> (requires equality)
<summary> Returns a new series whose values are the results of applying the given function to values of the original series. This specified function is called even when the value is missing. It returns <c>option<'T></c> so that it can create/eliminate missing values in the result. </summary>
<category>Series transformations</category>

val v: string option

union case Option.Some: Value: 'T -> Option<'T>

property Option.IsSome: bool with get

property Frame.Columns: ColumnSeries<int,string> with get
<category>Accessors and slicing</category>

val aggregateRowsBy: groupBy: 'C seq -> aggBy: 'C seq -> aggFunc: (Series<'R,'V1> -> 'V2) -> frame: Frame<'R,'C> -> Frame<int,'C> (requires equality and equality)
<summary> Returns a data frame whose rows are grouped by `groupBy` and whose columns specified in `aggBy` are aggregated according to `aggFunc`. </summary>
<param name="groupBy">sequence of columns to group by</param>
<param name="aggBy">sequence of columns to apply aggFunc to</param>
<param name="aggFunc">invoked in order to aggregate values</param>
<param name="frame">The input data frame to be aggregated</param>
<category>Grouping, windowing and chunking</category>

val byClassAndSex: Frame<(string * int * int),string>

val groupRowsByInt: column: 'C -> frame: Frame<'R,'C> -> Frame<(int * 'R),'C> (requires equality and equality)
<summary> Groups the rows of a frame by a specified column in the same way as `groupRowsBy`. This function assumes that the values of the specified column are of type `int`. <category>Grouping, windowing and chunking</category> </summary>

val groupRowsByString: column: 'C -> frame: Frame<'R,'C> -> Frame<(string * 'R),'C> (requires equality and equality)
<summary> Groups the rows of a frame by a specified column in the same way as `groupRowsBy`. This function assumes that the values of the specified column are of type `string`. <category>Grouping, windowing and chunking</category> </summary>

val mapRowKeys: f: ('R1 -> 'R2) -> frame: Frame<'R1,'C> -> Frame<'R2,'C> (requires equality and equality and equality)
<summary> Builds a new data frame whose row keys are the results of applying the specified function on the row keys of the original data frame. </summary>
<param name="frame">Input data frame to be transformed</param>
<param name="f">Function of one argument that defines the row key mapping</param>
<category>Frame transformations</category>

module Pair from Deedle
<summary> Module with helper functions for extracting values from hierarchical tuples </summary>
<category>Primitive types and values</category>

val flatten3: v1: 'a * ('b * 'c) -> 'a * 'b * 'c
<summary> Flatten a two-level nested tuple into a flat tuple of 3 elements </summary>

val applyLevel: level: ('K1 -> 'K2) -> op: (Series<'K1,'V> -> 'R) -> series: Series<'K1,'V> -> Series<'K2,'R> (requires equality and equality)
<summary> Groups the elements of the input series in groups based on the keys produced by `level` and then aggregates series representing each group using the specified function `op`. The result is a new series containing the aggregates of each group. This operation is designed to be used with [hierarchical indexing](../frame.html#indexing). </summary>
<param name="series">An input series to be aggregated</param>
<param name="op">A function that takes a series and produces an aggregated result</param>
<param name="level">A delegate that returns a new group key, based on the key in the input series</param>
<category>Hierarchical index operations</category>

val get1And2Of3: v1: 'a * v2: 'b * 'c -> 'a * 'b
<summary> Returns the first and the second value of a three-level hierarchical tuple </summary>

val s: Series<(string * int * int),bool>

val series: observations: ('a * 'b) seq -> Series<'a,'b> (requires equality)
<summary> Create a series from a sequence of key-value pairs that represent the observations of the series. This function can be used together with the `=>` operator to create key-value pairs. </summary>
<example> // Creates a series with squares of numbers let sqs = series [ 1 => 1.0; 2 => 4.0; 3 => 9.0 ] </example>

val countBy: projection: ('T -> 'Key) -> source: 'T seq -> ('Key * int) seq (requires equality)

val id: x: 'T -> 'T

property Series.Values: bool seq with get
<summary> Returns a collection of values that are available in the series data. Note that the length of this sequence does not match the `Keys` sequence if there are missing values. To get matching sequence, use the `Observations` property or `Series.observation`. </summary>
<category>Series data</category>

static member Frame.ofRows: rows: ('R * #ISeries<'C>) seq -> Frame<'R,'C> (requires equality and equality)
static member Frame.ofRows: rows: Series<'R,#ISeries<'C>> -> Frame<'R,'C> (requires equality and equality)

val pivotTable: rowGrp: ('R -> ObjectSeries<'C> -> 'RNew) -> colGrp: ('R -> ObjectSeries<'C> -> 'CNew) -> op: (Frame<'R,'C> -> 'T) -> frame: Frame<'R,'C> -> Frame<'RNew,'CNew> (requires equality and equality and equality and equality)
<summary> Creates a new data frame resulting from a 'pivot' operation. Consider a denormalized data frame representing a table: column labels are field names & table values are observations of those fields. pivotTable buckets the rows along two axes, according to the results of the functions `rowGrp` and `colGrp`; and then computes a value for the frame of rows that land in each bucket. </summary>
<param name="rowGrp">A function from rowkey & row to group value for the resulting row index</param>
<param name="colGrp">A function from rowkey & row to group value for the resulting col index</param>
<param name="op">A function computing a value from the corresponding bucket frame</param>
<param name="frame">The input data frame to pivot</param>
<category>Grouping, windowing and chunking</category>

val k: int

val r: ObjectSeries<string>

val countRows: frame: Frame<'R,'C> -> int (requires equality and equality)
<summary> Returns the total number of row keys in the specified frame. This returns the total length of the row series, including keys for which there is no value available. </summary>
<category>Accessing frame data and lookup</category>

val ageCol: Series<int,float>

val total: int

val countKeys: series: Series<'K,'T> -> int (requires equality)
<summary> Returns the total number of keys in the specified series. This returns the total length of the series, including keys for which there is no value available. </summary>
<category>Accessing series data and lookup</category>

val present: int

val countValues: series: Series<'K,'T> -> int (requires equality)
<summary> Returns the total number of values in the specified series. This excludes missing values or not available values (such as values created from `null`, `Double.NaN`, or those that are missing due to outer join etc.). </summary>
<category>Accessing series data and lookup</category>

val fillMissingWith: value: 'a -> series: Series<'K,'T> -> Series<'K,'T> (requires equality)
<summary> Fill missing values in the series with a constant value. </summary>
<param name="series">An input series that is to be filled</param>
<param name="value">A constant value that is used to fill all missing values</param>
<category>Missing values</category>

val fillMissing: direction: Direction -> series: Series<'K,'T> -> Series<'K,'T> (requires equality)
<summary> Fill missing values in the series with the nearest available value (using the specified direction). Note that the series may still contain missing values after call to this function. This operation can only be used on ordered series. </summary>
<param name="series">An input series that is to be filled</param>
<param name="direction">Specifies the direction used when searching for the nearest available value. `Backward` means that we want to look for the first value with a smaller key while `Forward` searches for the nearest greater key.</param>
<example><code> let sample = Series.ofValues [ Double.NaN; 1.0; Double.NaN; 3.0 ] // Returns a series consisting of [1; 1; 3; 3] sample |> Series.fillMissing Direction.Backward // Returns a series consisting of [<missing>; 1; 1; 3] sample |> Series.fillMissing Direction.Forward </code></example>
<category>Missing values</category>

type Direction = | Backward = 0 | Forward = 1
<summary> Specifies in which direction should we look when performing operations such as `Series.Pairwise`. </summary>
<example><code> let abc = [ 1 => "a"; 2 => "b"; 3 => "c" ] |> Series.ofObservations // Using 'Forward' the key of the first element is used abc.Pairwise(direction=Direction.Forward) // [ 1 => ("a", "b"); 2 => ("b", "c") ] // Using 'Backward' the key of the second element is used abc.Pairwise(direction=Direction.Backward) // [ 2 => ("a", "b"); 3 => ("b", "c") ] </code></example>
<category>Parameters and results of various operations</category>

Direction.Forward: Direction = 1

val dropMissing: series: Series<'K,'T> -> Series<'K,'T> (requires equality)
<summary> Drop missing values from the specified series. The returned series contains only those keys for which there is a value available in the original one. </summary>
<param name="series">An input series to be filtered</param>
<example><code> let s = series [ 1 => 1.0; 2 => Double.NaN ] s |> Series.dropMissing // val it : Series<int,float> = series [ 1 => 1] </code></example>
<category>Missing values</category>

val ages: Series<string,float>

val people: Frame<string,string>

static member Frame.ofColumns: cols: Series<'C,#ISeries<'R>> -> Frame<'R,'C> (requires equality and equality)
static member Frame.ofColumns: cols: ('C * #ISeries<'R>) seq -> Frame<'R,'C> (requires equality and equality)

type Person = { Name: string Age: int }

val records: Person list

static member Frame.ofRecords: series: Series<'K,'R> -> Frame<'K,string> (requires equality)
static member Frame.ofRecords: values: 'T seq -> Frame<int,string>
static member Frame.ofRecords: values: Collections.IEnumerable * indexCol: string -> Frame<'R,string> (requires equality)

val sliceCols: columns: 'C seq -> frame: Frame<'R,'C> -> Frame<'R,'C> (requires equality and equality)
<summary> Returns a frame consisting of the specified columns from the original data frame. The function uses exact key matching semantics. <category>Accessing frame data and lookup</category> </summary>

val sortRowsBy: colKey: 'C -> f: ('T -> 'V) -> frame: Frame<'R,'C> -> Frame<'R,'C> (requires equality and comparison and equality)
<summary> Returns a data frame that contains the same data as the input, but whose rows are ordered on a particular column of the frame. <category>Sorting and index manipulation</category> </summary>

val v: float

Multiple items
val float: value: 'T -> float (requires member op_Explicit)

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

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