neulab/docprompting-conala huggingface dataset:
numpy.ma.ptp   ma.ptp(obj, axis=None, out=None, fill_value=None, keepdims=<no value>)[source]
 
Return (maximum - minimum) along the given dimension (i.e. peak-to-peak value).  Warning ptp preserves the data type of the array. This means the return value for an input of signed integers with n bits (e.g. np.int8, np.int16, etc) is also a signed integer with n bits. In that case, peak-to-peak values greater than 2**(n-1)-1 will be returned as negative values. An example with a work-around is shown below.   Parameters 
 
axis{None, int}, optional


Axis along which to find the peaks. If None (default) the flattened array is used.  
out{None, array_like}, optional


Alternative output array in which to place the result. It must have the same shape and buffer length as the expected output but the type will be cast if necessary.  
fill_valuescalar or None, optional


Value used to fill in the masked values.  
keepdimsbool, optional


If this is set to True, the axes which are reduced are left in the result as dimensions with size one. With this option, the result will broadcast correctly against the array.    Returns 
 
ptpndarray.


A new array holding the result, unless out was specified, in which case a reference to out is returned.     Examples >>> x = np.ma.MaskedArray([[4, 9, 2, 10],
...                        [6, 9, 7, 12]])
 >>> x.ptp(axis=1)
masked_array(data=[8, 6],
             mask=False,
       fill_value=999999)
 >>> x.ptp(axis=0)
masked_array(data=[2, 0, 5, 2],
             mask=False,
       fill_value=999999)
 >>> x.ptp()
10
 This example shows that a negative value can be returned when the input is an array of signed integers. >>> y = np.ma.MaskedArray([[1, 127],
...                        [0, 127],
...                        [-1, 127],
...                        [-2, 127]], dtype=np.int8)
>>> y.ptp(axis=1)
masked_array(data=[ 126,  127, -128, -127],
             mask=False,
       fill_value=999999,
            dtype=int8)
 A work-around is to use the view() method to view the result as unsigned integers with the same bit width: >>> y.ptp(axis=1).view(np.uint8)
masked_array(data=[126, 127, 128, 129],
             mask=False,
       fill_value=999999,
            dtype=uint8)
numpy.ma.ravel   ma.ravel(self, order='C') = <numpy.ma.core._frommethod object>
 
Returns a 1D version of self, as a view.  Parameters 
 
order{‘C’, ‘F’, ‘A’, ‘K’}, optional


The elements of a are read using this index order. ‘C’ means to index the elements in C-like order, with the last axis index changing fastest, back to the first axis index changing slowest. ‘F’ means to index the elements in Fortran-like index order, with the first index changing fastest, and the last index changing slowest. Note that the ‘C’ and ‘F’ options take no account of the memory layout of the underlying array, and only refer to the order of axis indexing. ‘A’ means to read the elements in Fortran-like index order if m is Fortran contiguous in memory, C-like order otherwise. ‘K’ means to read the elements in the order they occur in memory, except for reversing the data when strides are negative. By default, ‘C’ index order is used.    Returns 
 MaskedArray

Output view is of shape (self.size,) (or (np.ma.product(self.shape),)).     Examples >>> x = np.ma.array([[1,2,3],[4,5,6],[7,8,9]], mask=[0] + [1,0]*4)
>>> x
masked_array(
  data=[[1, --, 3],
        [--, 5, --],
        [7, --, 9]],
  mask=[[False,  True, False],
        [ True, False,  True],
        [False,  True, False]],
  fill_value=999999)
>>> x.ravel()
masked_array(data=[1, --, 3, --, 5, --, 7, --, 9],
             mask=[False,  True, False,  True, False,  True, False,  True,
                   False],
       fill_value=999999)
numpy.ma.reshape   ma.reshape(a, new_shape, order='C')[source]
 
Returns an array containing the same data with a new shape. Refer to MaskedArray.reshape for full documentation.  See also  MaskedArray.reshape

equivalent function
numpy.ma.resize   ma.resize(x, new_shape)[source]
 
Return a new masked array with the specified size and shape. This is the masked equivalent of the numpy.resize function. The new array is filled with repeated copies of x (in the order that the data are stored in memory). If x is masked, the new array will be masked, and the new mask will be a repetition of the old one.  See also  numpy.resize

Equivalent function in the top level NumPy module.    Examples >>> import numpy.ma as ma
>>> a = ma.array([[1, 2] ,[3, 4]])
>>> a[0, 1] = ma.masked
>>> a
masked_array(
  data=[[1, --],
        [3, 4]],
  mask=[[False,  True],
        [False, False]],
  fill_value=999999)
>>> np.resize(a, (3, 3))
masked_array(
  data=[[1, 2, 3],
        [4, 1, 2],
        [3, 4, 1]],
  mask=False,
  fill_value=999999)
>>> ma.resize(a, (3, 3))
masked_array(
  data=[[1, --, 3],
        [4, 1, --],
        [3, 4, 1]],
  mask=[[False,  True, False],
        [False, False,  True],
        [False, False, False]],
  fill_value=999999)
 A MaskedArray is always returned, regardless of the input type. >>> a = np.array([[1, 2] ,[3, 4]])
>>> ma.resize(a, (3, 3))
masked_array(
  data=[[1, 2, 3],
        [4, 1, 2],
        [3, 4, 1]],
  mask=False,
  fill_value=999999)
numpy.ma.round   ma.round(a, decimals=0, out=None)[source]
 
Return a copy of a, rounded to ‘decimals’ places. When ‘decimals’ is negative, it specifies the number of positions to the left of the decimal point. The real and imaginary parts of complex numbers are rounded separately. Nothing is done if the array is not of float type and ‘decimals’ is greater than or equal to 0.  Parameters 
 
decimalsint


Number of decimals to round to. May be negative.  
outarray_like


Existing array to use for output. If not given, returns a default copy of a.     Notes If out is given and does not have a mask attribute, the mask of a is lost!
numpy.ma.row_stack   ma.row_stack(*args, **kwargs) = <numpy.ma.extras._fromnxfunction_seq object>
 
Stack arrays in sequence vertically (row wise). This is equivalent to concatenation along the first axis after 1-D arrays of shape (N,) have been reshaped to (1,N). Rebuilds arrays divided by vsplit. This function makes most sense for arrays with up to 3 dimensions. For instance, for pixel-data with a height (first axis), width (second axis), and r/g/b channels (third axis). The functions concatenate, stack and block provide more general stacking and concatenation operations.  Parameters 
 
tupsequence of ndarrays


The arrays must have the same shape along all but the first axis. 1-D arrays must have the same length.    Returns 
 
stackedndarray


The array formed by stacking the given arrays, will be at least 2-D.      See also  concatenate

Join a sequence of arrays along an existing axis.  stack

Join a sequence of arrays along a new axis.  block

Assemble an nd-array from nested lists of blocks.  hstack

Stack arrays in sequence horizontally (column wise).  dstack

Stack arrays in sequence depth wise (along third axis).  column_stack

Stack 1-D arrays as columns into a 2-D array.  vsplit

Split an array into multiple sub-arrays vertically (row-wise).    Notes The function is applied to both the _data and the _mask, if any. Examples >>> a = np.array([1, 2, 3])
>>> b = np.array([4, 5, 6])
>>> np.vstack((a,b))
array([[1, 2, 3],
       [4, 5, 6]])
 >>> a = np.array([[1], [2], [3]])
>>> b = np.array([[4], [5], [6]])
>>> np.vstack((a,b))
array([[1],
       [2],
       [3],
       [4],
       [5],
       [6]])
numpy.ma.set_fill_value   ma.set_fill_value(a, fill_value)[source]
 
Set the filling value of a, if a is a masked array. This function changes the fill value of the masked array a in place. If a is not a masked array, the function returns silently, without doing anything.  Parameters 
 
aarray_like


Input array.  
fill_valuedtype


Filling value. A consistency test is performed to make sure the value is compatible with the dtype of a.    Returns 
 None

Nothing returned by this function.      See also  maximum_fill_value

Return the default fill value for a dtype.  MaskedArray.fill_value

Return current fill value.  MaskedArray.set_fill_value

Equivalent method.    Examples >>> import numpy.ma as ma
>>> a = np.arange(5)
>>> a
array([0, 1, 2, 3, 4])
>>> a = ma.masked_where(a < 3, a)
>>> a
masked_array(data=[--, --, --, 3, 4],
             mask=[ True,  True,  True, False, False],
       fill_value=999999)
>>> ma.set_fill_value(a, -999)
>>> a
masked_array(data=[--, --, --, 3, 4],
             mask=[ True,  True,  True, False, False],
       fill_value=-999)
 Nothing happens if a is not a masked array. >>> a = list(range(5))
>>> a
[0, 1, 2, 3, 4]
>>> ma.set_fill_value(a, 100)
>>> a
[0, 1, 2, 3, 4]
>>> a = np.arange(5)
>>> a
array([0, 1, 2, 3, 4])
>>> ma.set_fill_value(a, 100)
>>> a
array([0, 1, 2, 3, 4])
numpy.ma.shape   ma.shape(obj)[source]
 
Return the shape of an array.  Parameters 
 
aarray_like


Input array.    Returns 
 
shapetuple of ints


The elements of the shape tuple give the lengths of the corresponding array dimensions.      See also  len
ndarray.shape

Equivalent array method.    Examples >>> np.shape(np.eye(3))
(3, 3)
>>> np.shape([[1, 2]])
(1, 2)
>>> np.shape([0])
(1,)
>>> np.shape(0)
()
 >>> a = np.array([(1, 2), (3, 4)], dtype=[('x', 'i4'), ('y', 'i4')])
>>> np.shape(a)
(2,)
>>> a.shape
(2,)
numpy.ma.size   ma.size(obj, axis=None)[source]
 
Return the number of elements along a given axis.  Parameters 
 
aarray_like


Input data.  
axisint, optional


Axis along which the elements are counted. By default, give the total number of elements.    Returns 
 
element_countint


Number of elements along the specified axis.      See also  shape

dimensions of array  ndarray.shape

dimensions of array  ndarray.size

number of elements in array    Examples >>> a = np.array([[1,2,3],[4,5,6]])
>>> np.size(a)
6
>>> np.size(a,1)
3
>>> np.size(a,0)
2
numpy.ma.soften_mask   ma.soften_mask(self) = <numpy.ma.core._frommethod object>
 
Force the mask to soft. Whether the mask of a masked array is hard or soft is determined by its hardmask property. soften_mask sets hardmask to False.  See also  ma.MaskedArray.hardmask
numpy.ma.sort   ma.sort(a, axis=- 1, kind=None, order=None, endwith=True, fill_value=None)[source]
 
Return a sorted copy of the masked array. Equivalent to creating a copy of the array and applying the MaskedArray sort() method. Refer to MaskedArray.sort for the full documentation  See also  MaskedArray.sort

equivalent method
numpy.ma.squeeze   ma.squeeze(*args, **kwargs) = <numpy.ma.core._convert2ma object>
 
Remove axes of length one from a.  Parameters 
 
aarray_like


Input data.  
axisNone or int or tuple of ints, optional


 New in version 1.7.0.  Selects a subset of the entries of length one in the shape. If an axis is selected with shape entry greater than one, an error is raised.    Returns 
 
squeezedMaskedArray


The input array, but with all or a subset of the dimensions of length 1 removed. This is always a itself or a view into a. Note that if all axes are squeezed, the result is a 0d array and not a scalar.    Raises 
 ValueError

If axis is not None, and an axis being squeezed is not of length 1      See also  expand_dims

The inverse operation, adding entries of length one  reshape

Insert, remove, and combine dimensions, and resize existing ones    Examples >>> x = np.array([[[0], [1], [2]]])
>>> x.shape
(1, 3, 1)
>>> np.squeeze(x).shape
(3,)
>>> np.squeeze(x, axis=0).shape
(3, 1)
>>> np.squeeze(x, axis=1).shape
Traceback (most recent call last):
...
ValueError: cannot select an axis to squeeze out which has size not equal to one
>>> np.squeeze(x, axis=2).shape
(1, 3)
>>> x = np.array([[1234]])
>>> x.shape
(1, 1)
>>> np.squeeze(x)
array(1234)  # 0d array
>>> np.squeeze(x).shape
()
>>> np.squeeze(x)[()]
1234
numpy.ma.stack   ma.stack(*args, **kwargs) = <numpy.ma.extras._fromnxfunction_seq object>
 
Join a sequence of arrays along a new axis. The axis parameter specifies the index of the new axis in the dimensions of the result. For example, if axis=0 it will be the first dimension and if axis=-1 it will be the last dimension.  New in version 1.10.0.   Parameters 
 
arrayssequence of array_like


Each array must have the same shape.  
axisint, optional


The axis in the result array along which the input arrays are stacked.  
outndarray, optional


If provided, the destination to place the result. The shape must be correct, matching that of what stack would have returned if no out argument were specified.    Returns 
 
stackedndarray


The stacked array has one more dimension than the input arrays.      See also  concatenate

Join a sequence of arrays along an existing axis.  block

Assemble an nd-array from nested lists of blocks.  split

Split array into a list of multiple sub-arrays of equal size.    Notes The function is applied to both the _data and the _mask, if any. Examples >>> arrays = [np.random.randn(3, 4) for _ in range(10)]
>>> np.stack(arrays, axis=0).shape
(10, 3, 4)
 >>> np.stack(arrays, axis=1).shape
(3, 10, 4)
 >>> np.stack(arrays, axis=2).shape
(3, 4, 10)
 >>> a = np.array([1, 2, 3])
>>> b = np.array([4, 5, 6])
>>> np.stack((a, b))
array([[1, 2, 3],
       [4, 5, 6]])
 >>> np.stack((a, b), axis=-1)
array([[1, 4],
       [2, 5],
       [3, 6]])
numpy.ma.std   ma.std(self, axis=None, dtype=None, out=None, ddof=0, keepdims=<no value>) = <numpy.ma.core._frommethod object>
 
Returns the standard deviation of the array elements along given axis. Masked entries are ignored. Refer to numpy.std for full documentation.  See also  numpy.ndarray.std

corresponding function for ndarrays  numpy.std

Equivalent function
numpy.ma.sum   ma.sum(self, axis=None, dtype=None, out=None, keepdims=<no value>) = <numpy.ma.core._frommethod object>
 
Return the sum of the array elements over the given axis. Masked elements are set to 0 internally. Refer to numpy.sum for full documentation.  See also  numpy.ndarray.sum

corresponding function for ndarrays  numpy.sum

equivalent function    Examples >>> x = np.ma.array([[1,2,3],[4,5,6],[7,8,9]], mask=[0] + [1,0]*4)
>>> x
masked_array(
  data=[[1, --, 3],
        [--, 5, --],
        [7, --, 9]],
  mask=[[False,  True, False],
        [ True, False,  True],
        [False,  True, False]],
  fill_value=999999)
>>> x.sum()
25
>>> x.sum(axis=1)
masked_array(data=[4, 5, 16],
             mask=[False, False, False],
       fill_value=999999)
>>> x.sum(axis=0)
masked_array(data=[8, 5, 12],
             mask=[False, False, False],
       fill_value=999999)
>>> print(type(x.sum(axis=0, dtype=np.int64)[0]))
<class 'numpy.int64'>
numpy.ma.swapaxes   ma.swapaxes(self, *args, **params) a.swapaxes(axis1, axis2) = <numpy.ma.core._frommethod object>
  Return a view of the array with axis1 and axis2 interchanged. Refer to numpy.swapaxes for full documentation.  See also  numpy.swapaxes

equivalent function
numpy.ma.trace   ma.trace(self, offset=0, axis1=0, axis2=1, dtype=None, out=None) a.trace(offset=0, axis1=0, axis2=1, dtype=None, out=None) = <numpy.ma.core._frommethod object>
  Return the sum along diagonals of the array. Refer to numpy.trace for full documentation.  See also  numpy.trace

equivalent function
numpy.ma.transpose   ma.transpose(a, axes=None)[source]
 
Permute the dimensions of an array. This function is exactly equivalent to numpy.transpose.  See also  numpy.transpose

Equivalent function in top-level NumPy module.    Examples >>> import numpy.ma as ma
>>> x = ma.arange(4).reshape((2,2))
>>> x[1, 1] = ma.masked
>>> x
masked_array(
  data=[[0, 1],
        [2, --]],
  mask=[[False, False],
        [False,  True]],
  fill_value=999999)
 >>> ma.transpose(x)
masked_array(
  data=[[0, 2],
        [1, --]],
  mask=[[False, False],
        [False,  True]],
  fill_value=999999)
numpy.ma.vander   ma.vander(x, n=None)[source]
 
Generate a Vandermonde matrix. The columns of the output matrix are powers of the input vector. The order of the powers is determined by the increasing boolean argument. Specifically, when increasing is False, the i-th output column is the input vector raised element-wise to the power of N - i - 1. Such a matrix with a geometric progression in each row is named for Alexandre- Theophile Vandermonde.  Parameters 
 
xarray_like


1-D input array.  
Nint, optional


Number of columns in the output. If N is not specified, a square array is returned (N = len(x)).  
increasingbool, optional


Order of the powers of the columns. If True, the powers increase from left to right, if False (the default) they are reversed.  New in version 1.9.0.     Returns 
 
outndarray


Vandermonde matrix. If increasing is False, the first column is x^(N-1), the second x^(N-2) and so forth. If increasing is True, the columns are x^0, x^1, ..., x^(N-1).      See also  polynomial.polynomial.polyvander
  Notes Masked values in the input array result in rows of zeros. Examples >>> x = np.array([1, 2, 3, 5])
>>> N = 3
>>> np.vander(x, N)
array([[ 1,  1,  1],
       [ 4,  2,  1],
       [ 9,  3,  1],
       [25,  5,  1]])
 >>> np.column_stack([x**(N-1-i) for i in range(N)])
array([[ 1,  1,  1],
       [ 4,  2,  1],
       [ 9,  3,  1],
       [25,  5,  1]])
 >>> x = np.array([1, 2, 3, 5])
>>> np.vander(x)
array([[  1,   1,   1,   1],
       [  8,   4,   2,   1],
       [ 27,   9,   3,   1],
       [125,  25,   5,   1]])
>>> np.vander(x, increasing=True)
array([[  1,   1,   1,   1],
       [  1,   2,   4,   8],
       [  1,   3,   9,  27],
       [  1,   5,  25, 125]])
 The determinant of a square Vandermonde matrix is the product of the differences between the values of the input vector: >>> np.linalg.det(np.vander(x))
48.000000000000043 # may vary
>>> (5-3)*(5-2)*(5-1)*(3-2)*(3-1)*(2-1)
48
numpy.ma.vstack   ma.vstack(*args, **kwargs) = <numpy.ma.extras._fromnxfunction_seq object>
 
Stack arrays in sequence vertically (row wise). This is equivalent to concatenation along the first axis after 1-D arrays of shape (N,) have been reshaped to (1,N). Rebuilds arrays divided by vsplit. This function makes most sense for arrays with up to 3 dimensions. For instance, for pixel-data with a height (first axis), width (second axis), and r/g/b channels (third axis). The functions concatenate, stack and block provide more general stacking and concatenation operations.  Parameters 
 
tupsequence of ndarrays


The arrays must have the same shape along all but the first axis. 1-D arrays must have the same length.    Returns 
 
stackedndarray


The array formed by stacking the given arrays, will be at least 2-D.      See also  concatenate

Join a sequence of arrays along an existing axis.  stack

Join a sequence of arrays along a new axis.  block

Assemble an nd-array from nested lists of blocks.  hstack

Stack arrays in sequence horizontally (column wise).  dstack

Stack arrays in sequence depth wise (along third axis).  column_stack

Stack 1-D arrays as columns into a 2-D array.  vsplit

Split an array into multiple sub-arrays vertically (row-wise).    Notes The function is applied to both the _data and the _mask, if any. Examples >>> a = np.array([1, 2, 3])
>>> b = np.array([4, 5, 6])
>>> np.vstack((a,b))
array([[1, 2, 3],
       [4, 5, 6]])
 >>> a = np.array([[1], [2], [3]])
>>> b = np.array([[4], [5], [6]])
>>> np.vstack((a,b))
array([[1],
       [2],
       [3],
       [4],
       [5],
       [6]])
numpy.ma.where   ma.where(condition, x=<no value>, y=<no value>)[source]
 
Return a masked array with elements from x or y, depending on condition.  Note When only condition is provided, this function is identical to nonzero. The rest of this documentation covers only the case where all three arguments are provided.   Parameters 
 
conditionarray_like, bool


Where True, yield x, otherwise yield y.  
x, yarray_like, optional


Values from which to choose. x, y and condition need to be broadcastable to some shape.    Returns 
 
outMaskedArray


An masked array with masked elements where the condition is masked, elements from x where condition is True, and elements from y elsewhere.      See also  numpy.where

Equivalent function in the top-level NumPy module.  nonzero

The function that is called when x and y are omitted    Examples >>> x = np.ma.array(np.arange(9.).reshape(3, 3), mask=[[0, 1, 0],
...                                                    [1, 0, 1],
...                                                    [0, 1, 0]])
>>> x
masked_array(
  data=[[0.0, --, 2.0],
        [--, 4.0, --],
        [6.0, --, 8.0]],
  mask=[[False,  True, False],
        [ True, False,  True],
        [False,  True, False]],
  fill_value=1e+20)
>>> np.ma.where(x > 5, x, -3.1416)
masked_array(
  data=[[-3.1416, --, -3.1416],
        [--, -3.1416, --],
        [6.0, --, 8.0]],
  mask=[[False,  True, False],
        [ True, False,  True],
        [False,  True, False]],
  fill_value=1e+20)
numpy.ma.zeros   ma.zeros(shape, dtype=float, order='C', *, like=None) = <numpy.ma.core._convert2ma object>
 
Return a new array of given shape and type, filled with zeros.  Parameters 
 
shapeint or tuple of ints


Shape of the new array, e.g., (2, 3) or 2.  
dtypedata-type, optional


The desired data-type for the array, e.g., numpy.int8. Default is numpy.float64.  
order{‘C’, ‘F’}, optional, default: ‘C’


Whether to store multi-dimensional data in row-major (C-style) or column-major (Fortran-style) order in memory.  
likearray_like


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.  New in version 1.20.0.     Returns 
 
outMaskedArray


Array of zeros with the given shape, dtype, and order.      See also  zeros_like

Return an array of zeros with shape and type of input.  empty

Return a new uninitialized array.  ones

Return a new array setting values to one.  full

Return a new array of given shape filled with value.    Examples >>> np.zeros(5)
array([ 0.,  0.,  0.,  0.,  0.])
 >>> np.zeros((5,), dtype=int)
array([0, 0, 0, 0, 0])
 >>> np.zeros((2, 1))
array([[ 0.],
       [ 0.]])
 >>> s = (2,2)
>>> np.zeros(s)
array([[ 0.,  0.],
       [ 0.,  0.]])
 >>> np.zeros((2,), dtype=[('x', 'i4'), ('y', 'i4')]) # custom dtype
array([(0, 0), (0, 0)],
      dtype=[('x', '<i4'), ('y', '<i4')])
numpy.ma.zeros_like   ma.zeros_like(*args, **kwargs) = <numpy.ma.core._convert2ma object>
 
Return an array of zeros with the same shape and type as a given array.  Parameters 
 
aarray_like


The shape and data-type of a define these same attributes of the returned array.  
dtypedata-type, optional


Overrides the data type of the result.  New in version 1.6.0.   
order{‘C’, ‘F’, ‘A’, or ‘K’}, optional


Overrides the memory layout of the result. ‘C’ means C-order, ‘F’ means F-order, ‘A’ means ‘F’ if a is Fortran contiguous, ‘C’ otherwise. ‘K’ means match the layout of a as closely as possible.  New in version 1.6.0.   
subokbool, optional.


If True, then the newly created array will use the sub-class type of a, otherwise it will be a base-class array. Defaults to True.  
shapeint or sequence of ints, optional.


Overrides the shape of the result. If order=’K’ and the number of dimensions is unchanged, will try to keep order, otherwise, order=’C’ is implied.  New in version 1.17.0.     Returns 
 
outMaskedArray


Array of zeros with the same shape and type as a.      See also  empty_like

Return an empty array with shape and type of input.  ones_like

Return an array of ones with shape and type of input.  full_like

Return a new array with shape of input filled with value.  zeros

Return a new array setting values to zero.    Examples >>> x = np.arange(6)
>>> x = x.reshape((2, 3))
>>> x
array([[0, 1, 2],
       [3, 4, 5]])
>>> np.zeros_like(x)
array([[0, 0, 0],
       [0, 0, 0]])
 >>> y = np.arange(3, dtype=float)
>>> y
array([0., 1., 2.])
>>> np.zeros_like(y)
array([0.,  0.,  0.])
make_config_py(name='__config__')[source]
 
Generate package __config__.py file containing system_info information used during building the package. This file is installed to the package installation directory.