public static partial class np

{

/// <summary>

/// Load arrays or pickled objects from .npy, .npz or pickled files.<br></br>

///

/// Notes

/// </summary>

/// <param name="file">

/// The file to read.<br></br>

/// File-like objects must support the

/// seek() and read() methods.<br></br>

/// Pickled files require that the

/// file-like object support the readline() method as well.

/// </param>

/// <param name="mmap_mode">

/// If not None, then memory-map the file, using the given mode (see

/// numpy.memmap for a detailed description of the modes).<br></br>

/// A

/// memory-mapped array is kept on disk.<br></br>

/// However, it can be accessed

/// and sliced like any ndarray.<br></br>

/// Memory mapping is especially useful

/// for accessing small fragments of large files without reading the

/// entire file into memory.

/// </param>

/// <param name="allow_pickle">

/// Allow loading pickled object arrays stored in npy files.<br></br>

/// Reasons for

/// disallowing pickles include security, as loading pickled data can

/// execute arbitrary code.<br></br>

/// If pickles are disallowed, loading object

/// arrays will fail.<br></br>

///

/// Default: True

/// </param>

/// <param name="fix_imports">

/// Only useful when loading Python 2 generated pickled files on Python 3,

/// which includes npy/npz files containing object arrays.<br></br>

/// If fix_imports

/// is True, pickle will try to map the old Python 2 names to the new names

/// used in Python 3.

/// </param>

/// <param name="encoding">

/// What encoding to use when reading Python 2 strings.<br></br>

/// Only useful when

/// loading Python 2 generated pickled files in Python 3, which includes

/// npy/npz files containing object arrays.<br></br>

/// Values other than ‘latin1’,

/// ‘ASCII’, and ‘bytes’ are not allowed, as they can corrupt numerical

/// data.<br></br>

/// Default: ‘ASCII’

/// </param>

/// <returns>

/// Data stored in the file.<br></br>

/// For .npz files, the returned instance

/// of NpzFile class must be closed to avoid leaking file descriptors.

/// </returns>

public static NDarray load(string file, MemMapMode mmap_mode = null, bool? allow_pickle = false, bool? fix_imports = true, string encoding = "ASCII")

{

//auto-generated code, do not change

var __self__=self;

var pyargs=ToTuple(new object[]

{

file,

});

var kwargs=new PyDict();

if (mmap_mode!=null) kwargs["mmap_mode"]=ToPython(mmap_mode);

if (allow_pickle!=false) kwargs["allow_pickle"]=ToPython(allow_pickle);

if (fix_imports!=true) kwargs["fix_imports"]=ToPython(fix_imports);

if (encoding!="ASCII") kwargs["encoding"]=ToPython(encoding);

dynamic py = __self__.InvokeMethod("load", pyargs, kwargs);

return ToCsharp<NDarray>(py);

}

/// <summary>

/// Save an array to a text file.<br></br>

///

/// Notes

///

/// Further explanation of the fmt parameter

/// (%[flag]width[.precision]specifier):

///

/// This explanation of fmt is not complete, for an exhaustive

/// specification see [1].<br></br>

///

/// References

/// </summary>

/// <param name="fname">

/// If the filename ends in .gz, the file is automatically saved in

/// compressed gzip format.<br></br>

/// loadtxt understands gzipped files

/// transparently.

/// </param>

/// <param name="X">

/// Data to be saved to a text file.

/// </param>

/// <param name="fmt">

/// A single format (%10.5f), a sequence of formats, or a

/// multi-format string, e.g.<br></br>

/// ‘Iteration %d – %10.5f’, in which

/// case delimiter is ignored.<br></br>

/// For complex X, the legal options

/// for fmt are:

/// </param>

/// <param name="delimiter">

/// String or character separating columns.

/// </param>

/// <param name="newline">

/// String or character separating lines.

/// </param>

/// <param name="header">

/// String that will be written at the beginning of the file.

/// </param>

/// <param name="footer">

/// String that will be written at the end of the file.

/// </param>

/// <param name="comments">

/// String that will be prepended to the header and footer strings,

/// to mark them as comments.<br></br>

/// Default: ‘# ‘, as expected by e.g.<br></br>

///

/// numpy.loadtxt.

/// </param>

/// <param name="encoding">

/// Encoding used to encode the outputfile.<br></br>

/// Does not apply to output

/// streams.<br></br>

/// If the encoding is something other than ‘bytes’ or ‘latin1’

/// you will not be able to load the file in NumPy versions &lt; 1.14. Default

/// is ‘latin1’.

/// </param>

public static void savetxt(string fname, NDarray X, string[] fmt = null, string delimiter = " ", string newline = "\n", string header = "", string footer = "", string comments = null, string encoding = null)

{

//auto-generated code, do not change

var __self__=self;

var pyargs=ToTuple(new object[]

{

fname,

X,

});

var kwargs=new PyDict();

if (fmt!=null) kwargs["fmt"]=ToPython(fmt);

if (delimiter!=" ") kwargs["delimiter"]=ToPython(delimiter);

if (newline!="\n") kwargs["newline"]=ToPython(newline);

if (header!="") kwargs["header"]=ToPython(header);

if (footer!="") kwargs["footer"]=ToPython(footer);

if (comments!=null) kwargs["comments"]=ToPython(comments);

if (encoding!=null) kwargs["encoding"]=ToPython(encoding);

dynamic py = __self__.InvokeMethod("savetxt", pyargs, kwargs);

}

/*

/// <summary>

/// Construct an array from a text file, using regular expression parsing.<br></br>

///

/// The returned array is always a structured array, and is constructed from

/// all matches of the regular expression in the file.<br></br>

/// Groups in the regular

/// expression are converted to fields of the structured array.<br></br>

///

/// Notes

///

/// Dtypes for structured arrays can be specified in several forms, but all

/// forms specify at least the data type and field name.<br></br>

/// For details see

/// doc.structured_arrays.

/// </summary>

/// <param name="file">

/// File name or file object to read.

/// </param>

/// <param name="regexp">

/// Regular expression used to parse the file.<br></br>

///

/// Groups in the regular expression correspond to fields in the dtype.

/// </param>

/// <param name="dtype">

/// Dtype for the structured array.

/// </param>

/// <param name="encoding">

/// Encoding used to decode the inputfile.<br></br>

/// Does not apply to input streams.

/// </param>

/// <returns>

/// The output array, containing the part of the content of file that

/// was matched by regexp.<br></br>

/// output is always a structured array.

/// </returns>

public static NDarray fromregex(string file, string regexp, Dtype dtype, string encoding = null)

{

//auto-generated code, do not change

var __self__=self;

var pyargs=ToTuple(new object[]

{

file,

regexp,

dtype,

});

var kwargs=new PyDict();

if (encoding!=null) kwargs["encoding"]=ToPython(encoding);

dynamic py = __self__.InvokeMethod("fromregex", pyargs, kwargs);

return ToCsharp<NDarray>(py);

}

/// <summary>

/// Write array to a file as text or binary (default).<br></br>

///

/// Data is always written in ‘C’ order, independent of the order of a.<br></br>

///

/// The data produced by this method can be recovered using the function

/// fromfile().<br></br>

///

/// Notes

///

/// This is a convenience function for quick storage of array data.<br></br>

///

/// Information on endianness and precision is lost, so this method is not a

/// good choice for files intended to archive data or transport data between

/// machines with different endianness.<br></br>

/// Some of these problems can be overcome

/// by outputting the data as text files, at the expense of speed and file

/// size.<br></br>

///

/// When fid is a file object, array contents are directly written to the

/// file, bypassing the file object’s write method.<br></br>

/// As a result, tofile

/// cannot be used with files objects supporting compression (e.g., GzipFile)

/// or file-like objects that do not support fileno() (e.g., BytesIO).

/// </summary>

/// <param name="fid">

/// An open file object, or a string containing a filename.

/// </param>

/// <param name="sep">

/// Separator between array items for text output.<br></br>

///

/// If “” (empty), a binary file is written, equivalent to

/// file.write(a.tobytes()).

/// </param>

/// <param name="format">

/// Format string for text file output.<br></br>

///

/// Each entry in the array is formatted to text by first converting

/// it to the closest Python type, and then using “format” % item.

/// </param>

public static void tofile(string fid, string sep, string format)

{

//auto-generated code, do not change

var __self__=self;

var pyargs=ToTuple(new object[]

{

fid,

sep,

format,

});

var kwargs=new PyDict();

dynamic py = __self__.InvokeMethod("tofile", pyargs, kwargs);

}

/*

/*

/// <summary>

/// Return the string representation of an array.

/// </summary>

/// <param name="arr">

/// Input array.

/// </param>

/// <param name="max_line_width">

/// The maximum number of columns the string should span.<br></br>

/// Newline

/// characters split the string appropriately after array elements.

/// </param>

/// <param name="precision">

/// Floating point precision.<br></br>

/// Default is the current printing precision

/// (usually 8), which can be altered using set_printoptions.

/// </param>

/// <param name="suppress_small">

/// Represent very small numbers as zero, default is False.<br></br>

/// Very small

/// is defined by precision, if the precision is 8 then

/// numbers smaller than 5e-9 are represented as zero.

/// </param>

/// <returns>

/// The string representation of an array.

/// </returns>

public static string array_repr(NDarray arr, int? max_line_width = null, int? precision = null, bool? suppress_small = null)

{

//auto-generated code, do not change

var __self__=self;

var pyargs=ToTuple(new object[]

{

arr,

});

var kwargs=new PyDict();

if (max_line_width!=null) kwargs["max_line_width"]=ToPython(max_line_width);

if (precision!=null) kwargs["precision"]=ToPython(precision);

if (suppress_small!=null) kwargs["suppress_small"]=ToPython(suppress_small);

dynamic py = __self__.InvokeMethod("array_repr", pyargs, kwargs);

return ToCsharp<string>(py);

}

/// <summary>

/// Return a string representation of the data in an array.<br></br>

///

/// The data in the array is returned as a single string.<br></br>

/// This function is

/// similar to array_repr, the difference being that array_repr also

/// returns information on the kind of array and its data type.

/// </summary>

/// <param name="a">

/// Input array.

/// </param>

/// <param name="max_line_width">

/// Inserts newlines if text is longer than max_line_width.<br></br>

/// The

/// default is, indirectly, 75.

/// </param>

/// <param name="precision">

/// Floating point precision.<br></br>

/// Default is the current printing precision

/// (usually 8), which can be altered using set_printoptions.

/// </param>

/// <param name="suppress_small">

/// Represent numbers “very close” to zero as zero; default is False.<br></br>

///

/// Very close is defined by precision: if the precision is 8, e.g.,

/// numbers smaller (in absolute value) than 5e-9 are represented as

/// zero.

/// </param>

public static void array_str(NDarray a, int? max_line_width = null, int? precision = null, bool? suppress_small = null)

{

//auto-generated code, do not change

var __self__=self;

var pyargs=ToTuple(new object[]

{

a,

});

var kwargs=new PyDict();

if (max_line_width!=null) kwargs["max_line_width"]=ToPython(max_line_width);

if (precision!=null) kwargs["precision"]=ToPython(precision);

if (suppress_small!=null) kwargs["suppress_small"]=ToPython(suppress_small);

dynamic py = __self__.InvokeMethod("array_str", pyargs, kwargs);

}

/*

/*

/// <summary>

/// Create a memory-map to an array stored in a binary file on disk.<br></br>

///

/// Memory-mapped files are used for accessing small segments of large files

/// on disk, without reading the entire file into memory.<br></br>

/// NumPy’s

/// memmap’s are array-like objects.<br></br>

/// This differs from Python’s mmap

/// module, which uses file-like objects.<br></br>

///

/// This subclass of ndarray has some unpleasant interactions with

/// some operations, because it doesn’t quite fit properly as a subclass.<br></br>

///

/// An alternative to using this subclass is to create the mmap

/// object yourself, then create an ndarray with ndarray.__new__ directly,

/// passing the object created in its ‘buffer=’ parameter.<br></br>

///

/// This class may at some point be turned into a factory function

/// which returns a view into an mmap buffer.<br></br>

///

/// Delete the memmap instance to close the memmap file.<br></br>

///

/// Notes

///

/// The memmap object can be used anywhere an ndarray is accepted.<br></br>

///

/// Given a memmap fp, isinstance(fp, numpy.ndarray) returns

/// True.<br></br>

///

/// Memory-mapped files cannot be larger than 2GB on 32-bit systems.<br></br>

///

/// When a memmap causes a file to be created or extended beyond its

/// current size in the filesystem, the contents of the new part are

/// unspecified.<br></br>

/// On systems with POSIX filesystem semantics, the extended

/// part will be filled with zero bytes.

/// </summary>

/// <param name="filename">

/// The file name or file object to be used as the array data buffer.

/// </param>

/// <param name="dtype">

/// The data-type used to interpret the file contents.<br></br>

///

/// Default is uint8.

/// </param>

/// <param name="mode">

/// The file is opened in this mode:

///

/// Default is ‘r+’.

/// </param>

/// <param name="offset">

/// In the file, array data starts at this offset.<br></br>

/// Since offset is

/// measured in bytes, it should normally be a multiple of the byte-size

/// of dtype.<br></br>

/// When mode != 'r', even positive offsets beyond end of

/// file are valid; The file will be extended to accommodate the

/// additional data.<br></br>

/// By default, memmap will start at the beginning of

/// the file, even if filename is a file pointer fp and

/// fp.tell() != 0.

/// </param>

/// <param name="shape">

/// The desired shape of the array.<br></br>

/// If mode == 'r' and the number

/// of remaining bytes after offset is not a multiple of the byte-size

/// of dtype, you must specify shape.<br></br>

/// By default, the returned array

/// will be 1-D with the number of elements determined by file size

/// and data-type.

/// </param>

/// <param name="order">

/// Specify the order of the ndarray memory layout:

/// row-major, C-style or column-major,

/// Fortran-style.<br></br>

/// This only has an effect if the shape is

/// greater than 1-D.<br></br>

/// The default order is ‘C’.

/// </param>

public static void memmap(string filename, Dtype dtype = null, string mode = null, int? offset = null, Shape shape = null, string order = null)

{

//auto-generated code, do not change

var __self__=self;

var pyargs=ToTuple(new object[]

{

filename,

});

var kwargs=new PyDict();

if (dtype!=null) kwargs["dtype"]=ToPython(dtype);

if (mode!=null) kwargs["mode"]=ToPython(mode);

if (offset!=null) kwargs["offset"]=ToPython(offset);

if (shape!=null) kwargs["shape"]=ToPython(shape);

if (order!=null) kwargs["order"]=ToPython(order);

dynamic py = __self__.InvokeMethod("memmap", pyargs, kwargs);

}

/*