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 = true, bool? fix_imports = true, string encoding = "ASCII")

=> NumPy.Instance.load(file, mmap_mode:mmap_mode, allow_pickle:allow_pickle, fix_imports:fix_imports, encoding:encoding);

/// <summary>

/// Save an array to a binary file in NumPy .npy format.<br></br>

///

/// Notes

///

/// For a description of the .npy format, see numpy.lib.format.

/// </summary>

/// <param name="file">

/// File or filename to which the data is saved.<br></br>

/// If file is a file-object,

/// then the filename is unchanged.<br></br>

/// If file is a string or Path, a .npy

/// extension will be appended to the file name if it does not already

/// have one.

/// </param>

/// <param name="arr">

/// Array data to be saved.

/// </param>

/// <param name="allow_pickle">

/// Allow saving object arrays using Python pickles.<br></br>

/// Reasons for disallowing

/// pickles include security (loading pickled data can execute arbitrary

/// code) and portability (pickled objects may not be loadable on different

/// Python installations, for example if the stored objects require libraries

/// that are not available, and not all pickled data is compatible between

/// Python 2 and Python 3).<br></br>

///

/// Default: True

/// </param>

/// <param name="fix_imports">

/// Only useful in forcing objects in object arrays on Python 3 to be

/// pickled in a Python 2 compatible way.<br></br>

/// If fix_imports is True, pickle

/// will try to map the new Python 3 names to the old module names used in

/// Python 2, so that the pickle data stream is readable with Python 2.

/// </param>

public static void save(string file, NDarray arr, bool? allow_pickle = true, bool? fix_imports = true)

=> NumPy.Instance.save(file, arr, allow_pickle:allow_pickle, fix_imports:fix_imports);

/// <summary>

/// Save several arrays into a single file in uncompressed .npz format.<br></br>

///

/// If arguments are passed in with no keywords, the corresponding variable

/// names, in the .npz file, are ‘arr_0’, ‘arr_1’, etc.<br></br>

/// If keyword

/// arguments are given, the corresponding variable names, in the .npz

/// file will match the keyword names.<br></br>

///

/// Notes

///

/// The .npz file format is a zipped archive of files named after the

/// variables they contain.<br></br>

/// The archive is not compressed and each file

/// in the archive contains one variable in .npy format.<br></br>

/// For a

/// description of the .npy format, see numpy.lib.format.<br></br>

///

/// When opening the saved .npz file with load a NpzFile object is

/// returned.<br></br>

/// This is a dictionary-like object which can be queried for

/// its list of arrays (with the .files attribute), and for the arrays

/// themselves.

/// </summary>

/// <param name="file">

/// Either the file name (string) or an open file (file-like object)

/// where the data will be saved.<br></br>

/// If file is a string or a Path, the

/// .npz extension will be appended to the file name if it is not

/// already there.

/// </param>

/// <param name="args">

/// Arrays to save to the file.<br></br>

/// Since it is not possible for Python to

/// know the names of the arrays outside savez, the arrays will be saved

/// with names “arr_0”, “arr_1”, and so on.<br></br>

/// These arguments can be any

/// expression.

/// </param>

/// <param name="kwds">

/// Arrays to save to the file.<br></br>

/// Arrays will be saved in the file with the

/// keyword names.

/// </param>

public static void savez(string file, NDarray[] args = null, Dictionary<string, NDarray> kwds = null)

=> NumPy.Instance.savez(file, args:args, kwds:kwds);

/// <summary>

/// Save several arrays into a single file in compressed .npz format.<br></br>

///

/// If keyword arguments are given, then filenames are taken from the keywords.<br></br>

///

/// If arguments are passed in with no keywords, then stored file names are

/// arr_0, arr_1, etc.<br></br>

///

/// Notes

///

/// The .npz file format is a zipped archive of files named after the

/// variables they contain.<br></br>

/// The archive is compressed with

/// zipfile.ZIP_DEFLATED and each file in the archive contains one variable

/// in .npy format.<br></br>

/// For a description of the .npy format, see

/// numpy.lib.format.<br></br>

///

/// When opening the saved .npz file with load a NpzFile object is

/// returned.<br></br>

/// This is a dictionary-like object which can be queried for

/// its list of arrays (with the .files attribute), and for the arrays

/// themselves.

/// </summary>

/// <param name="file">

/// Either the file name (string) or an open file (file-like object)

/// where the data will be saved.<br></br>

/// If file is a string or a Path, the

/// .npz extension will be appended to the file name if it is not

/// already there.

/// </param>

/// <param name="args">

/// Arrays to save to the file.<br></br>

/// Since it is not possible for Python to

/// know the names of the arrays outside savez, the arrays will be saved

/// with names “arr_0”, “arr_1”, and so on.<br></br>

/// These arguments can be any

/// expression.

/// </param>

/// <param name="kwds">

/// Arrays to save to the file.<br></br>

/// Arrays will be saved in the file with the

/// keyword names.

/// </param>

public static void savez_compressed(string file, NDarray[] args = null, Dictionary<string, NDarray> kwds = null)

=> NumPy.Instance.savez_compressed(file, args:args, kwds:kwds);

/// <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)

=> NumPy.Instance.savetxt(fname, X, fmt:fmt, delimiter:delimiter, newline:newline, header:header, footer:footer, comments:comments, encoding:encoding);

/*

/// <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)

=> NumPy.Instance.fromregex(file, regexp, dtype, encoding:encoding);

/// <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)

=> NumPy.Instance.tofile(fid, sep, format);

/*

/*

/// <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)

=> NumPy.Instance.array_repr(arr, max_line_width:max_line_width, precision:precision, suppress_small:suppress_small);

/// <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)

=> NumPy.Instance.array_str(a, max_line_width:max_line_width, precision:precision, suppress_small:suppress_small);

/*

/*

/// <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)

=> NumPy.Instance.memmap(filename, dtype:dtype, mode:mode, offset:offset, shape:shape, order:order);

/*

/// <summary>

/// Return the current print options.

/// </summary>

/// <param name="print_opts">

/// Dictionary of current print options with keys

///

/// For a full description of these options, see set_printoptions.

/// </param>

/// <returns>

/// Dictionary of current print options with keys

///

/// For a full description of these options, see set_printoptions.

/// </returns>

public static Hashtable get_printoptions(Hashtable print_opts)

=> NumPy.Instance.get_printoptions(print_opts);

/*

/// <summary>

/// Return a string representation of a number in the given base system.

/// </summary>

/// <param name="number">

/// The value to convert.<br></br>

/// Positive and negative values are handled.

/// </param>

/// <param name="base">