# Frame

Namespace: Deedle

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.

## Configuration

### Static members

Static memberDescription
 CustomExpanders 
Signature: Dictionary<Type,Func<obj,seq<string * Type * obj>>>

Configures how reflection-based expansion behaves - see also df.ExpandColumns. This (mutable, non-thread-safe) collection lets you specify custom expansion behavior for any type. This is a dictionary with types as keys and functions that implement the expansion as values.

## Example

For example, say you have a type MyPair with propreties Item1 of type int and Item2 of type string (and perhaps other properties which makes the default behavior inappropriate). You can register custom expander as:

 1: 2: 3: 4:  Frame.CustomExpanders.Add(typeof, fun v -> let a = v :?> MyPair [ "First", typeof, box a.Item1; "Second", typeof, box a.Item2 ] :> seq<_> ) 
val typeof<'T> : System.Type

Full name: Microsoft.FSharp.Core.Operators.typeof
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 box : value:'T -> obj

Full name: Microsoft.FSharp.Core.Operators.box
Multiple items
val string : value:'T -> string

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

--------------------
type string = System.String

Full name: Microsoft.FSharp.Core.string
Multiple items
val seq : sequence:seq<'T> -> seq<'T>

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

--------------------
type seq<'T> = System.Collections.Generic.IEnumerable<'T>

Full name: Microsoft.FSharp.Collections.seq<_>
 NonExpandableInterfaces 
Signature: List<Type>

Configures how reflection-based expansion behaves - see also df.ExpandColumns. This (mutable, non-thread-safe) collection specifies interfaces whose implementations should not be expanded. By default, this includes collections such as IList.

 NonExpandableTypes 
Signature: HashSet<Type>

Configures how reflection-based expansion behaves - see also df.ExpandColumns. This (mutable, non-thread-safe) collection specifies additional primitive (but reference) types that should not be expaneded. By default, this includes DateTime, string, etc.

## Input and output

### Static members

Static memberDescription
 ReadCsv(...) 
Signature: (stream:Stream * hasHeaders:Nullable<bool> * inferTypes:Nullable<bool> * inferRows:Nullable<int> * schema:string * separators:string * culture:string * maxRows:Nullable<int> * missingValues:string []) -> Frame<int,string>

Load data frame from a CSV file. The operation automatically reads column names from the CSV file (if they are present) and infers the type of values for each column. Columns of primitive types (int, float, etc.) are converted to the right type. Columns of other types (such as dates) are not converted automatically.

## Parameters

• stream - Specifies the input stream, opened at the beginning of CSV data
• hasHeaders - Specifies whether the input CSV file has header row (when not set, the default value is true)
• inferTypes - Specifies whether the method should attempt to infer types of columns automatically (set this to false if you want to specify schema)
• inferRows - If inferTypes=true, this parameter specifies the number of rows to use for type inference. The default value is 100.
• schema - A string that specifies CSV schema. See the documentation for information about the schema format.
• separators - A string that specifies one or more (single character) separators that are used to separate columns in the CSV file. Use for example ";" to parse semicolon separated files.
• culture - Specifies the name of the culture that is used when parsing values in the CSV file (such as "en-US"). The default is invariant culture.
• maxRows - The maximal number of rows that should be read from the CSV file.
• missingValues - An array of strings that contains values which should be treated as missing when reading the file. The default value is: "NaN"; "NA"; "#N/A"; ":"; "-"; "TBA"; "TBD".
 ReadCsv(...) 
Signature: (location:string * hasHeaders:Nullable<bool> * inferTypes:Nullable<bool> * inferRows:Nullable<int> * schema:string * separators:string * culture:string * maxRows:Nullable<int> * missingValues:string []) -> Frame<int,string>

Load data frame from a CSV file. The operation automatically reads column names from the CSV file (if they are present) and infers the type of values for each column. Columns of primitive types (int, float, etc.) are converted to the right type. Columns of other types (such as dates) are not converted automatically.

## Parameters

• location - Specifies a file name or an web location of the resource.
• hasHeaders - Specifies whether the input CSV file has header row (when not set, the default value is true)
• inferTypes - Specifies whether the method should attempt to infer types of columns automatically (set this to false if you want to specify schema)
• inferRows - If inferTypes=true, this parameter specifies the number of rows to use for type inference. The default value is 100.
• schema - A string that specifies CSV schema. See the documentation for information about the schema format.
• separators - A string that specifies one or more (single character) separators that are used to separate columns in the CSV file. Use for example ";" to parse semicolon separated files.
• culture - Specifies the name of the culture that is used when parsing values in the CSV file (such as "en-US"). The default is invariant culture.
• maxRows - Specifies the maximum number of rows that will be read from the CSV file
 ReadReader(reader) 

Read data from IDataReader. The method reads all rows from the data reader and for each row, gets all the columns. When a value is DBNull, it is treated as missing. The types of created vectors are determined by the field types reported by the data reader.

## Other type members

### Static members

Static memberDescription
 CreateEmpty() 
Signature: unit -> Frame<'R,'C>
Type parameters: 'R, 'C
 FromArray2D(array) 
Signature: (array:'T [,]) -> Frame<int,int>
Type parameters: 'T

Create data frame from a 2D array of values. The first dimension of the array is used as rows and the second dimension is treated as columns. Rows and columns of the returned frame are indexed with the element's offset in the array.

## Parameters

• array - A two-dimensional array to be converted into a data frame
 FromColumns(cols) 
Signature: cols:Series<'TColKey,Series<'TRowKey,'V>> -> Frame<'TRowKey,'TColKey>
Type parameters: 'TColKey, 'TRowKey, 'V
 FromColumns(cols) 
Signature: cols:Series<'TColKey,ObjectSeries<'TRowKey>> -> Frame<'TRowKey,'TColKey>
Type parameters: 'TColKey, 'TRowKey
 FromColumns(columns) 
Signature: columns:seq<KeyValuePair<'ColKey,ObjectSeries<'RowKey>>> -> Frame<'RowKey,'ColKey>
Type parameters: 'ColKey, 'RowKey
 FromColumns(columns) 
Signature: columns:seq<KeyValuePair<'ColKey,Series<'RowKey,'V>>> -> Frame<'RowKey,'ColKey>
Type parameters: 'ColKey, 'RowKey, 'V
 FromColumns(cols) 
Signature: cols:seq<Series<'ColKey,'V>> -> Frame<'ColKey,int>
Type parameters: 'ColKey, 'V
 FromRecords(values) 
Signature: values:seq<'T> -> Frame<int,string>
Type parameters: 'T

Creates a data frame from a sequence of any .NET objects. The method uses reflection over the specified type parameter 'T and turns its properties to columns. The rows of the resulting frame are automatically indexed by int.

## Example

The method can be nicely used to create a data frame using C# anonymous types (the result is a data frame with columns "A" and "B" containing two rows).

[lang=csharp] var df = Frame.FromRecords(new[] { new { A = 1, B = "Test" }, new { A = 2, B = "Another"} });

 FromRecords(series) 
Signature: series:Series<'K,'R> -> Frame<'K,string>
Type parameters: 'K, 'R

Creates a data frame from a sequence of any .NET objects. The method uses reflection over the specified type parameter 'T and turns its properties to columns.

 FromRowKeys(keys) 
Signature: keys:seq<'K> -> Frame<'K,string>
Type parameters: 'K
 FromRows(rows) 
Signature: rows:Series<'TColKey,Series<'TRowKey,'V>> -> Frame<'TColKey,'TRowKey>
Type parameters: 'TColKey, 'TRowKey, 'V
 FromRows(rows) 
Signature: rows:Series<'TColKey,ObjectSeries<'TRowKey>> -> Frame<'TColKey,'TRowKey>
Type parameters: 'TColKey, 'TRowKey
 FromRows(rows) 
Signature: rows:seq<KeyValuePair<'RowKey,ObjectSeries<'ColKey>>> -> Frame<'RowKey,'ColKey>
Type parameters: 'RowKey, 'ColKey
 FromRows(rows) 
Signature: rows:seq<KeyValuePair<'RowKey,Series<'ColKey,'V>>> -> Frame<'RowKey,'ColKey>
Type parameters: 'RowKey, 'ColKey, 'V
 FromRows(rows) 
Signature: rows:seq<Series<'ColKey,'V>> -> Frame<int,'ColKey>
Type parameters: 'ColKey, 'V
 FromValues(values) 
Signature: (values:seq<'?491432 * '?491433 * '?491434>) -> Frame<'?491432,'?491433>
Type parameters: '?491432, '?491433, '?491434

Create a data frame from a sequence of tuples containing row key, column key and a value

 FromValues(...) 
Signature: (values:seq<'T> * colSel:Func<'T,'C> * rowSel:Func<'T,'R> * valSel:Func<'T,'V>) -> Frame<'R,'C>
Type parameters: 'T, 'C, 'R, 'V

Create a data frame from a sequence of objects and functions that return row key, column key and value for each object in the input sequence.

## Parameters

• values - Input sequence of objects
• colSel - A function that returns the column key of an object
• rowSel - A function that returns the row key of an object
• valSel - A function that returns the value of an object