RdataFile.Write Method

Definition

Namespace: Extreme.Data.R
Assembly: Extreme.Data (in Extreme.Data.dll) Version: 3.2.0

Overload List

Write(Stream, IDictionary<String, DataFrame<Int64, String>>, Boolean, Boolean)	Writes the data frames in a collection to the specified file.
Write(Stream, IEnumerable<DataFrame<Int64, String>>, Boolean, Boolean)	Writes a sequence of data frames to the specified file.
Write(String, IDictionary<String, DataFrame<Int64, String>>, Boolean, Boolean)	Writes the data frames in a collection to the specified file.
Write(String, IEnumerable<DataFrame<Int64, String>>, Boolean, Boolean)	Writes a sequence of data frames to the specified file.
Write(Stream, DataFrame<Int64, String>, String, Boolean, Boolean)	Writes a data frame to the specified file.
Write(Stream, IEnumerable<DataFrame<Int64, String>>, IEnumerable<String>, Boolean, Boolean)	Writes a sequence of data frames to the specified file.
Write(String, DataFrame<Int64, String>, String, Boolean, Boolean)	Writes a data frame to the specified file.
Write(String, IEnumerable<DataFrame<Int64, String>>, IEnumerable<String>, Boolean, Boolean)	Writes a sequence of data frames to the specified file.
Write<T>(Stream, IDictionary<String, Matrix<T>>, Boolean, Boolean)	Writes the matrices in a collection to the specified file.
Write<T>(Stream, IDictionary<String, Vector<T>>, Boolean, Boolean)	Writes the vectors in a collection to the specified file.
Write<T>(Stream, IEnumerable<Matrix<T>>, Boolean, Boolean)	Writes a sequence of matrices to the specified file.
Write<T>(Stream, IEnumerable<Vector<T>>, Boolean, Boolean)	Writes a sequence of vectors to the specified file.
Write<T>(String, IDictionary<String, Matrix<T>>, Boolean, Boolean)	Writes the matrices in a collection to the specified file.
Write<T>(String, IDictionary<String, Vector<T>>, Boolean, Boolean)	Writes the vectors in a collection to the specified file.
Write<T>(String, IEnumerable<Matrix<T>>, Boolean, Boolean)	Writes a sequence of matrices to the specified file.
Write<T>(String, IEnumerable<Vector<T>>, Boolean, Boolean)	Writes a sequence of vectors to the specified file.
Write<T>(Stream, Matrix<T>, String, Boolean, Boolean)	Writes a matrix to the specified file.
Write<T>(Stream, Vector<T>, String, Boolean, Boolean)	Writes a vector to the specified file.
Write<T>(Stream, IEnumerable<Matrix<T>>, IEnumerable<String>, Boolean, Boolean)	Writes a sequence of matrices to the specified file.
Write<T>(Stream, IEnumerable<Vector<T>>, IEnumerable<String>, Boolean, Boolean)	Writes a sequence of vectors to the specified file.
Write<T>(String, Matrix<T>, String, Boolean, Boolean)	Writes a matrix to the specified file.
Write<T>(String, Vector<T>, String, Boolean, Boolean)	Writes a vector to the specified file.
Write<T>(String, IEnumerable<Matrix<T>>, IEnumerable<String>, Boolean, Boolean)	Writes a sequence of matrices to the specified file.
Write<T>(String, IEnumerable<Vector<T>>, IEnumerable<String>, Boolean, Boolean)	Writes a sequence of vectors to the specified file.
Write<R, C>(Stream, IDictionary<String, DataFrame<R, C>>, Boolean, Boolean)	Writes the data frames in a collection to the specified file.
Write<R, C>(Stream, IEnumerable<DataFrame<R, C>>, Boolean, Boolean)	Writes a sequence of data frames to the specified file.
Write<R, C>(String, IDictionary<String, DataFrame<R, C>>, Boolean, Boolean)	Writes the data frames in a collection to the specified file.
Write<R, C>(String, IEnumerable<DataFrame<R, C>>, Boolean, Boolean)	Writes a sequence of data frames to the specified file.
Write<R, C>(Stream, DataFrame<R, C>, String, Boolean, Boolean)	Writes a data frame to the specified file.
Write<R, C>(Stream, IEnumerable<DataFrame<R, C>>, IEnumerable<String>, Boolean, Boolean)	Writes a sequence of data frames to the specified file.
Write<R, C>(String, DataFrame<R, C>, String, Boolean, Boolean)	Writes a data frame to the specified file.
Write<R, C>(String, IEnumerable<DataFrame<R, C>>, IEnumerable<String>, Boolean, Boolean)	Writes a sequence of data frames to the specified file.

RdataFile.Write(Stream, IDictionary<String, DataFrame<Int64, String>>, Boolean, Boolean)

Writes the data frames in a collection to the specified file.

public static void Write(
	Stream stream,
	IDictionary<string, DataFrame<long, string>> dataFrames,
	bool compress = true,
	bool ascii = false
)

Visual Basic

Public Shared Sub Write ( 
	stream As Stream,
	dataFrames As IDictionary(Of String, DataFrame(Of Long, String)),
	Optional compress As Boolean = true,
	Optional ascii As Boolean = false
)

C++/CLI

public:
static void Write(
	Stream^ stream, 
	IDictionary<String^, DataFrame<long long, String^>^>^ dataFrames, 
	bool compress = true, 
	bool ascii = false
)

static member Write : 
        stream : Stream * 
        dataFrames : IDictionary<string, DataFrame<int64, string>> * 
        ?compress : bool * 
        ?ascii : bool 
(* Defaults:
        let _compress = defaultArg compress true
        let _ascii = defaultArg ascii false
*)
-> unit

Parameters

stream Stream: The stream to write the data frames to.
dataFrames IDictionary<String, DataFrame<Int64, String>>: A dictionary that maps names to the data frames to write.
compress Boolean (Optional): Optional. Specifies whether the data should be compressed. The default is true.
ascii Boolean (Optional): Optional. Specifies whether the data should be written in human-readable ASCII format. The default is false.

RdataFile.Write(Stream, IEnumerable<DataFrame<Int64, String>>, Boolean, Boolean)

Writes a sequence of data frames to the specified file.

public static void Write(
	Stream stream,
	IEnumerable<DataFrame<long, string>> dataFrames,
	bool compress = true,
	bool ascii = false
)

Visual Basic

Public Shared Sub Write ( 
	stream As Stream,
	dataFrames As IEnumerable(Of DataFrame(Of Long, String)),
	Optional compress As Boolean = true,
	Optional ascii As Boolean = false
)

C++/CLI

public:
static void Write(
	Stream^ stream, 
	IEnumerable<DataFrame<long long, String^>^>^ dataFrames, 
	bool compress = true, 
	bool ascii = false
)

static member Write : 
        stream : Stream * 
        dataFrames : IEnumerable<DataFrame<int64, string>> * 
        ?compress : bool * 
        ?ascii : bool 
(* Defaults:
        let _compress = defaultArg compress true
        let _ascii = defaultArg ascii false
*)
-> unit

Parameters

stream Stream: The stream to write the data frames to.
dataFrames IEnumerable<DataFrame<Int64, String>>: A sequence of data frames to write.
compress Boolean (Optional): Optional. Specifies whether the data should be compressed. The default is true.
ascii Boolean (Optional): Optional. Specifies whether the data should be written in human-readable ASCII format. The default is false.

RdataFile.Write<T>(Stream, IDictionary<String, Matrix<T>>, Boolean, Boolean)

Writes the matrices in a collection to the specified file.

public static void Write<T>(
	Stream stream,
	IDictionary<string, Matrix<T>> matrices,
	bool compress = true,
	bool ascii = false
)

Visual Basic

Public Shared Sub Write(Of T) ( 
	stream As Stream,
	matrices As IDictionary(Of String, Matrix(Of T)),
	Optional compress As Boolean = true,
	Optional ascii As Boolean = false
)

C++/CLI

public:
generic<typename T>
static void Write(
	Stream^ stream, 
	IDictionary<String^, Matrix<T>^>^ matrices, 
	bool compress = true, 
	bool ascii = false
)

static member Write : 
        stream : Stream * 
        matrices : IDictionary<string, Matrix<'T>> * 
        ?compress : bool * 
        ?ascii : bool 
(* Defaults:
        let _compress = defaultArg compress true
        let _ascii = defaultArg ascii false
*)
-> unit

Parameters

stream Stream: The stream to write the matrices to.
matrices IDictionary<String, Matrix<T>>: A dictionary that maps names to the matrices to write.
compress Boolean (Optional): Optional. Specifies whether the data should be compressed. The default is true.
ascii Boolean (Optional): Optional. Specifies whether the data should be written in human-readable ASCII format. The default is false.

Type Parameters

T: The type of the elements of the matrices.

RdataFile.Write<T>(Stream, IDictionary<String, Vector<T>>, Boolean, Boolean)

Writes the vectors in a collection to the specified file.

public static void Write<T>(
	Stream stream,
	IDictionary<string, Vector<T>> vectors,
	bool compress = true,
	bool ascii = false
)

Visual Basic

Public Shared Sub Write(Of T) ( 
	stream As Stream,
	vectors As IDictionary(Of String, Vector(Of T)),
	Optional compress As Boolean = true,
	Optional ascii As Boolean = false
)

C++/CLI

public:
generic<typename T>
static void Write(
	Stream^ stream, 
	IDictionary<String^, Vector<T>^>^ vectors, 
	bool compress = true, 
	bool ascii = false
)

static member Write : 
        stream : Stream * 
        vectors : IDictionary<string, Vector<'T>> * 
        ?compress : bool * 
        ?ascii : bool 
(* Defaults:
        let _compress = defaultArg compress true
        let _ascii = defaultArg ascii false
*)
-> unit

Parameters

stream Stream: The stream to write the vectors to.
vectors IDictionary<String, Vector<T>>: A dictionary that maps names to the vectors to write.
compress Boolean (Optional): Optional. Specifies whether the data should be compressed. The default is true.
ascii Boolean (Optional): Optional. Specifies whether the data should be written in human-readable ASCII format. The default is false.

Type Parameters

T: The type of the elements of the vectors.

RdataFile.Write<T>(Stream, IEnumerable<Matrix<T>>, Boolean, Boolean)

Writes a sequence of matrices to the specified file.

public static void Write<T>(
	Stream stream,
	IEnumerable<Matrix<T>> matrices,
	bool compress = true,
	bool ascii = false
)

Visual Basic

Public Shared Sub Write(Of T) ( 
	stream As Stream,
	matrices As IEnumerable(Of Matrix(Of T)),
	Optional compress As Boolean = true,
	Optional ascii As Boolean = false
)

C++/CLI

public:
generic<typename T>
static void Write(
	Stream^ stream, 
	IEnumerable<Matrix<T>^>^ matrices, 
	bool compress = true, 
	bool ascii = false
)

static member Write : 
        stream : Stream * 
        matrices : IEnumerable<Matrix<'T>> * 
        ?compress : bool * 
        ?ascii : bool 
(* Defaults:
        let _compress = defaultArg compress true
        let _ascii = defaultArg ascii false
*)
-> unit

Parameters

stream Stream: The stream to write the matrices to.
matrices IEnumerable<Matrix<T>>: A sequence of matrices to write.
compress Boolean (Optional): Optional. Specifies whether the data should be compressed. The default is true.
ascii Boolean (Optional): Optional. Specifies whether the data should be written in human-readable ASCII format. The default is false.

Type Parameters

T: The type of the elements of the matrices.

RdataFile.Write<T>(Stream, IEnumerable<Vector<T>>, Boolean, Boolean)

Writes a sequence of vectors to the specified file.

public static void Write<T>(
	Stream stream,
	IEnumerable<Vector<T>> vectors,
	bool compress = true,
	bool ascii = false
)

Visual Basic

Public Shared Sub Write(Of T) ( 
	stream As Stream,
	vectors As IEnumerable(Of Vector(Of T)),
	Optional compress As Boolean = true,
	Optional ascii As Boolean = false
)

C++/CLI

public:
generic<typename T>
static void Write(
	Stream^ stream, 
	IEnumerable<Vector<T>^>^ vectors, 
	bool compress = true, 
	bool ascii = false
)

static member Write : 
        stream : Stream * 
        vectors : IEnumerable<Vector<'T>> * 
        ?compress : bool * 
        ?ascii : bool 
(* Defaults:
        let _compress = defaultArg compress true
        let _ascii = defaultArg ascii false
*)
-> unit

Parameters

stream Stream: The stream to write the vectors to.
vectors IEnumerable<Vector<T>>: A sequence of vectors to write.
compress Boolean (Optional): Optional. Specifies whether the data should be compressed. The default is true.
ascii Boolean (Optional): Optional. Specifies whether the data should be written in human-readable ASCII format. The default is false.

Type Parameters

T: The type of the elements of the vectors.

RdataFile.Write<R, C>(Stream, IDictionary<String, DataFrame<R, C>>, Boolean, Boolean)

Writes the data frames in a collection to the specified file.

public static void Write<R, C>(
	Stream stream,
	IDictionary<string, DataFrame<R, C>> dataFrames,
	bool compress = true,
	bool ascii = false
)

Visual Basic

Public Shared Sub Write(Of R, C) ( 
	stream As Stream,
	dataFrames As IDictionary(Of String, DataFrame(Of R, C)),
	Optional compress As Boolean = true,
	Optional ascii As Boolean = false
)

C++/CLI

public:
generic<typename R, typename C>
static void Write(
	Stream^ stream, 
	IDictionary<String^, DataFrame<R, C>^>^ dataFrames, 
	bool compress = true, 
	bool ascii = false
)

static member Write : 
        stream : Stream * 
        dataFrames : IDictionary<string, DataFrame<'R, 'C>> * 
        ?compress : bool * 
        ?ascii : bool 
(* Defaults:
        let _compress = defaultArg compress true
        let _ascii = defaultArg ascii false
*)
-> unit

Parameters

stream Stream: The stream to write the data frames to.
dataFrames IDictionary<String, DataFrame<R, C>>: A dictionary that maps names to the data frames to write.
compress Boolean (Optional): Optional. Specifies whether the data should be compressed. The default is true.
ascii Boolean (Optional): Optional. Specifies whether the data should be written in human-readable ASCII format. The default is false.

Type Parameters

R: The type of the row keys of the data frames.
C: The type of the column keys of the data frames.

RdataFile.Write<R, C>(Stream, IEnumerable<DataFrame<R, C>>, Boolean, Boolean)

Writes a sequence of data frames to the specified file.

public static void Write<R, C>(
	Stream stream,
	IEnumerable<DataFrame<R, C>> dataFrames,
	bool compress = true,
	bool ascii = false
)

Visual Basic

Public Shared Sub Write(Of R, C) ( 
	stream As Stream,
	dataFrames As IEnumerable(Of DataFrame(Of R, C)),
	Optional compress As Boolean = true,
	Optional ascii As Boolean = false
)

C++/CLI

public:
generic<typename R, typename C>
static void Write(
	Stream^ stream, 
	IEnumerable<DataFrame<R, C>^>^ dataFrames, 
	bool compress = true, 
	bool ascii = false
)

static member Write : 
        stream : Stream * 
        dataFrames : IEnumerable<DataFrame<'R, 'C>> * 
        ?compress : bool * 
        ?ascii : bool 
(* Defaults:
        let _compress = defaultArg compress true
        let _ascii = defaultArg ascii false
*)
-> unit

Parameters

stream Stream: The stream to write the data frames to.
dataFrames IEnumerable<DataFrame<R, C>>: A sequence of data frames to write.
compress Boolean (Optional): Optional. Specifies whether the data should be compressed. The default is true.
ascii Boolean (Optional): Optional. Specifies whether the data should be written in human-readable ASCII format. The default is false.

Type Parameters

R: The type of the row keys of the data frames.
C: The type of the column keys of the data frames.

RdataFile.Write(String, IDictionary<String, DataFrame<Int64, String>>, Boolean, Boolean)

Writes the data frames in a collection to the specified file.

public static void Write(
	string path,
	IDictionary<string, DataFrame<long, string>> dataFrames,
	bool compress = true,
	bool ascii = false
)

Visual Basic

Public Shared Sub Write ( 
	path As String,
	dataFrames As IDictionary(Of String, DataFrame(Of Long, String)),
	Optional compress As Boolean = true,
	Optional ascii As Boolean = false
)

C++/CLI

public:
static void Write(
	String^ path, 
	IDictionary<String^, DataFrame<long long, String^>^>^ dataFrames, 
	bool compress = true, 
	bool ascii = false
)

static member Write : 
        path : string * 
        dataFrames : IDictionary<string, DataFrame<int64, string>> * 
        ?compress : bool * 
        ?ascii : bool 
(* Defaults:
        let _compress = defaultArg compress true
        let _ascii = defaultArg ascii false
*)
-> unit

Parameters

path String: The file to write the data frames to.
dataFrames IDictionary<String, DataFrame<Int64, String>>: A dictionary that maps names to the data frames to write.
compress Boolean (Optional): Optional. Specifies whether the data should be compressed. The default is true.
ascii Boolean (Optional): Optional. Specifies whether the data should be written in human-readable ASCII format. The default is false.

RdataFile.Write(String, IEnumerable<DataFrame<Int64, String>>, Boolean, Boolean)

Writes a sequence of data frames to the specified file.

public static void Write(
	string path,
	IEnumerable<DataFrame<long, string>> dataFrames,
	bool compress = true,
	bool ascii = false
)

Visual Basic

Public Shared Sub Write ( 
	path As String,
	dataFrames As IEnumerable(Of DataFrame(Of Long, String)),
	Optional compress As Boolean = true,
	Optional ascii As Boolean = false
)

C++/CLI

public:
static void Write(
	String^ path, 
	IEnumerable<DataFrame<long long, String^>^>^ dataFrames, 
	bool compress = true, 
	bool ascii = false
)

static member Write : 
        path : string * 
        dataFrames : IEnumerable<DataFrame<int64, string>> * 
        ?compress : bool * 
        ?ascii : bool 
(* Defaults:
        let _compress = defaultArg compress true
        let _ascii = defaultArg ascii false
*)
-> unit

Parameters

path String: The file to write the data frames to.
dataFrames IEnumerable<DataFrame<Int64, String>>: A sequence of data frames to write.
compress Boolean (Optional): Optional. Specifies whether the data should be compressed. The default is true.
ascii Boolean (Optional): Optional. Specifies whether the data should be written in human-readable ASCII format. The default is false.

RdataFile.Write<T>(String, IDictionary<String, Matrix<T>>, Boolean, Boolean)

Writes the matrices in a collection to the specified file.

public static void Write<T>(
	string path,
	IDictionary<string, Matrix<T>> matrices,
	bool compress = true,
	bool ascii = false
)

Visual Basic

Public Shared Sub Write(Of T) ( 
	path As String,
	matrices As IDictionary(Of String, Matrix(Of T)),
	Optional compress As Boolean = true,
	Optional ascii As Boolean = false
)

C++/CLI

public:
generic<typename T>
static void Write(
	String^ path, 
	IDictionary<String^, Matrix<T>^>^ matrices, 
	bool compress = true, 
	bool ascii = false
)

static member Write : 
        path : string * 
        matrices : IDictionary<string, Matrix<'T>> * 
        ?compress : bool * 
        ?ascii : bool 
(* Defaults:
        let _compress = defaultArg compress true
        let _ascii = defaultArg ascii false
*)
-> unit

Parameters

path String: The file to write the matrices to.
matrices IDictionary<String, Matrix<T>>: A dictionary that maps names to the matrices to write.
compress Boolean (Optional): Optional. Specifies whether the data should be compressed. The default is true.
ascii Boolean (Optional): Optional. Specifies whether the data should be written in human-readable ASCII format. The default is false.

Type Parameters

T: The type of the elements of the matrices.

RdataFile.Write<T>(String, IDictionary<String, Vector<T>>, Boolean, Boolean)

Writes the vectors in a collection to the specified file.

public static void Write<T>(
	string path,
	IDictionary<string, Vector<T>> vectors,
	bool compress = true,
	bool ascii = false
)

Visual Basic

Public Shared Sub Write(Of T) ( 
	path As String,
	vectors As IDictionary(Of String, Vector(Of T)),
	Optional compress As Boolean = true,
	Optional ascii As Boolean = false
)

C++/CLI

public:
generic<typename T>
static void Write(
	String^ path, 
	IDictionary<String^, Vector<T>^>^ vectors, 
	bool compress = true, 
	bool ascii = false
)

static member Write : 
        path : string * 
        vectors : IDictionary<string, Vector<'T>> * 
        ?compress : bool * 
        ?ascii : bool 
(* Defaults:
        let _compress = defaultArg compress true
        let _ascii = defaultArg ascii false
*)
-> unit

Parameters

path String: The file to write the vectors to.
vectors IDictionary<String, Vector<T>>: A dictionary that maps names to the vectors to write.
compress Boolean (Optional): Optional. Specifies whether the data should be compressed. The default is true.
ascii Boolean (Optional): Optional. Specifies whether the data should be written in human-readable ASCII format. The default is false.

Type Parameters

T: The type of the elements of the vectors.

RdataFile.Write<T>(String, IEnumerable<Matrix<T>>, Boolean, Boolean)

Writes a sequence of matrices to the specified file.

public static void Write<T>(
	string path,
	IEnumerable<Matrix<T>> matrices,
	bool compress = true,
	bool ascii = false
)

Visual Basic

Public Shared Sub Write(Of T) ( 
	path As String,
	matrices As IEnumerable(Of Matrix(Of T)),
	Optional compress As Boolean = true,
	Optional ascii As Boolean = false
)

C++/CLI

public:
generic<typename T>
static void Write(
	String^ path, 
	IEnumerable<Matrix<T>^>^ matrices, 
	bool compress = true, 
	bool ascii = false
)

static member Write : 
        path : string * 
        matrices : IEnumerable<Matrix<'T>> * 
        ?compress : bool * 
        ?ascii : bool 
(* Defaults:
        let _compress = defaultArg compress true
        let _ascii = defaultArg ascii false
*)
-> unit

Parameters

path String: The file to write the matrices to.
matrices IEnumerable<Matrix<T>>: A sequence of matrices to write.
compress Boolean (Optional): Optional. Specifies whether the data should be compressed. The default is true.
ascii Boolean (Optional): Optional. Specifies whether the data should be written in human-readable ASCII format. The default is false.

Type Parameters

T: The type of the elements of the matrices.

RdataFile.Write<T>(String, IEnumerable<Vector<T>>, Boolean, Boolean)

Writes a sequence of vectors to the specified file.

public static void Write<T>(
	string path,
	IEnumerable<Vector<T>> vectors,
	bool compress = true,
	bool ascii = false
)

Visual Basic

Public Shared Sub Write(Of T) ( 
	path As String,
	vectors As IEnumerable(Of Vector(Of T)),
	Optional compress As Boolean = true,
	Optional ascii As Boolean = false
)

C++/CLI

public:
generic<typename T>
static void Write(
	String^ path, 
	IEnumerable<Vector<T>^>^ vectors, 
	bool compress = true, 
	bool ascii = false
)

static member Write : 
        path : string * 
        vectors : IEnumerable<Vector<'T>> * 
        ?compress : bool * 
        ?ascii : bool 
(* Defaults:
        let _compress = defaultArg compress true
        let _ascii = defaultArg ascii false
*)
-> unit

Parameters

path String: The file to write the vectors to.
vectors IEnumerable<Vector<T>>: A sequence of vectors to write.
compress Boolean (Optional): Optional. Specifies whether the data should be compressed. The default is true.
ascii Boolean (Optional): Optional. Specifies whether the data should be written in human-readable ASCII format. The default is false.

Type Parameters

T: The type of the elements of the vectors.

RdataFile.Write<R, C>(String, IDictionary<String, DataFrame<R, C>>, Boolean, Boolean)

Writes the data frames in a collection to the specified file.

public static void Write<R, C>(
	string path,
	IDictionary<string, DataFrame<R, C>> dataFrames,
	bool compress = true,
	bool ascii = false
)

Visual Basic

Public Shared Sub Write(Of R, C) ( 
	path As String,
	dataFrames As IDictionary(Of String, DataFrame(Of R, C)),
	Optional compress As Boolean = true,
	Optional ascii As Boolean = false
)

C++/CLI

public:
generic<typename R, typename C>
static void Write(
	String^ path, 
	IDictionary<String^, DataFrame<R, C>^>^ dataFrames, 
	bool compress = true, 
	bool ascii = false
)

static member Write : 
        path : string * 
        dataFrames : IDictionary<string, DataFrame<'R, 'C>> * 
        ?compress : bool * 
        ?ascii : bool 
(* Defaults:
        let _compress = defaultArg compress true
        let _ascii = defaultArg ascii false
*)
-> unit

Parameters

path String: The file to write the data frames to.
dataFrames IDictionary<String, DataFrame<R, C>>: A dictionary that maps names to the data frames to write.
compress Boolean (Optional): Optional. Specifies whether the data should be compressed. The default is true.
ascii Boolean (Optional): Optional. Specifies whether the data should be written in human-readable ASCII format. The default is false.

Type Parameters

R: The type of the row keys of the data frames.
C: The type of the column keys of the data frames.

RdataFile.Write<R, C>(String, IEnumerable<DataFrame<R, C>>, Boolean, Boolean)

Writes a sequence of data frames to the specified file.

public static void Write<R, C>(
	string path,
	IEnumerable<DataFrame<R, C>> dataFrames,
	bool compress = true,
	bool ascii = false
)

Visual Basic

Public Shared Sub Write(Of R, C) ( 
	path As String,
	dataFrames As IEnumerable(Of DataFrame(Of R, C)),
	Optional compress As Boolean = true,
	Optional ascii As Boolean = false
)

C++/CLI

public:
generic<typename R, typename C>
static void Write(
	String^ path, 
	IEnumerable<DataFrame<R, C>^>^ dataFrames, 
	bool compress = true, 
	bool ascii = false
)

static member Write : 
        path : string * 
        dataFrames : IEnumerable<DataFrame<'R, 'C>> * 
        ?compress : bool * 
        ?ascii : bool 
(* Defaults:
        let _compress = defaultArg compress true
        let _ascii = defaultArg ascii false
*)
-> unit

Parameters

path String: The file to write the data frames to.
dataFrames IEnumerable<DataFrame<R, C>>: A sequence of data frames to write.
compress Boolean (Optional): Optional. Specifies whether the data should be compressed. The default is true.
ascii Boolean (Optional): Optional. Specifies whether the data should be written in human-readable ASCII format. The default is false.

Type Parameters

R: The type of the row keys of the data frames.
C: The type of the column keys of the data frames.

RdataFile.Write(Stream, DataFrame<Int64, String>, String, Boolean, Boolean)

Writes a data frame to the specified file.

public static void Write(
	Stream stream,
	DataFrame<long, string> dataFrame,
	string name = "df",
	bool compress = true,
	bool ascii = false
)

Visual Basic

Public Shared Sub Write ( 
	stream As Stream,
	dataFrame As DataFrame(Of Long, String),
	Optional name As String = "df",
	Optional compress As Boolean = true,
	Optional ascii As Boolean = false
)

C++/CLI

public:
static void Write(
	Stream^ stream, 
	DataFrame<long long, String^>^ dataFrame, 
	String^ name = L"df", 
	bool compress = true, 
	bool ascii = false
)

static member Write : 
        stream : Stream * 
        dataFrame : DataFrame<int64, string> * 
        ?name : string * 
        ?compress : bool * 
        ?ascii : bool 
(* Defaults:
        let _name = defaultArg name "df"
        let _compress = defaultArg compress true
        let _ascii = defaultArg ascii false
*)
-> unit

Parameters

stream Stream: The stream to write the data frame to.
dataFrame DataFrame<Int64, String>: The data frame to write.
name String (Optional): A name for the data frame. The default is df.
compress Boolean (Optional): Optional. Specifies whether the data should be compressed. The default is true.
ascii Boolean (Optional): Optional. Specifies whether the data should be written in human-readable ASCII format. The default is false.

RdataFile.Write(Stream, IEnumerable<DataFrame<Int64, String>>, IEnumerable<String>, Boolean, Boolean)

Writes a sequence of data frames to the specified file.

public static void Write(
	Stream stream,
	IEnumerable<DataFrame<long, string>> dataFrames,
	IEnumerable<string> names,
	bool compress = true,
	bool ascii = false
)

Visual Basic

Public Shared Sub Write ( 
	stream As Stream,
	dataFrames As IEnumerable(Of DataFrame(Of Long, String)),
	names As IEnumerable(Of String),
	Optional compress As Boolean = true,
	Optional ascii As Boolean = false
)

C++/CLI

public:
static void Write(
	Stream^ stream, 
	IEnumerable<DataFrame<long long, String^>^>^ dataFrames, 
	IEnumerable<String^>^ names, 
	bool compress = true, 
	bool ascii = false
)

static member Write : 
        stream : Stream * 
        dataFrames : IEnumerable<DataFrame<int64, string>> * 
        names : IEnumerable<string> * 
        ?compress : bool * 
        ?ascii : bool 
(* Defaults:
        let _compress = defaultArg compress true
        let _ascii = defaultArg ascii false
*)
-> unit

Parameters

stream Stream: The stream to write the data frames to.
dataFrames IEnumerable<DataFrame<Int64, String>>: A sequence of data frames to write.
names IEnumerable<String>: A sequence of corresponding names for the data frames.
compress Boolean (Optional): Optional. Specifies whether the data should be compressed. The default is true.
ascii Boolean (Optional): Optional. Specifies whether the data should be written in human-readable ASCII format. The default is false.

RdataFile.Write<T>(Stream, Matrix<T>, String, Boolean, Boolean)

Writes a matrix to the specified file.

public static void Write<T>(
	Stream stream,
	Matrix<T> matrix,
	string name = "matrix",
	bool compress = true,
	bool ascii = false
)

Visual Basic

Public Shared Sub Write(Of T) ( 
	stream As Stream,
	matrix As Matrix(Of T),
	Optional name As String = "matrix",
	Optional compress As Boolean = true,
	Optional ascii As Boolean = false
)

C++/CLI

public:
generic<typename T>
static void Write(
	Stream^ stream, 
	Matrix<T>^ matrix, 
	String^ name = L"matrix", 
	bool compress = true, 
	bool ascii = false
)

static member Write : 
        stream : Stream * 
        matrix : Matrix<'T> * 
        ?name : string * 
        ?compress : bool * 
        ?ascii : bool 
(* Defaults:
        let _name = defaultArg name "matrix"
        let _compress = defaultArg compress true
        let _ascii = defaultArg ascii false
*)
-> unit

Parameters

stream Stream: The stream to write the matrix to.
matrix Matrix<T>: The matrix to write.
name String (Optional): A name for the matrix. The default is matrix.
compress Boolean (Optional): Optional. Specifies whether the data should be compressed. The default is true.
ascii Boolean (Optional): Optional. Specifies whether the data should be written in human-readable ASCII format. The default is false.

Type Parameters

T: The type of the elements of the matrix.

RdataFile.Write<T>(Stream, Vector<T>, String, Boolean, Boolean)

Writes a vector to the specified file.

public static void Write<T>(
	Stream stream,
	Vector<T> vector,
	string name = "vector",
	bool compress = true,
	bool ascii = false
)

Visual Basic

Public Shared Sub Write(Of T) ( 
	stream As Stream,
	vector As Vector(Of T),
	Optional name As String = "vector",
	Optional compress As Boolean = true,
	Optional ascii As Boolean = false
)

C++/CLI

public:
generic<typename T>
static void Write(
	Stream^ stream, 
	Vector<T>^ vector, 
	String^ name = L"vector", 
	bool compress = true, 
	bool ascii = false
)

static member Write : 
        stream : Stream * 
        vector : Vector<'T> * 
        ?name : string * 
        ?compress : bool * 
        ?ascii : bool 
(* Defaults:
        let _name = defaultArg name "vector"
        let _compress = defaultArg compress true
        let _ascii = defaultArg ascii false
*)
-> unit

Parameters

stream Stream: The stream to write the vector to.
vector Vector<T>: The vector to write.
name String (Optional): A name for the vector. The default is vector.
compress Boolean (Optional): Optional. Specifies whether the data should be compressed. The default is true.
ascii Boolean (Optional): Optional. Specifies whether the data should be written in human-readable ASCII format. The default is false.

Type Parameters

T: The type of the elements of the vector.

RdataFile.Write<T>(Stream, IEnumerable<Matrix<T>>, IEnumerable<String>, Boolean, Boolean)

Writes a sequence of matrices to the specified file.

public static void Write<T>(
	Stream stream,
	IEnumerable<Matrix<T>> matrices,
	IEnumerable<string> names,
	bool compress = true,
	bool ascii = false
)

Visual Basic

Public Shared Sub Write(Of T) ( 
	stream As Stream,
	matrices As IEnumerable(Of Matrix(Of T)),
	names As IEnumerable(Of String),
	Optional compress As Boolean = true,
	Optional ascii As Boolean = false
)

C++/CLI

public:
generic<typename T>
static void Write(
	Stream^ stream, 
	IEnumerable<Matrix<T>^>^ matrices, 
	IEnumerable<String^>^ names, 
	bool compress = true, 
	bool ascii = false
)

static member Write : 
        stream : Stream * 
        matrices : IEnumerable<Matrix<'T>> * 
        names : IEnumerable<string> * 
        ?compress : bool * 
        ?ascii : bool 
(* Defaults:
        let _compress = defaultArg compress true
        let _ascii = defaultArg ascii false
*)
-> unit

Parameters

stream Stream: The stream to write the matrices to.
matrices IEnumerable<Matrix<T>>: A sequence of matrices to write.
names IEnumerable<String>: A sequence of corresponding names for the matrices.
compress Boolean (Optional): Optional. Specifies whether the data should be compressed. The default is true.
ascii Boolean (Optional): Optional. Specifies whether the data should be written in human-readable ASCII format. The default is false.

Type Parameters

T: The type of the elements of the matrices.

RdataFile.Write<T>(Stream, IEnumerable<Vector<T>>, IEnumerable<String>, Boolean, Boolean)

Writes a sequence of vectors to the specified file.

public static void Write<T>(
	Stream stream,
	IEnumerable<Vector<T>> vectors,
	IEnumerable<string> names,
	bool compress = true,
	bool ascii = false
)

Visual Basic

Public Shared Sub Write(Of T) ( 
	stream As Stream,
	vectors As IEnumerable(Of Vector(Of T)),
	names As IEnumerable(Of String),
	Optional compress As Boolean = true,
	Optional ascii As Boolean = false
)

C++/CLI

public:
generic<typename T>
static void Write(
	Stream^ stream, 
	IEnumerable<Vector<T>^>^ vectors, 
	IEnumerable<String^>^ names, 
	bool compress = true, 
	bool ascii = false
)

static member Write : 
        stream : Stream * 
        vectors : IEnumerable<Vector<'T>> * 
        names : IEnumerable<string> * 
        ?compress : bool * 
        ?ascii : bool 
(* Defaults:
        let _compress = defaultArg compress true
        let _ascii = defaultArg ascii false
*)
-> unit

Parameters

stream Stream: The stream to write the vectors to.
vectors IEnumerable<Vector<T>>: A sequence of vectors to write.
names IEnumerable<String>: A sequence of corresponding names for the vectors.
compress Boolean (Optional): Optional. Specifies whether the data should be compressed. The default is true.
ascii Boolean (Optional): Optional. Specifies whether the data should be written in human-readable ASCII format. The default is false.

Type Parameters

T: The type of the elements of the vectors.

RdataFile.Write<R, C>(Stream, DataFrame<R, C>, String, Boolean, Boolean)

Writes a data frame to the specified file.

public static void Write<R, C>(
	Stream stream,
	DataFrame<R, C> dataFrame,
	string name = "df",
	bool compress = true,
	bool ascii = false
)

Visual Basic

Public Shared Sub Write(Of R, C) ( 
	stream As Stream,
	dataFrame As DataFrame(Of R, C),
	Optional name As String = "df",
	Optional compress As Boolean = true,
	Optional ascii As Boolean = false
)

C++/CLI

public:
generic<typename R, typename C>
static void Write(
	Stream^ stream, 
	DataFrame<R, C>^ dataFrame, 
	String^ name = L"df", 
	bool compress = true, 
	bool ascii = false
)

static member Write : 
        stream : Stream * 
        dataFrame : DataFrame<'R, 'C> * 
        ?name : string * 
        ?compress : bool * 
        ?ascii : bool 
(* Defaults:
        let _name = defaultArg name "df"
        let _compress = defaultArg compress true
        let _ascii = defaultArg ascii false
*)
-> unit

Parameters

stream Stream: The stream to write the data frame to.
dataFrame DataFrame<R, C>: The data frame to write.
name String (Optional): A name for the data frame. The default is df.
compress Boolean (Optional): Optional. Specifies whether the data should be compressed. The default is true.
ascii Boolean (Optional): Optional. Specifies whether the data should be written in human-readable ASCII format. The default is false.

Type Parameters

R: The type of the row keys of the data frame.
C: The type of the column keys of the data frame.

RdataFile.Write<R, C>(Stream, IEnumerable<DataFrame<R, C>>, IEnumerable<String>, Boolean, Boolean)

Writes a sequence of data frames to the specified file.

public static void Write<R, C>(
	Stream stream,
	IEnumerable<DataFrame<R, C>> dataFrames,
	IEnumerable<string> names,
	bool compress = true,
	bool ascii = false
)

Visual Basic

Public Shared Sub Write(Of R, C) ( 
	stream As Stream,
	dataFrames As IEnumerable(Of DataFrame(Of R, C)),
	names As IEnumerable(Of String),
	Optional compress As Boolean = true,
	Optional ascii As Boolean = false
)

C++/CLI

public:
generic<typename R, typename C>
static void Write(
	Stream^ stream, 
	IEnumerable<DataFrame<R, C>^>^ dataFrames, 
	IEnumerable<String^>^ names, 
	bool compress = true, 
	bool ascii = false
)

static member Write : 
        stream : Stream * 
        dataFrames : IEnumerable<DataFrame<'R, 'C>> * 
        names : IEnumerable<string> * 
        ?compress : bool * 
        ?ascii : bool 
(* Defaults:
        let _compress = defaultArg compress true
        let _ascii = defaultArg ascii false
*)
-> unit

Parameters

stream Stream: The stream to write the data frames to.
dataFrames IEnumerable<DataFrame<R, C>>: A sequence of data frames to write.
names IEnumerable<String>: A sequence of corresponding names for the data frames.
compress Boolean (Optional): Optional. Specifies whether the data should be compressed. The default is true.
ascii Boolean (Optional): Optional. Specifies whether the data should be written in human-readable ASCII format. The default is false.

Type Parameters

R: The type of the row keys of the data frames.
C: The type of the column keys of the data frames.

RdataFile.Write(String, DataFrame<Int64, String>, String, Boolean, Boolean)

Writes a data frame to the specified file.

public static void Write(
	string path,
	DataFrame<long, string> dataFrame,
	string name = "df",
	bool compress = true,
	bool ascii = false
)

Visual Basic

Public Shared Sub Write ( 
	path As String,
	dataFrame As DataFrame(Of Long, String),
	Optional name As String = "df",
	Optional compress As Boolean = true,
	Optional ascii As Boolean = false
)

C++/CLI

public:
static void Write(
	String^ path, 
	DataFrame<long long, String^>^ dataFrame, 
	String^ name = L"df", 
	bool compress = true, 
	bool ascii = false
)

static member Write : 
        path : string * 
        dataFrame : DataFrame<int64, string> * 
        ?name : string * 
        ?compress : bool * 
        ?ascii : bool 
(* Defaults:
        let _name = defaultArg name "df"
        let _compress = defaultArg compress true
        let _ascii = defaultArg ascii false
*)
-> unit

Parameters

path String: The file to write the data frame to.
dataFrame DataFrame<Int64, String>: The data frame to write.
name String (Optional): A name for the data frame. The default is df.
compress Boolean (Optional): Optional. Specifies whether the data should be compressed. The default is true.
ascii Boolean (Optional): Optional. Specifies whether the data should be written in human-readable ASCII format. The default is false.

RdataFile.Write(String, IEnumerable<DataFrame<Int64, String>>, IEnumerable<String>, Boolean, Boolean)

Writes a sequence of data frames to the specified file.

public static void Write(
	string path,
	IEnumerable<DataFrame<long, string>> dataFrames,
	IEnumerable<string> names,
	bool compress = true,
	bool ascii = false
)

Visual Basic

Public Shared Sub Write ( 
	path As String,
	dataFrames As IEnumerable(Of DataFrame(Of Long, String)),
	names As IEnumerable(Of String),
	Optional compress As Boolean = true,
	Optional ascii As Boolean = false
)

C++/CLI

public:
static void Write(
	String^ path, 
	IEnumerable<DataFrame<long long, String^>^>^ dataFrames, 
	IEnumerable<String^>^ names, 
	bool compress = true, 
	bool ascii = false
)

static member Write : 
        path : string * 
        dataFrames : IEnumerable<DataFrame<int64, string>> * 
        names : IEnumerable<string> * 
        ?compress : bool * 
        ?ascii : bool 
(* Defaults:
        let _compress = defaultArg compress true
        let _ascii = defaultArg ascii false
*)
-> unit

Parameters

path String: The file to write the data frames to.
dataFrames IEnumerable<DataFrame<Int64, String>>: A sequence of data frames to write.
names IEnumerable<String>: A sequence of corresponding names for the data frames.
compress Boolean (Optional): Optional. Specifies whether the data should be compressed. The default is true.
ascii Boolean (Optional): Optional. Specifies whether the data should be written in human-readable ASCII format. The default is false.

RdataFile.Write<T>(String, Matrix<T>, String, Boolean, Boolean)

Writes a matrix to the specified file.

public static void Write<T>(
	string path,
	Matrix<T> matrix,
	string name = "matrix",
	bool compress = true,
	bool ascii = false
)

Visual Basic

Public Shared Sub Write(Of T) ( 
	path As String,
	matrix As Matrix(Of T),
	Optional name As String = "matrix",
	Optional compress As Boolean = true,
	Optional ascii As Boolean = false
)

C++/CLI

public:
generic<typename T>
static void Write(
	String^ path, 
	Matrix<T>^ matrix, 
	String^ name = L"matrix", 
	bool compress = true, 
	bool ascii = false
)

static member Write : 
        path : string * 
        matrix : Matrix<'T> * 
        ?name : string * 
        ?compress : bool * 
        ?ascii : bool 
(* Defaults:
        let _name = defaultArg name "matrix"
        let _compress = defaultArg compress true
        let _ascii = defaultArg ascii false
*)
-> unit

Parameters

path String: The file to write the matrix to.
matrix Matrix<T>: The matrix to write.
name String (Optional): A name for the matrix. The default is matrix.
compress Boolean (Optional): Optional. Specifies whether the data should be compressed. The default is true.
ascii Boolean (Optional): Optional. Specifies whether the data should be written in human-readable ASCII format. The default is false.

Type Parameters

T: The type of the elements of the matrix.

RdataFile.Write<T>(String, Vector<T>, String, Boolean, Boolean)

Writes a vector to the specified file.

public static void Write<T>(
	string path,
	Vector<T> vector,
	string name = "vector",
	bool compress = true,
	bool ascii = false
)

Visual Basic

Public Shared Sub Write(Of T) ( 
	path As String,
	vector As Vector(Of T),
	Optional name As String = "vector",
	Optional compress As Boolean = true,
	Optional ascii As Boolean = false
)

C++/CLI

public:
generic<typename T>
static void Write(
	String^ path, 
	Vector<T>^ vector, 
	String^ name = L"vector", 
	bool compress = true, 
	bool ascii = false
)

static member Write : 
        path : string * 
        vector : Vector<'T> * 
        ?name : string * 
        ?compress : bool * 
        ?ascii : bool 
(* Defaults:
        let _name = defaultArg name "vector"
        let _compress = defaultArg compress true
        let _ascii = defaultArg ascii false
*)
-> unit

Parameters

path String: The file to write the vector to.
vector Vector<T>: The vector to write.
name String (Optional): A name for the vector. The default is vector.
compress Boolean (Optional): Optional. Specifies whether the data should be compressed. The default is true.
ascii Boolean (Optional): Optional. Specifies whether the data should be written in human-readable ASCII format. The default is false.

Type Parameters

T: The type of the elements of the vector.

RdataFile.Write<T>(String, IEnumerable<Matrix<T>>, IEnumerable<String>, Boolean, Boolean)

Writes a sequence of matrices to the specified file.

public static void Write<T>(
	string path,
	IEnumerable<Matrix<T>> matrices,
	IEnumerable<string> names,
	bool compress = true,
	bool ascii = false
)

Visual Basic

Public Shared Sub Write(Of T) ( 
	path As String,
	matrices As IEnumerable(Of Matrix(Of T)),
	names As IEnumerable(Of String),
	Optional compress As Boolean = true,
	Optional ascii As Boolean = false
)

C++/CLI

public:
generic<typename T>
static void Write(
	String^ path, 
	IEnumerable<Matrix<T>^>^ matrices, 
	IEnumerable<String^>^ names, 
	bool compress = true, 
	bool ascii = false
)

static member Write : 
        path : string * 
        matrices : IEnumerable<Matrix<'T>> * 
        names : IEnumerable<string> * 
        ?compress : bool * 
        ?ascii : bool 
(* Defaults:
        let _compress = defaultArg compress true
        let _ascii = defaultArg ascii false
*)
-> unit

Parameters

path String: The file to write the matrices to.
matrices IEnumerable<Matrix<T>>: A sequence of matrices to write.
names IEnumerable<String>: A sequence of corresponding names for the matrices.
compress Boolean (Optional): Optional. Specifies whether the data should be compressed. The default is true.
ascii Boolean (Optional): Optional. Specifies whether the data should be written in human-readable ASCII format. The default is false.

Type Parameters

T: The type of the elements of the matrices.

RdataFile.Write<T>(String, IEnumerable<Vector<T>>, IEnumerable<String>, Boolean, Boolean)

Writes a sequence of vectors to the specified file.

public static void Write<T>(
	string path,
	IEnumerable<Vector<T>> vectors,
	IEnumerable<string> names,
	bool compress = true,
	bool ascii = false
)

Visual Basic

Public Shared Sub Write(Of T) ( 
	path As String,
	vectors As IEnumerable(Of Vector(Of T)),
	names As IEnumerable(Of String),
	Optional compress As Boolean = true,
	Optional ascii As Boolean = false
)

C++/CLI

public:
generic<typename T>
static void Write(
	String^ path, 
	IEnumerable<Vector<T>^>^ vectors, 
	IEnumerable<String^>^ names, 
	bool compress = true, 
	bool ascii = false
)

static member Write : 
        path : string * 
        vectors : IEnumerable<Vector<'T>> * 
        names : IEnumerable<string> * 
        ?compress : bool * 
        ?ascii : bool 
(* Defaults:
        let _compress = defaultArg compress true
        let _ascii = defaultArg ascii false
*)
-> unit

Parameters

path String: The file to write the vectors to.
vectors IEnumerable<Vector<T>>: A sequence of vectors to write.
names IEnumerable<String>: A sequence of corresponding names for the vectors.
compress Boolean (Optional): Optional. Specifies whether the data should be compressed. The default is true.
ascii Boolean (Optional): Optional. Specifies whether the data should be written in human-readable ASCII format. The default is false.

Type Parameters

T: The type of the elements of the vectors.

RdataFile.Write<R, C>(String, DataFrame<R, C>, String, Boolean, Boolean)

Writes a data frame to the specified file.

public static void Write<R, C>(
	string path,
	DataFrame<R, C> dataFrame,
	string name = "df",
	bool compress = true,
	bool ascii = false
)

Visual Basic

Public Shared Sub Write(Of R, C) ( 
	path As String,
	dataFrame As DataFrame(Of R, C),
	Optional name As String = "df",
	Optional compress As Boolean = true,
	Optional ascii As Boolean = false
)

C++/CLI

public:
generic<typename R, typename C>
static void Write(
	String^ path, 
	DataFrame<R, C>^ dataFrame, 
	String^ name = L"df", 
	bool compress = true, 
	bool ascii = false
)

static member Write : 
        path : string * 
        dataFrame : DataFrame<'R, 'C> * 
        ?name : string * 
        ?compress : bool * 
        ?ascii : bool 
(* Defaults:
        let _name = defaultArg name "df"
        let _compress = defaultArg compress true
        let _ascii = defaultArg ascii false
*)
-> unit

Parameters

path String: The file to write the data frame to.
dataFrame DataFrame<R, C>: The data frame to write.
name String (Optional): A name for the data frame. The default is df.
compress Boolean (Optional): Optional. Specifies whether the data should be compressed. The default is true.
ascii Boolean (Optional): Optional. Specifies whether the data should be written in human-readable ASCII format. The default is false.

Type Parameters

R: The type of the row keys of the data frame.
C: The type of the column keys of the data frame.

RdataFile.Write<R, C>(String, IEnumerable<DataFrame<R, C>>, IEnumerable<String>, Boolean, Boolean)

Writes a sequence of data frames to the specified file.

public static void Write<R, C>(
	string path,
	IEnumerable<DataFrame<R, C>> dataFrames,
	IEnumerable<string> names,
	bool compress = true,
	bool ascii = false
)

Visual Basic

Public Shared Sub Write(Of R, C) ( 
	path As String,
	dataFrames As IEnumerable(Of DataFrame(Of R, C)),
	names As IEnumerable(Of String),
	Optional compress As Boolean = true,
	Optional ascii As Boolean = false
)

C++/CLI

public:
generic<typename R, typename C>
static void Write(
	String^ path, 
	IEnumerable<DataFrame<R, C>^>^ dataFrames, 
	IEnumerable<String^>^ names, 
	bool compress = true, 
	bool ascii = false
)

static member Write : 
        path : string * 
        dataFrames : IEnumerable<DataFrame<'R, 'C>> * 
        names : IEnumerable<string> * 
        ?compress : bool * 
        ?ascii : bool 
(* Defaults:
        let _compress = defaultArg compress true
        let _ascii = defaultArg ascii false
*)
-> unit

Parameters

path String: The file to write the data frames to.
dataFrames IEnumerable<DataFrame<R, C>>: A sequence of data frames to write.
names IEnumerable<String>: A sequence of corresponding names for the data frames.
compress Boolean (Optional): Optional. Specifies whether the data should be compressed. The default is true.
ascii Boolean (Optional): Optional. Specifies whether the data should be written in human-readable ASCII format. The default is false.

Type Parameters

R: The type of the row keys of the data frames.
C: The type of the column keys of the data frames.