diff --git a/py/numpy/gen.go b/py/numpy/gen.go index 85d6a435..d1e15f98 100644 --- a/py/numpy/gen.go +++ b/py/numpy/gen.go @@ -111,6 +111,102 @@ func ShowConfig(mode *py.Object) *py.Object //go:linkname Isfortran py.isfortran func Isfortran(a *py.Object) *py.Object +// Return an array representing the indices of a grid. +// +// Compute an array where the subarrays contain index values 0, 1, ... +// varying only along the corresponding axis. +// +// Parameters +// ---------- +// dimensions : sequence of ints +// +// The shape of the grid. +// +// dtype : dtype, optional +// +// Data type of the result. +// +// sparse : boolean, optional +// +// Return a sparse representation of the grid instead of a dense +// representation. Default is False. +// +// .. versionadded:: 1.17 +// +// Returns +// ------- +// grid : one ndarray or tuple of ndarrays +// +// If sparse is False: +// Returns one array of grid indices, +// ``grid.shape = (len(dimensions),) + tuple(dimensions)``. +// If sparse is True: +// Returns a tuple of arrays, with +// ``grid[i].shape = (1, ..., 1, dimensions[i], 1, ..., 1)`` with +// dimensions[i] in the ith place +// +// See Also +// -------- +// mgrid, ogrid, meshgrid +// +// Notes +// ----- +// The output shape in the dense case is obtained by prepending the number +// of dimensions in front of the tuple of dimensions, i.e. if `dimensions` +// is a tuple “(r0, ..., rN-1)“ of length “N“, the output shape is +// “(N, r0, ..., rN-1)“. +// +// The subarrays “grid[k]“ contains the N-D array of indices along the +// “k-th“ axis. Explicitly:: +// +// grid[k, i0, i1, ..., iN-1] = ik +// +// Examples +// -------- +// >>> grid = np.indices((2, 3)) +// >>> grid.shape +// (2, 2, 3) +// >>> grid[0] # row indices +// array([[0, 0, 0], +// +// [1, 1, 1]]) +// +// >>> grid[1] # column indices +// array([[0, 1, 2], +// +// [0, 1, 2]]) +// +// The indices can be used as an index into an array. +// +// >>> x = np.arange(20).reshape(5, 4) +// >>> row, col = np.indices((2, 3)) +// >>> x[row, col] +// array([[0, 1, 2], +// +// [4, 5, 6]]) +// +// Note that it would be more straightforward in the above example to +// extract the required elements directly with “x[:2, :3]“. +// +// If sparse is set to true, the grid will be returned in a sparse +// representation. +// +// >>> i, j = np.indices((2, 3), sparse=True) +// >>> i.shape +// (2, 1) +// >>> j.shape +// (1, 3) +// >>> i # row indices +// array([[0], +// +// [1]]) +// +// >>> j # column indices +// array([[0, 1, 2]]) +// +//go:linkname Indices py.indices +func Indices(dimensions *py.Object, dtype *py.Object, sparse *py.Object) *py.Object + // Construct an array by executing a function over each coordinate. // // The resulting array therefore has a value “fn(x, y, z)“ at @@ -3458,67 +3554,6 @@ func Frexp(__llgo_va_list ...interface{}) *py.Object //go:linkname Gcd py.gcd func Gcd(__llgo_va_list ...interface{}) *py.Object -// greater_equal(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) -// -// Return the truth value of (x1 >= x2) element-wise. -// -// Parameters -// ---------- -// x1, x2 : array_like -// -// Input arrays. -// If ``x1.shape != x2.shape``, they must be broadcastable to a common -// shape (which becomes the shape of the output). -// -// out : ndarray, None, or tuple of ndarray and None, optional -// -// A location into which the result is stored. If provided, it must have -// a shape that the inputs broadcast to. If not provided or None, -// a freshly-allocated array is returned. A tuple (possible only as a -// keyword argument) must have length equal to the number of outputs. -// -// where : array_like, optional -// -// This condition is broadcast over the input. At locations where the -// condition is True, the `out` array will be set to the ufunc result. -// Elsewhere, the `out` array will retain its original value. -// Note that if an uninitialized `out` array is created via the default -// ``out=None``, locations within it where the condition is False will -// remain uninitialized. -// -// **kwargs -// -// For other keyword-only arguments, see the -// :ref:`ufunc docs `. -// -// Returns -// ------- -// out : bool or ndarray of bool -// -// Output array, element-wise comparison of `x1` and `x2`. -// Typically of type bool, unless ``dtype=object`` is passed. -// This is a scalar if both `x1` and `x2` are scalars. -// -// See Also -// -------- -// greater, less, less_equal, equal, not_equal -// -// Examples -// -------- -// >>> np.greater_equal([4, 2, 1], [2, 2, 2]) -// array([ True, True, False]) -// -// The “>=“ operator can be used as a shorthand for “np.greater_equal“ -// on ndarrays. -// -// >>> a = np.array([4, 2, 1]) -// >>> b = np.array([2, 2, 2]) -// >>> a >= b -// array([ True, True, False]) -// -//go:linkname GreaterEqual py.greater_equal -func GreaterEqual(__llgo_va_list ...interface{}) *py.Object - // heaviside(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) // // Compute the Heaviside step function. @@ -6204,6 +6239,70 @@ func RightShift(__llgo_va_list ...interface{}) *py.Object //go:linkname Rint py.rint func Rint(__llgo_va_list ...interface{}) *py.Object +// sign(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) +// +// Returns an element-wise indication of the sign of a number. +// +// The `sign` function returns “-1 if x < 0, 0 if x==0, 1 if x > 0“. nan +// is returned for nan inputs. +// +// For complex inputs, the `sign` function returns +// “sign(x.real) + 0j if x.real != 0 else sign(x.imag) + 0j“. +// +// complex(nan, 0) is returned for complex nan inputs. +// +// Parameters +// ---------- +// x : array_like +// +// Input values. +// +// out : ndarray, None, or tuple of ndarray and None, optional +// +// A location into which the result is stored. If provided, it must have +// a shape that the inputs broadcast to. If not provided or None, +// a freshly-allocated array is returned. A tuple (possible only as a +// keyword argument) must have length equal to the number of outputs. +// +// where : array_like, optional +// +// This condition is broadcast over the input. At locations where the +// condition is True, the `out` array will be set to the ufunc result. +// Elsewhere, the `out` array will retain its original value. +// Note that if an uninitialized `out` array is created via the default +// ``out=None``, locations within it where the condition is False will +// remain uninitialized. +// +// **kwargs +// +// For other keyword-only arguments, see the +// :ref:`ufunc docs `. +// +// Returns +// ------- +// y : ndarray +// +// The sign of `x`. +// This is a scalar if `x` is a scalar. +// +// Notes +// ----- +// There is more than one definition of sign in common use for complex +// numbers. The definition used here is equivalent to :math:`x/\sqrt{x*x}` +// which is different from a common alternative, :math:`x/|x|`. +// +// Examples +// -------- +// >>> np.sign([-5., 4.5]) +// array([-1., 1.]) +// >>> np.sign(0) +// 0 +// >>> np.sign(5-2j) +// (1+0j) +// +//go:linkname Sign py.sign +func Sign(__llgo_va_list ...interface{}) *py.Object + // signbit(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) // // Returns element-wise True where signbit is set (less than zero). @@ -9017,6 +9116,130 @@ func GetArrayWrap(__llgo_va_list ...interface{}) *py.Object //go:linkname BroadcastShapes py.broadcast_shapes func BroadcastShapes(__llgo_va_list ...interface{}) *py.Object +// Return a 2-D array with ones on the diagonal and zeros elsewhere. +// +// Parameters +// ---------- +// N : int +// +// Number of rows in the output. +// +// M : int, optional +// +// Number of columns in the output. If None, defaults to `N`. +// +// k : int, optional +// +// Index of the diagonal: 0 (the default) refers to the main diagonal, +// a positive value refers to an upper diagonal, and a negative value +// to a lower diagonal. +// +// dtype : data-type, optional +// +// Data-type of the returned array. +// +// order : {'C', 'F'}, optional +// +// Whether the output should be stored in row-major (C-style) or +// column-major (Fortran-style) order in memory. +// +// .. versionadded:: 1.14.0 +// +// like : array_like, optional +// +// Reference object to allow the creation of arrays which are not +// NumPy arrays. If an array-like passed in as ``like`` supports +// the ``__array_function__`` protocol, the result will be defined +// by it. In this case, it ensures the creation of an array object +// compatible with that passed in via this argument. +// +// .. versionadded:: 1.20.0 +// +// Returns +// ------- +// I : ndarray of shape (N,M) +// +// An array where all elements are equal to zero, except for the `k`-th +// diagonal, whose values are equal to one. +// +// See Also +// -------- +// identity : (almost) equivalent function +// diag : diagonal 2-D array from a 1-D array specified by the user. +// +// Examples +// -------- +// >>> np.eye(2, dtype=int) +// array([[1, 0], +// +// [0, 1]]) +// +// >>> np.eye(3, k=1) +// array([[0., 1., 0.], +// +// [0., 0., 1.], +// [0., 0., 0.]]) +// +//go:linkname Eye py.eye +func Eye(N *py.Object, M *py.Object, k *py.Object, dtype *py.Object, order *py.Object) *py.Object + +// An array with ones at and below the given diagonal and zeros elsewhere. +// +// Parameters +// ---------- +// N : int +// +// Number of rows in the array. +// +// M : int, optional +// +// Number of columns in the array. +// By default, `M` is taken equal to `N`. +// +// k : int, optional +// +// The sub-diagonal at and below which the array is filled. +// `k` = 0 is the main diagonal, while `k` < 0 is below it, +// and `k` > 0 is above. The default is 0. +// +// dtype : dtype, optional +// +// Data type of the returned array. The default is float. +// +// like : array_like, optional +// +// Reference object to allow the creation of arrays which are not +// NumPy arrays. If an array-like passed in as ``like`` supports +// the ``__array_function__`` protocol, the result will be defined +// by it. In this case, it ensures the creation of an array object +// compatible with that passed in via this argument. +// +// .. versionadded:: 1.20.0 +// +// Returns +// ------- +// tri : ndarray of shape (N, M) +// +// Array with its lower triangle filled with ones and zero elsewhere; +// in other words ``T[i,j] == 1`` for ``j <= i + k``, 0 otherwise. +// +// Examples +// -------- +// >>> np.tri(3, 5, 2, dtype=int) +// array([[1, 1, 1, 0, 0], +// +// [1, 1, 1, 1, 0], +// [1, 1, 1, 1, 1]]) +// +// >>> np.tri(3, 5, -1) +// array([[0., 0., 0., 0., 0.], +// +// [1., 0., 0., 0., 0.], +// [1., 1., 0., 0., 0.]]) +// +//go:linkname Tri py.tri +func Tri(N *py.Object, M *py.Object, k *py.Object, dtype *py.Object) *py.Object + // Return the indices to access (n, n) arrays, given a masking function. // // Assume `mask_func` is a function that, for a square array a of size @@ -9502,6 +9725,49 @@ func GetInclude() *py.Object //go:linkname Info py.info func Info(object *py.Object, maxwidth *py.Object, output *py.Object, toplevel *py.Object) *py.Object +// Print or write to a file the source code for a NumPy object. +// +// The source code is only returned for objects written in Python. Many +// functions and classes are defined in C and will therefore not return +// useful information. +// +// Parameters +// ---------- +// object : numpy object +// +// Input object. This can be any object (function, class, module, +// ...). +// +// output : file object, optional +// +// If `output` not supplied then source code is printed to screen +// (sys.stdout). File object must be created with either write 'w' or +// append 'a' modes. +// +// See Also +// -------- +// lookfor, info +// +// Examples +// -------- +// >>> np.source(np.interp) #doctest: +SKIP +// In file: /usr/lib/python2.6/dist-packages/numpy/lib/function_base.py +// def interp(x, xp, fp, left=None, right=None): +// +// """.... (full docstring printed)""" +// if isinstance(x, (float, int, number)): +// return compiled_interp([x], xp, fp, left, right).item() +// else: +// return compiled_interp(x, xp, fp, left, right) +// +// The source code is only returned for objects written in Python. +// +// >>> np.source(np.array) #doctest: +SKIP +// Not available for this object. +// +//go:linkname Source py.source +func Source(object *py.Object, output *py.Object) *py.Object + // Print the NumPy arrays in the given dictionary. // // If there is no dictionary passed in or `vardict` is None then returns @@ -9718,6 +9984,538 @@ func SafeEval(source *py.Object) *py.Object //go:linkname ShowRuntime py.show_runtime func ShowRuntime() *py.Object +// Load data from a text file. +// +// Parameters +// ---------- +// fname : file, str, pathlib.Path, list of str, generator +// +// File, filename, list, or generator to read. If the filename +// extension is ``.gz`` or ``.bz2``, the file is first decompressed. Note +// that generators must return bytes or strings. The strings +// in a list or produced by a generator are treated as lines. +// +// dtype : data-type, optional +// +// Data-type of the resulting array; default: float. If this is a +// structured data-type, the resulting array will be 1-dimensional, and +// each row will be interpreted as an element of the array. In this +// case, the number of columns used must match the number of fields in +// the data-type. +// +// comments : str or sequence of str or None, optional +// +// The characters or list of characters used to indicate the start of a +// comment. None implies no comments. For backwards compatibility, byte +// strings will be decoded as 'latin1'. The default is '#'. +// +// delimiter : str, optional +// +// The character used to separate the values. For backwards compatibility, +// byte strings will be decoded as 'latin1'. The default is whitespace. +// +// .. versionchanged:: 1.23.0 +// Only single character delimiters are supported. Newline characters +// cannot be used as the delimiter. +// +// converters : dict or callable, optional +// +// Converter functions to customize value parsing. If `converters` is +// callable, the function is applied to all columns, else it must be a +// dict that maps column number to a parser function. +// See examples for further details. +// Default: None. +// +// .. versionchanged:: 1.23.0 +// The ability to pass a single callable to be applied to all columns +// was added. +// +// skiprows : int, optional +// +// Skip the first `skiprows` lines, including comments; default: 0. +// +// usecols : int or sequence, optional +// +// Which columns to read, with 0 being the first. For example, +// ``usecols = (1,4,5)`` will extract the 2nd, 5th and 6th columns. +// The default, None, results in all columns being read. +// +// .. versionchanged:: 1.11.0 +// When a single column has to be read it is possible to use +// an integer instead of a tuple. E.g ``usecols = 3`` reads the +// fourth column the same way as ``usecols = (3,)`` would. +// +// unpack : bool, optional +// +// If True, the returned array is transposed, so that arguments may be +// unpacked using ``x, y, z = loadtxt(...)``. When used with a +// structured data-type, arrays are returned for each field. +// Default is False. +// +// ndmin : int, optional +// +// The returned array will have at least `ndmin` dimensions. +// Otherwise mono-dimensional axes will be squeezed. +// Legal values: 0 (default), 1 or 2. +// +// .. versionadded:: 1.6.0 +// +// encoding : str, optional +// +// Encoding used to decode the inputfile. Does not apply to input streams. +// The special value 'bytes' enables backward compatibility workarounds +// that ensures you receive byte arrays as results if possible and passes +// 'latin1' encoded strings to converters. Override this value to receive +// unicode arrays and pass strings as input to converters. If set to None +// the system default is used. The default value is 'bytes'. +// +// .. versionadded:: 1.14.0 +// +// max_rows : int, optional +// +// Read `max_rows` rows of content after `skiprows` lines. The default is +// to read all the rows. Note that empty rows containing no data such as +// empty lines and comment lines are not counted towards `max_rows`, +// while such lines are counted in `skiprows`. +// +// .. versionadded:: 1.16.0 +// +// .. versionchanged:: 1.23.0 +// Lines containing no data, including comment lines (e.g., lines +// starting with '#' or as specified via `comments`) are not counted +// towards `max_rows`. +// +// quotechar : unicode character or None, optional +// +// The character used to denote the start and end of a quoted item. +// Occurrences of the delimiter or comment characters are ignored within +// a quoted item. The default value is ``quotechar=None``, which means +// quoting support is disabled. +// +// If two consecutive instances of `quotechar` are found within a quoted +// field, the first is treated as an escape character. See examples. +// +// .. versionadded:: 1.23.0 +// +// like : array_like, optional +// +// Reference object to allow the creation of arrays which are not +// NumPy arrays. If an array-like passed in as ``like`` supports +// the ``__array_function__`` protocol, the result will be defined +// by it. In this case, it ensures the creation of an array object +// compatible with that passed in via this argument. +// +// .. versionadded:: 1.20.0 +// +// Returns +// ------- +// out : ndarray +// +// Data read from the text file. +// +// See Also +// -------- +// load, fromstring, fromregex +// genfromtxt : Load data with missing values handled as specified. +// scipy.io.loadmat : reads MATLAB data files +// +// Notes +// ----- +// This function aims to be a fast reader for simply formatted files. The +// `genfromtxt` function provides more sophisticated handling of, e.g., +// lines with missing values. +// +// Each row in the input text file must have the same number of values to be +// able to read all values. If all rows do not have same number of values, a +// subset of up to n columns (where n is the least number of values present +// in all rows) can be read by specifying the columns via `usecols`. +// +// .. versionadded:: 1.10.0 +// +// The strings produced by the Python float.hex method can be used as +// input for floats. +// +// Examples +// -------- +// >>> from io import StringIO # StringIO behaves like a file object +// >>> c = StringIO("0 1\n2 3") +// >>> np.loadtxt(c) +// array([[0., 1.], +// +// [2., 3.]]) +// +// >>> d = StringIO("M 21 72\nF 35 58") +// >>> np.loadtxt(d, dtype={'names': ('gender', 'age', 'weight'), +// ... 'formats': ('S1', 'i4', 'f4')}) +// array([(b'M', 21, 72.), (b'F', 35, 58.)], +// +// dtype=[('gender', 'S1'), ('age', '>> c = StringIO("1,0,2\n3,0,4") +// >>> x, y = np.loadtxt(c, delimiter=',', usecols=(0, 2), unpack=True) +// >>> x +// array([1., 3.]) +// >>> y +// array([2., 4.]) +// +// The `converters` argument is used to specify functions to preprocess the +// text prior to parsing. `converters` can be a dictionary that maps +// preprocessing functions to each column: +// +// >>> s = StringIO("1.618, 2.296\n3.141, 4.669\n") +// >>> conv = { +// ... 0: lambda x: np.floor(float(x)), # conversion fn for column 0 +// ... 1: lambda x: np.ceil(float(x)), # conversion fn for column 1 +// ... } +// >>> np.loadtxt(s, delimiter=",", converters=conv) +// array([[1., 3.], +// +// [3., 5.]]) +// +// `converters` can be a callable instead of a dictionary, in which case it +// is applied to all columns: +// +// >>> s = StringIO("0xDE 0xAD\n0xC0 0xDE") +// >>> import functools +// >>> conv = functools.partial(int, base=16) +// >>> np.loadtxt(s, converters=conv) +// array([[222., 173.], +// +// [192., 222.]]) +// +// This example shows how `converters` can be used to convert a field +// with a trailing minus sign into a negative number. +// +// >>> s = StringIO('10.01 31.25-\n19.22 64.31\n17.57- 63.94') +// >>> def conv(fld): +// ... return -float(fld[:-1]) if fld.endswith(b'-') else float(fld) +// ... +// >>> np.loadtxt(s, converters=conv) +// array([[ 10.01, -31.25], +// +// [ 19.22, 64.31], +// [-17.57, 63.94]]) +// +// Using a callable as the converter can be particularly useful for handling +// values with different formatting, e.g. floats with underscores: +// +// >>> s = StringIO("1 2.7 100_000") +// >>> np.loadtxt(s, converters=float) +// array([1.e+00, 2.7e+00, 1.e+05]) +// +// This idea can be extended to automatically handle values specified in +// many different formats: +// +// >>> def conv(val): +// ... try: +// ... return float(val) +// ... except ValueError: +// ... return float.fromhex(val) +// >>> s = StringIO("1, 2.5, 3_000, 0b4, 0x1.4000000000000p+2") +// >>> np.loadtxt(s, delimiter=",", converters=conv, encoding=None) +// array([1.0e+00, 2.5e+00, 3.0e+03, 1.8e+02, 5.0e+00]) +// +// Note that with the default “encoding="bytes"“, the inputs to the +// converter function are latin-1 encoded byte strings. To deactivate the +// implicit encoding prior to conversion, use “encoding=None“ +// +// >>> s = StringIO('10.01 31.25-\n19.22 64.31\n17.57- 63.94') +// >>> conv = lambda x: -float(x[:-1]) if x.endswith('-') else float(x) +// >>> np.loadtxt(s, converters=conv, encoding=None) +// array([[ 10.01, -31.25], +// +// [ 19.22, 64.31], +// [-17.57, 63.94]]) +// +// Support for quoted fields is enabled with the `quotechar` parameter. +// Comment and delimiter characters are ignored when they appear within a +// quoted item delineated by `quotechar`: +// +// >>> s = StringIO('"alpha, #42", 10.0\n"beta, #64", 2.0\n') +// >>> dtype = np.dtype([("label", "U12"), ("value", float)]) +// >>> np.loadtxt(s, dtype=dtype, delimiter=",", quotechar='"') +// array([('alpha, #42', 10.), ('beta, #64', 2.)], +// +// dtype=[('label', '>> s = StringIO('"alpha, #42" 10.0\n"beta, #64" 2.0\n') +// >>> dtype = np.dtype([("label", "U12"), ("value", float)]) +// >>> np.loadtxt(s, dtype=dtype, delimiter=None, quotechar='"') +// array([('alpha, #42', 10.), ('beta, #64', 2.)], +// +// dtype=[('label', '>> s = StringIO('"Hello, my name is ""Monty""!"') +// >>> np.loadtxt(s, dtype="U", delimiter=",", quotechar='"') +// array('Hello, my name is "Monty"!', dtype='>> d = StringIO("1 2\n2 4\n3 9 12\n4 16 20") +// >>> np.loadtxt(d, usecols=(0, 1)) +// array([[ 1., 2.], +// +// [ 2., 4.], +// [ 3., 9.], +// [ 4., 16.]]) +// +//go:linkname Loadtxt py.loadtxt +func Loadtxt(fname *py.Object, dtype *py.Object, comments *py.Object, delimiter *py.Object, converters *py.Object, skiprows *py.Object, usecols *py.Object, unpack *py.Object, ndmin *py.Object, encoding *py.Object, maxRows *py.Object) *py.Object + +// Load data from a text file, with missing values handled as specified. +// +// Each line past the first `skip_header` lines is split at the `delimiter` +// character, and characters following the `comments` character are discarded. +// +// Parameters +// ---------- +// fname : file, str, pathlib.Path, list of str, generator +// +// File, filename, list, or generator to read. If the filename +// extension is ``.gz`` or ``.bz2``, the file is first decompressed. Note +// that generators must return bytes or strings. The strings +// in a list or produced by a generator are treated as lines. +// +// dtype : dtype, optional +// +// Data type of the resulting array. +// If None, the dtypes will be determined by the contents of each +// column, individually. +// +// comments : str, optional +// +// The character used to indicate the start of a comment. +// All the characters occurring on a line after a comment are discarded. +// +// delimiter : str, int, or sequence, optional +// +// The string used to separate values. By default, any consecutive +// whitespaces act as delimiter. An integer or sequence of integers +// can also be provided as width(s) of each field. +// +// skiprows : int, optional +// +// `skiprows` was removed in numpy 1.10. Please use `skip_header` instead. +// +// skip_header : int, optional +// +// The number of lines to skip at the beginning of the file. +// +// skip_footer : int, optional +// +// The number of lines to skip at the end of the file. +// +// converters : variable, optional +// +// The set of functions that convert the data of a column to a value. +// The converters can also be used to provide a default value +// for missing data: ``converters = {3: lambda s: float(s or 0)}``. +// +// missing : variable, optional +// +// `missing` was removed in numpy 1.10. Please use `missing_values` +// instead. +// +// missing_values : variable, optional +// +// The set of strings corresponding to missing data. +// +// filling_values : variable, optional +// +// The set of values to be used as default when the data are missing. +// +// usecols : sequence, optional +// +// Which columns to read, with 0 being the first. For example, +// ``usecols = (1, 4, 5)`` will extract the 2nd, 5th and 6th columns. +// +// names : {None, True, str, sequence}, optional +// +// If `names` is True, the field names are read from the first line after +// the first `skip_header` lines. This line can optionally be preceded +// by a comment delimiter. If `names` is a sequence or a single-string of +// comma-separated names, the names will be used to define the field names +// in a structured dtype. If `names` is None, the names of the dtype +// fields will be used, if any. +// +// excludelist : sequence, optional +// +// A list of names to exclude. This list is appended to the default list +// ['return','file','print']. Excluded names are appended with an +// underscore: for example, `file` would become `file_`. +// +// deletechars : str, optional +// +// A string combining invalid characters that must be deleted from the +// names. +// +// defaultfmt : str, optional +// +// A format used to define default field names, such as "f%i" or "f_%02i". +// +// autostrip : bool, optional +// +// Whether to automatically strip white spaces from the variables. +// +// replace_space : char, optional +// +// Character(s) used in replacement of white spaces in the variable +// names. By default, use a '_'. +// +// case_sensitive : {True, False, 'upper', 'lower'}, optional +// +// If True, field names are case sensitive. +// If False or 'upper', field names are converted to upper case. +// If 'lower', field names are converted to lower case. +// +// unpack : bool, optional +// +// If True, the returned array is transposed, so that arguments may be +// unpacked using ``x, y, z = genfromtxt(...)``. When used with a +// structured data-type, arrays are returned for each field. +// Default is False. +// +// usemask : bool, optional +// +// If True, return a masked array. +// If False, return a regular array. +// +// loose : bool, optional +// +// If True, do not raise errors for invalid values. +// +// invalid_raise : bool, optional +// +// If True, an exception is raised if an inconsistency is detected in the +// number of columns. +// If False, a warning is emitted and the offending lines are skipped. +// +// max_rows : int, optional +// +// The maximum number of rows to read. Must not be used with skip_footer +// at the same time. If given, the value must be at least 1. Default is +// to read the entire file. +// +// .. versionadded:: 1.10.0 +// +// encoding : str, optional +// +// Encoding used to decode the inputfile. Does not apply when `fname` is +// a file object. The special value 'bytes' enables backward compatibility +// workarounds that ensure that you receive byte arrays when possible +// and passes latin1 encoded strings to converters. Override this value to +// receive unicode arrays and pass strings as input to converters. If set +// to None the system default is used. The default value is 'bytes'. +// +// .. versionadded:: 1.14.0 +// +// ndmin : int, optional +// +// Same parameter as `loadtxt` +// +// .. versionadded:: 1.23.0 +// +// like : array_like, optional +// +// Reference object to allow the creation of arrays which are not +// NumPy arrays. If an array-like passed in as ``like`` supports +// the ``__array_function__`` protocol, the result will be defined +// by it. In this case, it ensures the creation of an array object +// compatible with that passed in via this argument. +// +// .. versionadded:: 1.20.0 +// +// Returns +// ------- +// out : ndarray +// +// Data read from the text file. If `usemask` is True, this is a +// masked array. +// +// See Also +// -------- +// numpy.loadtxt : equivalent function when no data is missing. +// +// Notes +// ----- +// - When spaces are used as delimiters, or when no delimiter has been given +// as input, there should not be any missing data between two fields. +// - When the variables are named (either by a flexible dtype or with `names`), +// there must not be any header in the file (else a ValueError +// exception is raised). +// - Individual values are not stripped of spaces by default. +// When using a custom converter, make sure the function does remove spaces. +// +// References +// ---------- +// .. [1] NumPy User Guide, section `I/O with NumPy +// +// `_. +// +// Examples +// -------- +// >>> from io import StringIO +// >>> import numpy as np +// +// # Comma delimited file with mixed dtype +// +// >>> s = StringIO(u"1,1.3,abcde") +// >>> data = np.genfromtxt(s, dtype=[('myint','i8'),('myfloat','f8'), +// ... ('mystring','S5')], delimiter=",") +// >>> data +// array((1, 1.3, b'abcde'), +// +// dtype=[('myint', '>> _ = s.seek(0) # needed for StringIO example only +// >>> data = np.genfromtxt(s, dtype=None, +// ... names = ['myint','myfloat','mystring'], delimiter=",") +// >>> data +// array((1, 1.3, b'abcde'), +// +// dtype=[('myint', '>> _ = s.seek(0) +// >>> data = np.genfromtxt(s, dtype="i8,f8,S5", +// ... names=['myint','myfloat','mystring'], delimiter=",") +// >>> data +// array((1, 1.3, b'abcde'), +// +// dtype=[('myint', '>> s = StringIO(u"11.3abcde") +// >>> data = np.genfromtxt(s, dtype=None, names=['intvar','fltvar','strvar'], +// ... delimiter=[1,3,5]) +// >>> data +// array((1, 1.3, b'abcde'), +// +// dtype=[('intvar', '>> f = StringIO(”' +// ... text,# of chars +// ... hello world,11 +// ... numpy,5”') +// >>> np.genfromtxt(f, dtype='S12,S12', delimiter=',') +// array([(b'text', b”), (b'hello world', b'11'), (b'numpy', b'5')], +// +// dtype=[('f0', 'S12'), ('f1', 'S12')]) +// +//go:linkname Genfromtxt py.genfromtxt +func Genfromtxt(fname *py.Object, dtype *py.Object, comments *py.Object, delimiter *py.Object, skipHeader *py.Object, skipFooter *py.Object, converters *py.Object, missingValues *py.Object, fillingValues *py.Object, usecols *py.Object, names *py.Object, excludelist *py.Object, deletechars *py.Object, replaceSpace *py.Object, autostrip *py.Object, caseSensitive *py.Object, defaultfmt *py.Object, unpack *py.Object, usemask *py.Object, loose *py.Object, invalidRaise *py.Object, maxRows *py.Object, encoding *py.Object) *py.Object + // Load ASCII data from a file and return it in a record array. // // If “usemask=False“ a standard `recarray` is returned, diff --git a/py/numpy/numpy.go b/py/numpy/numpy.go index 80c2528c..319edd1f 100644 --- a/py/numpy/numpy.go +++ b/py/numpy/numpy.go @@ -42,15 +42,6 @@ func Arange(start, stop, step, dtype *py.Object) *py.Object //go:linkname Empty py.empty func Empty(shape, dtype, order *py.Object) *py.Object -// Return a 2-D array with ones on the diagonal and zeros elsewhere. -// -// numpy.eye(N, M=None, k=0, dtype=, order='C', *, like=None) -// -// See https://numpy.org/doc/stable/reference/generated/numpy.eye.html#numpy-eye -// -//go:linkname Eye py.eye -func Eye(N, M, k, dtype, order *py.Object) *py.Object - // Return a new array of given shape and type, filled with zeros. // // numpy.zeros(shape, dtype=float, order='C', *, like=None) diff --git a/py/pandas/llgo_autogen.lla b/py/pandas/llgo_autogen.lla new file mode 100644 index 00000000..d375cd10 Binary files /dev/null and b/py/pandas/llgo_autogen.lla differ diff --git a/py/pandas/pandas.go b/py/pandas/pandas.go new file mode 100644 index 00000000..abc798a2 --- /dev/null +++ b/py/pandas/pandas.go @@ -0,0 +1,57 @@ +/* + * Copyright (c) 2024 The GoPlus Authors (goplus.org). All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package pandas + +import ( + _ "unsafe" + + "github.com/goplus/llgo/py" +) + +// https://pandas.pydata.org/docs/reference/index.html + +// read_excel(io, sheet_name=0, *, header=0, names=None, index_col=None, usecols=None, +// dtype=None, engine=None, converters=None, true_values=None, false_values=None, +// skiprows=None, nrows=None, na_values=None, keep_default_na=True, na_filter=True, +// verbose=False, parse_dates=False, date_parser=_NoDefault.no_default, date_format=None, +// thousands=None, decimal='.', comment=None, skipfooter=0, storage_options=None, +// dtype_backend=_NoDefault.no_default, engine_kwargs=None) +// +// See https://pandas.pydata.org/docs/reference/api/pandas.read_excel.html +// +//go:linkname ReadExcel py.read_excel +func ReadExcel(io, sheetName *py.Object) *py.Object + +// See https://pandas.pydata.org/docs/reference/api/pandas.read_csv.html +// +//go:linkname ReadCsv py.read_csv +func ReadCsv(filepathOrBuffer *py.Object) *py.Object + +// eval(expr, parser='pandas', engine=None, local_dict=None, global_dict=None, resolvers=(), +// level=0, target=None, inplace=False) +// +// See https://pandas.pydata.org/docs/reference/api/pandas.eval.html#pandas.eval +// +//go:linkname Eval py.eval +func Eval(expr, parser, engine, localDict, globalDict, resolvers, level, target, inplace *py.Object) *py.Object + +// show_versions(as_json=False) +// +// See https://pandas.pydata.org/docs/reference/api/pandas.show_versions.html +// +//go:linkname ShowVersions py.show_versions +func ShowVersions(asJson *py.Object) *py.Object