>> a = np.array([[1,2], [3,4]])\n>>> a.flatten()\narray([1, 2, 3, 4])\n>>> a.flatten('F')\narray([1, 3, 2, 4])\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n>> x = np.ma.array([[1,2,3],[4,5,6],[7,8,9]], mask=[0] + [1,0]*4)\n>>> x\nmasked_array(\n data=[[1, --, 3],\n [--, 5, --],\n [7, --, 9]],\n mask=[[False, True, False],\n [ True, False, True],\n [False, True, False]],\n fill_value=999999)\n>>> x.ravel()\nmasked_array(data=[1, --, 3, --, 5, --, 7, --, 9],\n mask=[False, True, False, True, False, True, False, True,\n False],\n fill_value=999999)\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n>> x = np.ma.array([[1,2],[3,4]], mask=[1,0,0,1])\n>>> x\nmasked_array(\n data=[[--, 2],\n [3, --]],\n mask=[[ True, False],\n [False, True]],\n fill_value=999999)\n>>> x = x.reshape((4,1))\n>>> x\nmasked_array(\n data=[[--],\n [2],\n [3],\n [--]],\n mask=[[ True],\n [False],\n [False],\n [ True]],\n fill_value=999999)\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n*\n Return a view of the array with `axis1` and `axis2` interchanged.\n\n Refer to [`numpy.swapaxes`](numpy.swapaxes#numpy.swapaxes \"numpy.swapaxes\") for full documentation.\n\n See also\n\n [`numpy.swapaxes`](numpy.swapaxes#numpy.swapaxes \"numpy.swapaxes\")\n\nequivalent function\n\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n>> import numpy.ma as ma\n>>> x = ma.arange(4).reshape((2,2))\n>>> x[1, 1] = ma.masked\n>>> x\nmasked_array(\n data=[[0, 1],\n [2, --]],\n mask=[[False, False],\n [False, True]],\n fill_value=999999)\n\n```\n \n```\n>>> ma.transpose(x)\nmasked_array(\n data=[[0, 2],\n [1, --]],\n mask=[[False, False],\n [False, True]],\n fill_value=999999)\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n>> a = np.array([[1, 2], [3, 4]])\n>>> a\narray([[1, 2],\n [3, 4]])\n>>> a.transpose()\narray([[1, 3],\n [2, 4]])\n>>> a.transpose((1, 0))\narray([[1, 3],\n [2, 4]])\n>>> a.transpose(1, 0)\narray([[1, 3],\n [2, 4]])\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n*\n \nConvert inputs to arrays with at least one dimension.\n\n Scalar inputs are converted to 1-dimensional arrays, whilst higher-dimensional inputs are preserved.\n\n Parameters \n \n**arys1, arys2, âŠ**array_like\n\nOne or more input arrays.\n\n Returns \n \n**ret**ndarray\n\nAn array, or list of arrays, each with `a.ndim >= 1`. Copies are made only if necessary.\n\n See also\n\n \n[`atleast_2d`](numpy.atleast_2d#numpy.atleast_2d \"numpy.atleast_2d\"), [`atleast_3d`](numpy.atleast_3d#numpy.atleast_3d \"numpy.atleast_3d\")\n\n #### Notes\n\n The function is applied to both the _data and the _mask, if any.\n\n #### Examples\n\n \n```\n>>> np.atleast_1d(1.0)\narray([1.])\n\n```\n \n```\n>>> x = np.arange(9.0).reshape(3,3)\n>>> np.atleast_1d(x)\narray([[0., 1., 2.],\n [3., 4., 5.],\n [6., 7., 8.]])\n>>> np.atleast_1d(x) is x\nTrue\n\n```\n \n```\n>>> np.atleast_1d(1, [3, 4])\n[array([1]), array([3, 4])]\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n*\n \nView inputs as arrays with at least two dimensions.\n\n Parameters \n \n**arys1, arys2, âŠ**array_like\n\nOne or more array-like sequences. Non-array inputs are converted to arrays. Arrays that already have two or more dimensions are preserved.\n\n Returns \n \n**res, res2, âŠ**ndarray\n\nAn array, or list of arrays, each with `a.ndim >= 2`. Copies are avoided where possible, and views with two or more dimensions are returned.\n\n See also\n\n \n[`atleast_1d`](numpy.atleast_1d#numpy.atleast_1d \"numpy.atleast_1d\"), [`atleast_3d`](numpy.atleast_3d#numpy.atleast_3d \"numpy.atleast_3d\")\n\n #### Notes\n\n The function is applied to both the _data and the _mask, if any.\n\n #### Examples\n\n \n```\n>>> np.atleast_2d(3.0)\narray([[3.]])\n\n```\n \n```\n>>> x = np.arange(3.0)\n>>> np.atleast_2d(x)\narray([[0., 1., 2.]])\n>>> np.atleast_2d(x).base is x\nTrue\n\n```\n \n```\n>>> np.atleast_2d(1, [1, 2], [[1, 2]])\n[array([[1]]), array([[1, 2]]), array([[1, 2]])]\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n*\n \nView inputs as arrays with at least three dimensions.\n\n Parameters \n \n**arys1, arys2, âŠ**array_like\n\nOne or more array-like sequences. Non-array inputs are converted to arrays. Arrays that already have three or more dimensions are preserved.\n\n Returns \n \n**res1, res2, âŠ**ndarray\n\nAn array, or list of arrays, each with `a.ndim >= 3`. Copies are avoided where possible, and views with three or more dimensions are returned. For example, a 1-D array of shape `(N,)` becomes a view of shape `(1, N, 1)`, and a 2-D array of shape `(M, N)` becomes a view of shape `(M, N, 1)`.\n\n See also\n\n \n[`atleast_1d`](numpy.atleast_1d#numpy.atleast_1d \"numpy.atleast_1d\"), [`atleast_2d`](numpy.atleast_2d#numpy.atleast_2d \"numpy.atleast_2d\")\n\n #### Notes\n\n The function is applied to both the _data and the _mask, if any.\n\n #### Examples\n\n \n```\n>>> np.atleast_3d(3.0)\narray([[[3.]]])\n\n```\n \n```\n>>> x = np.arange(3.0)\n>>> np.atleast_3d(x).shape\n(1, 3, 1)\n\n```\n \n```\n>>> x = np.arange(12.0).reshape(4,3)\n>>> np.atleast_3d(x).shape\n(4, 3, 1)\n>>> np.atleast_3d(x).base is x.base # x is a reshape, so not base itself\nTrue\n\n```\n \n```\n>>> for arr in np.atleast_3d([1, 2], [[1, 2]], [[[1, 2]]]):\n... print(arr, arr.shape) \n...\n[[[1]\n [2]]] (1, 2, 1)\n[[[1]\n [2]]] (1, 2, 1)\n[[[1 2]]] (1, 1, 2)\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n a.ndim` will be treated as `axis == a.ndim`, and passing `axis < -a.ndim - 1` will be treated as `axis == 0`. This behavior is deprecated.\n\n Changed in version 1.18.0: A tuple of axes is now supported. Out of range axes as described above are now forbidden and raise an [`AxisError`](numpy.axiserror#numpy.AxisError \"numpy.AxisError\").\n\n Returns \n \n**result**ndarray\n\nView of `a` with the number of dimensions increased.\n\n See also\n\n [`squeeze`](numpy.squeeze#numpy.squeeze \"numpy.squeeze\")\n\nThe inverse operation, removing singleton dimensions\n\n [`reshape`](numpy.reshape#numpy.reshape \"numpy.reshape\")\n\nInsert, remove, and combine dimensions, and resize existing ones\n\n \n`doc.indexing`, [`atleast_1d`](numpy.atleast_1d#numpy.atleast_1d \"numpy.atleast_1d\"), [`atleast_2d`](numpy.atleast_2d#numpy.atleast_2d \"numpy.atleast_2d\"), [`atleast_3d`](numpy.atleast_3d#numpy.atleast_3d \"numpy.atleast_3d\")\n\n #### Examples\n\n \n```\n>>> x = np.array([1, 2])\n>>> x.shape\n(2,)\n\n```\n The following is equivalent to `x[np.newaxis, :]` or `x[np.newaxis]`:\n\n \n```\n>>> y = np.expand_dims(x, axis=0)\n>>> y\narray([[1, 2]])\n>>> y.shape\n(1, 2)\n\n```\n The following is equivalent to `x[:, np.newaxis]`:\n\n \n```\n>>> y = np.expand_dims(x, axis=1)\n>>> y\narray([[1],\n [2]])\n>>> y.shape\n(2, 1)\n\n```\n `axis` may also be a tuple:\n\n \n```\n>>> y = np.expand_dims(x, axis=(0, 1))\n>>> y\narray([[[1, 2]]])\n\n```\n \n```\n>>> y = np.expand_dims(x, axis=(2, 0))\n>>> y\narray([[[1],\n [2]]])\n\n```\n Note that some examples may use `None` instead of `np.newaxis`. These are the same objects:\n\n \n```\n>>> np.newaxis is None\nTrue\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n*\n \nRemove axes of length one from `a`.\n\n Parameters \n \n**a**array_like\n\nInput data.\n\n \n**axis**None or int or tuple of ints, optional\n\n New in version 1.7.0.\n\n 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.\n\n Returns \n \n**squeezed**MaskedArray\n\nThe 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.\n\n Raises \n ValueError\n\nIf `axis` is not None, and an axis being squeezed is not of length 1\n\n See also\n\n [`expand_dims`](numpy.expand_dims#numpy.expand_dims \"numpy.expand_dims\")\n\nThe inverse operation, adding entries of length one\n\n [`reshape`](numpy.reshape#numpy.reshape \"numpy.reshape\")\n\nInsert, remove, and combine dimensions, and resize existing ones\n\n #### Examples\n\n \n```\n>>> x = np.array([[[0], [1], [2]]])\n>>> x.shape\n(1, 3, 1)\n>>> np.squeeze(x).shape\n(3,)\n>>> np.squeeze(x, axis=0).shape\n(3, 1)\n>>> np.squeeze(x, axis=1).shape\nTraceback (most recent call last):\n...\nValueError: cannot select an axis to squeeze out which has size not equal to one\n>>> np.squeeze(x, axis=2).shape\n(1, 3)\n>>> x = np.array([[1234]])\n>>> x.shape\n(1, 1)\n>>> np.squeeze(x)\narray(1234) # 0d array\n>>> np.squeeze(x).shape\n()\n>>> np.squeeze(x)[()]\n1234\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n*\n \nJoin a sequence of arrays along a new axis.\n\n 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.\n\n New in version 1.10.0.\n\n Parameters \n \n**arrays**sequence of array_like\n\nEach array must have the same shape.\n\n \n**axis**int, optional\n\nThe axis in the result array along which the input arrays are stacked.\n\n \n**out**ndarray, optional\n\nIf 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.\n\n Returns \n \n**stacked**ndarray\n\nThe stacked array has one more dimension than the input arrays.\n\n See also\n\n [`concatenate`](numpy.concatenate#numpy.concatenate \"numpy.concatenate\")\n\nJoin a sequence of arrays along an existing axis.\n\n [`block`](numpy.block#numpy.block \"numpy.block\")\n\nAssemble an nd-array from nested lists of blocks.\n\n [`split`](numpy.split#numpy.split \"numpy.split\")\n\nSplit array into a list of multiple sub-arrays of equal size.\n\n #### Notes\n\n The function is applied to both the _data and the _mask, if any.\n\n #### Examples\n\n \n```\n>>> arrays = [np.random.randn(3, 4) for _ in range(10)]\n>>> np.stack(arrays, axis=0).shape\n(10, 3, 4)\n\n```\n \n```\n>>> np.stack(arrays, axis=1).shape\n(3, 10, 4)\n\n```\n \n```\n>>> np.stack(arrays, axis=2).shape\n(3, 4, 10)\n\n```\n \n```\n>>> a = np.array([1, 2, 3])\n>>> b = np.array([4, 5, 6])\n>>> np.stack((a, b))\narray([[1, 2, 3],\n [4, 5, 6]])\n\n```\n \n```\n>>> np.stack((a, b), axis=-1)\narray([[1, 4],\n [2, 5],\n [3, 6]])\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n*\n \nStack 1-D arrays as columns into a 2-D array.\n\n Take a sequence of 1-D arrays and stack them as columns to make a single 2-D array. 2-D arrays are stacked as-is, just like with [`hstack`](numpy.hstack#numpy.hstack \"numpy.hstack\"). 1-D arrays are turned into 2-D columns first.\n\n Parameters \n \n**tup**sequence of 1-D or 2-D arrays.\n\nArrays to stack. All of them must have the same first dimension.\n\n Returns \n \n**stacked**2-D array\n\nThe array formed by stacking the given arrays.\n\n See also\n\n \n[`stack`](numpy.stack#numpy.stack \"numpy.stack\"), [`hstack`](numpy.hstack#numpy.hstack \"numpy.hstack\"), [`vstack`](numpy.vstack#numpy.vstack \"numpy.vstack\"), [`concatenate`](numpy.concatenate#numpy.concatenate \"numpy.concatenate\")\n\n #### Notes\n\n The function is applied to both the _data and the _mask, if any.\n\n #### Examples\n\n \n```\n>>> a = np.array((1,2,3))\n>>> b = np.array((2,3,4))\n>>> np.column_stack((a,b))\narray([[1, 2],\n [2, 3],\n [3, 4]])\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n>> import numpy.ma as ma\n>>> a = ma.arange(3)\n>>> a[1] = ma.masked\n>>> b = ma.arange(2, 5)\n>>> a\nmasked_array(data=[0, --, 2],\n mask=[False, True, False],\n fill_value=999999)\n>>> b\nmasked_array(data=[2, 3, 4],\n mask=False,\n fill_value=999999)\n>>> ma.concatenate([a, b])\nmasked_array(data=[0, --, 2, 2, 3, 4],\n mask=[False, True, False, False, False, False],\n fill_value=999999)\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n*\n \nStack arrays in sequence depth wise (along third axis).\n\n This is equivalent to concatenation along the third axis after 2-D arrays of shape `(M,N)` have been reshaped to `(M,N,1)` and 1-D arrays of shape `(N,)` have been reshaped to `(1,N,1)`. Rebuilds arrays divided by [`dsplit`](numpy.dsplit#numpy.dsplit \"numpy.dsplit\").\n\n 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`](numpy.concatenate#numpy.concatenate \"numpy.concatenate\"), [`stack`](numpy.stack#numpy.stack \"numpy.stack\") and [`block`](numpy.block#numpy.block \"numpy.block\") provide more general stacking and concatenation operations.\n\n Parameters \n \n**tup**sequence of arrays\n\nThe arrays must have the same shape along all but the third axis. 1-D or 2-D arrays must have the same shape.\n\n Returns \n \n**stacked**ndarray\n\nThe array formed by stacking the given arrays, will be at least 3-D.\n\n See also\n\n [`concatenate`](numpy.concatenate#numpy.concatenate \"numpy.concatenate\")\n\nJoin a sequence of arrays along an existing axis.\n\n [`stack`](numpy.stack#numpy.stack \"numpy.stack\")\n\nJoin a sequence of arrays along a new axis.\n\n [`block`](numpy.block#numpy.block \"numpy.block\")\n\nAssemble an nd-array from nested lists of blocks.\n\n [`vstack`](numpy.vstack#numpy.vstack \"numpy.vstack\")\n\nStack arrays in sequence vertically (row wise).\n\n [`hstack`](numpy.hstack#numpy.hstack \"numpy.hstack\")\n\nStack arrays in sequence horizontally (column wise).\n\n [`column_stack`](numpy.column_stack#numpy.column_stack \"numpy.column_stack\")\n\nStack 1-D arrays as columns into a 2-D array.\n\n [`dsplit`](numpy.dsplit#numpy.dsplit \"numpy.dsplit\")\n\nSplit array along third axis.\n\n #### Notes\n\n The function is applied to both the _data and the _mask, if any.\n\n #### Examples\n\n \n```\n>>> a = np.array((1,2,3))\n>>> b = np.array((2,3,4))\n>>> np.dstack((a,b))\narray([[[1, 2],\n [2, 3],\n [3, 4]]])\n\n```\n \n```\n>>> a = np.array([[1],[2],[3]])\n>>> b = np.array([[2],[3],[4]])\n>>> np.dstack((a,b))\narray([[[1, 2]],\n [[2, 3]],\n [[3, 4]]])\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n*\n \nStack arrays in sequence horizontally (column wise).\n\n This is equivalent to concatenation along the second axis, except for 1-D arrays where it concatenates along the first axis. Rebuilds arrays divided by [`hsplit`](numpy.hsplit#numpy.hsplit \"numpy.hsplit\").\n\n 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`](numpy.concatenate#numpy.concatenate \"numpy.concatenate\"), [`stack`](numpy.stack#numpy.stack \"numpy.stack\") and [`block`](numpy.block#numpy.block \"numpy.block\") provide more general stacking and concatenation operations.\n\n Parameters \n \n**tup**sequence of ndarrays\n\nThe arrays must have the same shape along all but the second axis, except 1-D arrays which can be any length.\n\n Returns \n \n**stacked**ndarray\n\nThe array formed by stacking the given arrays.\n\n See also\n\n [`concatenate`](numpy.concatenate#numpy.concatenate \"numpy.concatenate\")\n\nJoin a sequence of arrays along an existing axis.\n\n [`stack`](numpy.stack#numpy.stack \"numpy.stack\")\n\nJoin a sequence of arrays along a new axis.\n\n [`block`](numpy.block#numpy.block \"numpy.block\")\n\nAssemble an nd-array from nested lists of blocks.\n\n [`vstack`](numpy.vstack#numpy.vstack \"numpy.vstack\")\n\nStack arrays in sequence vertically (row wise).\n\n [`dstack`](numpy.dstack#numpy.dstack \"numpy.dstack\")\n\nStack arrays in sequence depth wise (along third axis).\n\n [`column_stack`](numpy.column_stack#numpy.column_stack \"numpy.column_stack\")\n\nStack 1-D arrays as columns into a 2-D array.\n\n [`hsplit`](numpy.hsplit#numpy.hsplit \"numpy.hsplit\")\n\nSplit an array into multiple sub-arrays horizontally (column-wise).\n\n #### Notes\n\n The function is applied to both the _data and the _mask, if any.\n\n #### Examples\n\n \n```\n>>> a = np.array((1,2,3))\n>>> b = np.array((4,5,6))\n>>> np.hstack((a,b))\narray([1, 2, 3, 4, 5, 6])\n>>> a = np.array([[1],[2],[3]])\n>>> b = np.array([[4],[5],[6]])\n>>> np.hstack((a,b))\narray([[1, 4],\n [2, 5],\n [3, 6]])\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n*\n \nSplit an array into multiple sub-arrays horizontally (column-wise).\n\n Please refer to the [`split`](numpy.split#numpy.split \"numpy.split\") documentation. [`hsplit`](numpy.hsplit#numpy.hsplit \"numpy.hsplit\") is equivalent to [`split`](numpy.split#numpy.split \"numpy.split\") with `axis=1`, the array is always split along the second axis except for 1-D arrays, where it is split at `axis=0`.\n\n See also\n\n [`split`](numpy.split#numpy.split \"numpy.split\")\n\nSplit an array into multiple sub-arrays of equal size.\n\n #### Notes\n\n The function is applied to both the _data and the _mask, if any.\n\n #### Examples\n\n \n```\n>>> x = np.arange(16.0).reshape(4, 4)\n>>> x\narray([[ 0., 1., 2., 3.],\n [ 4., 5., 6., 7.],\n [ 8., 9., 10., 11.],\n [12., 13., 14., 15.]])\n>>> np.hsplit(x, 2)\n[array([[ 0., 1.],\n [ 4., 5.],\n [ 8., 9.],\n [12., 13.]]),\n array([[ 2., 3.],\n [ 6., 7.],\n [10., 11.],\n [14., 15.]])]\n>>> np.hsplit(x, np.array([3, 6]))\n[array([[ 0., 1., 2.],\n [ 4., 5., 6.],\n [ 8., 9., 10.],\n [12., 13., 14.]]),\n array([[ 3.],\n [ 7.],\n [11.],\n [15.]]),\n array([], shape=(4, 0), dtype=float64)]\n\n```\n With a higher dimensional array the split is still along the second axis.\n\n \n```\n>>> x = np.arange(8.0).reshape(2, 2, 2)\n>>> x\narray([[[0., 1.],\n [2., 3.]],\n [[4., 5.],\n [6., 7.]]])\n>>> np.hsplit(x, 2)\n[array([[[0., 1.]],\n [[4., 5.]]]),\n array([[[2., 3.]],\n [[6., 7.]]])]\n\n```\n With a 1-D array, the split is along axis 0.\n\n \n```\n>>> x = np.array([0, 1, 2, 3, 4, 5])\n>>> np.hsplit(x, 2)\n[array([0, 1, 2]), array([3, 4, 5])]\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n*\n \nTranslate slice objects to concatenation along the first axis.\n\n This is the masked array version of `lib.index_tricks.RClass`.\n\n See also\n\n `lib.index_tricks.RClass`\n #### Examples\n\n \n```\n>>> np.ma.mr_[np.ma.array([1,2,3]), 0, 0, np.ma.array([4,5,6])]\nmasked_array(data=[1, 2, 3, ..., 4, 5, 6],\n mask=False,\n fill_value=999999)\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n*\n \nStack arrays in sequence vertically (row wise).\n\n 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`](numpy.vsplit#numpy.vsplit \"numpy.vsplit\").\n\n 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`](numpy.concatenate#numpy.concatenate \"numpy.concatenate\"), [`stack`](numpy.stack#numpy.stack \"numpy.stack\") and [`block`](numpy.block#numpy.block \"numpy.block\") provide more general stacking and concatenation operations.\n\n Parameters \n \n**tup**sequence of ndarrays\n\nThe arrays must have the same shape along all but the first axis. 1-D arrays must have the same length.\n\n Returns \n \n**stacked**ndarray\n\nThe array formed by stacking the given arrays, will be at least 2-D.\n\n See also\n\n [`concatenate`](numpy.concatenate#numpy.concatenate \"numpy.concatenate\")\n\nJoin a sequence of arrays along an existing axis.\n\n [`stack`](numpy.stack#numpy.stack \"numpy.stack\")\n\nJoin a sequence of arrays along a new axis.\n\n [`block`](numpy.block#numpy.block \"numpy.block\")\n\nAssemble an nd-array from nested lists of blocks.\n\n [`hstack`](numpy.hstack#numpy.hstack \"numpy.hstack\")\n\nStack arrays in sequence horizontally (column wise).\n\n [`dstack`](numpy.dstack#numpy.dstack \"numpy.dstack\")\n\nStack arrays in sequence depth wise (along third axis).\n\n [`column_stack`](numpy.column_stack#numpy.column_stack \"numpy.column_stack\")\n\nStack 1-D arrays as columns into a 2-D array.\n\n [`vsplit`](numpy.vsplit#numpy.vsplit \"numpy.vsplit\")\n\nSplit an array into multiple sub-arrays vertically (row-wise).\n\n #### Notes\n\n The function is applied to both the _data and the _mask, if any.\n\n #### Examples\n\n \n```\n>>> a = np.array([1, 2, 3])\n>>> b = np.array([4, 5, 6])\n>>> np.vstack((a,b))\narray([[1, 2, 3],\n [4, 5, 6]])\n\n```\n \n```\n>>> a = np.array([[1], [2], [3]])\n>>> b = np.array([[4], [5], [6]])\n>>> np.vstack((a,b))\narray([[1],\n [2],\n [3],\n [4],\n [5],\n [6]])\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n*\n \nStack arrays in sequence vertically (row wise).\n\n 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`](numpy.vsplit#numpy.vsplit \"numpy.vsplit\").\n\n 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`](numpy.concatenate#numpy.concatenate \"numpy.concatenate\"), [`stack`](numpy.stack#numpy.stack \"numpy.stack\") and [`block`](numpy.block#numpy.block \"numpy.block\") provide more general stacking and concatenation operations.\n\n Parameters \n \n**tup**sequence of ndarrays\n\nThe arrays must have the same shape along all but the first axis. 1-D arrays must have the same length.\n\n Returns \n \n**stacked**ndarray\n\nThe array formed by stacking the given arrays, will be at least 2-D.\n\n See also\n\n [`concatenate`](numpy.concatenate#numpy.concatenate \"numpy.concatenate\")\n\nJoin a sequence of arrays along an existing axis.\n\n [`stack`](numpy.stack#numpy.stack \"numpy.stack\")\n\nJoin a sequence of arrays along a new axis.\n\n [`block`](numpy.block#numpy.block \"numpy.block\")\n\nAssemble an nd-array from nested lists of blocks.\n\n [`hstack`](numpy.hstack#numpy.hstack \"numpy.hstack\")\n\nStack arrays in sequence horizontally (column wise).\n\n [`dstack`](numpy.dstack#numpy.dstack \"numpy.dstack\")\n\nStack arrays in sequence depth wise (along third axis).\n\n [`column_stack`](numpy.column_stack#numpy.column_stack \"numpy.column_stack\")\n\nStack 1-D arrays as columns into a 2-D array.\n\n [`vsplit`](numpy.vsplit#numpy.vsplit \"numpy.vsplit\")\n\nSplit an array into multiple sub-arrays vertically (row-wise).\n\n #### Notes\n\n The function is applied to both the _data and the _mask, if any.\n\n #### Examples\n\n \n```\n>>> a = np.array([1, 2, 3])\n>>> b = np.array([4, 5, 6])\n>>> np.vstack((a,b))\narray([[1, 2, 3],\n [4, 5, 6]])\n\n```\n \n```\n>>> a = np.array([[1], [2], [3]])\n>>> b = np.array([[4], [5], [6]])\n>>> np.vstack((a,b))\narray([[1],\n [2],\n [3],\n [4],\n [5],\n [6]])\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n>> import numpy.ma as ma\n>>> a = ma.masked_values([1, 2, 3], 2)\n>>> b = ma.masked_values([[4, 5, 6], [7, 8, 9]], 7)\n>>> ma.append(a, b)\nmasked_array(data=[1, --, 3, 4, 5, 6, --, 8, 9],\n mask=[False, True, False, False, False, False, True, False,\n False],\n fill_value=999999)\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n*)[[source]](https://github.com/numpy/numpy/blob/v1.23.0/numpy/ma/core.py#L1548-L1634)\n \nCreate a boolean mask from an array.\n\n Return `m` as a boolean mask, creating a copy if necessary or requested. The function can accept any sequence that is convertible to integers, or `nomask`. Does not require that contents must be 0s and 1s, values of 0 are interpreted as False, everything else as True.\n\n Parameters \n \n**m**array_like\n\nPotential mask.\n\n \n**copy**bool, optional\n\nWhether to return a copy of `m` (True) or `m` itself (False).\n\n \n**shrink**bool, optional\n\nWhether to shrink `m` to `nomask` if all its values are False.\n\n \n**dtype**dtype, optional\n\nData-type of the output mask. By default, the output mask has a dtype of MaskType (bool). If the dtype is flexible, each field has a boolean dtype. This is ignored when `m` is `nomask`, in which case `nomask` is always returned.\n\n Returns \n \n**result**ndarray\n\nA boolean mask derived from `m`.\n\n #### Examples\n\n \n```\n>>> import numpy.ma as ma\n>>> m = [True, False, True, True]\n>>> ma.make_mask(m)\narray([ True, False, True, True])\n>>> m = [1, 0, 1, 1]\n>>> ma.make_mask(m)\narray([ True, False, True, True])\n>>> m = [1, 0, 2, -3]\n>>> ma.make_mask(m)\narray([ True, False, True, True])\n\n```\n Effect of the `shrink` parameter.\n\n \n```\n>>> m = np.zeros(4)\n>>> m\narray([0., 0., 0., 0.])\n>>> ma.make_mask(m)\nFalse\n>>> ma.make_mask(m, shrink=False)\narray([False, False, False, False])\n\n```\n Using a flexible [`dtype`](numpy.dtype#numpy.dtype \"numpy.dtype\").\n\n \n```\n>>> m = [1, 0, 1, 1]\n>>> n = [0, 1, 0, 0]\n>>> arr = []\n>>> for man, mouse in zip(m, n):\n... arr.append((man, mouse))\n>>> arr\n[(1, 0), (0, 1), (1, 0), (1, 0)]\n>>> dtype = np.dtype({'names':['man', 'mouse'],\n... 'formats':[np.int64, np.int64]})\n>>> arr = np.array(arr, dtype=dtype)\n>>> arr\narray([(1, 0), (0, 1), (1, 0), (1, 0)],\n dtype=[('man', '>> ma.make_mask(arr, dtype=dtype)\narray([(True, False), (False, True), (True, False), (True, False)],\n dtype=[('man', '|b1'), ('mouse', '|b1')])\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n>> import numpy.ma as ma\n>>> ma.make_mask_none((3,))\narray([False, False, False])\n\n```\n Defining a more complex dtype.\n\n \n```\n>>> dtype = np.dtype({'names':['foo', 'bar'],\n... 'formats':[np.float32, np.int64]})\n>>> dtype\ndtype([('foo', '>> ma.make_mask_none((3,), dtype=dtype)\narray([(False, False), (False, False), (False, False)],\n dtype=[('foo', '|b1'), ('bar', '|b1')])\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n>> m1 = np.ma.make_mask([0, 1, 1, 0])\n>>> m2 = np.ma.make_mask([1, 0, 0, 0])\n>>> np.ma.mask_or(m1, m2)\narray([ True, True, True, False])\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n>> import numpy.ma as ma\n>>> dtype = np.dtype({'names':['foo', 'bar'],\n... 'formats':[np.float32, np.int64]})\n>>> dtype\ndtype([('foo', '>> ma.make_mask_descr(dtype)\ndtype([('foo', '|b1'), ('bar', '|b1')])\n>>> ma.make_mask_descr(np.float32)\ndtype('bool')\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n>> a = np.ma.arange(9).reshape((3, 3))\n>>> a[1, 0] = np.ma.masked\n>>> a[1, 2] = np.ma.masked\n>>> a[2, 1] = np.ma.masked\n>>> a\nmasked_array(\n data=[[0, 1, 2],\n [--, 4, --],\n [6, --, 8]],\n mask=[[False, False, False],\n [ True, False, True],\n [False, True, False]],\n fill_value=999999)\n>>> for index, x in np.ma.ndenumerate(a):\n... print(index, x)\n(0, 0) 0\n(0, 1) 1\n(0, 2) 2\n(1, 1) 4\n(2, 0) 6\n(2, 2) 8\n\n```\n \n```\n>>> for index, x in np.ma.ndenumerate(a, compressed=False):\n... print(index, x)\n(0, 0) 0\n(0, 1) 1\n(0, 2) 2\n(1, 0) --\n(1, 1) 4\n(1, 2) --\n(2, 0) 6\n(2, 1) --\n(2, 2) 8\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n>> a = np.ma.arange(10)\n>>> np.ma.flatnotmasked_contiguous(a)\n[slice(0, 10, None)]\n\n```\n \n```\n>>> mask = (a < 3) | (a > 8) | (a == 5)\n>>> a[mask] = np.ma.masked\n>>> np.array(a[~a.mask])\narray([3, 4, 6, 7, 8])\n\n```\n \n```\n>>> np.ma.flatnotmasked_contiguous(a)\n[slice(3, 5, None), slice(6, 9, None)]\n>>> a[:] = np.ma.masked\n>>> np.ma.flatnotmasked_contiguous(a)\n[]\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n>> a = np.ma.arange(10)\n>>> np.ma.flatnotmasked_edges(a)\narray([0, 9])\n\n```\n \n```\n>>> mask = (a < 3) | (a > 8) | (a == 5)\n>>> a[mask] = np.ma.masked\n>>> np.array(a[~a.mask])\narray([3, 4, 6, 7, 8])\n\n```\n \n```\n>>> np.ma.flatnotmasked_edges(a)\narray([3, 8])\n\n```\n \n```\n>>> a[:] = np.ma.masked\n>>> print(np.ma.flatnotmasked_edges(a))\nNone\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n>> a = np.arange(12).reshape((3, 4))\n>>> mask = np.zeros_like(a)\n>>> mask[1:, :-1] = 1; mask[0, 1] = 1; mask[-1, 0] = 0\n>>> ma = np.ma.array(a, mask=mask)\n>>> ma\nmasked_array(\n data=[[0, --, 2, 3],\n [--, --, --, 7],\n [8, --, --, 11]],\n mask=[[False, True, False, False],\n [ True, True, True, False],\n [False, True, True, False]],\n fill_value=999999)\n>>> np.array(ma[~ma.mask])\narray([ 0, 2, 3, 7, 8, 11])\n\n```\n \n```\n>>> np.ma.notmasked_contiguous(ma)\n[slice(0, 1, None), slice(2, 4, None), slice(7, 9, None), slice(11, 12, None)]\n\n```\n \n```\n>>> np.ma.notmasked_contiguous(ma, axis=0)\n[[slice(0, 1, None), slice(2, 3, None)], [], [slice(0, 1, None)], [slice(0, 3, None)]]\n\n```\n \n```\n>>> np.ma.notmasked_contiguous(ma, axis=1)\n[[slice(0, 1, None), slice(2, 4, None)], [slice(3, 4, None)], [slice(0, 1, None), slice(3, 4, None)]]\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n>> a = np.arange(9).reshape((3, 3))\n>>> m = np.zeros_like(a)\n>>> m[1:, 1:] = 1\n\n```\n \n```\n>>> am = np.ma.array(a, mask=m)\n>>> np.array(am[~am.mask])\narray([0, 1, 2, 3, 6])\n\n```\n \n```\n>>> np.ma.notmasked_edges(am)\narray([0, 6])\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n>> a = np.ma.masked_array(np.arange(10))\n>>> a[[0, 1, 2, 6, 8, 9]] = np.ma.masked\n>>> np.ma.clump_masked(a)\n[slice(0, 3, None), slice(6, 7, None), slice(8, 10, None)]\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n>> a = np.ma.masked_array(np.arange(10))\n>>> a[[0, 1, 2, 6, 8, 9]] = np.ma.masked\n>>> np.ma.clump_unmasked(a)\n[slice(3, 6, None), slice(7, 8, None)]\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n*)[[source]](https://github.com/numpy/numpy/blob/v1.23.0/numpy/ma/extras.py#L1013-L1060)\n \nMask columns of a 2D array that contain masked values.\n\n This function is a shortcut to `mask_rowcols` with `axis` equal to 1.\n\n See also\n\n [`mask_rowcols`](numpy.ma.mask_rowcols#numpy.ma.mask_rowcols \"numpy.ma.mask_rowcols\")\n\nMask rows and/or columns of a 2D array.\n\n [`masked_where`](numpy.ma.masked_where#numpy.ma.masked_where \"numpy.ma.masked_where\")\n\nMask where a condition is met.\n\n #### Examples\n\n \n```\n>>> import numpy.ma as ma\n>>> a = np.zeros((3, 3), dtype=int)\n>>> a[1, 1] = 1\n>>> a\narray([[0, 0, 0],\n [0, 1, 0],\n [0, 0, 0]])\n>>> a = ma.masked_equal(a, 1)\n>>> a\nmasked_array(\n data=[[0, 0, 0],\n [0, --, 0],\n [0, 0, 0]],\n mask=[[False, False, False],\n [False, True, False],\n [False, False, False]],\n fill_value=1)\n>>> ma.mask_cols(a)\nmasked_array(\n data=[[0, --, 0],\n [0, --, 0],\n [0, --, 0]],\n mask=[[False, True, False],\n [False, True, False],\n [False, True, False]],\n fill_value=1)\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n>> import numpy.ma as ma\n>>> a = np.zeros((3, 3), dtype=int)\n>>> a[1, 1] = 1\n>>> a\narray([[0, 0, 0],\n [0, 1, 0],\n [0, 0, 0]])\n>>> a = ma.masked_equal(a, 1)\n>>> a\nmasked_array(\n data=[[0, 0, 0],\n [0, --, 0],\n [0, 0, 0]],\n mask=[[False, False, False],\n [False, True, False],\n [False, False, False]],\n fill_value=1)\n>>> ma.mask_rowcols(a)\nmasked_array(\n data=[[0, --, 0],\n [--, --, --],\n [0, --, 0]],\n mask=[[False, True, False],\n [ True, True, True],\n [False, True, False]],\n fill_value=1)\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n*)[[source]](https://github.com/numpy/numpy/blob/v1.23.0/numpy/ma/extras.py#L962-L1010)\n \nMask rows of a 2D array that contain masked values.\n\n This function is a shortcut to `mask_rowcols` with `axis` equal to 0.\n\n See also\n\n [`mask_rowcols`](numpy.ma.mask_rowcols#numpy.ma.mask_rowcols \"numpy.ma.mask_rowcols\")\n\nMask rows and/or columns of a 2D array.\n\n [`masked_where`](numpy.ma.masked_where#numpy.ma.masked_where \"numpy.ma.masked_where\")\n\nMask where a condition is met.\n\n #### Examples\n\n \n```\n>>> import numpy.ma as ma\n>>> a = np.zeros((3, 3), dtype=int)\n>>> a[1, 1] = 1\n>>> a\narray([[0, 0, 0],\n [0, 1, 0],\n [0, 0, 0]])\n>>> a = ma.masked_equal(a, 1)\n>>> a\nmasked_array(\n data=[[0, 0, 0],\n [0, --, 0],\n [0, 0, 0]],\n mask=[[False, False, False],\n [False, True, False],\n [False, False, False]],\n fill_value=1)\n\n```\n \n```\n>>> ma.mask_rows(a)\nmasked_array(\n data=[[0, 0, 0],\n [--, --, --],\n [0, 0, 0]],\n mask=[[False, False, False],\n [ True, True, True],\n [False, False, False]],\n fill_value=1)\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n*\n \nForce the mask to hard, preventing unmasking by assignment.\n\n Whether the mask of a masked array is hard or soft is determined by its [`hardmask`](../maskedarray.baseclass#numpy.ma.MaskedArray.hardmask \"numpy.ma.MaskedArray.hardmask\") property. [`harden_mask`](#numpy.ma.harden_mask \"numpy.ma.harden_mask\") sets [`hardmask`](../maskedarray.baseclass#numpy.ma.MaskedArray.hardmask \"numpy.ma.MaskedArray.hardmask\") to `True` (and returns the modified self).\n\n See also\n\n [`ma.MaskedArray.hardmask`](../maskedarray.baseclass#numpy.ma.MaskedArray.hardmask \"numpy.ma.MaskedArray.hardmask\")\n[`ma.MaskedArray.soften_mask`](numpy.ma.maskedarray.soften_mask#numpy.ma.MaskedArray.soften_mask \"numpy.ma.MaskedArray.soften_mask\")\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n*\n \nForce the mask to soft (default), allowing unmasking by assignment.\n\n Whether the mask of a masked array is hard or soft is determined by its [`hardmask`](../maskedarray.baseclass#numpy.ma.MaskedArray.hardmask \"numpy.ma.MaskedArray.hardmask\") property. [`soften_mask`](#numpy.ma.soften_mask \"numpy.ma.soften_mask\") sets [`hardmask`](../maskedarray.baseclass#numpy.ma.MaskedArray.hardmask \"numpy.ma.MaskedArray.hardmask\") to `False` (and returns the modified self).\n\n See also\n\n [`ma.MaskedArray.hardmask`](../maskedarray.baseclass#numpy.ma.MaskedArray.hardmask \"numpy.ma.MaskedArray.hardmask\")\n[`ma.MaskedArray.harden_mask`](numpy.ma.maskedarray.harden_mask#numpy.ma.MaskedArray.harden_mask \"numpy.ma.MaskedArray.harden_mask\")\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n>> x = np.ma.array([[1,2 ], [3, 4]], mask=[0]*4)\n>>> x.mask\narray([[False, False],\n [False, False]])\n>>> x.shrink_mask()\nmasked_array(\n data=[[1, 2],\n [3, 4]],\n mask=False,\n fill_value=999999)\n>>> x.mask\nFalse\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n>> x = np.arange(10.).reshape(2, 5)\n>>> x\narray([[0., 1., 2., 3., 4.],\n [5., 6., 7., 8., 9.]])\n>>> np.ma.asarray(x)\nmasked_array(\n data=[[0., 1., 2., 3., 4.],\n [5., 6., 7., 8., 9.]],\n mask=False,\n fill_value=1e+20)\n>>> type(np.ma.asarray(x))\n>> x = np.arange(10.).reshape(2, 5)\n>>> x\narray([[0., 1., 2., 3., 4.],\n [5., 6., 7., 8., 9.]])\n>>> np.ma.asanyarray(x)\nmasked_array(\n data=[[0., 1., 2., 3., 4.],\n [5., 6., 7., 8., 9.]],\n mask=False,\n fill_value=1e+20)\n>>> type(np.ma.asanyarray(x))\n>> x = np.ma.array([1., -1, np.nan, np.inf], mask=[1] + [0]*3)\n>>> x\nmasked_array(data=[--, -1.0, nan, inf],\n mask=[ True, False, False, False],\n fill_value=1e+20)\n>>> np.ma.fix_invalid(x)\nmasked_array(data=[--, -1.0, --, --],\n mask=[ True, False, True, True],\n fill_value=1e+20)\n\n```\n \n```\n>>> fixed = np.ma.fix_invalid(x)\n>>> fixed.data\narray([ 1.e+00, -1.e+00, 1.e+20, 1.e+20])\n>>> x.data\narray([ 1., -1., nan, inf])\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n>> import numpy.ma as ma\n>>> a = np.arange(4)\n>>> a\narray([0, 1, 2, 3])\n>>> ma.masked_equal(a, 2)\nmasked_array(data=[0, 1, --, 3],\n mask=[False, False, True, False],\n fill_value=2)\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n value).\n\n See also\n\n [`masked_where`](numpy.ma.masked_where#numpy.ma.masked_where \"numpy.ma.masked_where\")\n\nMask where a condition is met.\n\n #### Examples\n\n \n```\n>>> import numpy.ma as ma\n>>> a = np.arange(4)\n>>> a\narray([0, 1, 2, 3])\n>>> ma.masked_greater(a, 2)\nmasked_array(data=[0, 1, 2, --],\n mask=[False, False, False, True],\n fill_value=999999)\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n= value).\n\n See also\n\n [`masked_where`](numpy.ma.masked_where#numpy.ma.masked_where \"numpy.ma.masked_where\")\n\nMask where a condition is met.\n\n #### Examples\n\n \n```\n>>> import numpy.ma as ma\n>>> a = np.arange(4)\n>>> a\narray([0, 1, 2, 3])\n>>> ma.masked_greater_equal(a, 2)\nmasked_array(data=[0, 1, --, --],\n mask=[False, False, True, True],\n fill_value=999999)\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n>> import numpy.ma as ma\n>>> x = [0.31, 1.2, 0.01, 0.2, -0.4, -1.1]\n>>> ma.masked_inside(x, -0.3, 0.3)\nmasked_array(data=[0.31, 1.2, --, --, -0.4, -1.1],\n mask=[False, False, True, True, False, False],\n fill_value=1e+20)\n\n```\n The order of `v1` and `v2` doesnât matter.\n\n \n```\n>>> ma.masked_inside(x, 0.3, -0.3)\nmasked_array(data=[0.31, 1.2, --, --, -0.4, -1.1],\n mask=[False, False, True, True, False, False],\n fill_value=1e+20)\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n>> import numpy.ma as ma\n>>> a = np.arange(5, dtype=float)\n>>> a[2] = np.NaN\n>>> a[3] = np.PINF\n>>> a\narray([ 0., 1., nan, inf, 4.])\n>>> ma.masked_invalid(a)\nmasked_array(data=[0.0, 1.0, --, --, 4.0],\n mask=[False, False, True, True, False],\n fill_value=1e+20)\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n>> import numpy.ma as ma\n>>> a = np.arange(4)\n>>> a\narray([0, 1, 2, 3])\n>>> ma.masked_less(a, 2)\nmasked_array(data=[--, --, 2, 3],\n mask=[ True, True, False, False],\n fill_value=999999)\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n>> import numpy.ma as ma\n>>> a = np.arange(4)\n>>> a\narray([0, 1, 2, 3])\n>>> ma.masked_less_equal(a, 2)\nmasked_array(data=[--, --, --, 3],\n mask=[ True, True, True, False],\n fill_value=999999)\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n>> import numpy.ma as ma\n>>> a = np.arange(4)\n>>> a\narray([0, 1, 2, 3])\n>>> ma.masked_not_equal(a, 2)\nmasked_array(data=[--, --, 2, --],\n mask=[ True, True, False, True],\n fill_value=999999)\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n>> import numpy.ma as ma\n>>> food = np.array(['green_eggs', 'ham'], dtype=object)\n>>> # don't eat spoiled food\n>>> eat = ma.masked_object(food, 'green_eggs')\n>>> eat\nmasked_array(data=[--, 'ham'],\n mask=[ True, False],\n fill_value='green_eggs',\n dtype=object)\n>>> # plain ol` ham is boring\n>>> fresh_food = np.array(['cheese', 'ham', 'pineapple'], dtype=object)\n>>> eat = ma.masked_object(fresh_food, 'green_eggs')\n>>> eat\nmasked_array(data=['cheese', 'ham', 'pineapple'],\n mask=False,\n fill_value='green_eggs',\n dtype=object)\n\n```\n Note that `mask` is set to `nomask` if possible.\n\n \n```\n>>> eat\nmasked_array(data=['cheese', 'ham', 'pineapple'],\n mask=False,\n fill_value='green_eggs',\n dtype=object)\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n v2). The boundaries `v1` and `v2` can be given in either order.\n\n See also\n\n [`masked_where`](numpy.ma.masked_where#numpy.ma.masked_where \"numpy.ma.masked_where\")\n\nMask where a condition is met.\n\n #### Notes\n\n The array `x` is prefilled with its filling value.\n\n #### Examples\n\n \n```\n>>> import numpy.ma as ma\n>>> x = [0.31, 1.2, 0.01, 0.2, -0.4, -1.1]\n>>> ma.masked_outside(x, -0.3, 0.3)\nmasked_array(data=[--, --, 0.01, 0.2, --, --],\n mask=[ True, True, False, False, True, True],\n fill_value=1e+20)\n\n```\n The order of `v1` and `v2` doesnât matter.\n\n \n```\n>>> ma.masked_outside(x, 0.3, -0.3)\nmasked_array(data=[--, --, 0.01, 0.2, --, --],\n mask=[ True, True, False, False, True, True],\n fill_value=1e+20)\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n>> import numpy.ma as ma\n>>> x = np.array([1, 1.1, 2, 1.1, 3])\n>>> ma.masked_values(x, 1.1)\nmasked_array(data=[1.0, --, 2.0, --, 3.0],\n mask=[False, True, False, True, False],\n fill_value=1.1)\n\n```\n Note that `mask` is set to `nomask` if possible.\n\n \n```\n>>> ma.masked_values(x, 1.5)\nmasked_array(data=[1. , 1.1, 2. , 1.1, 3. ],\n mask=False,\n fill_value=1.5)\n\n```\n For integers, the fill value will be different in general to the result of `masked_equal`.\n\n \n```\n>>> x = np.arange(5)\n>>> x\narray([0, 1, 2, 3, 4])\n>>> ma.masked_values(x, 2)\nmasked_array(data=[0, 1, --, 3, 4],\n mask=[False, False, True, False, False],\n fill_value=2)\n>>> ma.masked_equal(x, 2)\nmasked_array(data=[0, 1, --, 3, 4],\n mask=[False, False, True, False, False],\n fill_value=2)\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n>> import numpy.ma as ma\n>>> a = np.arange(4)\n>>> a\narray([0, 1, 2, 3])\n>>> ma.masked_where(a <= 2, a)\nmasked_array(data=[--, --, --, 3],\n mask=[ True, True, True, False],\n fill_value=999999)\n\n```\n Mask array `b` conditional on `a`.\n\n \n```\n>>> b = ['a', 'b', 'c', 'd']\n>>> ma.masked_where(a == 2, b)\nmasked_array(data=['a', 'b', --, 'd'],\n mask=[False, False, True, False],\n fill_value='N/A',\n dtype='>> c = ma.masked_where(a <= 2, a)\n>>> c\nmasked_array(data=[--, --, --, 3],\n mask=[ True, True, True, False],\n fill_value=999999)\n>>> c[0] = 99\n>>> c\nmasked_array(data=[99, --, --, 3],\n mask=[False, True, True, False],\n fill_value=999999)\n>>> a\narray([0, 1, 2, 3])\n>>> c = ma.masked_where(a <= 2, a, copy=False)\n>>> c[0] = 99\n>>> c\nmasked_array(data=[99, --, --, 3],\n mask=[False, True, True, False],\n fill_value=999999)\n>>> a\narray([99, 1, 2, 3])\n\n```\n When `condition` or `a` contain masked values.\n\n \n```\n>>> a = np.arange(4)\n>>> a = ma.masked_where(a == 2, a)\n>>> a\nmasked_array(data=[0, 1, --, 3],\n mask=[False, False, True, False],\n fill_value=999999)\n>>> b = np.arange(4)\n>>> b = ma.masked_where(b == 0, b)\n>>> b\nmasked_array(data=[--, 1, 2, 3],\n mask=[ True, False, False, False],\n fill_value=999999)\n>>> ma.masked_where(a == 3, b)\nmasked_array(data=[--, 1, --, --],\n mask=[ True, False, True, True],\n fill_value=999999)\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n>> x = np.ma.array(np.arange(9).reshape(3, 3), mask=[[1, 0, 0],\n... [1, 0, 0],\n... [0, 0, 0]])\n>>> x\nmasked_array(\n data=[[--, 1, 2],\n [--, 4, 5],\n [6, 7, 8]],\n mask=[[ True, False, False],\n [ True, False, False],\n [False, False, False]],\n fill_value=999999)\n\n```\n \n```\n>>> np.ma.compress_rowcols(x)\narray([[7, 8]])\n>>> np.ma.compress_rowcols(x, 0)\narray([[6, 7, 8]])\n>>> np.ma.compress_rowcols(x, 1)\narray([[1, 2],\n [4, 5],\n [7, 8]])\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n>> x = np.ma.array(np.arange(9).reshape(3, 3), mask=[[1, 0, 0],\n... [1, 0, 0],\n... [0, 0, 0]])\n>>> x.filled()\narray([[999999, 1, 2],\n [999999, 4, 5],\n [ 6, 7, 8]])\n>>> x.filled(fill_value=333)\narray([[333, 1, 2],\n [333, 4, 5],\n [ 6, 7, 8]])\n>>> x.filled(fill_value=np.arange(3))\narray([[0, 1, 2],\n [0, 4, 5],\n [6, 7, 8]])\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n>> x = np.ma.array(np.arange(5), mask=[0]*2 + [1]*3)\n>>> x.compressed()\narray([0, 1])\n>>> type(x.compressed())\n>> x = np.ma.array([1,2,3,4,5], mask=[0,0,1,0,1], fill_value=-999)\n>>> x.filled()\narray([ 1, 2, -999, 4, -999])\n>>> x.filled(fill_value=1000)\narray([ 1, 2, 1000, 4, 1000])\n>>> type(x.filled())\n>> x = np.array([(-1, 2), (-3, 4)], dtype='i8,i8').view(np.recarray)\n>>> m = np.ma.array(x, mask=[(True, False), (False, True)])\n>>> m.filled()\nrec.array([(999999, 2), ( -3, 999999)],\n dtype=[('f0', '>> x = np.ma.array([[1,2,3], [4,5,6], [7,8,9]], mask=[0] + [1,0]*4)\n>>> x.tolist()\n[[1, None, 3], [None, 5, None], [7, None, 9]]\n>>> x.tolist(-999)\n[[1, -999, 3], [-999, 5, -999], [7, -999, 9]]\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n>> x = np.ma.array([[1,2,3],[4,5,6],[7,8,9]], mask=[0] + [1,0]*4)\n>>> x\nmasked_array(\n data=[[1, --, 3],\n [--, 5, --],\n [7, --, 9]],\n mask=[[False, True, False],\n [ True, False, True],\n [False, True, False]],\n fill_value=999999)\n>>> x.toflex()\narray([[(1, False), (2, True), (3, False)],\n [(4, True), (5, False), (6, True)],\n [(7, False), (8, True), (9, False)]],\n dtype=[('_data', '>> x = np.ma.array(np.array([[1, 2], [3, 4]]), mask=[[0, 1], [1, 0]])\n>>> x.tobytes()\nb'\\x01\\x00\\x00\\x00\\x00\\x00\\x00\\x00?B\\x0f\\x00\\x00\\x00\\x00\\x00?B\\x0f\\x00\\x00\\x00\\x00\\x00\\x04\\x00\\x00\\x00\\x00\\x00\\x00\\x00'\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n>> x = np.ma.array([0, 1.], fill_value=3)\n>>> y = np.ma.array([0, 1.], fill_value=3)\n>>> np.ma.common_fill_value(x, y)\n3.0\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n>> np.ma.default_fill_value(1)\n999999\n>>> np.ma.default_fill_value(np.array([1.1, 2., np.pi]))\n1e+20\n>>> np.ma.default_fill_value(np.dtype(complex))\n(1e+20+0j)\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n>> import numpy.ma as ma\n>>> a = np.int8()\n>>> ma.maximum_fill_value(a)\n-128\n>>> a = np.int32()\n>>> ma.maximum_fill_value(a)\n-2147483648\n\n```\n An array of numeric data can also be passed.\n\n \n```\n>>> a = np.array([1, 2, 3], dtype=np.int8)\n>>> ma.maximum_fill_value(a)\n-128\n>>> a = np.array([1, 2, 3], dtype=np.float32)\n>>> ma.maximum_fill_value(a)\n-inf\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n>> import numpy.ma as ma\n>>> a = np.int8()\n>>> ma.minimum_fill_value(a)\n127\n>>> a = np.int32()\n>>> ma.minimum_fill_value(a)\n2147483647\n\n```\n An array of numeric data can also be passed.\n\n \n```\n>>> a = np.array([1, 2, 3], dtype=np.int8)\n>>> ma.minimum_fill_value(a)\n127\n>>> a = np.array([1, 2, 3], dtype=np.float32)\n>>> ma.minimum_fill_value(a)\ninf\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n>> import numpy.ma as ma\n>>> a = np.arange(5)\n>>> a\narray([0, 1, 2, 3, 4])\n>>> a = ma.masked_where(a < 3, a)\n>>> a\nmasked_array(data=[--, --, --, 3, 4],\n mask=[ True, True, True, False, False],\n fill_value=999999)\n>>> ma.set_fill_value(a, -999)\n>>> a\nmasked_array(data=[--, --, --, 3, 4],\n mask=[ True, True, True, False, False],\n fill_value=-999)\n\n```\n Nothing happens if `a` is not a masked array.\n\n \n```\n>>> a = list(range(5))\n>>> a\n[0, 1, 2, 3, 4]\n>>> ma.set_fill_value(a, 100)\n>>> a\n[0, 1, 2, 3, 4]\n>>> a = np.arange(5)\n>>> a\narray([0, 1, 2, 3, 4])\n>>> ma.set_fill_value(a, 100)\n>>> a\narray([0, 1, 2, 3, 4])\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n>> for dt in [np.int32, np.int64, np.float64, np.complex128]:\n... np.ma.array([0, 1], dtype=dt).get_fill_value()\n...\n999999\n999999\n1e+20\n(1e+20+0j)\n\n```\n \n```\n>>> x = np.ma.array([0, 1.], fill_value=-np.inf)\n>>> x.fill_value\n-inf\n>>> x.fill_value = np.pi\n>>> x.fill_value\n3.1415926535897931 # may vary\n\n```\n Reset to default:\n\n \n```\n>>> x.fill_value = None\n>>> x.fill_value\n1e+20\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n*\n \nCompute the anomalies (deviations from the arithmetic mean) along the given axis.\n\n Returns an array of anomalies, with the same shape as the input and where the arithmetic mean is computed along the given axis.\n\n Parameters \n \n**axis**int, optional\n\nAxis over which the anomalies are taken. The default is to use the mean of the flattened array as reference.\n\n \n**dtype**dtype, optional\n\n Type to use in computing the variance. For arrays of integer type\n\nthe default is float32; for arrays of float types it is the same as the array type.\n\n See also\n\n [`mean`](numpy.mean#numpy.mean \"numpy.mean\")\n\nCompute the mean of the array.\n\n #### Examples\n\n \n```\n>>> a = np.ma.array([1,2,3])\n>>> a.anom()\nmasked_array(data=[-1., 0., 1.],\n mask=False,\n fill_value=1e+20)\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n*\n \nCompute the anomalies (deviations from the arithmetic mean) along the given axis.\n\n Returns an array of anomalies, with the same shape as the input and where the arithmetic mean is computed along the given axis.\n\n Parameters \n \n**axis**int, optional\n\nAxis over which the anomalies are taken. The default is to use the mean of the flattened array as reference.\n\n \n**dtype**dtype, optional\n\n Type to use in computing the variance. For arrays of integer type\n\nthe default is float32; for arrays of float types it is the same as the array type.\n\n See also\n\n [`mean`](numpy.mean#numpy.mean \"numpy.mean\")\n\nCompute the mean of the array.\n\n #### Examples\n\n \n```\n>>> a = np.ma.array([1,2,3])\n>>> a.anom()\nmasked_array(data=[-1., 0., 1.],\n mask=False,\n fill_value=1e+20)\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n*)[[source]](https://github.com/numpy/numpy/blob/v1.23.0/numpy/ma/extras.py#L528-L657)\n \nReturn the weighted average of array over the given axis.\n\n Parameters \n \n**a**array_like\n\nData to be averaged. Masked entries are not taken into account in the computation.\n\n \n**axis**int, optional\n\nAxis along which to average `a`. If None, averaging is done over the flattened array.\n\n \n**weights**array_like, optional\n\nThe importance that each element has in the computation of the average. The weights array can either be 1-D (in which case its length must be the size of `a` along the given axis) or of the same shape as `a`. If `weights=None`, then all data in `a` are assumed to have a weight equal to one. The 1-D calculation is:\n\n \n```\navg = sum(a * weights) / sum(weights)\n\n```\n The only constraint on `weights` is that `sum(weights)` must not be 0.\n\n \n**returned**bool, optional\n\nFlag indicating whether a tuple `(result, sum of weights)` should be returned as output (True), or just the result (False). Default is False.\n\n \n**keepdims**bool, optional\n\nIf 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 original `a`. *Note:* `keepdims` will not work with instances of [`numpy.matrix`](numpy.matrix#numpy.matrix \"numpy.matrix\") or other classes whose methods do not support `keepdims`.\n\n New in version 1.23.0.\n\n Returns \n \n**average, [sum_of_weights]**(tuple of) scalar or MaskedArray\n\nThe average along the specified axis. When returned is `True`, return a tuple with the average as the first element and the sum of the weights as the second element. The return type is `np.float64` if `a` is of integer type and floats smaller than [`float64`](../arrays.scalars#numpy.float64 \"numpy.float64\"), or the input data-type, otherwise. If returned, `sum_of_weights` is always [`float64`](../arrays.scalars#numpy.float64 \"numpy.float64\").\n\n #### Examples\n\n \n```\n>>> a = np.ma.array([1., 2., 3., 4.], mask=[False, False, True, True])\n>>> np.ma.average(a, weights=[3, 1, 0, 0])\n1.25\n\n```\n \n```\n>>> x = np.ma.arange(6.).reshape(3, 2)\n>>> x\nmasked_array(\n data=[[0., 1.],\n [2., 3.],\n [4., 5.]],\n mask=False,\n fill_value=1e+20)\n>>> avg, sumweights = np.ma.average(x, axis=0, weights=[1, 2, 3],\n... returned=True)\n>>> avg\nmasked_array(data=[2.6666666666666665, 3.6666666666666665],\n mask=[False, False],\n fill_value=1e+20)\n\n```\n With `keepdims=True`, the following result has shape (3, 1).\n\n \n```\n>>> np.ma.average(x, axis=1, keepdims=True)\nmasked_array(\n data=[[0.5],\n [2.5],\n [4.5]],\n mask=False,\n fill_value=1e+20)\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n*\n \nReturn the complex conjugate, element-wise.\n\n The complex conjugate of a complex number is obtained by changing the sign of its imaginary part.\n\n Parameters \n \n**x**array_like\n\nInput value.\n\n \n**out**ndarray, None, or tuple of ndarray and None, optional\n\nA 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.\n\n \n**where**array_like, optional\n\nThis 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.\n\n ****kwargs**\n\nFor other keyword-only arguments, see the [ufunc docs](../ufuncs#ufuncs-kwargs).\n\n Returns \n \n**y**ndarray\n\nThe complex conjugate of `x`, with same dtype as `y`. This is a scalar if `x` is a scalar.\n\n #### Notes\n\n [`conj`](numpy.conj#numpy.conj \"numpy.conj\") is an alias for [`conjugate`](numpy.conjugate#numpy.conjugate \"numpy.conjugate\"):\n\n \n```\n>>> np.conj is np.conjugate\nTrue\n\n```\n #### Examples\n\n \n```\n>>> np.conjugate(1+2j)\n(1-2j)\n\n```\n \n```\n>>> x = np.eye(2) + 1j * np.eye(2)\n>>> np.conjugate(x)\narray([[ 1.-1.j, 0.-0.j],\n [ 0.-0.j, 1.-1.j]])\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n*, *allow_masked=True*, *ddof=*)[[source]](https://github.com/numpy/numpy/blob/v1.23.0/numpy/ma/extras.py#L1407-L1491)\n \nReturn Pearson product-moment correlation coefficients.\n\n Except for the handling of missing data this function does the same as [`numpy.corrcoef`](numpy.corrcoef#numpy.corrcoef \"numpy.corrcoef\"). For more details and examples, see [`numpy.corrcoef`](numpy.corrcoef#numpy.corrcoef \"numpy.corrcoef\").\n\n Parameters \n \n**x**array_like\n\nA 1-D or 2-D array containing multiple variables and observations. Each row of `x` represents a variable, and each column a single observation of all those variables. Also see `rowvar` below.\n\n \n**y**array_like, optional\n\nAn additional set of variables and observations. `y` has the same shape as `x`.\n\n \n**rowvar**bool, optional\n\nIf `rowvar` is True (default), then each row represents a variable, with observations in the columns. Otherwise, the relationship is transposed: each column represents a variable, while the rows contain observations.\n\n \n**bias**_NoValue, optional\n\nHas no effect, do not use.\n\n Deprecated since version 1.10.0.\n\n \n**allow_masked**bool, optional\n\nIf True, masked values are propagated pair-wise: if a value is masked in `x`, the corresponding value is masked in `y`. If False, raises an exception. Because `bias` is deprecated, this argument needs to be treated as keyword only to avoid a warning.\n\n \n**ddof**_NoValue, optional\n\nHas no effect, do not use.\n\n Deprecated since version 1.10.0.\n\n See also\n\n [`numpy.corrcoef`](numpy.corrcoef#numpy.corrcoef \"numpy.corrcoef\")\n\nEquivalent function in top-level NumPy module.\n\n [`cov`](numpy.cov#numpy.cov \"numpy.cov\")\n\nEstimate the covariance matrix.\n\n #### Notes\n\n This function accepts but discards arguments `bias` and `ddof`. This is for backwards compatibility with previous versions of this function. These arguments had no effect on the return values of the function and can be safely ignored in this and previous versions of numpy.\n\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n= 1.5.\n\n \n**allow_masked**bool, optional\n\nIf True, masked values are propagated pair-wise: if a value is masked in `x`, the corresponding value is masked in `y`. If False, raises a `ValueError` exception when some values are missing.\n\n \n**ddof**{None, int}, optional\n\nIf not `None` normalization is by `(N - ddof)`, where `N` is the number of observations; this overrides the value implied by `bias`. The default value is `None`.\n\n New in version 1.5.\n\n Raises \n ValueError\n\nRaised if some values are missing and `allow_masked` is False.\n\n See also\n\n [`numpy.cov`](numpy.cov#numpy.cov \"numpy.cov\")\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n*\n \nReturn the cumulative sum of the array elements over the given axis.\n\n Masked values are set to 0 internally during the computation. However, their position is saved, and the result will be masked at the same locations.\n\n Refer to [`numpy.cumsum`](numpy.cumsum#numpy.cumsum \"numpy.cumsum\") for full documentation.\n\n See also\n\n [`numpy.ndarray.cumsum`](numpy.ndarray.cumsum#numpy.ndarray.cumsum \"numpy.ndarray.cumsum\")\n\ncorresponding function for ndarrays\n\n [`numpy.cumsum`](numpy.cumsum#numpy.cumsum \"numpy.cumsum\")\n\nequivalent function\n\n #### Notes\n\n The mask is lost if `out` is not a valid [`ma.MaskedArray`](../maskedarray.baseclass#numpy.ma.MaskedArray \"numpy.ma.MaskedArray\") !\n\n Arithmetic is modular when using integer types, and no error is raised on overflow.\n\n #### Examples\n\n \n```\n>>> marr = np.ma.array(np.arange(10), mask=[0,0,0,1,1,1,0,0,0,0])\n>>> marr.cumsum()\nmasked_array(data=[0, 1, 3, --, --, --, 9, 16, 24, 33],\n mask=[False, False, False, True, True, True, False, False,\n False, False],\n fill_value=999999)\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n*\n \nReturn the cumulative product of the array elements over the given axis.\n\n Masked values are set to 1 internally during the computation. However, their position is saved, and the result will be masked at the same locations.\n\n Refer to [`numpy.cumprod`](numpy.cumprod#numpy.cumprod \"numpy.cumprod\") for full documentation.\n\n See also\n\n [`numpy.ndarray.cumprod`](numpy.ndarray.cumprod#numpy.ndarray.cumprod \"numpy.ndarray.cumprod\")\n\ncorresponding function for ndarrays\n\n [`numpy.cumprod`](numpy.cumprod#numpy.cumprod \"numpy.cumprod\")\n\nequivalent function\n\n #### Notes\n\n The mask is lost if `out` is not a valid MaskedArray !\n\n Arithmetic is modular when using integer types, and no error is raised on overflow.\n\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n*)*=*\n \nReturns the average of the array elements along given axis.\n\n Masked entries are ignored, and result elements which are not finite will be masked.\n\n Refer to [`numpy.mean`](numpy.mean#numpy.mean \"numpy.mean\") for full documentation.\n\n See also\n\n [`numpy.ndarray.mean`](numpy.ndarray.mean#numpy.ndarray.mean \"numpy.ndarray.mean\")\n\ncorresponding function for ndarrays\n\n [`numpy.mean`](numpy.mean#numpy.mean \"numpy.mean\")\n\nEquivalent function\n\n [`numpy.ma.average`](numpy.ma.average#numpy.ma.average \"numpy.ma.average\")\n\nWeighted average.\n\n #### Examples\n\n \n```\n>>> a = np.ma.array([1,2,3], mask=[False, False, True])\n>>> a\nmasked_array(data=[1, 2, --],\n mask=[False, False, True],\n fill_value=999999)\n>>> a.mean()\n1.5\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n>> x = np.ma.array(np.arange(8), mask=[0]*4 + [1]*4)\n>>> np.ma.median(x)\n1.5\n\n```\n \n```\n>>> x = np.ma.array(np.arange(10).reshape(2, 5), mask=[0]*6 + [1]*4)\n>>> np.ma.median(x)\n2.5\n>>> np.ma.median(x, axis=-1, overwrite_input=True)\nmasked_array(data=[2.0, 5.0],\n mask=[False, False],\n fill_value=1e+20)\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n*)*=*\n \nReturn the product of the array elements over the given axis.\n\n Masked elements are set to 1 internally for computation.\n\n Refer to [`numpy.prod`](numpy.prod#numpy.prod \"numpy.prod\") for full documentation.\n\n See also\n\n [`numpy.ndarray.prod`](numpy.ndarray.prod#numpy.ndarray.prod \"numpy.ndarray.prod\")\n\ncorresponding function for ndarrays\n\n [`numpy.prod`](numpy.prod#numpy.prod \"numpy.prod\")\n\nequivalent function\n\n #### Notes\n\n Arithmetic is modular when using integer types, and no error is raised on overflow.\n\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n*)*=*\n \nReturns the standard deviation of the array elements along given axis.\n\n Masked entries are ignored.\n\n Refer to [`numpy.std`](numpy.std#numpy.std \"numpy.std\") for full documentation.\n\n See also\n\n [`numpy.ndarray.std`](numpy.ndarray.std#numpy.ndarray.std \"numpy.ndarray.std\")\n\ncorresponding function for ndarrays\n\n [`numpy.std`](numpy.std#numpy.std \"numpy.std\")\n\nEquivalent function\n\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n*)*=*\n \nReturn the sum of the array elements over the given axis.\n\n Masked elements are set to 0 internally.\n\n Refer to [`numpy.sum`](numpy.sum#numpy.sum \"numpy.sum\") for full documentation.\n\n See also\n\n [`numpy.ndarray.sum`](numpy.ndarray.sum#numpy.ndarray.sum \"numpy.ndarray.sum\")\n\ncorresponding function for ndarrays\n\n [`numpy.sum`](numpy.sum#numpy.sum \"numpy.sum\")\n\nequivalent function\n\n #### Examples\n\n \n```\n>>> x = np.ma.array([[1,2,3],[4,5,6],[7,8,9]], mask=[0] + [1,0]*4)\n>>> x\nmasked_array(\n data=[[1, --, 3],\n [--, 5, --],\n [7, --, 9]],\n mask=[[False, True, False],\n [ True, False, True],\n [False, True, False]],\n fill_value=999999)\n>>> x.sum()\n25\n>>> x.sum(axis=1)\nmasked_array(data=[4, 5, 16],\n mask=[False, False, False],\n fill_value=999999)\n>>> x.sum(axis=0)\nmasked_array(data=[8, 5, 12],\n mask=[False, False, False],\n fill_value=999999)\n>>> print(type(x.sum(axis=0, dtype=np.int64)[0]))\n*)*=*\n \nCompute the variance along the specified axis.\n\n Returns the variance of the array elements, a measure of the spread of a distribution. The variance is computed for the flattened array by default, otherwise over the specified axis.\n\n Parameters \n \n**a**array_like\n\nArray containing numbers whose variance is desired. If `a` is not an array, a conversion is attempted.\n\n \n**axis**None or int or tuple of ints, optional\n\nAxis or axes along which the variance is computed. The default is to compute the variance of the flattened array.\n\n New in version 1.7.0.\n\n If this is a tuple of ints, a variance is performed over multiple axes, instead of a single axis or all the axes as before.\n\n \n**dtype**data-type, optional\n\nType to use in computing the variance. For arrays of integer type the default is [`float64`](../arrays.scalars#numpy.float64 \"numpy.float64\"); for arrays of float types it is the same as the array type.\n\n \n**out**ndarray, optional\n\nAlternate output array in which to place the result. It must have the same shape as the expected output, but the type is cast if necessary.\n\n \n**ddof**int, optional\n\nâDelta Degrees of Freedomâ: the divisor used in the calculation is `N - ddof`, where `N` represents the number of elements. By default `ddof` is zero.\n\n \n**keepdims**bool, optional\n\nIf 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 input array.\n\n If the default value is passed, then `keepdims` will not be passed through to the [`var`](numpy.var#numpy.var \"numpy.var\") method of sub-classes of [`ndarray`](numpy.ndarray#numpy.ndarray \"numpy.ndarray\"), however any non-default value will be. If the sub-classâ method does not implement `keepdims` any exceptions will be raised.\n\n \n**where**array_like of bool, optional\n\nElements to include in the variance. See [`reduce`](numpy.ufunc.reduce#numpy.ufunc.reduce \"numpy.ufunc.reduce\") for details.\n\n New in version 1.20.0.\n\n Returns \n \n**variance**ndarray, see dtype parameter above\n\nIf `out=None`, returns a new array containing the variance; otherwise, a reference to the output array is returned.\n\n See also\n\n \n[`std`](numpy.std#numpy.std \"numpy.std\"), [`mean`](numpy.mean#numpy.mean \"numpy.mean\"), [`nanmean`](numpy.nanmean#numpy.nanmean \"numpy.nanmean\"), [`nanstd`](numpy.nanstd#numpy.nanstd \"numpy.nanstd\"), [`nanvar`](numpy.nanvar#numpy.nanvar \"numpy.nanvar\")\n\n[Output type determination](../../user/basics.ufuncs#ufuncs-output-type)\n #### Notes\n\n The variance is the average of the squared deviations from the mean, i.e., `var = mean(x)`, where `x = abs(a - a.mean())**2`.\n\n The mean is typically calculated as `x.sum() / N`, where `N = len(x)`. If, however, `ddof` is specified, the divisor `N - ddof` is used instead. In standard statistical practice, `ddof=1` provides an unbiased estimator of the variance of a hypothetical infinite population. `ddof=0` provides a maximum likelihood estimate of the variance for normally distributed variables.\n\n Note that for complex numbers, the absolute value is taken before squaring, so that the result is always real and nonnegative.\n\n For floating-point input, the variance is computed using the same precision the input has. Depending on the input data, this can cause the results to be inaccurate, especially for [`float32`](../arrays.scalars#numpy.float32 \"numpy.float32\") (see example below). Specifying a higher-accuracy accumulator using the `dtype` keyword can alleviate this issue.\n\n #### Examples\n\n \n```\n>>> a = np.array([[1, 2], [3, 4]])\n>>> np.var(a)\n1.25\n>>> np.var(a, axis=0)\narray([1., 1.])\n>>> np.var(a, axis=1)\narray([0.25, 0.25])\n\n```\n In single precision, var() can be inaccurate:\n\n \n```\n>>> a = np.zeros((2, 512*512), dtype=np.float32)\n>>> a[0, :] = 1.0\n>>> a[1, :] = 0.1\n>>> np.var(a)\n0.20250003\n\n```\n Computing the variance in float64 is more accurate:\n\n \n```\n>>> np.var(a, dtype=np.float64)\n0.20249999932944759 # may vary\n>>> ((1-0.55)**2 + (0.1-0.55)**2)/2\n0.2025\n\n```\n Specifying a where argument:\n\n \n```\n>>> a = np.array([[14, 8, 11, 10], [7, 9, 10, 11], [10, 15, 5, 10]])\n>>> np.var(a)\n6.833333333333333 # may vary\n>>> np.var(a, where=[[True], [True], [False]])\n4.0\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n>> a = np.ma.array([1,2,3])\n>>> a.anom()\nmasked_array(data=[-1., 0., 1.],\n mask=False,\n fill_value=1e+20)\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n>> marr = np.ma.array(np.arange(10), mask=[0,0,0,1,1,1,0,0,0,0])\n>>> marr.cumsum()\nmasked_array(data=[0, 1, 3, --, --, --, 9, 16, 24, 33],\n mask=[False, False, False, True, True, True, False, False,\n False, False],\n fill_value=999999)\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n*)[[source]](https://github.com/numpy/numpy/blob/v1.23.0/numpy/ma/core.py#L5259-L5304)\n \nReturns the average of the array elements along given axis.\n\n Masked entries are ignored, and result elements which are not finite will be masked.\n\n Refer to [`numpy.mean`](numpy.mean#numpy.mean \"numpy.mean\") for full documentation.\n\n See also\n\n [`numpy.ndarray.mean`](numpy.ndarray.mean#numpy.ndarray.mean \"numpy.ndarray.mean\")\n\ncorresponding function for ndarrays\n\n [`numpy.mean`](numpy.mean#numpy.mean \"numpy.mean\")\n\nEquivalent function\n\n [`numpy.ma.average`](numpy.ma.average#numpy.ma.average \"numpy.ma.average\")\n\nWeighted average.\n\n #### Examples\n\n \n```\n>>> a = np.ma.array([1,2,3], mask=[False, False, True])\n>>> a\nmasked_array(data=[1, 2, --],\n mask=[False, False, True],\n fill_value=999999)\n>>> a.mean()\n1.5\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n*)[[source]](https://github.com/numpy/numpy/blob/v1.23.0/numpy/ma/core.py#L5186-L5225)\n \nReturn the product of the array elements over the given axis.\n\n Masked elements are set to 1 internally for computation.\n\n Refer to [`numpy.prod`](numpy.prod#numpy.prod \"numpy.prod\") for full documentation.\n\n See also\n\n [`numpy.ndarray.prod`](numpy.ndarray.prod#numpy.ndarray.prod \"numpy.ndarray.prod\")\n\ncorresponding function for ndarrays\n\n [`numpy.prod`](numpy.prod#numpy.prod \"numpy.prod\")\n\nequivalent function\n\n #### Notes\n\n Arithmetic is modular when using integer types, and no error is raised on overflow.\n\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n*)[[source]](https://github.com/numpy/numpy/blob/v1.23.0/numpy/ma/core.py#L5407-L5429)\n \nReturns the standard deviation of the array elements along given axis.\n\n Masked entries are ignored.\n\n Refer to [`numpy.std`](numpy.std#numpy.std \"numpy.std\") for full documentation.\n\n See also\n\n [`numpy.ndarray.std`](numpy.ndarray.std#numpy.ndarray.std \"numpy.ndarray.std\")\n\ncorresponding function for ndarrays\n\n [`numpy.std`](numpy.std#numpy.std \"numpy.std\")\n\nEquivalent function\n\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n*)[[source]](https://github.com/numpy/numpy/blob/v1.23.0/numpy/ma/core.py#L5083-L5143)\n \nReturn the sum of the array elements over the given axis.\n\n Masked elements are set to 0 internally.\n\n Refer to [`numpy.sum`](numpy.sum#numpy.sum \"numpy.sum\") for full documentation.\n\n See also\n\n [`numpy.ndarray.sum`](numpy.ndarray.sum#numpy.ndarray.sum \"numpy.ndarray.sum\")\n\ncorresponding function for ndarrays\n\n [`numpy.sum`](numpy.sum#numpy.sum \"numpy.sum\")\n\nequivalent function\n\n #### Examples\n\n \n```\n>>> x = np.ma.array([[1,2,3],[4,5,6],[7,8,9]], mask=[0] + [1,0]*4)\n>>> x\nmasked_array(\n data=[[1, --, 3],\n [--, 5, --],\n [7, --, 9]],\n mask=[[False, True, False],\n [ True, False, True],\n [False, True, False]],\n fill_value=999999)\n>>> x.sum()\n25\n>>> x.sum(axis=1)\nmasked_array(data=[4, 5, 16],\n mask=[False, False, False],\n fill_value=999999)\n>>> x.sum(axis=0)\nmasked_array(data=[8, 5, 12],\n mask=[False, False, False],\n fill_value=999999)\n>>> print(type(x.sum(axis=0, dtype=np.int64)[0]))\n*)[[source]](https://github.com/numpy/numpy/blob/v1.23.0/numpy/ma/core.py#L5343-L5404)\n \nCompute the variance along the specified axis.\n\n Returns the variance of the array elements, a measure of the spread of a distribution. The variance is computed for the flattened array by default, otherwise over the specified axis.\n\n Parameters \n \n**a**array_like\n\nArray containing numbers whose variance is desired. If `a` is not an array, a conversion is attempted.\n\n \n**axis**None or int or tuple of ints, optional\n\nAxis or axes along which the variance is computed. The default is to compute the variance of the flattened array.\n\n New in version 1.7.0.\n\n If this is a tuple of ints, a variance is performed over multiple axes, instead of a single axis or all the axes as before.\n\n \n**dtype**data-type, optional\n\nType to use in computing the variance. For arrays of integer type the default is [`float64`](../arrays.scalars#numpy.float64 \"numpy.float64\"); for arrays of float types it is the same as the array type.\n\n \n**out**ndarray, optional\n\nAlternate output array in which to place the result. It must have the same shape as the expected output, but the type is cast if necessary.\n\n \n**ddof**int, optional\n\nâDelta Degrees of Freedomâ: the divisor used in the calculation is `N - ddof`, where `N` represents the number of elements. By default `ddof` is zero.\n\n \n**keepdims**bool, optional\n\nIf 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 input array.\n\n If the default value is passed, then `keepdims` will not be passed through to the [`var`](numpy.var#numpy.var \"numpy.var\") method of sub-classes of [`ndarray`](numpy.ndarray#numpy.ndarray \"numpy.ndarray\"), however any non-default value will be. If the sub-classâ method does not implement `keepdims` any exceptions will be raised.\n\n \n**where**array_like of bool, optional\n\nElements to include in the variance. See [`reduce`](numpy.ufunc.reduce#numpy.ufunc.reduce \"numpy.ufunc.reduce\") for details.\n\n New in version 1.20.0.\n\n Returns \n \n**variance**ndarray, see dtype parameter above\n\nIf `out=None`, returns a new array containing the variance; otherwise, a reference to the output array is returned.\n\n See also\n\n \n[`std`](numpy.std#numpy.std \"numpy.std\"), [`mean`](numpy.mean#numpy.mean \"numpy.mean\"), [`nanmean`](numpy.nanmean#numpy.nanmean \"numpy.nanmean\"), [`nanstd`](numpy.nanstd#numpy.nanstd \"numpy.nanstd\"), [`nanvar`](numpy.nanvar#numpy.nanvar \"numpy.nanvar\")\n\n[Output type determination](../../user/basics.ufuncs#ufuncs-output-type)\n #### Notes\n\n The variance is the average of the squared deviations from the mean, i.e., `var = mean(x)`, where `x = abs(a - a.mean())**2`.\n\n The mean is typically calculated as `x.sum() / N`, where `N = len(x)`. If, however, `ddof` is specified, the divisor `N - ddof` is used instead. In standard statistical practice, `ddof=1` provides an unbiased estimator of the variance of a hypothetical infinite population. `ddof=0` provides a maximum likelihood estimate of the variance for normally distributed variables.\n\n Note that for complex numbers, the absolute value is taken before squaring, so that the result is always real and nonnegative.\n\n For floating-point input, the variance is computed using the same precision the input has. Depending on the input data, this can cause the results to be inaccurate, especially for [`float32`](../arrays.scalars#numpy.float32 \"numpy.float32\") (see example below). Specifying a higher-accuracy accumulator using the `dtype` keyword can alleviate this issue.\n\n #### Examples\n\n \n```\n>>> a = np.array([[1, 2], [3, 4]])\n>>> np.var(a)\n1.25\n>>> np.var(a, axis=0)\narray([1., 1.])\n>>> np.var(a, axis=1)\narray([0.25, 0.25])\n\n```\n In single precision, var() can be inaccurate:\n\n \n```\n>>> a = np.zeros((2, 512*512), dtype=np.float32)\n>>> a[0, :] = 1.0\n>>> a[1, :] = 0.1\n>>> np.var(a)\n0.20250003\n\n```\n Computing the variance in float64 is more accurate:\n\n \n```\n>>> np.var(a, dtype=np.float64)\n0.20249999932944759 # may vary\n>>> ((1-0.55)**2 + (0.1-0.55)**2)/2\n0.2025\n\n```\n Specifying a where argument:\n\n \n```\n>>> a = np.array([[14, 8, 11, 10], [7, 9, 10, 11], [10, 15, 5, 10]])\n>>> np.var(a)\n6.833333333333333 # may vary\n>>> np.var(a, where=[[True], [True], [False]])\n4.0\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n*\n \nReturns array of indices of the maximum values along the given axis. Masked values are treated as if they had the value fill_value.\n\n Parameters \n \n**axis**{None, integer}\n\nIf None, the index is into the flattened array, otherwise along the specified axis\n\n \n**fill_value**scalar or None, optional\n\nValue used to fill in the masked values. If None, the output of maximum_fill_value(self._data) is used instead.\n\n \n**out**{None, array}, optional\n\nArray into which the result can be placed. Its type is preserved and it must be of the right shape to hold the output.\n\n Returns \n \n**index_array**{integer_array}\n\n #### Examples\n\n \n```\n>>> a = np.arange(6).reshape(2,3)\n>>> a.argmax()\n5\n>>> a.argmax(0)\narray([1, 1, 1])\n>>> a.argmax(1)\narray([2, 2])\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n*\n \nReturn array of indices to the minimum values along the given axis.\n\n Parameters \n \n**axis**{None, integer}\n\nIf None, the index is into the flattened array, otherwise along the specified axis\n\n \n**fill_value**scalar or None, optional\n\nValue used to fill in the masked values. If None, the output of minimum_fill_value(self._data) is used instead.\n\n \n**out**{None, array}, optional\n\nArray into which the result can be placed. Its type is preserved and it must be of the right shape to hold the output.\n\n Returns \n ndarray or scalar\n\nIf multi-dimension input, returns a new ndarray of indices to the minimum values along the given axis. Otherwise, returns a scalar of index to the minimum values along the given axis.\n\n #### Examples\n\n \n```\n>>> x = np.ma.array(np.arange(4), mask=[1,1,0,0])\n>>> x.shape = (2,2)\n>>> x\nmasked_array(\n data=[[--, --],\n [2, 3]],\n mask=[[ True, True],\n [False, False]],\n fill_value=999999)\n>>> x.argmin(axis=0, fill_value=-1)\narray([0, 0])\n>>> x.argmin(axis=0, fill_value=9)\narray([1, 1])\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n*)[[source]](https://github.com/numpy/numpy/blob/v1.23.0/numpy/ma/core.py#L6760-L6769)\n \nReturn the maximum along a given axis.\n\n Parameters \n \n**axis**None or int or tuple of ints, optional\n\nAxis along which to operate. By default, `axis` is None and the flattened input is used. .. versionadded:: 1.7.0 If this is a tuple of ints, the maximum is selected over multiple axes, instead of a single axis or all the axes as before.\n\n \n**out**array_like, optional\n\nAlternative output array in which to place the result. Must be of the same shape and buffer length as the expected output.\n\n \n**fill_value**scalar or None, optional\n\nValue used to fill in the masked values. If None, use the output of maximum_fill_value().\n\n \n**keepdims**bool, optional\n\nIf 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.\n\n Returns \n \n**amax**array_like\n\nNew array holding the result. If `out` was specified, `out` is returned.\n\n See also\n\n [`ma.maximum_fill_value`](numpy.ma.maximum_fill_value#numpy.ma.maximum_fill_value \"numpy.ma.maximum_fill_value\")\n\nReturns the maximum filling value for a given datatype.\n\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n*)[[source]](https://github.com/numpy/numpy/blob/v1.23.0/numpy/ma/core.py#L6748-L6757)\n \nReturn the minimum along a given axis.\n\n Parameters \n \n**axis**None or int or tuple of ints, optional\n\nAxis along which to operate. By default, `axis` is None and the flattened input is used. .. versionadded:: 1.7.0 If this is a tuple of ints, the minimum is selected over multiple axes, instead of a single axis or all the axes as before.\n\n \n**out**array_like, optional\n\nAlternative output array in which to place the result. Must be of the same shape and buffer length as the expected output.\n\n \n**fill_value**scalar or None, optional\n\nValue used to fill in the masked values. If None, use the output of [`minimum_fill_value`](numpy.ma.minimum_fill_value#numpy.ma.minimum_fill_value \"numpy.ma.minimum_fill_value\").\n\n \n**keepdims**bool, optional\n\nIf 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.\n\n Returns \n \n**amin**array_like\n\nNew array holding the result. If `out` was specified, `out` is returned.\n\n See also\n\n [`ma.minimum_fill_value`](numpy.ma.minimum_fill_value#numpy.ma.minimum_fill_value \"numpy.ma.minimum_fill_value\")\n\nReturns the minimum filling value for a given datatype.\n\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n*)[[source]](https://github.com/numpy/numpy/blob/v1.23.0/numpy/ma/core.py#L6773-L6781)\n \nReturn (maximum - minimum) along the given dimension (i.e. peak-to-peak value).\n\n Warning\n\n [`ptp`](numpy.ptp#numpy.ptp \"numpy.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.\n\n Parameters \n \n**axis**{None, int}, optional\n\nAxis along which to find the peaks. If None (default) the flattened array is used.\n\n \n**out**{None, array_like}, optional\n\nAlternative 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.\n\n \n**fill_value**scalar or None, optional\n\nValue used to fill in the masked values.\n\n \n**keepdims**bool, optional\n\nIf 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.\n\n Returns \n \n**ptp**ndarray.\n\nA new array holding the result, unless `out` was specified, in which case a reference to `out` is returned.\n\n #### Examples\n\n \n```\n>>> x = np.ma.MaskedArray([[4, 9, 2, 10],\n... [6, 9, 7, 12]])\n\n```\n \n```\n>>> x.ptp(axis=1)\nmasked_array(data=[8, 6],\n mask=False,\n fill_value=999999)\n\n```\n \n```\n>>> x.ptp(axis=0)\nmasked_array(data=[2, 0, 5, 2],\n mask=False,\n fill_value=999999)\n\n```\n \n```\n>>> x.ptp()\n10\n\n```\n This example shows that a negative value can be returned when the input is an array of signed integers.\n\n \n```\n>>> y = np.ma.MaskedArray([[1, 127],\n... [0, 127],\n... [-1, 127],\n... [-2, 127]], dtype=np.int8)\n>>> y.ptp(axis=1)\nmasked_array(data=[ 126, 127, -128, -127],\n mask=False,\n fill_value=999999,\n dtype=int8)\n\n```\n A work-around is to use the `view()` method to view the result as unsigned integers with the same bit width:\n\n \n```\n>>> y.ptp(axis=1).view(np.uint8)\nmasked_array(data=[126, 127, 128, 129],\n mask=False,\n fill_value=999999,\n dtype=uint8)\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n*\n \nCalculate the n-th discrete difference along the given axis.\n\n The first difference is given by `out[i] = a[i+1] - a[i]` along the given axis, higher differences are calculated by using [`diff`](numpy.diff#numpy.diff \"numpy.diff\") recursively.\n\n Parameters \n \n**a**array_like\n\nInput array\n\n \n**n**int, optional\n\nThe number of times values are differenced. If zero, the input is returned as-is.\n\n \n**axis**int, optional\n\nThe axis along which the difference is taken, default is the last axis.\n\n \n**prepend, append**array_like, optional\n\nValues to prepend or append to `a` along axis prior to performing the difference. Scalar values are expanded to arrays with length 1 in the direction of axis and the shape of the input array in along all other axes. Otherwise the dimension and shape must match `a` except along axis.\n\n New in version 1.16.0.\n\n Returns \n \n**diff**MaskedArray\n\nThe n-th differences. The shape of the output is the same as `a` except along `axis` where the dimension is smaller by `n`. The type of the output is the same as the type of the difference between any two elements of `a`. This is the same as the type of `a` in most cases. A notable exception is [`datetime64`](../arrays.scalars#numpy.datetime64 \"numpy.datetime64\"), which results in a [`timedelta64`](../arrays.scalars#numpy.timedelta64 \"numpy.timedelta64\") output array.\n\n See also\n\n \n[`gradient`](numpy.gradient#numpy.gradient \"numpy.gradient\"), [`ediff1d`](numpy.ediff1d#numpy.ediff1d \"numpy.ediff1d\"), [`cumsum`](numpy.cumsum#numpy.cumsum \"numpy.cumsum\")\n\n #### Notes\n\n Type is preserved for boolean arrays, so the result will contain `False` when consecutive elements are the same and `True` when they differ.\n\n For unsigned integer arrays, the results will also be unsigned. This should not be surprising, as the result is consistent with calculating the difference directly:\n\n \n```\n>>> u8_arr = np.array([1, 0], dtype=np.uint8)\n>>> np.diff(u8_arr)\narray([255], dtype=uint8)\n>>> u8_arr[1,...] - u8_arr[0,...]\n255\n\n```\n If this is not desirable, then the array should be cast to a larger integer type first:\n\n \n```\n>>> i16_arr = u8_arr.astype(np.int16)\n>>> np.diff(i16_arr)\narray([-1], dtype=int16)\n\n```\n #### Examples\n\n \n```\n>>> x = np.array([1, 2, 4, 7, 0])\n>>> np.diff(x)\narray([ 1, 2, 3, -7])\n>>> np.diff(x, n=2)\narray([ 1, 1, -10])\n\n```\n \n```\n>>> x = np.array([[1, 3, 6, 10], [0, 5, 6, 8]])\n>>> np.diff(x)\narray([[2, 3, 4],\n [5, 1, 2]])\n>>> np.diff(x, axis=0)\narray([[-1, 2, 0, -2]])\n\n```\n \n```\n>>> x = np.arange('1066-10-13', '1066-10-16', dtype=np.datetime64)\n>>> np.diff(x)\narray([1, 1], dtype='timedelta64[D]')\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n*)[[source]](https://github.com/numpy/numpy/blob/v1.23.0/numpy/ma/core.py#L5583-L5620)\n \nReturns array of indices of the maximum values along the given axis. Masked values are treated as if they had the value fill_value.\n\n Parameters \n \n**axis**{None, integer}\n\nIf None, the index is into the flattened array, otherwise along the specified axis\n\n \n**fill_value**scalar or None, optional\n\nValue used to fill in the masked values. If None, the output of maximum_fill_value(self._data) is used instead.\n\n \n**out**{None, array}, optional\n\nArray into which the result can be placed. Its type is preserved and it must be of the right shape to hold the output.\n\n Returns \n \n**index_array**{integer_array}\n\n #### Examples\n\n \n```\n>>> a = np.arange(6).reshape(2,3)\n>>> a.argmax()\n5\n>>> a.argmax(0)\narray([1, 1, 1])\n>>> a.argmax(1)\narray([2, 2])\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n*)[[source]](https://github.com/numpy/numpy/blob/v1.23.0/numpy/ma/core.py#L5536-L5581)\n \nReturn array of indices to the minimum values along the given axis.\n\n Parameters \n \n**axis**{None, integer}\n\nIf None, the index is into the flattened array, otherwise along the specified axis\n\n \n**fill_value**scalar or None, optional\n\nValue used to fill in the masked values. If None, the output of minimum_fill_value(self._data) is used instead.\n\n \n**out**{None, array}, optional\n\nArray into which the result can be placed. Its type is preserved and it must be of the right shape to hold the output.\n\n Returns \n ndarray or scalar\n\nIf multi-dimension input, returns a new ndarray of indices to the minimum values along the given axis. Otherwise, returns a scalar of index to the minimum values along the given axis.\n\n #### Examples\n\n \n```\n>>> x = np.ma.array(np.arange(4), mask=[1,1,0,0])\n>>> x.shape = (2,2)\n>>> x\nmasked_array(\n data=[[--, --],\n [2, 3]],\n mask=[[ True, True],\n [False, False]],\n fill_value=999999)\n>>> x.argmin(axis=0, fill_value=-1)\narray([0, 0])\n>>> x.argmin(axis=0, fill_value=9)\narray([1, 1])\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n*)[[source]](https://github.com/numpy/numpy/blob/v1.23.0/numpy/ma/core.py#L5842-L5910)\n \nReturn the maximum along a given axis.\n\n Parameters \n \n**axis**None or int or tuple of ints, optional\n\nAxis along which to operate. By default, `axis` is None and the flattened input is used. .. versionadded:: 1.7.0 If this is a tuple of ints, the maximum is selected over multiple axes, instead of a single axis or all the axes as before.\n\n \n**out**array_like, optional\n\nAlternative output array in which to place the result. Must be of the same shape and buffer length as the expected output.\n\n \n**fill_value**scalar or None, optional\n\nValue used to fill in the masked values. If None, use the output of maximum_fill_value().\n\n \n**keepdims**bool, optional\n\nIf 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.\n\n Returns \n \n**amax**array_like\n\nNew array holding the result. If `out` was specified, `out` is returned.\n\n See also\n\n [`ma.maximum_fill_value`](numpy.ma.maximum_fill_value#numpy.ma.maximum_fill_value \"numpy.ma.maximum_fill_value\")\n\nReturns the maximum filling value for a given datatype.\n\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n*)[[source]](https://github.com/numpy/numpy/blob/v1.23.0/numpy/ma/core.py#L5705-L5772)\n \nReturn the minimum along a given axis.\n\n Parameters \n \n**axis**None or int or tuple of ints, optional\n\nAxis along which to operate. By default, `axis` is None and the flattened input is used. .. versionadded:: 1.7.0 If this is a tuple of ints, the minimum is selected over multiple axes, instead of a single axis or all the axes as before.\n\n \n**out**array_like, optional\n\nAlternative output array in which to place the result. Must be of the same shape and buffer length as the expected output.\n\n \n**fill_value**scalar or None, optional\n\nValue used to fill in the masked values. If None, use the output of `minimum_fill_value`.\n\n \n**keepdims**bool, optional\n\nIf 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.\n\n Returns \n \n**amin**array_like\n\nNew array holding the result. If `out` was specified, `out` is returned.\n\n See also\n\n [`ma.minimum_fill_value`](numpy.ma.minimum_fill_value#numpy.ma.minimum_fill_value \"numpy.ma.minimum_fill_value\")\n\nReturns the minimum filling value for a given datatype.\n\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n>> x = np.ma.MaskedArray([[4, 9, 2, 10],\n... [6, 9, 7, 12]])\n\n```\n \n```\n>>> x.ptp(axis=1)\nmasked_array(data=[8, 6],\n mask=False,\n fill_value=999999)\n\n```\n \n```\n>>> x.ptp(axis=0)\nmasked_array(data=[2, 0, 5, 2],\n mask=False,\n fill_value=999999)\n\n```\n \n```\n>>> x.ptp()\n10\n\n```\n This example shows that a negative value can be returned when the input is an array of signed integers.\n\n \n```\n>>> y = np.ma.MaskedArray([[1, 127],\n... [0, 127],\n... [-1, 127],\n... [-2, 127]], dtype=np.int8)\n>>> y.ptp(axis=1)\nmasked_array(data=[ 126, 127, -128, -127],\n mask=False,\n fill_value=999999,\n dtype=int8)\n\n```\n A work-around is to use the `view()` method to view the result as unsigned integers with the same bit width:\n\n \n```\n>>> y.ptp(axis=1).view(np.uint8)\nmasked_array(data=[126, 127, 128, 129],\n mask=False,\n fill_value=999999,\n dtype=uint8)\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n*, *kind=None*, *order=None*, *endwith=True*, *fill_value=None*)[[source]](https://github.com/numpy/numpy/blob/v1.23.0/numpy/ma/core.py#L6921-L6933)\n \nReturn an ndarray of indices that sort the array along the specified axis. Masked values are filled beforehand to `fill_value`.\n\n Parameters \n \n**axis**int, optional\n\nAxis along which to sort. If None, the default, the flattened array is used.\n\n Changed in version 1.13.0: Previously, the default was documented to be -1, but that was in error. At some future date, the default will change to -1, as originally intended. Until then, the axis should be given explicitly when `arr.ndim > 1`, to avoid a FutureWarning.\n\n \n**kind**{âquicksortâ, âmergesortâ, âheapsortâ, âstableâ}, optional\n\nThe sorting algorithm used.\n\n \n**order**list, optional\n\nWhen `a` is an array with fields defined, this argument specifies which fields to compare first, second, etc. Not all fields need be specified.\n\n \n**endwith**{True, False}, optional\n\nWhether missing values (if any) should be treated as the largest values (True) or the smallest values (False) When the array contains unmasked values at the same extremes of the datatype, the ordering of these values and the masked values is undefined.\n\n \n**fill_value**scalar or None, optional\n\nValue used internally for the masked values. If `fill_value` is not None, it supersedes `endwith`.\n\n Returns \n \n**index_array**ndarray, int\n\nArray of indices that sort `a` along the specified axis. In other words, `a[index_array]` yields a sorted `a`.\n\n See also\n\n [`ma.MaskedArray.sort`](numpy.ma.maskedarray.sort#numpy.ma.MaskedArray.sort \"numpy.ma.MaskedArray.sort\")\n\nDescribes sorting algorithms used.\n\n [`lexsort`](numpy.lexsort#numpy.lexsort \"numpy.lexsort\")\n\nIndirect stable sort with multiple keys.\n\n [`numpy.ndarray.sort`](numpy.ndarray.sort#numpy.ndarray.sort \"numpy.ndarray.sort\")\n\nInplace sort.\n\n #### Notes\n\n See [`sort`](numpy.sort#numpy.sort \"numpy.sort\") for notes on the different sorting algorithms.\n\n #### Examples\n\n \n```\n>>> a = np.ma.array([3,2,1], mask=[False, False, True])\n>>> a\nmasked_array(data=[3, 2, --],\n mask=[False, False, True],\n fill_value=999999)\n>>> a.argsort()\narray([1, 0, 2])\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n*, *kind=None*, *order=None*, *endwith=True*, *fill_value=None*)[[source]](https://github.com/numpy/numpy/blob/v1.23.0/numpy/ma/core.py#L5456-L5534)\n \nReturn an ndarray of indices that sort the array along the specified axis. Masked values are filled beforehand to [`fill_value`](../maskedarray.baseclass#numpy.ma.MaskedArray.fill_value \"numpy.ma.MaskedArray.fill_value\").\n\n Parameters \n \n**axis**int, optional\n\nAxis along which to sort. If None, the default, the flattened array is used.\n\n Changed in version 1.13.0: Previously, the default was documented to be -1, but that was in error. At some future date, the default will change to -1, as originally intended. Until then, the axis should be given explicitly when `arr.ndim > 1`, to avoid a FutureWarning.\n\n \n**kind**{âquicksortâ, âmergesortâ, âheapsortâ, âstableâ}, optional\n\nThe sorting algorithm used.\n\n \n**order**list, optional\n\nWhen `a` is an array with fields defined, this argument specifies which fields to compare first, second, etc. Not all fields need be specified.\n\n \n**endwith**{True, False}, optional\n\nWhether missing values (if any) should be treated as the largest values (True) or the smallest values (False) When the array contains unmasked values at the same extremes of the datatype, the ordering of these values and the masked values is undefined.\n\n \n**fill_value**scalar or None, optional\n\nValue used internally for the masked values. If `fill_value` is not None, it supersedes `endwith`.\n\n Returns \n \n**index_array**ndarray, int\n\nArray of indices that sort `a` along the specified axis. In other words, `a[index_array]` yields a sorted `a`.\n\n See also\n\n [`ma.MaskedArray.sort`](numpy.ma.maskedarray.sort#numpy.ma.MaskedArray.sort \"numpy.ma.MaskedArray.sort\")\n\nDescribes sorting algorithms used.\n\n [`lexsort`](numpy.lexsort#numpy.lexsort \"numpy.lexsort\")\n\nIndirect stable sort with multiple keys.\n\n [`numpy.ndarray.sort`](numpy.ndarray.sort#numpy.ndarray.sort \"numpy.ndarray.sort\")\n\nInplace sort.\n\n #### Notes\n\n See [`sort`](numpy.sort#numpy.sort \"numpy.sort\") for notes on the different sorting algorithms.\n\n #### Examples\n\n \n```\n>>> a = np.ma.array([3,2,1], mask=[False, False, True])\n>>> a\nmasked_array(data=[3, 2, --],\n mask=[False, False, True],\n fill_value=999999)\n>>> a.argsort()\narray([1, 0, 2])\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n>> a = np.ma.array([1, 2, 5, 4, 3],mask=[0, 1, 0, 1, 0])\n>>> # Default\n>>> a.sort()\n>>> a\nmasked_array(data=[1, 3, 5, --, --],\n mask=[False, False, False, True, True],\n fill_value=999999)\n\n```\n \n```\n>>> a = np.ma.array([1, 2, 5, 4, 3],mask=[0, 1, 0, 1, 0])\n>>> # Put missing values in the front\n>>> a.sort(endwith=False)\n>>> a\nmasked_array(data=[--, --, 1, 3, 5],\n mask=[ True, True, False, False, False],\n fill_value=999999)\n\n```\n \n```\n>>> a = np.ma.array([1, 2, 5, 4, 3],mask=[0, 1, 0, 1, 0])\n>>> # fill_value takes over endwith\n>>> a.sort(endwith=False, fill_value=3)\n>>> a\nmasked_array(data=[1, --, --, 3, 5],\n mask=[False, True, True, False, False],\n fill_value=999999)\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n>> a = np.ma.array([[1, 2, 3], [4, 5, 6]], mask=[[1, 0, 0], [0, 0, 0]])\n>>> b = np.ma.array([[1, 2], [3, 4], [5, 6]], mask=[[1, 0], [0, 0], [0, 0]])\n>>> np.ma.dot(a, b)\nmasked_array(\n data=[[21, 26],\n [45, 64]],\n mask=[[False, False],\n [False, False]],\n fill_value=999999)\n>>> np.ma.dot(a, b, strict=True)\nmasked_array(\n data=[[--, --],\n [--, 64]],\n mask=[[ True, True],\n [ True, False]],\n fill_value=999999)\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n*\n \nReturn the identity array.\n\n The identity array is a square array with ones on the main diagonal.\n\n Parameters \n \n**n**int\n\nNumber of rows (and columns) in `n` x `n` output.\n\n \n**dtype**data-type, optional\n\nData-type of the output. Defaults to `float`.\n\n \n**like**array_like, optional\n\nReference 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.\n\n New in version 1.20.0.\n\n Returns \n \n**out**MaskedArray\n\n`n` x `n` array with its main diagonal set to one, and all other elements 0.\n\n #### Examples\n\n \n```\n>>> np.identity(3)\narray([[1., 0., 0.],\n [0., 1., 0.],\n [0., 0., 1.]])\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n 0` and `ndim(b) = s > 0`:\n\n \n```\nnp.inner(a, b) = np.tensordot(a, b, axes=(-1,-1))\n\n```\n or explicitly:\n\n \n```\nnp.inner(a, b)[i0,...,ir-2,j0,...,js-2]\n = sum(a[i0,...,ir-2,:]*b[j0,...,js-2,:])\n\n```\n In addition `a` or `b` may be scalars, in which case:\n\n \n```\nnp.inner(a,b) = a*b\n\n```\n #### Examples\n\n Ordinary inner product for vectors:\n\n \n```\n>>> a = np.array([1,2,3])\n>>> b = np.array([0,1,0])\n>>> np.inner(a, b)\n2\n\n```\n Some multidimensional examples:\n\n \n```\n>>> a = np.arange(24).reshape((2,3,4))\n>>> b = np.arange(4)\n>>> c = np.inner(a, b)\n>>> c.shape\n(2, 3)\n>>> c\narray([[ 14, 38, 62],\n [ 86, 110, 134]])\n\n```\n \n```\n>>> a = np.arange(2).reshape((1,1,2))\n>>> b = np.arange(6).reshape((3,2))\n>>> c = np.inner(a, b)\n>>> c.shape\n(1, 1, 3)\n>>> c\narray([[[1, 3, 5]]])\n\n```\n An example where `b` is a scalar:\n\n \n```\n>>> np.inner(np.eye(2), 7)\narray([[7., 0.],\n [0., 7.]])\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n 0` and `ndim(b) = s > 0`:\n\n \n```\nnp.inner(a, b) = np.tensordot(a, b, axes=(-1,-1))\n\n```\n or explicitly:\n\n \n```\nnp.inner(a, b)[i0,...,ir-2,j0,...,js-2]\n = sum(a[i0,...,ir-2,:]*b[j0,...,js-2,:])\n\n```\n In addition `a` or `b` may be scalars, in which case:\n\n \n```\nnp.inner(a,b) = a*b\n\n```\n #### Examples\n\n Ordinary inner product for vectors:\n\n \n```\n>>> a = np.array([1,2,3])\n>>> b = np.array([0,1,0])\n>>> np.inner(a, b)\n2\n\n```\n Some multidimensional examples:\n\n \n```\n>>> a = np.arange(24).reshape((2,3,4))\n>>> b = np.arange(4)\n>>> c = np.inner(a, b)\n>>> c.shape\n(2, 3)\n>>> c\narray([[ 14, 38, 62],\n [ 86, 110, 134]])\n\n```\n \n```\n>>> a = np.arange(2).reshape((1,1,2))\n>>> b = np.arange(6).reshape((3,2))\n>>> c = np.inner(a, b)\n>>> c.shape\n(1, 1, 3)\n>>> c\narray([[[1, 3, 5]]])\n\n```\n An example where `b` is a scalar:\n\n \n```\n>>> np.inner(np.eye(2), 7)\narray([[7., 0.],\n [0., 7.]])\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\nij', a.ravel(), b.ravel())` is the equivalent.\n\n [`ufunc.outer`](numpy.ufunc.outer#numpy.ufunc.outer \"numpy.ufunc.outer\")\n\nA generalization to dimensions other than 1D and other operations. `np.multiply.outer(a.ravel(), b.ravel())` is the equivalent.\n\n [`tensordot`](numpy.tensordot#numpy.tensordot \"numpy.tensordot\")\n\n`np.tensordot(a.ravel(), b.ravel(), axes=((), ()))` is the equivalent.\n\n #### Notes\n\n Masked values are replaced by 0.\n\n #### References\n\n [1](#id1) \n: and , *Matrix Computations*, 3rd ed., Baltimore, MD, Johns Hopkins University Press, 1996, pg. 8.\n\n #### Examples\n\n Make a (*very* coarse) grid for computing a Mandelbrot set:\n\n \n```\n>>> rl = np.outer(np.ones((5,)), np.linspace(-2, 2, 5))\n>>> rl\narray([[-2., -1., 0., 1., 2.],\n [-2., -1., 0., 1., 2.],\n [-2., -1., 0., 1., 2.],\n [-2., -1., 0., 1., 2.],\n [-2., -1., 0., 1., 2.]])\n>>> im = np.outer(1j*np.linspace(2, -2, 5), np.ones((5,)))\n>>> im\narray([[0.+2.j, 0.+2.j, 0.+2.j, 0.+2.j, 0.+2.j],\n [0.+1.j, 0.+1.j, 0.+1.j, 0.+1.j, 0.+1.j],\n [0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j],\n [0.-1.j, 0.-1.j, 0.-1.j, 0.-1.j, 0.-1.j],\n [0.-2.j, 0.-2.j, 0.-2.j, 0.-2.j, 0.-2.j]])\n>>> grid = rl + im\n>>> grid\narray([[-2.+2.j, -1.+2.j, 0.+2.j, 1.+2.j, 2.+2.j],\n [-2.+1.j, -1.+1.j, 0.+1.j, 1.+1.j, 2.+1.j],\n [-2.+0.j, -1.+0.j, 0.+0.j, 1.+0.j, 2.+0.j],\n [-2.-1.j, -1.-1.j, 0.-1.j, 1.-1.j, 2.-1.j],\n [-2.-2.j, -1.-2.j, 0.-2.j, 1.-2.j, 2.-2.j]])\n\n```\n An example using a âvectorâ of letters:\n\n \n```\n>>> x = np.array(['a', 'b', 'c'], dtype=object)\n>>> np.outer(x, [1, 2, 3])\narray([['a', 'aa', 'aaa'],\n ['b', 'bb', 'bbb'],\n ['c', 'cc', 'ccc']], dtype=object)\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\nij', a.ravel(), b.ravel())` is the equivalent.\n\n [`ufunc.outer`](numpy.ufunc.outer#numpy.ufunc.outer \"numpy.ufunc.outer\")\n\nA generalization to dimensions other than 1D and other operations. `np.multiply.outer(a.ravel(), b.ravel())` is the equivalent.\n\n [`tensordot`](numpy.tensordot#numpy.tensordot \"numpy.tensordot\")\n\n`np.tensordot(a.ravel(), b.ravel(), axes=((), ()))` is the equivalent.\n\n #### Notes\n\n Masked values are replaced by 0.\n\n #### References\n\n [1](#id1) \n: and , *Matrix Computations*, 3rd ed., Baltimore, MD, Johns Hopkins University Press, 1996, pg. 8.\n\n #### Examples\n\n Make a (*very* coarse) grid for computing a Mandelbrot set:\n\n \n```\n>>> rl = np.outer(np.ones((5,)), np.linspace(-2, 2, 5))\n>>> rl\narray([[-2., -1., 0., 1., 2.],\n [-2., -1., 0., 1., 2.],\n [-2., -1., 0., 1., 2.],\n [-2., -1., 0., 1., 2.],\n [-2., -1., 0., 1., 2.]])\n>>> im = np.outer(1j*np.linspace(2, -2, 5), np.ones((5,)))\n>>> im\narray([[0.+2.j, 0.+2.j, 0.+2.j, 0.+2.j, 0.+2.j],\n [0.+1.j, 0.+1.j, 0.+1.j, 0.+1.j, 0.+1.j],\n [0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j],\n [0.-1.j, 0.-1.j, 0.-1.j, 0.-1.j, 0.-1.j],\n [0.-2.j, 0.-2.j, 0.-2.j, 0.-2.j, 0.-2.j]])\n>>> grid = rl + im\n>>> grid\narray([[-2.+2.j, -1.+2.j, 0.+2.j, 1.+2.j, 2.+2.j],\n [-2.+1.j, -1.+1.j, 0.+1.j, 1.+1.j, 2.+1.j],\n [-2.+0.j, -1.+0.j, 0.+0.j, 1.+0.j, 2.+0.j],\n [-2.-1.j, -1.-1.j, 0.-1.j, 1.-1.j, 2.-1.j],\n [-2.-2.j, -1.-2.j, 0.-2.j, 1.-2.j, 2.-2.j]])\n\n```\n An example using a âvectorâ of letters:\n\n \n```\n>>> x = np.array(['a', 'b', 'c'], dtype=object)\n>>> np.outer(x, [1, 2, 3])\narray([['a', 'aa', 'aaa'],\n ['b', 'bb', 'bbb'],\n ['c', 'cc', 'ccc']], dtype=object)\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n*\n Return the sum along diagonals of the array.\n\n Refer to [`numpy.trace`](numpy.trace#numpy.trace \"numpy.trace\") for full documentation.\n\n See also\n\n [`numpy.trace`](numpy.trace#numpy.trace \"numpy.trace\")\n\nequivalent function\n\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n.\n\n Parameters \n \n**x**array_like\n\n1-D input array.\n\n \n**N**int, optional\n\nNumber of columns in the output. If `N` is not specified, a square array is returned (`N = len(x)`).\n\n \n**increasing**bool, optional\n\nOrder of the powers of the columns. If True, the powers increase from left to right, if False (the default) they are reversed.\n\n New in version 1.9.0.\n\n Returns \n \n**out**ndarray\n\nVandermonde 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)`.\n\n See also\n\n [`polynomial.polynomial.polyvander`](numpy.polynomial.polynomial.polyvander#numpy.polynomial.polynomial.polyvander \"numpy.polynomial.polynomial.polyvander\")\n #### Notes\n\n Masked values in the input array result in rows of zeros.\n\n #### Examples\n\n \n```\n>>> x = np.array([1, 2, 3, 5])\n>>> N = 3\n>>> np.vander(x, N)\narray([[ 1, 1, 1],\n [ 4, 2, 1],\n [ 9, 3, 1],\n [25, 5, 1]])\n\n```\n \n```\n>>> np.column_stack([x**(N-1-i) for i in range(N)])\narray([[ 1, 1, 1],\n [ 4, 2, 1],\n [ 9, 3, 1],\n [25, 5, 1]])\n\n```\n \n```\n>>> x = np.array([1, 2, 3, 5])\n>>> np.vander(x)\narray([[ 1, 1, 1, 1],\n [ 8, 4, 2, 1],\n [ 27, 9, 3, 1],\n [125, 25, 5, 1]])\n>>> np.vander(x, increasing=True)\narray([[ 1, 1, 1, 1],\n [ 1, 2, 4, 8],\n [ 1, 3, 9, 27],\n [ 1, 5, 25, 125]])\n\n```\n The determinant of a square Vandermonde matrix is the product of the differences between the values of the input vector:\n\n \n```\n>>> np.linalg.det(np.vander(x))\n48.000000000000043 # may vary\n>>> (5-3)*(5-2)*(5-1)*(3-2)*(3-1)*(2-1)\n48\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n>> import warnings\n>>> warnings.simplefilter('ignore', np.RankWarning)\n\n```\n See also\n\n [`polyval`](numpy.polyval#numpy.polyval \"numpy.polyval\")\n\nCompute polynomial values.\n\n [`linalg.lstsq`](numpy.linalg.lstsq#numpy.linalg.lstsq \"numpy.linalg.lstsq\")\n\nComputes a least-squares fit.\n\n [`scipy.interpolate.UnivariateSpline`](https://docs.scipy.org/doc/scipy/reference/generated/scipy.interpolate.UnivariateSpline.html#scipy.interpolate.UnivariateSpline \"(in SciPy v1.8.1)\")\n\nComputes spline fits.\n\n #### Notes\n\n Any masked values in x is propagated in y, and vice-versa.\n\n The solution minimizes the squared error\n\n \\[E = \\sum_{j=0}^k |p(x_j) - y_j|^2\\] in the equations:\n\n \n```\nx[0]**n * p[0] + ... + x[0] * p[n-1] + p[n] = y[0]\nx[1]**n * p[0] + ... + x[1] * p[n-1] + p[n] = y[1]\n...\nx[k]**n * p[0] + ... + x[k] * p[n-1] + p[n] = y[k]\n\n```\n The coefficient matrix of the coefficients `p` is a Vandermonde matrix.\n\n [`polyfit`](numpy.polyfit#numpy.polyfit \"numpy.polyfit\") issues a [`RankWarning`](numpy.rankwarning#numpy.RankWarning \"numpy.RankWarning\") when the least-squares fit is badly conditioned. This implies that the best fit is not well-defined due to numerical error. The results may be improved by lowering the polynomial degree or by replacing `x` by `x` - `x`.mean(). The `rcond` parameter can also be set to a value smaller than its default, but the resulting fit may be spurious: including contributions from the small singular values can add numerical noise to the result.\n\n Note that fitting polynomial coefficients is inherently badly conditioned when the degree of the polynomial is large or the interval of sample points is badly centered. The quality of the fit should always be checked in these cases. When polynomial fits are not satisfactory, splines may be a good alternative.\n\n #### References\n\n 1 \nWikipedia, âCurve fittingâ, >> import warnings\n>>> x = np.array([0.0, 1.0, 2.0, 3.0, 4.0, 5.0])\n>>> y = np.array([0.0, 0.8, 0.9, 0.1, -0.8, -1.0])\n>>> z = np.polyfit(x, y, 3)\n>>> z\narray([ 0.08703704, -0.81349206, 1.69312169, -0.03968254]) # may vary\n\n```\n It is convenient to use [`poly1d`](numpy.poly1d#numpy.poly1d \"numpy.poly1d\") objects for dealing with polynomials:\n\n \n```\n>>> p = np.poly1d(z)\n>>> p(0.5)\n0.6143849206349179 # may vary\n>>> p(3.5)\n-0.34732142857143039 # may vary\n>>> p(10)\n22.579365079365115 # may vary\n\n```\n High-order polynomials may oscillate wildly:\n\n \n```\n>>> with warnings.catch_warnings():\n... warnings.simplefilter('ignore', np.RankWarning)\n... p30 = np.poly1d(np.polyfit(x, y, 30))\n...\n>>> p30(4)\n-0.80000000000000204 # may vary\n>>> p30(5)\n-0.99999999999999445 # may vary\n>>> p30(4.5)\n-0.10547061179440398 # may vary\n\n```\n Illustration:\n\n \n```\n>>> import matplotlib.pyplot as plt\n>>> xp = np.linspace(-2, 6, 100)\n>>> _ = plt.plot(x, y, '.', xp, p(xp), '-', xp, p30(xp), '--')\n>>> plt.ylim(-2,2)\n(-2, 2)\n>>> plt.show()\n\n```\n ![../../_images/numpy-ma-polyfit-1.png] \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n*\n \nRound an array to the given number of decimals.\n\n See also\n\n [`around`](numpy.around#numpy.around \"numpy.around\")\n\nequivalent function; see for details.\n\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n*\n \nClip (limit) the values in an array.\n\n Given an interval, values outside the interval are clipped to the interval edges. For example, if an interval of `[0, 1]` is specified, values smaller than 0 become 0, and values larger than 1 become 1.\n\n Equivalent to but faster than `np.minimum(a_max, np.maximum(a, a_min))`.\n\n No check is performed to ensure `a_min < a_max`.\n\n Parameters \n \n**a**array_like\n\nArray containing elements to clip.\n\n \n**a_min, a_max**array_like or None\n\nMinimum and maximum value. If `None`, clipping is not performed on the corresponding edge. Only one of `a_min` and `a_max` may be `None`. Both are broadcast against `a`.\n\n \n**out**ndarray, optional\n\nThe results will be placed in this array. It may be the input array for in-place clipping. `out` must be of the right shape to hold the output. Its type is preserved.\n\n ****kwargs**\n\nFor other keyword-only arguments, see the [ufunc docs](../ufuncs#ufuncs-kwargs).\n\n New in version 1.17.0.\n\n Returns \n \n**clipped_array**MaskedArray\n\nAn array with the elements of `a`, but where values < `a_min` are replaced with `a_min`, and those > `a_max` with `a_max`.\n\n See also\n\n [Output type determination](../../user/basics.ufuncs#ufuncs-output-type)\n #### Notes\n\n When `a_min` is greater than `a_max`, [`clip`](numpy.clip#numpy.clip \"numpy.clip\") returns an array in which all values are equal to `a_max`, as shown in the second example.\n\n #### Examples\n\n \n```\n>>> a = np.arange(10)\n>>> a\narray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])\n>>> np.clip(a, 1, 8)\narray([1, 1, 2, 3, 4, 5, 6, 7, 8, 8])\n>>> np.clip(a, 8, 1)\narray([1, 1, 1, 1, 1, 1, 1, 1, 1, 1])\n>>> np.clip(a, 3, 6, out=a)\narray([3, 3, 3, 3, 4, 5, 6, 6, 6, 6])\n>>> a\narray([3, 3, 3, 3, 4, 5, 6, 6, 6, 6])\n>>> a = np.arange(10)\n>>> a\narray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])\n>>> np.clip(a, [3, 4, 1, 1, 1, 4, 4, 4, 4, 4], 8)\narray([3, 4, 2, 3, 4, 5, 6, 7, 8, 8])\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n>> a = np.ma.array([1e10, 1e-7, 42.0], mask=[0, 0, 1])\n>>> a\nmasked_array(data=[10000000000.0, 1e-07, --],\n mask=[False, False, True],\n fill_value=1e+20)\n\n```\n \n```\n>>> b = np.array([1e10, 1e-7, -42.0])\n>>> b\narray([ 1.00000000e+10, 1.00000000e-07, -4.20000000e+01])\n>>> np.ma.allequal(a, b, fill_value=False)\nFalse\n>>> np.ma.allequal(a, b)\nTrue\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n>> a = np.ma.array([1e10, 1e-7, 42.0], mask=[0, 0, 1])\n>>> a\nmasked_array(data=[10000000000.0, 1e-07, --],\n mask=[False, False, True],\n fill_value=1e+20)\n>>> b = np.ma.array([1e10, 1e-8, -42.0], mask=[0, 0, 1])\n>>> np.ma.allclose(a, b)\nFalse\n\n```\n \n```\n>>> a = np.ma.array([1e10, 1e-8, 42.0], mask=[0, 0, 1])\n>>> b = np.ma.array([1.00001e10, 1e-9, -42.0], mask=[0, 0, 1])\n>>> np.ma.allclose(a, b)\nTrue\n>>> np.ma.allclose(a, b, masked_equal=False)\nFalse\n\n```\n Masked values are not compared directly.\n\n \n```\n>>> a = np.ma.array([1e10, 1e-8, 42.0], mask=[0, 0, 1])\n>>> b = np.ma.array([1.00001e10, 1e-9, 42.0], mask=[0, 0, 1])\n>>> np.ma.allclose(a, b)\nTrue\n>>> np.ma.allclose(a, b, masked_equal=False)\nFalse\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n (NjâŠ)\n\nThis function should accept 1-D arrays. It is applied to 1-D slices of `arr` along the specified axis.\n\n \n**axis**integer\n\nAxis along which `arr` is sliced.\n\n \n**arr**ndarray (NiâŠ, M, NkâŠ)\n\nInput array.\n\n \n**args**any\n\nAdditional arguments to `func1d`.\n\n \n**kwargs**any\n\nAdditional named arguments to `func1d`.\n\n New in version 1.9.0.\n\n Returns \n \n**out**ndarray (NiâŠ, NjâŠ, NkâŠ)\n\nThe output array. The shape of `out` is identical to the shape of `arr`, except along the `axis` dimension. This axis is removed, and replaced with new dimensions equal to the shape of the return value of `func1d`. So if `func1d` returns a scalar `out` will have one fewer dimensions than `arr`.\n\n See also\n\n [`apply_over_axes`](numpy.apply_over_axes#numpy.apply_over_axes \"numpy.apply_over_axes\")\n\nApply a function repeatedly over multiple axes.\n\n #### Examples\n\n \n```\n>>> def my_func(a):\n... \"\"\"Average first and last element of a 1-D array\"\"\"\n... return (a[0] + a[-1]) * 0.5\n>>> b = np.array([[1,2,3], [4,5,6], [7,8,9]])\n>>> np.apply_along_axis(my_func, 0, b)\narray([4., 5., 6.])\n>>> np.apply_along_axis(my_func, 1, b)\narray([2., 5., 8.])\n\n```\n For a function that returns a 1D array, the number of dimensions in `outarr` is the same as `arr`.\n\n \n```\n>>> b = np.array([[8,1,7], [4,3,9], [5,2,6]])\n>>> np.apply_along_axis(sorted, 1, b)\narray([[1, 7, 8],\n [3, 4, 9],\n [2, 5, 6]])\n\n```\n For a function that returns a higher dimensional array, those dimensions are inserted in place of the `axis` dimension.\n\n \n```\n>>> b = np.array([[1,2,3], [4,5,6], [7,8,9]])\n>>> np.apply_along_axis(np.diag, -1, b)\narray([[[1, 0, 0],\n [0, 2, 0],\n [0, 0, 3]],\n [[4, 0, 0],\n [0, 5, 0],\n [0, 0, 6]],\n [[7, 0, 0],\n [0, 8, 0],\n [0, 0, 9]]])\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n>> a = np.ma.arange(24).reshape(2,3,4)\n>>> a[:,0,1] = np.ma.masked\n>>> a[:,1,:] = np.ma.masked\n>>> a\nmasked_array(\n data=[[[0, --, 2, 3],\n [--, --, --, --],\n [8, 9, 10, 11]],\n [[12, --, 14, 15],\n [--, --, --, --],\n [20, 21, 22, 23]]],\n mask=[[[False, True, False, False],\n [ True, True, True, True],\n [False, False, False, False]],\n [[False, True, False, False],\n [ True, True, True, True],\n [False, False, False, False]]],\n fill_value=999999)\n>>> np.ma.apply_over_axes(np.ma.sum, a, [0,2])\nmasked_array(\n data=[[[46],\n [--],\n [124]]],\n mask=[[[False],\n [ True],\n [False]]],\n fill_value=999999)\n\n```\n Tuple axis arguments to ufuncs are equivalent:\n\n \n```\n>>> np.ma.sum(a, axis=(0,2)).reshape((1,-1,1))\nmasked_array(\n data=[[[46],\n [--],\n [124]]],\n mask=[[[False],\n [ True],\n [False]]],\n fill_value=999999)\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n*\n \nReturn evenly spaced values within a given interval.\n\n `arange` can be called with a varying number of positional arguments:\n\n * `arange(stop)`: Values are generated within the half-open interval `[0, stop)` (in other words, the interval including `start` but excluding `stop`).\n* `arange(start, stop)`: Values are generated within the half-open interval `[start, stop)`.\n* `arange(start, stop, step)` Values are generated within the half-open interval `[start, stop)`, with spacing between values given by `step`.\n\n For integer arguments the function is roughly equivalent to the Python built-in [`range`](https://docs.python.org/3/library/stdtypes.html#range \"(in Python v3.10)\"), but returns an ndarray rather than a `range` instance.\n\n When using a non-integer step, such as 0.1, it is often better to use [`numpy.linspace`](numpy.linspace#numpy.linspace \"numpy.linspace\").\n\n See the Warning sections below for more information.\n\n Parameters \n \n**start**integer or real, optional\n\nStart of interval. The interval includes this value. The default start value is 0.\n\n \n**stop**integer or real\n\nEnd of interval. The interval does not include this value, except in some cases where `step` is not an integer and floating point round-off affects the length of `out`.\n\n \n**step**integer or real, optional\n\nSpacing between values. For any output `out`, this is the distance between two adjacent values, `out[i+1] - out[i]`. The default step size is 1. If `step` is specified as a position argument, `start` must also be given.\n\n \n**dtype**dtype, optional\n\nThe type of the output array. If [`dtype`](numpy.dtype#numpy.dtype \"numpy.dtype\") is not given, infer the data type from the other input arguments.\n\n \n**like**array_like, optional\n\nReference 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.\n\n New in version 1.20.0.\n\n Returns \n \n**arange**MaskedArray\n\nArray of evenly spaced values.\n\n For floating point arguments, the length of the result is `ceil((stop - start)/step)`. Because of floating point overflow, this rule may result in the last element of `out` being greater than `stop`.\n\n Warning\n\n The length of the output might not be numerically stable.\n\n Another stability issue is due to the internal implementation of [`numpy.arange`](numpy.arange#numpy.arange \"numpy.arange\"). The actual step value used to populate the array is `dtype(start + step) - dtype(start)` and not `step`. Precision loss can occur here, due to casting or due to using floating points when `start` is much larger than `step`. This can lead to unexpected behaviour. For example:\n\n \n```\n>>> np.arange(0, 5, 0.5, dtype=int)\narray([0, 0, 0, 0, 0, 0, 0, 0, 0, 0])\n>>> np.arange(-3, 3, 0.5, dtype=int)\narray([-3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8])\n\n```\n In such cases, the use of [`numpy.linspace`](numpy.linspace#numpy.linspace \"numpy.linspace\") should be preferred.\n\n The built-in [`range`](https://docs.python.org/3/library/stdtypes.html#range \"(in Python v3.10)\") generates [Python built-in integers that have arbitrary size](https://docs.python.org/3/c-api/long.html \"(in Python v3.10)\"), while [`numpy.arange`](numpy.arange#numpy.arange \"numpy.arange\") produces [`numpy.int32`](../arrays.scalars#numpy.int32 \"numpy.int32\") or [`numpy.int64`](../arrays.scalars#numpy.int64 \"numpy.int64\") numbers. This may result in incorrect results for large integer values:\n\n \n```\n>>> power = 40\n>>> modulo = 10000\n>>> x1 = [(n ** power) % modulo for n in range(8)]\n>>> x2 = [(n ** power) % modulo for n in np.arange(8)]\n>>> print(x1)\n[0, 1, 7776, 8801, 6176, 625, 6576, 4001] # correct\n>>> print(x2)\n[0, 1, 7776, 7185, 0, 5969, 4816, 3361] # incorrect\n\n```\n See also\n\n [`numpy.linspace`](numpy.linspace#numpy.linspace \"numpy.linspace\")\n\nEvenly spaced numbers with careful handling of endpoints.\n\n [`numpy.ogrid`](numpy.ogrid#numpy.ogrid \"numpy.ogrid\")\n\nArrays of evenly spaced numbers in N-dimensions.\n\n [`numpy.mgrid`](numpy.mgrid#numpy.mgrid \"numpy.mgrid\")\n\nGrid-shaped arrays of evenly spaced numbers in N-dimensions.\n\n #### Examples\n\n \n```\n>>> np.arange(3)\narray([0, 1, 2])\n>>> np.arange(3.0)\narray([ 0., 1., 2.])\n>>> np.arange(3,7)\narray([3, 4, 5, 6])\n>>> np.arange(3,7,2)\narray([3, 5])\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n>> choice = np.array([[1,1,1], [2,2,2], [3,3,3]])\n>>> a = np.array([2, 1, 0])\n>>> np.ma.choose(a, choice)\nmasked_array(data=[3, 2, 1],\n mask=False,\n fill_value=999999)\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n*, *sparse=False*)*=*\n \nReturn an array representing the indices of a grid.\n\n Compute an array where the subarrays contain index values 0, 1, ⊠varying only along the corresponding axis.\n\n Parameters \n \n**dimensions**sequence of ints\n\nThe shape of the grid.\n\n \n**dtype**dtype, optional\n\nData type of the result.\n\n \n**sparse**boolean, optional\n\nReturn a sparse representation of the grid instead of a dense representation. Default is False.\n\n New in version 1.17.\n\n Returns \n \n**grid**one MaskedArray or tuple of MaskedArrays\n\n If sparse is False:\n\nReturns one array of grid indices, `grid.shape = (len(dimensions),) + tuple(dimensions)`.\n\n If sparse is True:\n\nReturns a tuple of arrays, with `grid[i].shape = (1, ..., 1, dimensions[i], 1, ..., 1)` with dimensions[i] in the ith place\n\n See also\n\n \n[`mgrid`](numpy.mgrid#numpy.mgrid \"numpy.mgrid\"), [`ogrid`](numpy.ogrid#numpy.ogrid \"numpy.ogrid\"), [`meshgrid`](numpy.meshgrid#numpy.meshgrid \"numpy.meshgrid\")\n\n #### Notes\n\n 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)`.\n\n The subarrays `grid[k]` contains the N-D array of indices along the `k-th` axis. Explicitly:\n\n \n```\ngrid[k, i0, i1, ..., iN-1] = ik\n\n```\n #### Examples\n\n \n```\n>>> grid = np.indices((2, 3))\n>>> grid.shape\n(2, 2, 3)\n>>> grid[0] # row indices\narray([[0, 0, 0],\n [1, 1, 1]])\n>>> grid[1] # column indices\narray([[0, 1, 2],\n [0, 1, 2]])\n\n```\n The indices can be used as an index into an array.\n\n \n```\n>>> x = np.arange(20).reshape(5, 4)\n>>> row, col = np.indices((2, 3))\n>>> x[row, col]\narray([[0, 1, 2],\n [4, 5, 6]])\n\n```\n Note that it would be more straightforward in the above example to extract the required elements directly with `x[:2, :3]`.\n\n If sparse is set to true, the grid will be returned in a sparse representation.\n\n \n```\n>>> i, j = np.indices((2, 3), sparse=True)\n>>> i.shape\n(2, 1)\n>>> j.shape\n(1, 3)\n>>> i # row indices\narray([[0],\n [1]])\n>>> j # column indices\narray([[0, 1, 2]])\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n>> phase = np.linspace(0, np.pi, num=5)\n>>> phase[3:] += np.pi\n>>> phase\narray([ 0. , 0.78539816, 1.57079633, 5.49778714, 6.28318531]) # may vary\n>>> np.unwrap(phase)\narray([ 0. , 0.78539816, 1.57079633, -0.78539816, 0. ]) # may vary\n>>> np.unwrap([0, 1, 2, -1, 0], period=4)\narray([0, 1, 2, 3, 4])\n>>> np.unwrap([ 1, 2, 3, 4, 5, 6, 1, 2, 3], period=6)\narray([1, 2, 3, 4, 5, 6, 7, 8, 9])\n>>> np.unwrap([2, 3, 4, 5, 2, 3, 4, 5], period=4)\narray([2, 3, 4, 5, 6, 7, 8, 9])\n>>> phase_deg = np.mod(np.linspace(0 ,720, 19), 360) - 180\n>>> np.unwrap(phase_deg, period=360)\narray([-180., -140., -100., -60., -20., 20., 60., 100., 140.,\n 180., 220., 260., 300., 340., 380., 420., 460., 500.,\n 540.])\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n>> np.fix(3.14)\n3.0\n>>> np.fix(3)\n3.0\n>>> np.fix([2.1, 2.9, -2.1, -2.9])\narray([ 2., 2., -2., -2.])\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n*, *initial=*, *where=*)[[source]](https://github.com/numpy/numpy/blob/v1.23.0/numpy/lib/nanfunctions.py#L732-L807)\n \nReturn the product of array elements over a given axis treating Not a Numbers (NaNs) as ones.\n\n One is returned for slices that are all-NaN or empty.\n\n New in version 1.10.0.\n\n Parameters \n \n**a**array_like\n\nArray containing numbers whose product is desired. If `a` is not an array, a conversion is attempted.\n\n \n**axis**{int, tuple of int, None}, optional\n\nAxis or axes along which the product is computed. The default is to compute the product of the flattened array.\n\n \n**dtype**data-type, optional\n\nThe type of the returned array and of the accumulator in which the elements are summed. By default, the dtype of `a` is used. An exception is when `a` has an integer type with less precision than the platform (u)intp. In that case, the default will be either (u)int32 or (u)int64 depending on whether the platform is 32 or 64 bits. For inexact inputs, dtype must be inexact.\n\n \n**out**ndarray, optional\n\nAlternate output array in which to place the result. The default is `None`. If provided, it must have the same shape as the expected output, but the type will be cast if necessary. See [Output type determination](../../user/basics.ufuncs#ufuncs-output-type) for more details. The casting of NaN to integer can yield unexpected results.\n\n \n**keepdims**bool, optional\n\nIf 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 original `arr`.\n\n \n**initial**scalar, optional\n\nThe starting value for this product. See [`reduce`](numpy.ufunc.reduce#numpy.ufunc.reduce \"numpy.ufunc.reduce\") for details.\n\n New in version 1.22.0.\n\n \n**where**array_like of bool, optional\n\nElements to include in the product. See [`reduce`](numpy.ufunc.reduce#numpy.ufunc.reduce \"numpy.ufunc.reduce\") for details.\n\n New in version 1.22.0.\n\n Returns \n \n**nanprod**ndarray\n\nA new array holding the result is returned unless `out` is specified, in which case it is returned.\n\n See also\n\n [`numpy.prod`](numpy.prod#numpy.prod \"numpy.prod\")\n\nProduct across array propagating NaNs.\n\n [`isnan`](numpy.isnan#numpy.isnan \"numpy.isnan\")\n\nShow which elements are NaN.\n\n #### Examples\n\n \n```\n>>> np.nanprod(1)\n1\n>>> np.nanprod([1])\n1\n>>> np.nanprod([1, np.nan])\n1.0\n>>> a = np.array([[1, 2], [3, np.nan]])\n>>> np.nanprod(a)\n6.0\n>>> np.nanprod(a, axis=0)\narray([3., 2.])\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n*, *initial=*, *where=*)[[source]](https://github.com/numpy/numpy/blob/v1.23.0/numpy/lib/nanfunctions.py#L623-L724)\n \nReturn the sum of array elements over a given axis treating Not a Numbers (NaNs) as zero.\n\n In NumPy versions <= 1.9.0 Nan is returned for slices that are all-NaN or empty. In later versions zero is returned.\n\n Parameters \n \n**a**array_like\n\nArray containing numbers whose sum is desired. If `a` is not an array, a conversion is attempted.\n\n \n**axis**{int, tuple of int, None}, optional\n\nAxis or axes along which the sum is computed. The default is to compute the sum of the flattened array.\n\n \n**dtype**data-type, optional\n\nThe type of the returned array and of the accumulator in which the elements are summed. By default, the dtype of `a` is used. An exception is when `a` has an integer type with less precision than the platform (u)intp. In that case, the default will be either (u)int32 or (u)int64 depending on whether the platform is 32 or 64 bits. For inexact inputs, dtype must be inexact.\n\n New in version 1.8.0.\n\n \n**out**ndarray, optional\n\nAlternate output array in which to place the result. The default is `None`. If provided, it must have the same shape as the expected output, but the type will be cast if necessary. See [Output type determination](../../user/basics.ufuncs#ufuncs-output-type) for more details. The casting of NaN to integer can yield unexpected results.\n\n New in version 1.8.0.\n\n \n**keepdims**bool, optional\n\nIf 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 original `a`.\n\n If the value is anything but the default, then `keepdims` will be passed through to the [`mean`](numpy.mean#numpy.mean \"numpy.mean\") or [`sum`](numpy.sum#numpy.sum \"numpy.sum\") methods of sub-classes of [`ndarray`](numpy.ndarray#numpy.ndarray \"numpy.ndarray\"). If the sub-classes methods does not implement `keepdims` any exceptions will be raised.\n\n New in version 1.8.0.\n\n \n**initial**scalar, optional\n\nStarting value for the sum. See [`reduce`](numpy.ufunc.reduce#numpy.ufunc.reduce \"numpy.ufunc.reduce\") for details.\n\n New in version 1.22.0.\n\n \n**where**array_like of bool, optional\n\nElements to include in the sum. See [`reduce`](numpy.ufunc.reduce#numpy.ufunc.reduce \"numpy.ufunc.reduce\") for details.\n\n New in version 1.22.0.\n\n Returns \n \n**nansum**ndarray.\n\nA new array holding the result is returned unless `out` is specified, in which it is returned. The result has the same size as `a`, and the same shape as `a` if `axis` is not None or `a` is a 1-d array.\n\n See also\n\n [`numpy.sum`](numpy.sum#numpy.sum \"numpy.sum\")\n\nSum across array propagating NaNs.\n\n [`isnan`](numpy.isnan#numpy.isnan \"numpy.isnan\")\n\nShow which elements are NaN.\n\n [`isfinite`](numpy.isfinite#numpy.isfinite \"numpy.isfinite\")\n\nShow which elements are not NaN or +/-inf.\n\n #### Notes\n\n If both positive and negative infinity are present, the sum will be Not A Number (NaN).\n\n #### Examples\n\n \n```\n>>> np.nansum(1)\n1\n>>> np.nansum([1])\n1\n>>> np.nansum([1, np.nan])\n1.0\n>>> a = np.array([[1, 1], [1, np.nan]])\n>>> np.nansum(a)\n3.0\n>>> np.nansum(a, axis=0)\narray([2., 1.])\n>>> np.nansum([1, np.nan, np.inf])\ninf\n>>> np.nansum([1, np.nan, np.NINF])\n-inf\n>>> from numpy.testing import suppress_warnings\n>>> with suppress_warnings() as sup:\n... sup.filter(RuntimeWarning)\n... np.nansum([1, np.nan, np.inf, -np.inf]) # both +/- infinity present\nnan\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n>> np.nancumprod(1)\narray([1])\n>>> np.nancumprod([1])\narray([1])\n>>> np.nancumprod([1, np.nan])\narray([1., 1.])\n>>> a = np.array([[1, 2], [3, np.nan]])\n>>> np.nancumprod(a)\narray([1., 2., 6., 6.])\n>>> np.nancumprod(a, axis=0)\narray([[1., 2.],\n [3., 2.]])\n>>> np.nancumprod(a, axis=1)\narray([[1., 2.],\n [3., 3.]])\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n>> np.nancumsum(1)\narray([1])\n>>> np.nancumsum([1])\narray([1])\n>>> np.nancumsum([1, np.nan])\narray([1., 1.])\n>>> a = np.array([[1, 2], [3, np.nan]])\n>>> np.nancumsum(a)\narray([1., 3., 6., 6.])\n>>> np.nancumsum(a, axis=0)\narray([[1., 2.],\n [4., 2.]])\n>>> np.nancumsum(a, axis=1)\narray([[1., 3.],\n [3., 3.]])\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n>> x = np.array([1, 2, 4, 7, 0])\n>>> np.ediff1d(x)\narray([ 1, 2, 3, -7])\n\n```\n \n```\n>>> np.ediff1d(x, to_begin=-99, to_end=np.array([88, 99]))\narray([-99, 1, 2, ..., -7, 88, 99])\n\n```\n The returned array is always 1D.\n\n \n```\n>>> y = [[1, 2, 4], [1, 6, 24]]\n>>> np.ediff1d(y)\narray([ 1, 2, -3, 5, 18])\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n., ., . (2007) Numerical Mathematics (Texts in Applied Mathematics). New York: Springer.\n\n 2 \n. (1999) Numerical Methods for Wave Equations in Geophysical Fluid Dynamics. New York: Springer.\n\n 3 \n. (1988) Generation of Finite Difference Formulas on Arbitrarily Spaced Grids, Mathematics of Computation 51, no. 184 : 699-706. [PDF](http://www.ams.org/journals/mcom/1988-51-184/S0025-5718-1988-0935077-0/S0025-5718-1988-0935077-0.pdf).\n\n #### Examples\n\n \n```\n>>> f = np.array([1, 2, 4, 7, 11, 16], dtype=float)\n>>> np.gradient(f)\narray([1. , 1.5, 2.5, 3.5, 4.5, 5. ])\n>>> np.gradient(f, 2)\narray([0.5 , 0.75, 1.25, 1.75, 2.25, 2.5 ])\n\n```\n Spacing can be also specified with an array that represents the coordinates of the values F along the dimensions. For instance a uniform spacing:\n\n \n```\n>>> x = np.arange(f.size)\n>>> np.gradient(f, x)\narray([1. , 1.5, 2.5, 3.5, 4.5, 5. ])\n\n```\n Or a non uniform one:\n\n \n```\n>>> x = np.array([0., 1., 1.5, 3.5, 4., 6.], dtype=float)\n>>> np.gradient(f, x)\narray([1. , 3. , 3.5, 6.7, 6.9, 2.5])\n\n```\n For two dimensional arrays, the return will be two arrays ordered by axis. In this example the first array stands for the gradient in rows and the second one in columns direction:\n\n \n```\n>>> np.gradient(np.array([[1, 2, 6], [3, 4, 5]], dtype=float))\n[array([[ 2., 2., -1.],\n [ 2., 2., -1.]]), array([[1. , 2.5, 4. ],\n [1. , 1. , 1. ]])]\n\n```\n In this example the spacing is also specified: uniform for axis=0 and non uniform for axis=1\n\n \n```\n>>> dx = 2.\n>>> y = [1., 1.5, 3.5]\n>>> np.gradient(np.array([[1, 2, 6], [3, 4, 5]], dtype=float), dx, y)\n[array([[ 1. , 1. , -0.5],\n [ 1. , 1. , -0.5]]), array([[2. , 2. , 2. ],\n [2. , 1.7, 0.5]])]\n\n```\n It is possible to specify how boundaries are treated using `edge_order`\n\n \n```\n>>> x = np.array([0, 1, 2, 3, 4])\n>>> f = x**2\n>>> np.gradient(f, edge_order=1)\narray([1., 2., 4., 6., 7.])\n>>> np.gradient(f, edge_order=2)\narray([0., 2., 4., 6., 8.])\n\n```\n The `axis` keyword can be used to specify a subset of axes of which the gradient is calculated\n\n \n```\n>>> np.gradient(np.array([[1, 2, 6], [3, 4, 5]], dtype=float), axis=0)\narray([[ 2., 2., -1.],\n [ 2., 2., -1.]])\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n>> np.trapz([1,2,3])\n4.0\n>>> np.trapz([1,2,3], x=[4,6,8])\n8.0\n>>> np.trapz([1,2,3], dx=2)\n8.0\n\n```\n Using a decreasing `x` corresponds to integrating in reverse:\n\n \n```\n>>> np.trapz([1,2,3], x=[8,6,4])\n-8.0\n\n```\n More generally `x` is used to integrate along a parametric curve. This finds the area of a circle, noting we repeat the sample which closes the curve:\n\n \n```\n>>> theta = np.linspace(0, 2 * np.pi, num=1000, endpoint=True)\n>>> np.trapz(np.cos(theta), x=np.sin(theta))\n3.141571941375841\n\n```\n \n```\n>>> a = np.arange(6).reshape(2, 3)\n>>> a\narray([[0, 1, 2],\n [3, 4, 5]])\n>>> np.trapz(a, axis=0)\narray([1.5, 2.5, 3.5])\n>>> np.trapz(a, axis=1)\narray([2., 8.])\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n. âSinc Function.â From MathWorldâA Wolfram Web Resource. >> import matplotlib.pyplot as plt\n>>> x = np.linspace(-4, 4, 41)\n>>> np.sinc(x)\n array([-3.89804309e-17, -4.92362781e-02, -8.40918587e-02, # may vary\n -8.90384387e-02, -5.84680802e-02, 3.89804309e-17,\n 6.68206631e-02, 1.16434881e-01, 1.26137788e-01,\n 8.50444803e-02, -3.89804309e-17, -1.03943254e-01,\n -1.89206682e-01, -2.16236208e-01, -1.55914881e-01,\n 3.89804309e-17, 2.33872321e-01, 5.04551152e-01,\n 7.56826729e-01, 9.35489284e-01, 1.00000000e+00,\n 9.35489284e-01, 7.56826729e-01, 5.04551152e-01,\n 2.33872321e-01, 3.89804309e-17, -1.55914881e-01,\n -2.16236208e-01, -1.89206682e-01, -1.03943254e-01,\n -3.89804309e-17, 8.50444803e-02, 1.26137788e-01,\n 1.16434881e-01, 6.68206631e-02, 3.89804309e-17,\n -5.84680802e-02, -8.90384387e-02, -8.40918587e-02,\n -4.92362781e-02, -3.89804309e-17])\n\n```\n \n```\n>>> plt.plot(x, np.sinc(x))\n[]\n>>> plt.title(\"Sinc Function\")\nText(0.5, 1.0, 'Sinc Function')\n>>> plt.ylabel(\"Amplitude\")\nText(0, 0.5, 'Amplitude')\n>>> plt.xlabel(\"X\")\nText(0.5, 0, 'X')\n>>> plt.show()\n\n```\n ![../../_images/numpy-sinc-1.png] \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n>> np.angle([1.0, 1.0j, 1+1j]) # in radians\narray([ 0. , 1.57079633, 0.78539816]) # may vary\n>>> np.angle(1+1j, deg=True) # in degrees\n45.0\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n*, *initial=*, *where=*)[[source]](https://github.com/numpy/numpy/blob/v1.23.0/numpy/lib/nanfunctions.py#L369-L494)\n \nReturn the maximum of an array or maximum along an axis, ignoring any NaNs. When all-NaN slices are encountered a `RuntimeWarning` is raised and NaN is returned for that slice.\n\n Parameters \n \n**a**array_like\n\nArray containing numbers whose maximum is desired. If `a` is not an array, a conversion is attempted.\n\n \n**axis**{int, tuple of int, None}, optional\n\nAxis or axes along which the maximum is computed. The default is to compute the maximum of the flattened array.\n\n \n**out**ndarray, optional\n\nAlternate output array in which to place the result. The default is `None`; if provided, it must have the same shape as the expected output, but the type will be cast if necessary. See [Output type determination](../../user/basics.ufuncs#ufuncs-output-type) for more details.\n\n New in version 1.8.0.\n\n \n**keepdims**bool, optional\n\nIf 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 original `a`.\n\n If the value is anything but the default, then `keepdims` will be passed through to the [`max`](https://docs.python.org/3/library/functions.html#max \"(in Python v3.10)\") method of sub-classes of [`ndarray`](numpy.ndarray#numpy.ndarray \"numpy.ndarray\"). If the sub-classes methods does not implement `keepdims` any exceptions will be raised.\n\n New in version 1.8.0.\n\n \n**initial**scalar, optional\n\nThe minimum value of an output element. Must be present to allow computation on empty slice. See [`reduce`](numpy.ufunc.reduce#numpy.ufunc.reduce \"numpy.ufunc.reduce\") for details.\n\n New in version 1.22.0.\n\n \n**where**array_like of bool, optional\n\nElements to compare for the maximum. See [`reduce`](numpy.ufunc.reduce#numpy.ufunc.reduce \"numpy.ufunc.reduce\") for details.\n\n New in version 1.22.0.\n\n Returns \n \n**nanmax**ndarray\n\nAn array with the same shape as `a`, with the specified axis removed. If `a` is a 0-d array, or if axis is None, an ndarray scalar is returned. The same dtype as `a` is returned.\n\n See also\n\n [`nanmin`](numpy.nanmin#numpy.nanmin \"numpy.nanmin\")\n\nThe minimum value of an array along a given axis, ignoring any NaNs.\n\n [`amax`](numpy.amax#numpy.amax \"numpy.amax\")\n\nThe maximum value of an array along a given axis, propagating any NaNs.\n\n [`fmax`](numpy.fmax#numpy.fmax \"numpy.fmax\")\n\nElement-wise maximum of two arrays, ignoring any NaNs.\n\n [`maximum`](numpy.maximum#numpy.maximum \"numpy.maximum\")\n\nElement-wise maximum of two arrays, propagating any NaNs.\n\n [`isnan`](numpy.isnan#numpy.isnan \"numpy.isnan\")\n\nShows which elements are Not a Number (NaN).\n\n [`isfinite`](numpy.isfinite#numpy.isfinite \"numpy.isfinite\")\n\nShows which elements are neither NaN nor infinity.\n\n \n[`amin`](numpy.amin#numpy.amin \"numpy.amin\"), [`fmin`](numpy.fmin#numpy.fmin \"numpy.fmin\"), [`minimum`](numpy.minimum#numpy.minimum \"numpy.minimum\")\n\n #### Notes\n\n NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic (IEEE 754). This means that Not a Number is not equivalent to infinity. Positive infinity is treated as a very large number and negative infinity is treated as a very small (i.e. negative) number.\n\n If the input has a integer type the function is equivalent to np.max.\n\n #### Examples\n\n \n```\n>>> a = np.array([[1, 2], [3, np.nan]])\n>>> np.nanmax(a)\n3.0\n>>> np.nanmax(a, axis=0)\narray([3., 2.])\n>>> np.nanmax(a, axis=1)\narray([2., 3.])\n\n```\n When positive infinity and negative infinity are present:\n\n \n```\n>>> np.nanmax([1, 2, np.nan, np.NINF])\n2.0\n>>> np.nanmax([1, 2, np.nan, np.inf])\ninf\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n*, *initial=*, *where=*)[[source]](https://github.com/numpy/numpy/blob/v1.23.0/numpy/lib/nanfunctions.py#L236-L361)\n \nReturn minimum of an array or minimum along an axis, ignoring any NaNs. When all-NaN slices are encountered a `RuntimeWarning` is raised and Nan is returned for that slice.\n\n Parameters \n \n**a**array_like\n\nArray containing numbers whose minimum is desired. If `a` is not an array, a conversion is attempted.\n\n \n**axis**{int, tuple of int, None}, optional\n\nAxis or axes along which the minimum is computed. The default is to compute the minimum of the flattened array.\n\n \n**out**ndarray, optional\n\nAlternate output array in which to place the result. The default is `None`; if provided, it must have the same shape as the expected output, but the type will be cast if necessary. See [Output type determination](../../user/basics.ufuncs#ufuncs-output-type) for more details.\n\n New in version 1.8.0.\n\n \n**keepdims**bool, optional\n\nIf 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 original `a`.\n\n If the value is anything but the default, then `keepdims` will be passed through to the [`min`](https://docs.python.org/3/library/functions.html#min \"(in Python v3.10)\") method of sub-classes of [`ndarray`](numpy.ndarray#numpy.ndarray \"numpy.ndarray\"). If the sub-classes methods does not implement `keepdims` any exceptions will be raised.\n\n New in version 1.8.0.\n\n \n**initial**scalar, optional\n\nThe maximum value of an output element. Must be present to allow computation on empty slice. See [`reduce`](numpy.ufunc.reduce#numpy.ufunc.reduce \"numpy.ufunc.reduce\") for details.\n\n New in version 1.22.0.\n\n \n**where**array_like of bool, optional\n\nElements to compare for the minimum. See [`reduce`](numpy.ufunc.reduce#numpy.ufunc.reduce \"numpy.ufunc.reduce\") for details.\n\n New in version 1.22.0.\n\n Returns \n \n**nanmin**ndarray\n\nAn array with the same shape as `a`, with the specified axis removed. If `a` is a 0-d array, or if axis is None, an ndarray scalar is returned. The same dtype as `a` is returned.\n\n See also\n\n [`nanmax`](numpy.nanmax#numpy.nanmax \"numpy.nanmax\")\n\nThe maximum value of an array along a given axis, ignoring any NaNs.\n\n [`amin`](numpy.amin#numpy.amin \"numpy.amin\")\n\nThe minimum value of an array along a given axis, propagating any NaNs.\n\n [`fmin`](numpy.fmin#numpy.fmin \"numpy.fmin\")\n\nElement-wise minimum of two arrays, ignoring any NaNs.\n\n [`minimum`](numpy.minimum#numpy.minimum \"numpy.minimum\")\n\nElement-wise minimum of two arrays, propagating any NaNs.\n\n [`isnan`](numpy.isnan#numpy.isnan \"numpy.isnan\")\n\nShows which elements are Not a Number (NaN).\n\n [`isfinite`](numpy.isfinite#numpy.isfinite \"numpy.isfinite\")\n\nShows which elements are neither NaN nor infinity.\n\n \n[`amax`](numpy.amax#numpy.amax \"numpy.amax\"), [`fmax`](numpy.fmax#numpy.fmax \"numpy.fmax\"), [`maximum`](numpy.maximum#numpy.maximum \"numpy.maximum\")\n\n #### Notes\n\n NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic (IEEE 754). This means that Not a Number is not equivalent to infinity. Positive infinity is treated as a very large number and negative infinity is treated as a very small (i.e. negative) number.\n\n If the input has a integer type the function is equivalent to np.min.\n\n #### Examples\n\n \n```\n>>> a = np.array([[1, 2], [3, np.nan]])\n>>> np.nanmin(a)\n1.0\n>>> np.nanmin(a, axis=0)\narray([1., 2.])\n>>> np.nanmin(a, axis=1)\narray([1., 3.])\n\n```\n When positive infinity and negative infinity are present:\n\n \n```\n>>> np.nanmin([1, 2, np.nan, np.inf])\n1.0\n>>> np.nanmin([1, 2, np.nan, np.NINF])\n-inf\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n>> np.convolve([1, 2, 3], [0, 1, 0.5])\narray([0. , 1. , 2.5, 4. , 1.5])\n\n```\n Only return the middle values of the convolution. Contains boundary effects, where zeros are taken into account:\n\n \n```\n>>> np.convolve([1,2,3],[0,1,0.5], 'same')\narray([1. , 2.5, 4. ])\n\n```\n The two arrays are of the same length, so there is only one position where they completely overlap:\n\n \n```\n>>> np.convolve([1,2,3],[0,1,0.5], 'valid')\narray([2.5])\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n>> np.nan_to_num(np.inf)\n1.7976931348623157e+308\n>>> np.nan_to_num(-np.inf)\n-1.7976931348623157e+308\n>>> np.nan_to_num(np.nan)\n0.0\n>>> x = np.array([np.inf, -np.inf, np.nan, -128, 128])\n>>> np.nan_to_num(x)\narray([ 1.79769313e+308, -1.79769313e+308, 0.00000000e+000, # may vary\n -1.28000000e+002, 1.28000000e+002])\n>>> np.nan_to_num(x, nan=-9999, posinf=33333333, neginf=33333333)\narray([ 3.3333333e+07, 3.3333333e+07, -9.9990000e+03,\n -1.2800000e+02, 1.2800000e+02])\n>>> y = np.array([complex(np.inf, np.nan), np.nan, complex(np.nan, np.inf)])\narray([ 1.79769313e+308, -1.79769313e+308, 0.00000000e+000, # may vary\n -1.28000000e+002, 1.28000000e+002])\n>>> np.nan_to_num(y)\narray([ 1.79769313e+308 +0.00000000e+000j, # may vary\n 0.00000000e+000 +0.00000000e+000j,\n 0.00000000e+000 +1.79769313e+308j])\n>>> np.nan_to_num(y, nan=111111, posinf=222222)\narray([222222.+111111.j, 111111. +0.j, 111111.+222222.j])\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n>> np.finfo(float).eps\n2.2204460492503131e-16 # may vary\n\n```\n \n```\n>>> np.real_if_close([2.1 + 4e-14j, 5.2 + 3e-15j], tol=1000)\narray([2.1, 5.2])\n>>> np.real_if_close([2.1 + 4e-13j, 5.2 + 3e-15j], tol=1000)\narray([2.1+4.e-13j, 5.2 + 3e-15j])\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n xp[-1]`, default is `fp[-1]`.\n\n \n**period**None or float, optional\n\nA period for the x-coordinates. This parameter allows the proper interpolation of angular x-coordinates. Parameters `left` and `right` are ignored if `period` is specified.\n\n New in version 1.10.0.\n\n Returns \n \n**y**float or complex (corresponding to fp) or ndarray\n\nThe interpolated values, same shape as `x`.\n\n Raises \n ValueError\n\nIf `xp` and `fp` have different length If `xp` or `fp` are not 1-D sequences If `period == 0`\n\n Warning\n\n The x-coordinate sequence is expected to be increasing, but this is not explicitly enforced. However, if the sequence `xp` is non-increasing, interpolation results are meaningless.\n\n Note that, since NaN is unsortable, `xp` also cannot contain NaNs.\n\n A simple check for `xp` being strictly increasing is:\n\n \n```\nnp.all(np.diff(xp) > 0)\n\n```\n See also\n\n [`scipy.interpolate`](https://docs.scipy.org/doc/scipy/reference/interpolate.html#module-scipy.interpolate \"(in SciPy v1.8.1)\")\n #### Examples\n\n \n```\n>>> xp = [1, 2, 3]\n>>> fp = [3, 2, 0]\n>>> np.interp(2.5, xp, fp)\n1.0\n>>> np.interp([0, 1, 1.5, 2.72, 3.14], xp, fp)\narray([3. , 3. , 2.5 , 0.56, 0. ])\n>>> UNDEF = -99.0\n>>> np.interp(3.14, xp, fp, right=UNDEF)\n-99.0\n\n```\n Plot an interpolant to the sine function:\n\n \n```\n>>> x = np.linspace(0, 2*np.pi, 10)\n>>> y = np.sin(x)\n>>> xvals = np.linspace(0, 2*np.pi, 50)\n>>> yinterp = np.interp(xvals, x, y)\n>>> import matplotlib.pyplot as plt\n>>> plt.plot(x, y, 'o')\n[]\n>>> plt.plot(xvals, yinterp, '-x')\n[]\n>>> plt.show()\n\n```\n ![../../_images/numpy-interp-1_00_00.png] Interpolation with periodic x-coordinates:\n\n \n```\n>>> x = [-180, -170, -185, 185, -10, -5, 0, 365]\n>>> xp = [190, -190, 350, -350]\n>>> fp = [5, 10, 3, 4]\n>>> np.interp(x, xp, fp, period=360)\narray([7.5 , 5. , 8.75, 6.25, 3. , 3.25, 3.5 , 3.75])\n\n```\n Complex interpolation:\n\n \n```\n>>> x = [1.5, 4.0]\n>>> xp = [2,3,5]\n>>> fp = [1.0j, 0, 2+3j]\n>>> np.interp(x, xp, fp)\narray([0.+1.j , 1.+1.5j])\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n>> np.may_share_memory(np.array([1,2]), np.array([5,8,9]))\nFalse\n>>> x = np.zeros([3, 4])\n>>> np.may_share_memory(x[:,0], x[:,1])\nTrue\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n>> I = np.eye(2, dtype='f'); I.dtype\ndtype('float32')\n>>> low, high = np.byte_bounds(I)\n>>> high - low == I.size*I.itemsize\nTrue\n>>> I = np.eye(2); I.dtype\ndtype('float64')\n>>> low, high = np.byte_bounds(I)\n>>> high - low == I.size*I.itemsize\nTrue\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n 9 in principle):\n\n * Released version: â1.8.0â, â1.8.1â, etc.\n* Alpha: â1.8.0a1â, â1.8.0a2â, etc.\n* Beta: â1.8.0b1â, â1.8.0b2â, etc.\n* Release candidates: â1.8.0rc1â, â1.8.0rc2â, etc.\n* Development versions: â1.8.0.dev-f1234afaâ (git commit hash appended)\n* Development versions after a1: â1.8.0a1.dev-f1234afaâ,\n\nâ1.8.0b2.dev-f1234afaâ, â1.8.1rc1.dev-f1234afaâ, etc.\n* Development versions (no git hash available): â1.8.0.dev-Unknownâ\n\n Comparing needs to be done against a valid version string or other [`NumpyVersion`](#numpy.lib.NumpyVersion \"numpy.lib.NumpyVersion\") instance. Note that all development versions of the same (pre-)release compare equal.\n\n New in version 1.9.0.\n\n Parameters \n \n**vstring**str\n\nNumPy version string (`np.__version__`).\n\n #### Examples\n\n \n```\n>>> from numpy.lib import NumpyVersion\n>>> if NumpyVersion(np.__version__) < '1.7.0':\n... print('skip')\n>>> # skip\n\n```\n \n```\n>>> NumpyVersion('1.7') # raises ValueError, add \".0\"\nTraceback (most recent call last):\n ...\nValueError: Not a valid numpy version string\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n>> import numpy as np\n>>> np.show_config()\nblas_opt_info:\n language = c\n define_macros = [('HAVE_CBLAS', None)]\n libraries = ['openblas', 'openblas']\n library_dirs = ['/usr/local/lib']\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n>> olduint = np.deprecate(np.uint)\nDeprecationWarning: `uint64` is deprecated! # may vary\n>>> olduint(6)\n6\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n>> np.broadcast_shapes((1, 2), (3, 1), (3, 2))\n(3, 2)\n\n```\n \n```\n>>> np.broadcast_shapes((6, 7), (5, 6, 1), (7,), (5, 1, 7))\n(5, 6, 7)\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n>> a = np.arange(10)\n>>> b = np.ones(20)\n>>> np.who()\nName Shape Bytes Type\n===========================================================\na 10 80 int64\nb 20 160 float64\nUpper bound on total bytes = 240\n\n```\n \n```\n>>> d = {'x': np.arange(2.0), 'y': np.arange(3.0), 'txt': 'Some str',\n... 'idx':5}\n>>> np.who(d)\nName Shape Bytes Type\n===========================================================\nx 2 16 float64\ny 3 24 float64\nUpper bound on total bytes = 40\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n>> from io import StringIO\n>>> buf = StringIO()\n>>> np.disp(u'\"Display\" in a file', device=buf)\n>>> buf.getvalue()\n'\"Display\" in a file\\n'\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n>> array_1d = np.arange(10)\n>>> np.cumsum(array_1d, axis=1)\nTraceback (most recent call last):\n ...\nnumpy.AxisError: axis 1 is out of bounds for array of dimension 1\n\n```\n Negative axes are preserved:\n\n \n```\n>>> np.cumsum(array_1d, axis=-2)\nTraceback (most recent call last):\n ...\nnumpy.AxisError: axis -2 is out of bounds for array of dimension 1\n\n```\n The class constructor generally takes the axis and arraysâ dimensionality as arguments:\n\n \n```\n>>> print(np.AxisError(2, 1, msg_prefix='error'))\nerror: axis 2 is out of bounds for array of dimension 1\n\n```\n Alternatively, a custom exception message can be passed:\n\n \n```\n>>> print(np.AxisError('Custom error message'))\nCustom error message\n\n```\n Attributes \n \n**axis**int, optional\n\nThe out of bounds axis or `None` if a custom exception message was provided. This should be the axis as passed by the user, before any normalization to resolve negative indices.\n\n New in version 1.22.\n\n \n**ndim**int, optional\n\nThe number of array dimensions or `None` if a custom exception message was provided.\n\n New in version 1.22.\n\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n>> from numpy.polynomial import Polynomial as P\n>>> p = P([1,2,3])\n>>> p\nPolynomial([1., 2., 3.], domain=[-1, 1], window=[-1, 1])\n\n```\n Note that there are three parts to the long version of the printout. The first is the coefficients, the second is the domain, and the third is the window:\n\n \n```\n>>> p.coef\narray([1., 2., 3.])\n>>> p.domain\narray([-1, 1])\n>>> p.window\narray([-1, 1])\n\n```\n Printing a polynomial yields the polynomial expression in a more familiar format:\n\n \n```\n>>> print(p)\n1.0 + 2.0·x¹ + 3.0·x²\n\n```\n Note that the string representation of polynomials uses Unicode characters by default (except on Windows) to express powers and subscripts. An ASCII-based representation is also available (default on Windows). The polynomial string format can be toggled at the package-level with the [`set_default_printstyle`](generated/numpy.polynomial.set_default_printstyle#numpy.polynomial.set_default_printstyle \"numpy.polynomial.set_default_printstyle\") function:\n\n \n```\n>>> np.polynomial.set_default_printstyle('ascii')\n>>> print(p)\n1.0 + 2.0 x**1 + 3.0 x**2\n\n```\n or controlled for individual polynomial instances with string formatting:\n\n \n```\n>>> print(f\"{p:unicode}\")\n1.0 + 2.0·x¹ + 3.0·x²\n\n```\n We will deal with the domain and window when we get to fitting, for the moment we ignore them and run through the basic algebraic and arithmetic operations.\n\n Addition and Subtraction:\n\n \n```\n>>> p + p\nPolynomial([2., 4., 6.], domain=[-1., 1.], window=[-1., 1.])\n>>> p - p\nPolynomial([0.], domain=[-1., 1.], window=[-1., 1.])\n\n```\n Multiplication:\n\n \n```\n>>> p * p\nPolynomial([ 1., 4., 10., 12., 9.], domain=[-1., 1.], window=[-1., 1.])\n\n```\n Powers:\n\n \n```\n>>> p**2\nPolynomial([ 1., 4., 10., 12., 9.], domain=[-1., 1.], window=[-1., 1.])\n\n```\n Division:\n\n Floor division, â//â, is the division operator for the polynomial classes, polynomials are treated like integers in this regard. For Python versions < 3.x the â/â operator maps to â//â, as it does for Python, for later versions the â/â will only work for division by scalars. At some point it will be deprecated:\n\n \n```\n>>> p // P([-1, 1])\nPolynomial([5., 3.], domain=[-1., 1.], window=[-1., 1.])\n\n```\n Remainder:\n\n \n```\n>>> p % P([-1, 1])\nPolynomial([6.], domain=[-1., 1.], window=[-1., 1.])\n\n```\n Divmod:\n\n \n```\n>>> quo, rem = divmod(p, P([-1, 1]))\n>>> quo\nPolynomial([5., 3.], domain=[-1., 1.], window=[-1., 1.])\n>>> rem\nPolynomial([6.], domain=[-1., 1.], window=[-1., 1.])\n\n```\n Evaluation:\n\n \n```\n>>> x = np.arange(5)\n>>> p(x)\narray([ 1., 6., 17., 34., 57.])\n>>> x = np.arange(6).reshape(3,2)\n>>> p(x)\narray([[ 1., 6.],\n [17., 34.],\n [57., 86.]])\n\n```\n Substitution:\n\n Substitute a polynomial for x and expand the result. Here we substitute p in itself leading to a new polynomial of degree 4 after expansion. If the polynomials are regarded as functions this is composition of functions:\n\n \n```\n>>> p(p)\nPolynomial([ 6., 16., 36., 36., 27.], domain=[-1., 1.], window=[-1., 1.])\n\n```\n Roots:\n\n \n```\n>>> p.roots()\narray([-0.33333333-0.47140452j, -0.33333333+0.47140452j])\n\n```\n It isnât always convenient to explicitly use Polynomial instances, so tuples, lists, arrays, and scalars are automatically cast in the arithmetic operations:\n\n \n```\n>>> p + [1, 2, 3]\nPolynomial([2., 4., 6.], domain=[-1., 1.], window=[-1., 1.])\n>>> [1, 2, 3] * p\nPolynomial([ 1., 4., 10., 12., 9.], domain=[-1., 1.], window=[-1., 1.])\n>>> p / 2\nPolynomial([0.5, 1. , 1.5], domain=[-1., 1.], window=[-1., 1.])\n\n```\n Polynomials that differ in domain, window, or class canât be mixed in arithmetic:\n\n \n```\n>>> from numpy.polynomial import Chebyshev as T\n>>> p + P([1], domain=[0,1])\nTraceback (most recent call last):\n File \"\", line 1, in \n File \"\", line 213, in __add__\nTypeError: Domains differ\n>>> p + P([1], window=[0,1])\nTraceback (most recent call last):\n File \"\", line 1, in \n File \"\", line 215, in __add__\nTypeError: Windows differ\n>>> p + T([1])\nTraceback (most recent call last):\n File \"\", line 1, in \n File \"\", line 211, in __add__\nTypeError: Polynomial types differ\n\n```\n But different types can be used for substitution. In fact, this is how conversion of Polynomial classes among themselves is done for type, domain, and window casting:\n\n \n```\n>>> p(T([0, 1]))\nChebyshev([2.5, 2. , 1.5], domain=[-1., 1.], window=[-1., 1.])\n\n```\n Which gives the polynomial `p` in Chebyshev form. This works because \\(T_1(x) = x\\) and substituting \\(x\\) for \\(x\\) doesnât change the original polynomial. However, all the multiplications and divisions will be done using Chebyshev series, hence the type of the result.\n\n It is intended that all polynomial instances are immutable, therefore augmented operations (`+=`, `-=`, etc.) and any other functionality that would violate the immutablity of a polynomial instance are intentionally unimplemented.\n\n Calculus\n--------\n\n Polynomial instances can be integrated and differentiated.:\n\n \n```\n>>> from numpy.polynomial import Polynomial as P\n>>> p = P([2, 6])\n>>> p.integ()\nPolynomial([0., 2., 3.], domain=[-1., 1.], window=[-1., 1.])\n>>> p.integ(2)\nPolynomial([0., 0., 1., 1.], domain=[-1., 1.], window=[-1., 1.])\n\n```\n The first example integrates `p` once, the second example integrates it twice. By default, the lower bound of the integration and the integration constant are 0, but both can be specified.:\n\n \n```\n>>> p.integ(lbnd=-1)\nPolynomial([-1., 2., 3.], domain=[-1., 1.], window=[-1., 1.])\n>>> p.integ(lbnd=-1, k=1)\nPolynomial([0., 2., 3.], domain=[-1., 1.], window=[-1., 1.])\n\n```\n In the first case the lower bound of the integration is set to -1 and the integration constant is 0. In the second the constant of integration is set to 1 as well. Differentiation is simpler since the only option is the number of times the polynomial is differentiated:\n\n \n```\n>>> p = P([1, 2, 3])\n>>> p.deriv(1)\nPolynomial([2., 6.], domain=[-1., 1.], window=[-1., 1.])\n>>> p.deriv(2)\nPolynomial([6.], domain=[-1., 1.], window=[-1., 1.])\n\n```\n Other Polynomial Constructors\n-----------------------------\n\n Constructing polynomials by specifying coefficients is just one way of obtaining a polynomial instance, they may also be created by specifying their roots, by conversion from other polynomial types, and by least squares fits. Fitting is discussed in its own section, the other methods are demonstrated below:\n\n \n```\n>>> from numpy.polynomial import Polynomial as P\n>>> from numpy.polynomial import Chebyshev as T\n>>> p = P.fromroots([1, 2, 3])\n>>> p\nPolynomial([-6., 11., -6., 1.], domain=[-1., 1.], window=[-1., 1.])\n>>> p.convert(kind=T)\nChebyshev([-9. , 11.75, -3. , 0.25], domain=[-1., 1.], window=[-1., 1.])\n\n```\n The convert method can also convert domain and window:\n\n \n```\n>>> p.convert(kind=T, domain=[0, 1])\nChebyshev([-2.4375 , 2.96875, -0.5625 , 0.03125], domain=[0., 1.], window=[-1., 1.])\n>>> p.convert(kind=P, domain=[0, 1])\nPolynomial([-1.875, 2.875, -1.125, 0.125], domain=[0., 1.], window=[-1., 1.])\n\n```\n In numpy versions >= 1.7.0 the `basis` and `cast` class methods are also available. The cast method works like the convert method while the basis method returns the basis polynomial of given degree:\n\n \n```\n>>> P.basis(3)\nPolynomial([0., 0., 0., 1.], domain=[-1., 1.], window=[-1., 1.])\n>>> T.cast(p)\nChebyshev([-9. , 11.75, -3. , 0.25], domain=[-1., 1.], window=[-1., 1.])\n\n```\n Conversions between types can be useful, but it is *not* recommended for routine use. The loss of numerical precision in passing from a Chebyshev series of degree 50 to a Polynomial series of the same degree can make the results of numerical evaluation essentially random.\n\n Fitting\n-------\n\n Fitting is the reason that the `domain` and `window` attributes are part of the convenience classes. To illustrate the problem, the values of the Chebyshev polynomials up to degree 5 are plotted below.\n\n \n```\n>>> import matplotlib.pyplot as plt\n>>> from numpy.polynomial import Chebyshev as T\n>>> x = np.linspace(-1, 1, 100)\n>>> for i in range(6):\n... ax = plt.plot(x, T.basis(i)(x), lw=2, label=f\"$T_{i}$\")\n...\n>>> plt.legend(loc=\"upper left\")\n>>> plt.show()\n\n```\n ![../_images/routines-polynomials-classes-1.png] In the range -1 <= `x` <= 1 they are nice, equiripple functions lying between +/- 1. The same plots over the range -2 <= `x` <= 2 look very different:\n\n \n```\n>>> import matplotlib.pyplot as plt\n>>> from numpy.polynomial import Chebyshev as T\n>>> x = np.linspace(-2, 2, 100)\n>>> for i in range(6):\n... ax = plt.plot(x, T.basis(i)(x), lw=2, label=f\"$T_{i}$\")\n...\n>>> plt.legend(loc=\"lower right\")\n>>> plt.show()\n\n```\n ![../_images/routines-polynomials-classes-2.png] As can be seen, the âgoodâ parts have shrunk to insignificance. In using Chebyshev polynomials for fitting we want to use the region where `x` is between -1 and 1 and that is what the `window` specifies. However, it is unlikely that the data to be fit has all its data points in that interval, so we use `domain` to specify the interval where the data points lie. When the fit is done, the domain is first mapped to the window by a linear transformation and the usual least squares fit is done using the mapped data points. The window and domain of the fit are part of the returned series and are automatically used when computing values, derivatives, and such. If they arenât specified in the call the fitting routine will use the default window and the smallest domain that holds all the data points. This is illustrated below for a fit to a noisy sine curve.\n\n \n```\n>>> import numpy as np\n>>> import matplotlib.pyplot as plt\n>>> from numpy.polynomial import Chebyshev as T\n>>> np.random.seed(11)\n>>> x = np.linspace(0, 2*np.pi, 20)\n>>> y = np.sin(x) + np.random.normal(scale=.1, size=x.shape)\n>>> p = T.fit(x, y, 5)\n>>> plt.plot(x, y, 'o')\n>>> xx, yy = p.linspace()\n>>> plt.plot(xx, yy, lw=2)\n>>> p.domain\narray([0. , 6.28318531])\n>>> p.window\narray([-1., 1.])\n>>> plt.show()\n\n```\n ![../_images/routines-polynomials-classes-3.png] \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n, et al., âCombinatorial Trigonometry with Chebyshev Polynomials,â *Journal of Statistical Planning and Inference 14*, 2008 (, pg. 4)\n\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n>> p = np.poly1d([1, 2, 3])\n>>> print(np.poly1d(p))\n 2\n1 x + 2 x + 3\n\n```\n Evaluate the polynomial at \\(x = 0.5\\):\n\n \n```\n>>> p(0.5)\n4.25\n\n```\n Find the roots:\n\n \n```\n>>> p.r\narray([-1.+1.41421356j, -1.-1.41421356j])\n>>> p(p.r)\narray([ -4.44089210e-16+0.j, -4.44089210e-16+0.j]) # may vary\n\n```\n These numbers in the previous line represent (0, 0) to machine precision\n\n Show the coefficients:\n\n \n```\n>>> p.c\narray([1, 2, 3])\n\n```\n Display the order (the leading zero-coefficients are removed):\n\n \n```\n>>> p.order\n2\n\n```\n Show the coefficient of the k-th power in the polynomial (which is equivalent to `p.c[-(i+1)]`):\n\n \n```\n>>> p[1]\n2\n\n```\n Polynomials can be added, subtracted, multiplied, and divided (returns quotient and remainder):\n\n \n```\n>>> p * p\npoly1d([ 1, 4, 10, 12, 9])\n\n```\n \n```\n>>> (p**3 + 4) / p\n(poly1d([ 1., 4., 10., 12., 9.]), poly1d([4.]))\n\n```\n `asarray(p)` gives the coefficient array, so polynomials can be used in all functions that accept arrays:\n\n \n```\n>>> p**2 # square of polynomial\npoly1d([ 1, 4, 10, 12, 9])\n\n```\n \n```\n>>> np.square(p) # square of individual coefficients\narray([1, 4, 9])\n\n```\n The variable used in the string representation of `p` can be modified, using the [`variable`](numpy.poly1d.variable#numpy.poly1d.variable \"numpy.poly1d.variable\") parameter:\n\n \n```\n>>> p = np.poly1d([1,2,3], variable='z')\n>>> print(p)\n 2\n1 z + 2 z + 3\n\n```\n Construct a polynomial from its roots:\n\n \n```\n>>> np.poly1d([1, 2], True)\npoly1d([ 1., -3., 2.])\n\n```\n This is the same polynomial as obtained by:\n\n \n```\n>>> np.poly1d([1, -1]) * np.poly1d([1, -2])\npoly1d([ 1, -3, 2])\n\n```\n Attributes \n [`c`](numpy.poly1d.c#numpy.poly1d.c \"numpy.poly1d.c\")\n\nThe polynomial coefficients\n\n [`coef`](numpy.poly1d.coef#numpy.poly1d.coef \"numpy.poly1d.coef\")\n\nThe polynomial coefficients\n\n [`coefficients`](numpy.poly1d.coefficients#numpy.poly1d.coefficients \"numpy.poly1d.coefficients\")\n\nThe polynomial coefficients\n\n [`coeffs`](numpy.poly1d.coeffs#numpy.poly1d.coeffs \"numpy.poly1d.coeffs\")\n\nThe polynomial coefficients\n\n [`o`](numpy.poly1d.o#numpy.poly1d.o \"numpy.poly1d.o\")\n\nThe order or degree of the polynomial\n\n [`order`](numpy.poly1d.order#numpy.poly1d.order \"numpy.poly1d.order\")\n\nThe order or degree of the polynomial\n\n [`r`](numpy.poly1d.r#numpy.poly1d.r \"numpy.poly1d.r\")\n\nThe roots of the polynomial, where self(x) == 0\n\n [`roots`](numpy.roots#numpy.roots \"numpy.roots\")\n\nThe roots of the polynomial, where self(x) == 0\n\n [`variable`](numpy.poly1d.variable#numpy.poly1d.variable \"numpy.poly1d.variable\")\n\nThe name of the polynomial variable\n\n #### Methods\n\n \n\n| | |\n| --- | --- |\n| [`__call__`](numpy.poly1d.__call__#numpy.poly1d.__call__ \"numpy.poly1d.__call__\")(val) | Call self as a function. |\n| [`deriv`](numpy.poly1d.deriv#numpy.poly1d.deriv \"numpy.poly1d.deriv\")([m]) | Return a derivative of this polynomial. |\n| [`integ`](numpy.poly1d.integ#numpy.poly1d.integ \"numpy.poly1d.integ\")([m, k]) | Return an antiderivative (indefinite integral) of this polynomial. |\n\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n>> np.polyadd([1, 2], [9, 5, 4])\narray([9, 6, 6])\n\n```\n Using poly1d objects:\n\n \n```\n>>> p1 = np.poly1d([1, 2])\n>>> p2 = np.poly1d([9, 5, 4])\n>>> print(p1)\n1 x + 2\n>>> print(p2)\n 2\n9 x + 5 x + 4\n>>> print(np.polyadd(p1, p2))\n 2\n9 x + 6 x + 6\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n `values` array_like, `x` a poly1d object => `values` is also.\n\n See also\n\n [`poly1d`](numpy.poly1d#numpy.poly1d \"numpy.poly1d\")\n\nA polynomial class.\n\n #### Notes\n\n Hornerâs scheme [[1]](#r138ee7027ddf-1) is used to evaluate the polynomial. Even so, for polynomials of high degree the values may be inaccurate due to rounding errors. Use carefully.\n\n If `x` is a subtype of [`ndarray`](numpy.ndarray#numpy.ndarray \"numpy.ndarray\") the return value will be of the same type.\n\n #### References\n\n [1](#id1) \n, , and (Eng. trans. Ed.), *Handbook of Mathematics*, New York, Van Nostrand Reinhold Co., 1985, pg. 720.\n\n #### Examples\n\n \n```\n>>> np.polyval([3,0,1], 5) # 3 * 5**2 + 0 * 5**1 + 1\n76\n>>> np.polyval([3,0,1], np.poly1d(5))\npoly1d([76])\n>>> np.polyval(np.poly1d([3,0,1]), 5)\n76\n>>> np.polyval(np.poly1d([3,0,1]), np.poly1d(5))\npoly1d([76])\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n>> import warnings\n>>> warnings.simplefilter('ignore', np.RankWarning)\n\n```\n See also\n\n [`polyval`](numpy.polyval#numpy.polyval \"numpy.polyval\")\n\nCompute polynomial values.\n\n [`linalg.lstsq`](numpy.linalg.lstsq#numpy.linalg.lstsq \"numpy.linalg.lstsq\")\n\nComputes a least-squares fit.\n\n [`scipy.interpolate.UnivariateSpline`](https://docs.scipy.org/doc/scipy/reference/generated/scipy.interpolate.UnivariateSpline.html#scipy.interpolate.UnivariateSpline \"(in SciPy v1.8.1)\")\n\nComputes spline fits.\n\n #### Notes\n\n The solution minimizes the squared error\n\n \\[E = \\sum_{j=0}^k |p(x_j) - y_j|^2\\] in the equations:\n\n \n```\nx[0]**n * p[0] + ... + x[0] * p[n-1] + p[n] = y[0]\nx[1]**n * p[0] + ... + x[1] * p[n-1] + p[n] = y[1]\n...\nx[k]**n * p[0] + ... + x[k] * p[n-1] + p[n] = y[k]\n\n```\n The coefficient matrix of the coefficients `p` is a Vandermonde matrix.\n\n [`polyfit`](#numpy.polyfit \"numpy.polyfit\") issues a [`RankWarning`](numpy.rankwarning#numpy.RankWarning \"numpy.RankWarning\") when the least-squares fit is badly conditioned. This implies that the best fit is not well-defined due to numerical error. The results may be improved by lowering the polynomial degree or by replacing `x` by `x` - `x`.mean(). The `rcond` parameter can also be set to a value smaller than its default, but the resulting fit may be spurious: including contributions from the small singular values can add numerical noise to the result.\n\n Note that fitting polynomial coefficients is inherently badly conditioned when the degree of the polynomial is large or the interval of sample points is badly centered. The quality of the fit should always be checked in these cases. When polynomial fits are not satisfactory, splines may be a good alternative.\n\n #### References\n\n 1 \nWikipedia, âCurve fittingâ, >> import warnings\n>>> x = np.array([0.0, 1.0, 2.0, 3.0, 4.0, 5.0])\n>>> y = np.array([0.0, 0.8, 0.9, 0.1, -0.8, -1.0])\n>>> z = np.polyfit(x, y, 3)\n>>> z\narray([ 0.08703704, -0.81349206, 1.69312169, -0.03968254]) # may vary\n\n```\n It is convenient to use [`poly1d`](numpy.poly1d#numpy.poly1d \"numpy.poly1d\") objects for dealing with polynomials:\n\n \n```\n>>> p = np.poly1d(z)\n>>> p(0.5)\n0.6143849206349179 # may vary\n>>> p(3.5)\n-0.34732142857143039 # may vary\n>>> p(10)\n22.579365079365115 # may vary\n\n```\n High-order polynomials may oscillate wildly:\n\n \n```\n>>> with warnings.catch_warnings():\n... warnings.simplefilter('ignore', np.RankWarning)\n... p30 = np.poly1d(np.polyfit(x, y, 30))\n...\n>>> p30(4)\n-0.80000000000000204 # may vary\n>>> p30(5)\n-0.99999999999999445 # may vary\n>>> p30(4.5)\n-0.10547061179440398 # may vary\n\n```\n Illustration:\n\n \n```\n>>> import matplotlib.pyplot as plt\n>>> xp = np.linspace(-2, 6, 100)\n>>> _ = plt.plot(x, y, '.', xp, p(xp), '-', xp, p30(xp), '--')\n>>> plt.ylim(-2,2)\n(-2, 2)\n>>> plt.show()\n\n```\n ![../../_images/numpy-polyfit-1.png] \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n and , III, âAlgebra and Trignometry, Enhanced With Graphing Utilities,â Prentice-Hall, pg. 318, 1996.\n\n [2](#id2) \n, âLinear Algebra and Its Applications, 2nd Edition,â Academic Press, pg. 182, 1980.\n\n #### Examples\n\n Given a sequence of a polynomialâs zeros:\n\n \n```\n>>> np.poly((0, 0, 0)) # Multiple root example\narray([1., 0., 0., 0.])\n\n```\n The line above represents z**3 + 0*z**2 + 0*z + 0.\n\n \n```\n>>> np.poly((-1./2, 0, 1./2))\narray([ 1. , 0. , -0.25, 0. ])\n\n```\n The line above represents z**3 - z/4\n\n \n```\n>>> np.poly((np.random.random(1)[0], 0, np.random.random(1)[0]))\narray([ 1. , -0.77086955, 0.08618131, 0. ]) # random\n\n```\n Given a square array object:\n\n \n```\n>>> P = np.array([[0, 1./3], [-1./2, 0]])\n>>> np.poly(P)\narray([1. , 0. , 0.16666667])\n\n```\n Note how in all cases the leading coefficient is always 1.\n\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n= 1.11.0 a list of integers specifying the degrees of the terms to include may be used instead.\n\n \n**domain**{None, [beg, end], []}, optional\n\nDomain to use for the returned series. If `None`, then a minimal domain that covers the points `x` is chosen. If `[]` the class domain is used. The default value was the class domain in NumPy 1.4 and `None` in later versions. The `[]` option was added in numpy 1.5.0.\n\n \n**rcond**float, optional\n\nRelative condition number of the fit. Singular values smaller than this relative to the largest singular value will be ignored. The default value is len(x)*eps, where eps is the relative precision of the float type, about 2e-16 in most cases.\n\n \n**full**bool, optional\n\nSwitch determining nature of return value. When it is False (the default) just the coefficients are returned, when True diagnostic information from the singular value decomposition is also returned.\n\n \n**w**array_like, shape (M,), optional\n\nWeights. If not None, the weight `w[i]` applies to the unsquared residual `y[i] - y_hat[i]` at `x[i]`. Ideally the weights are chosen so that the errors of the products `w[i]*y[i]` all have the same variance. When using inverse-variance weighting, use `w[i] = 1/sigma(y[i])`. The default value is None.\n\n New in version 1.5.0.\n\n \n**window**{[beg, end]}, optional\n\nWindow to use for the returned series. The default value is the default class domain\n\n New in version 1.6.0.\n\n Returns \n \n**new_series**series\n\nA series that represents the least squares fit to the data and has the domain and window specified in the call. If the coefficients for the unscaled and unshifted basis polynomials are of interest, do `new_series.convert().coef`.\n\n \n**[resid, rank, sv, rcond]**list\n\nThese values are only returned if `full == True`\n\n * resid â sum of squared residuals of the least squares fit\n* rank â the numerical rank of the scaled Vandermonde matrix\n* sv â singular values of the scaled Vandermonde matrix\n* rcond â value of `rcond`.\n\n For more details, see [`linalg.lstsq`](numpy.linalg.lstsq#numpy.linalg.lstsq \"numpy.linalg.lstsq\").\n\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n>> import numpy as np\n>>> rng = np.random.default_rng(12345)\n>>> print(rng)\nGenerator(PCG64)\n>>> rfloat = rng.random()\n>>> rfloat\n0.22733602246716966\n>>> type(rfloat)\n>> import numpy as np\n>>> rng = np.random.default_rng(12345)\n>>> rints = rng.integers(low=0, high=10, size=3)\n>>> rints\narray([6, 2, 7])\n>>> type(rints[0])\n>> import numpy as np\n>>> rng = np.random.default_rng(seed=42)\n>>> print(rng)\nGenerator(PCG64)\n>>> arr1 = rng.random((3, 3))\n>>> arr1\narray([[0.77395605, 0.43887844, 0.85859792],\n [0.69736803, 0.09417735, 0.97562235],\n [0.7611397 , 0.78606431, 0.12811363]])\n\n```\n If we exit and restart our Python interpreter, weâll see that we generate the same random numbers again:\n\n \n```\n>>> import numpy as np\n>>> rng = np.random.default_rng(seed=42)\n>>> arr2 = rng.random((3, 3))\n>>> arr2\narray([[0.77395605, 0.43887844, 0.85859792],\n [0.69736803, 0.09417735, 0.97562235],\n [0.7611397 , 0.78606431, 0.12811363]])\n\n```\n \n *class*numpy.random.Generator(*bit_generator*)\n \nContainer for the BitGenerators.\n\n `Generator` exposes a number of methods for generating random numbers drawn from a variety of probability distributions. In addition to the distribution-specific arguments, each method takes a keyword argument `size` that defaults to `None`. If `size` is `None`, then a single value is generated and returned. If `size` is an integer, then a 1-D array filled with generated values is returned. If `size` is a tuple, then an array with that shape is filled and returned.\n\n The function [`numpy.random.default_rng`](#numpy.random.default_rng \"numpy.random.default_rng\") will instantiate a [`Generator`](#numpy.random.Generator \"numpy.random.Generator\") with numpyâs default [`BitGenerator`](bit_generators/generated/numpy.random.bitgenerator#numpy.random.BitGenerator \"numpy.random.BitGenerator\").\n\n **No Compatibility Guarantee**\n\n `Generator` does not provide a version compatibility guarantee. In particular, as better algorithms evolve the bit stream may change.\n\n Parameters \n \n**bit_generator**BitGenerator\n\nBitGenerator to use as the core generator.\n\n See also\n\n [`default_rng`](#numpy.random.default_rng \"numpy.random.default_rng\")\n\nRecommended constructor for [`Generator`](#numpy.random.Generator \"numpy.random.Generator\").\n\n #### Notes\n\n The Python stdlib module [`random`](generated/numpy.random.random#numpy.random.random \"numpy.random.random\") contains pseudo-random number generator with a number of methods that are similar to the ones available in `Generator`. It uses Mersenne Twister, and this bit generator can be accessed using `MT19937`. `Generator`, besides being NumPy-aware, has the advantage that it provides a much larger number of probability distributions to choose from.\n\n #### Examples\n\n \n```\n>>> from numpy.random import Generator, PCG64\n>>> rng = Generator(PCG64())\n>>> rng.standard_normal()\n-0.203 # random\n\n```\n \n Accessing the BitGenerator\n--------------------------\n\n \n\n| | |\n| --- | --- |\n| [`bit_generator`](generated/numpy.random.generator.bit_generator#numpy.random.Generator.bit_generator \"numpy.random.Generator.bit_generator\") | Gets the bit generator instance used by the generator |\n\n Simple random data\n------------------\n\n \n\n| | |\n| --- | --- |\n| [`integers`](generated/numpy.random.generator.integers#numpy.random.Generator.integers \"numpy.random.Generator.integers\")(low[, high, size, dtype, endpoint]) | Return random integers from `low` (inclusive) to `high` (exclusive), or if endpoint=True, `low` (inclusive) to `high` (inclusive). |\n| [`random`](generated/numpy.random.generator.random#numpy.random.Generator.random \"numpy.random.Generator.random\")([size, dtype, out]) | Return random floats in the half-open interval [0.0, 1.0). |\n| [`choice`](generated/numpy.random.generator.choice#numpy.random.Generator.choice \"numpy.random.Generator.choice\")(a[, size, replace, p, axis, shuffle]) | Generates a random sample from a given array |\n| [`bytes`](generated/numpy.random.generator.bytes#numpy.random.Generator.bytes \"numpy.random.Generator.bytes\")(length) | Return random bytes. |\n\n Permutations\n------------\n\n The methods for randomly permuting a sequence are\n\n \n\n| | |\n| --- | --- |\n| [`shuffle`](generated/numpy.random.generator.shuffle#numpy.random.Generator.shuffle \"numpy.random.Generator.shuffle\")(x[, axis]) | Modify an array or sequence in-place by shuffling its contents. |\n| [`permutation`](generated/numpy.random.generator.permutation#numpy.random.Generator.permutation \"numpy.random.Generator.permutation\")(x[, axis]) | Randomly permute a sequence, or return a permuted range. |\n| [`permuted`](generated/numpy.random.generator.permuted#numpy.random.Generator.permuted \"numpy.random.Generator.permuted\")(x[, axis, out]) | Randomly permute `x` along axis `axis`. |\n\n The following table summarizes the behaviors of the methods.\n\n \n\n| method | copy/in-place | axis handling |\n| --- | --- | --- |\n| shuffle | in-place | as if 1d |\n| permutation | copy | as if 1d |\n| permuted | either (use âoutâ for in-place) | axis independent |\n\n The following subsections provide more details about the differences.\n\n ### In-place vs. copy\n\n The main difference between [`Generator.shuffle`](generated/numpy.random.generator.shuffle#numpy.random.Generator.shuffle \"numpy.random.Generator.shuffle\") and [`Generator.permutation`](generated/numpy.random.generator.permutation#numpy.random.Generator.permutation \"numpy.random.Generator.permutation\") is that [`Generator.shuffle`](generated/numpy.random.generator.shuffle#numpy.random.Generator.shuffle \"numpy.random.Generator.shuffle\") operates in-place, while [`Generator.permutation`](generated/numpy.random.generator.permutation#numpy.random.Generator.permutation \"numpy.random.Generator.permutation\") returns a copy.\n\n By default, [`Generator.permuted`](generated/numpy.random.generator.permuted#numpy.random.Generator.permuted \"numpy.random.Generator.permuted\") returns a copy. To operate in-place with [`Generator.permuted`](generated/numpy.random.generator.permuted#numpy.random.Generator.permuted \"numpy.random.Generator.permuted\"), pass the same array as the first argument *and* as the value of the `out` parameter. For example,\n\n \n```\n>>> rng = np.random.default_rng()\n>>> x = np.arange(0, 15).reshape(3, 5)\n>>> x \narray([[ 0, 1, 2, 3, 4],\n [ 5, 6, 7, 8, 9],\n [10, 11, 12, 13, 14]])\n>>> y = rng.permuted(x, axis=1, out=x)\n>>> x \narray([[ 1, 0, 2, 4, 3], # random\n [ 6, 7, 8, 9, 5],\n [10, 14, 11, 13, 12]])\n\n```\n Note that when `out` is given, the return value is `out`:\n\n \n```\n>>> y is x\nTrue\n\n```\n ### Handling the `axis` parameter\n\n An important distinction for these methods is how they handle the `axis` parameter. Both [`Generator.shuffle`](generated/numpy.random.generator.shuffle#numpy.random.Generator.shuffle \"numpy.random.Generator.shuffle\") and [`Generator.permutation`](generated/numpy.random.generator.permutation#numpy.random.Generator.permutation \"numpy.random.Generator.permutation\") treat the input as a one-dimensional sequence, and the `axis` parameter determines which dimension of the input array to use as the sequence. In the case of a two-dimensional array, `axis=0` will, in effect, rearrange the rows of the array, and `axis=1` will rearrange the columns. For example\n\n \n```\n>>> rng = np.random.default_rng()\n>>> x = np.arange(0, 15).reshape(3, 5)\n>>> x\narray([[ 0, 1, 2, 3, 4],\n [ 5, 6, 7, 8, 9],\n [10, 11, 12, 13, 14]])\n>>> rng.permutation(x, axis=1) \narray([[ 1, 3, 2, 0, 4], # random\n [ 6, 8, 7, 5, 9],\n [11, 13, 12, 10, 14]])\n\n```\n Note that the columns have been rearranged âin bulkâ: the values within each column have not changed.\n\n The method [`Generator.permuted`](generated/numpy.random.generator.permuted#numpy.random.Generator.permuted \"numpy.random.Generator.permuted\") treats the `axis` parameter similar to how [`numpy.sort`](../generated/numpy.sort#numpy.sort \"numpy.sort\") treats it. Each slice along the given axis is shuffled independently of the others. Compare the following example of the use of [`Generator.permuted`](generated/numpy.random.generator.permuted#numpy.random.Generator.permuted \"numpy.random.Generator.permuted\") to the above example of [`Generator.permutation`](generated/numpy.random.generator.permutation#numpy.random.Generator.permutation \"numpy.random.Generator.permutation\"):\n\n \n```\n>>> rng.permuted(x, axis=1) \narray([[ 1, 0, 2, 4, 3], # random\n [ 5, 7, 6, 9, 8],\n [10, 14, 12, 13, 11]])\n\n```\n In this example, the values within each row (i.e. the values along `axis=1`) have been shuffled independently. This is not a âbulkâ shuffle of the columns.\n\n ### Shuffling non-NumPy sequences\n\n [`Generator.shuffle`](generated/numpy.random.generator.shuffle#numpy.random.Generator.shuffle \"numpy.random.Generator.shuffle\") works on non-NumPy sequences. That is, if it is given a sequence that is not a NumPy array, it shuffles that sequence in-place. For example,\n\n \n```\n>>> rng = np.random.default_rng()\n>>> a = ['A', 'B', 'C', 'D', 'E']\n>>> rng.shuffle(a) # shuffle the list in-place\n>>> a \n['B', 'D', 'A', 'E', 'C'] # random\n\n```\n Distributions\n-------------\n\n \n\n| | |\n| --- | --- |\n| [`beta`](generated/numpy.random.generator.beta#numpy.random.Generator.beta \"numpy.random.Generator.beta\")(a, b[, size]) | Draw samples from a Beta distribution. |\n| [`binomial`](generated/numpy.random.generator.binomial#numpy.random.Generator.binomial \"numpy.random.Generator.binomial\")(n, p[, size]) | Draw samples from a binomial distribution. |\n| [`chisquare`](generated/numpy.random.generator.chisquare#numpy.random.Generator.chisquare \"numpy.random.Generator.chisquare\")(df[, size]) | Draw samples from a chi-square distribution. |\n| [`dirichlet`](generated/numpy.random.generator.dirichlet#numpy.random.Generator.dirichlet \"numpy.random.Generator.dirichlet\")(alpha[, size]) | Draw samples from the Dirichlet distribution. |\n| [`exponential`](generated/numpy.random.generator.exponential#numpy.random.Generator.exponential \"numpy.random.Generator.exponential\")([scale, size]) | Draw samples from an exponential distribution. |\n| [`f`](generated/numpy.random.generator.f#numpy.random.Generator.f \"numpy.random.Generator.f\")(dfnum, dfden[, size]) | Draw samples from an F distribution. |\n| [`gamma`](generated/numpy.random.generator.gamma#numpy.random.Generator.gamma \"numpy.random.Generator.gamma\")(shape[, scale, size]) | Draw samples from a Gamma distribution. |\n| [`geometric`](generated/numpy.random.generator.geometric#numpy.random.Generator.geometric \"numpy.random.Generator.geometric\")(p[, size]) | Draw samples from the geometric distribution. |\n| [`gumbel`](generated/numpy.random.generator.gumbel#numpy.random.Generator.gumbel \"numpy.random.Generator.gumbel\")([loc, scale, size]) | Draw samples from a Gumbel distribution. |\n| [`hypergeometric`](generated/numpy.random.generator.hypergeometric#numpy.random.Generator.hypergeometric \"numpy.random.Generator.hypergeometric\")(ngood, nbad, nsample[, size]) | Draw samples from a Hypergeometric distribution. |\n| [`laplace`](generated/numpy.random.generator.laplace#numpy.random.Generator.laplace \"numpy.random.Generator.laplace\")([loc, scale, size]) | Draw samples from the Laplace or double exponential distribution with specified location (or mean) and scale (decay). |\n| [`logistic`](generated/numpy.random.generator.logistic#numpy.random.Generator.logistic \"numpy.random.Generator.logistic\")([loc, scale, size]) | Draw samples from a logistic distribution. |\n| [`lognormal`](generated/numpy.random.generator.lognormal#numpy.random.Generator.lognormal \"numpy.random.Generator.lognormal\")([mean, sigma, size]) | Draw samples from a log-normal distribution. |\n| [`logseries`](generated/numpy.random.generator.logseries#numpy.random.Generator.logseries \"numpy.random.Generator.logseries\")(p[, size]) | Draw samples from a logarithmic series distribution. |\n| [`multinomial`](generated/numpy.random.generator.multinomial#numpy.random.Generator.multinomial \"numpy.random.Generator.multinomial\")(n, pvals[, size]) | Draw samples from a multinomial distribution. |\n| [`multivariate_hypergeometric`](generated/numpy.random.generator.multivariate_hypergeometric#numpy.random.Generator.multivariate_hypergeometric \"numpy.random.Generator.multivariate_hypergeometric\")(colors, nsample) | Generate variates from a multivariate hypergeometric distribution. |\n| [`multivariate_normal`](generated/numpy.random.generator.multivariate_normal#numpy.random.Generator.multivariate_normal \"numpy.random.Generator.multivariate_normal\")(mean, cov[, size, ...]) | Draw random samples from a multivariate normal distribution. |\n| [`negative_binomial`](generated/numpy.random.generator.negative_binomial#numpy.random.Generator.negative_binomial \"numpy.random.Generator.negative_binomial\")(n, p[, size]) | Draw samples from a negative binomial distribution. |\n| [`noncentral_chisquare`](generated/numpy.random.generator.noncentral_chisquare#numpy.random.Generator.noncentral_chisquare \"numpy.random.Generator.noncentral_chisquare\")(df, nonc[, size]) | Draw samples from a noncentral chi-square distribution. |\n| [`noncentral_f`](generated/numpy.random.generator.noncentral_f#numpy.random.Generator.noncentral_f \"numpy.random.Generator.noncentral_f\")(dfnum, dfden, nonc[, size]) | Draw samples from the noncentral F distribution. |\n| [`normal`](generated/numpy.random.generator.normal#numpy.random.Generator.normal \"numpy.random.Generator.normal\")([loc, scale, size]) | Draw random samples from a normal (Gaussian) distribution. |\n| [`pareto`](generated/numpy.random.generator.pareto#numpy.random.Generator.pareto \"numpy.random.Generator.pareto\")(a[, size]) | Draw samples from a Pareto II or Lomax distribution with specified shape. |\n| [`poisson`](generated/numpy.random.generator.poisson#numpy.random.Generator.poisson \"numpy.random.Generator.poisson\")([lam, size]) | Draw samples from a Poisson distribution. |\n| [`power`](generated/numpy.random.generator.power#numpy.random.Generator.power \"numpy.random.Generator.power\")(a[, size]) | Draws samples in [0, 1] from a power distribution with positive exponent a - 1. |\n| [`rayleigh`](generated/numpy.random.generator.rayleigh#numpy.random.Generator.rayleigh \"numpy.random.Generator.rayleigh\")([scale, size]) | Draw samples from a Rayleigh distribution. |\n| [`standard_cauchy`](generated/numpy.random.generator.standard_cauchy#numpy.random.Generator.standard_cauchy \"numpy.random.Generator.standard_cauchy\")([size]) | Draw samples from a standard Cauchy distribution with mode = 0. |\n| [`standard_exponential`](generated/numpy.random.generator.standard_exponential#numpy.random.Generator.standard_exponential \"numpy.random.Generator.standard_exponential\")([size, dtype, method, out]) | Draw samples from the standard exponential distribution. |\n| [`standard_gamma`](generated/numpy.random.generator.standard_gamma#numpy.random.Generator.standard_gamma \"numpy.random.Generator.standard_gamma\")(shape[, size, dtype, out]) | Draw samples from a standard Gamma distribution. |\n| [`standard_normal`](generated/numpy.random.generator.standard_normal#numpy.random.Generator.standard_normal \"numpy.random.Generator.standard_normal\")([size, dtype, out]) | Draw samples from a standard Normal distribution (mean=0, stdev=1). |\n| [`standard_t`](generated/numpy.random.generator.standard_t#numpy.random.Generator.standard_t \"numpy.random.Generator.standard_t\")(df[, size]) | Draw samples from a standard Student's t distribution with `df` degrees of freedom. |\n| [`triangular`](generated/numpy.random.generator.triangular#numpy.random.Generator.triangular \"numpy.random.Generator.triangular\")(left, mode, right[, size]) | Draw samples from the triangular distribution over the interval `[left, right]`. |\n| [`uniform`](generated/numpy.random.generator.uniform#numpy.random.Generator.uniform \"numpy.random.Generator.uniform\")([low, high, size]) | Draw samples from a uniform distribution. |\n| [`vonmises`](generated/numpy.random.generator.vonmises#numpy.random.Generator.vonmises \"numpy.random.Generator.vonmises\")(mu, kappa[, size]) | Draw samples from a von Mises distribution. |\n| [`wald`](generated/numpy.random.generator.wald#numpy.random.Generator.wald \"numpy.random.Generator.wald\")(mean, scale[, size]) | Draw samples from a Wald, or inverse Gaussian, distribution. |\n| [`weibull`](generated/numpy.random.generator.weibull#numpy.random.Generator.weibull \"numpy.random.Generator.weibull\")(a[, size]) | Draw samples from a Weibull distribution. |\n| [`zipf`](generated/numpy.random.generator.zipf#numpy.random.Generator.zipf \"numpy.random.Generator.zipf\")(a[, size]) | Draw samples from a Zipf distribution. |\n\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n= 1.0 or r2 == 0.0:\n x1 = 2.0 * next_d(state) - 1.0\n x2 = 2.0 * next_d(state) - 1.0\n r2 = x1 * x1 + x2 * x2\n f = np.sqrt(-2.0 * np.log(r2) / r2)\n out[2 * i] = f * x1\n if 2 * i + 1 < n:\n out[2 * i + 1] = f * x2\n return out\n\n# Compile using Numba\nnormalsj = nb.jit(normals, nopython=True)\n# Must use state address not state with numba\nn = 10000\n\ndef numbacall():\n return normalsj(n, state_addr)\n\nrg = np.random.Generator(PCG64())\n\ndef numpycall():\n return rg.normal(size=n)\n\n# Check that the functions work\nr1 = numbacall()\nr2 = numpycall()\nassert r1.shape == (n,)\nassert r1.shape == r2.shape\n\nt1 = timeit(numbacall, number=1000)\nprint(f'{t1:.2f} secs for {n} PCG64 (Numba/PCG64) gaussian randoms')\nt2 = timeit(numpycall, number=1000)\nprint(f'{t2:.2f} secs for {n} PCG64 (NumPy/PCG64) gaussian randoms')\n\n```\n Both CTypes and CFFI allow the more complicated distributions to be used directly in Numba after compiling the file distributions.c into a `DLL` or `so`. An example showing the use of a more complicated distribution is in the `examples` section below.\n\n Cython\n------\n\n Cython can be used to unpack the `PyCapsule` provided by a BitGenerator. This example uses [`PCG64`](bit_generators/pcg64#numpy.random.PCG64 \"numpy.random.PCG64\") and the example from above. The usual caveats for writing high-performance code using Cython â removing bounds checks and wrap around, providing array alignment information â still apply.\n\n \n```\n#!/usr/bin/env python3\n#cython: language_level=3\n\"\"\"\nThis file shows how the to use a BitGenerator to create a distribution.\n\"\"\"\nimport numpy as np\ncimport numpy as np\ncimport cython\nfrom cpython.pycapsule cimport PyCapsule_IsValid, PyCapsule_GetPointer\nfrom libc.stdint cimport uint16_t, uint64_t\nfrom numpy.random cimport bitgen_t\nfrom numpy.random import PCG64\nfrom numpy.random.c_distributions cimport (\n random_standard_uniform_fill, random_standard_uniform_fill_f)\n\n@cython.boundscheck(False)\n@cython.wraparound(False)\ndef uniforms(Py_ssize_t n):\n \"\"\"\n Create an array of `n` uniformly distributed doubles.\n A 'real' distribution would want to process the values into\n some non-uniform distribution\n \"\"\"\n cdef Py_ssize_t i\n cdef bitgen_t *rng\n cdef const char *capsule_name = \"BitGenerator\"\n cdef double[::1] random_values\n\n x = PCG64()\n capsule = x.capsule\n # Optional check that the capsule if from a BitGenerator\n if not PyCapsule_IsValid(capsule, capsule_name):\n raise ValueError(\"Invalid pointer to anon_func_state\")\n # Cast the pointer\n rng = PyCapsule_GetPointer(capsule, capsule_name)\n random_values = np.empty(n, dtype='float64')\n with x.lock, nogil:\n for i in range(n):\n # Call the function\n random_values[i] = rng.next_double(rng.state)\n randoms = np.asarray(random_values)\n\n return randoms\n\n```\n The BitGenerator can also be directly accessed using the members of the `bitgen_t` struct.\n\n \n```\n@cython.boundscheck(False)\n@cython.wraparound(False)\ndef uint10_uniforms(Py_ssize_t n):\n \"\"\"Uniform 10 bit integers stored as 16-bit unsigned integers\"\"\"\n cdef Py_ssize_t i\n cdef bitgen_t *rng\n cdef const char *capsule_name = \"BitGenerator\"\n cdef uint16_t[::1] random_values\n cdef int bits_remaining\n cdef int width = 10\n cdef uint64_t buff, mask = 0x3FF\n\n x = PCG64()\n capsule = x.capsule\n if not PyCapsule_IsValid(capsule, capsule_name):\n raise ValueError(\"Invalid pointer to anon_func_state\")\n rng = PyCapsule_GetPointer(capsule, capsule_name)\n random_values = np.empty(n, dtype='uint16')\n # Best practice is to release GIL and acquire the lock\n bits_remaining = 0\n with x.lock, nogil:\n for i in range(n):\n if bits_remaining < width:\n buff = rng.next_uint64(rng.state)\n random_values[i] = buff & mask\n buff >>= width\n\n randoms = np.asarray(random_values)\n return randoms\n\n```\n Cython can be used to directly access the functions in `numpy/random/c_distributions.pxd`. This requires linking with the `npyrandom` library located in `numpy/random/lib`.\n\n \n```\ndef uniforms_ex(bit_generator, Py_ssize_t n, dtype=np.float64):\n \"\"\"\n Create an array of `n` uniformly distributed doubles via a \"fill\" function.\n\n A 'real' distribution would want to process the values into\n some non-uniform distribution\n\n Parameters\n ----------\n bit_generator: BitGenerator instance\n n: int\n Output vector length\n dtype: {str, dtype}, optional\n Desired dtype, either 'd' (or 'float64') or 'f' (or 'float32'). The\n default dtype value is 'd'\n \"\"\"\n cdef Py_ssize_t i\n cdef bitgen_t *rng\n cdef const char *capsule_name = \"BitGenerator\"\n cdef np.ndarray randoms\n\n capsule = bit_generator.capsule\n # Optional check that the capsule if from a BitGenerator\n if not PyCapsule_IsValid(capsule, capsule_name):\n raise ValueError(\"Invalid pointer to anon_func_state\")\n # Cast the pointer\n rng = PyCapsule_GetPointer(capsule, capsule_name)\n\n _dtype = np.dtype(dtype)\n randoms = np.empty(n, dtype=_dtype)\n if _dtype == np.float32:\n with bit_generator.lock:\n random_standard_uniform_fill_f(rng, n, np.PyArray_DATA(randoms))\n elif _dtype == np.float64:\n with bit_generator.lock:\n random_standard_uniform_fill(rng, n, np.PyArray_DATA(randoms))\n else:\n raise TypeError('Unsupported dtype %r for random' % _dtype)\n return randoms\n\n```\n See [Extending numpy.random via Cython](examples/cython/index#extending-cython-example) for the complete listings of these examples and a minimal `setup.py` to build the c-extension modules.\n\n CFFI\n----\n\n CFFI can be used to directly access the functions in `include/numpy/random/distributions.h`. Some âmassagingâ of the header file is required:\n\n \n```\n\"\"\"\nUse cffi to access any of the underlying C functions from distributions.h\n\"\"\"\nimport os\nimport numpy as np\nimport cffi\nfrom .parse import parse_distributions_h\nffi = cffi.FFI()\n\ninc_dir = os.path.join(np.get_include(), 'numpy')\n\n# Basic numpy types\nffi.cdef('''\n typedef intptr_t npy_intp;\n typedef unsigned char npy_bool;\n\n''')\n\nparse_distributions_h(ffi, inc_dir)\n\n```\n Once the header is parsed by `ffi.cdef`, the functions can be accessed directly from the `_generator` shared object, using the [`BitGenerator.cffi`](bit_generators/generated/numpy.random.bitgenerator.cffi#numpy.random.BitGenerator.cffi \"numpy.random.BitGenerator.cffi\") interface.\n\n \n```\n\n# Compare the distributions.h random_standard_normal_fill to\n# Generator.standard_random\nbit_gen = np.random.PCG64()\nrng = np.random.Generator(bit_gen)\nstate = bit_gen.state\n\ninterface = rng.bit_generator.cffi\nn = 100\nvals_cffi = ffi.new('double[%d]' % n)\nlib.random_standard_normal_fill(interface.bit_generator, n, vals_cffi)\n\n# reset the state\nbit_gen.state = state\n\nvals = rng.standard_normal(n)\n\nfor i in range(n):\n assert vals[i] == vals_cffi[i]\n\n```\n New Bit Generators\n------------------\n\n [`Generator`](generator#numpy.random.Generator \"numpy.random.Generator\") can be used with user-provided [`BitGenerator`](bit_generators/generated/numpy.random.bitgenerator#numpy.random.BitGenerator \"numpy.random.BitGenerator\")s. The simplest way to write a new BitGenerator is to examine the pyx file of one of the existing BitGenerators. The key structure that must be provided is the `capsule` which contains a `PyCapsule` to a struct pointer of type `bitgen_t`,\n\n \n```\ntypedef struct bitgen {\n void *state;\n uint64_t (*next_uint64)(void *st);\n uint32_t (*next_uint32)(void *st);\n double (*next_double)(void *st);\n uint64_t (*next_raw)(void *st);\n} bitgen_t;\n\n```\n which provides 5 pointers. The first is an opaque pointer to the data structure used by the BitGenerators. The next three are function pointers which return the next 64- and 32-bit unsigned integers, the next random double and the next raw value. This final function is used for testing and so can be set to the next 64-bit unsigned integer function if not needed. Functions inside `Generator` use this structure as in\n\n \n```\nbitgen_state->next_uint64(bitgen_state->state)\n\n```\n Examples\n--------\n\n * [Numba](examples/numba)\n* [CFFI + Numba](examples/numba_cffi)\n* [Cython](examples/cython/index)\n\t+ [setup.py](examples/cython/setup.py)\n\t+ [extending.pyx](examples/cython/extending.pyx)\n\t+ [extending_distributions.pyx](examples/cython/extending_distributions.pyx)\n* [CFFI](examples/cffi)\n\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n>> from numpy.random import Generator, PCG64, SeedSequence\n>>> sg = SeedSequence(1234)\n>>> rg = [Generator(PCG64(s)) for s in sg.spawn(10)]\n\n```\n **Compatibility Guarantee**\n\n `PCG64` makes a guarantee that a fixed seed will always produce the same random integer stream.\n\n #### References\n\n [1](#id1) \n[âPCG, A Family of Better Random Number Generatorsâ](http://www.pcg-random.org/)\n\n \n2([1](#id2),[2](#id3))\n \nOâNeill, . [âPCG: A Family of Simple Fast Space-Efficient Statistically Good Algorithms for Random Number Generationâ](https://www.cs.hmc.edu/tr/hmc-cs-2014-0905.pdf)\n\n \n State\n-----\n\n \n\n| | |\n| --- | --- |\n| [`state`](generated/numpy.random.pcg64.state#numpy.random.PCG64.state \"numpy.random.PCG64.state\") | Get or set the PRNG state |\n\n Parallel generation\n-------------------\n\n \n\n| | |\n| --- | --- |\n| [`advance`](generated/numpy.random.pcg64.advance#numpy.random.PCG64.advance \"numpy.random.PCG64.advance\")(delta) | Advance the underlying RNG as-if delta draws have occurred. |\n| [`jumped`](generated/numpy.random.pcg64.jumped#numpy.random.PCG64.jumped \"numpy.random.PCG64.jumped\")([jumps]) | Returns a new bit generator with the state jumped. |\n\n Extending\n---------\n\n \n\n| | |\n| --- | --- |\n| [`cffi`](generated/numpy.random.pcg64.cffi#numpy.random.PCG64.cffi \"numpy.random.PCG64.cffi\") | CFFI interface |\n| [`ctypes`](generated/numpy.random.pcg64.ctypes#numpy.random.PCG64.ctypes \"numpy.random.PCG64.ctypes\") | ctypes interface |\n\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n>> from numpy.random import Generator, MT19937, SeedSequence\n>>> sg = SeedSequence(1234)\n>>> rg = [Generator(MT19937(s)) for s in sg.spawn(10)]\n\n```\n Another method is to use [`MT19937.jumped`](generated/numpy.random.mt19937.jumped#numpy.random.MT19937.jumped \"numpy.random.MT19937.jumped\") which advances the state as-if \\(2^{128}\\) random numbers have been generated ([[1]](#r312276d80bfa-1), [[2]](#r312276d80bfa-2)). This allows the original sequence to be split so that distinct segments can be used in each worker process. All generators should be chained to ensure that the segments come from the same sequence.\n\n \n```\n>>> from numpy.random import Generator, MT19937, SeedSequence\n>>> sg = SeedSequence(1234)\n>>> bit_generator = MT19937(sg)\n>>> rg = []\n>>> for _ in range(10):\n... rg.append(Generator(bit_generator))\n... # Chain the BitGenerators\n... bit_generator = bit_generator.jumped()\n\n```\n **Compatibility Guarantee**\n\n `MT19937` makes a guarantee that a fixed seed will always produce the same random integer stream.\n\n #### References\n\n \n1([1](#id1),[2](#id2))\n \n, , and , âA Fast Jump Ahead Algorithm for Linear Recurrences in a Polynomial Spaceâ, Sequences and Their Applications - SETA, 290â298, 2008.\n\n [2](#id3) \n, , , , , âEfficient Jump Ahead for F2-Linear Random Number Generatorsâ, INFORMS JOURNAL ON COMPUTING, Vol. 20, No. 3, Summer 2008, pp. 385-390.\n\n Attributes \n **lock: threading.Lock**\n\nLock instance that is shared so that the same bit git generator can be used in multiple Generators without corrupting the state. Code that generates values from a bit generator should hold the bit generatorâs lock.\n\n \n State\n-----\n\n \n\n| | |\n| --- | --- |\n| [`state`](generated/numpy.random.mt19937.state#numpy.random.MT19937.state \"numpy.random.MT19937.state\") | Get or set the PRNG state |\n\n Parallel generation\n-------------------\n\n \n\n| | |\n| --- | --- |\n| [`jumped`](generated/numpy.random.mt19937.jumped#numpy.random.MT19937.jumped \"numpy.random.MT19937.jumped\")([jumps]) | Returns a new bit generator with the state jumped |\n\n Extending\n---------\n\n \n\n| | |\n| --- | --- |\n| [`cffi`](generated/numpy.random.mt19937.cffi#numpy.random.MT19937.cffi \"numpy.random.MT19937.cffi\") | CFFI interface |\n| [`ctypes`](generated/numpy.random.mt19937.ctypes#numpy.random.MT19937.ctypes \"numpy.random.MT19937.ctypes\") | ctypes interface |\n\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n>> sq1 = np.random.SeedSequence()\n>>> sq1.entropy\n243799254704924441050048792905230269161 # random\n>>> sq2 = np.random.SeedSequence(sq1.entropy)\n>>> np.all(sq1.generate_state(10) == sq2.generate_state(10))\nTrue\n\n```\n Attributes \n **entropy**\n**n_children_spawned**\n**pool**\n**pool_size**\n**spawn_key**\n**state**\n #### Methods\n\n \n\n| | |\n| --- | --- |\n| [`generate_state`](numpy.random.seedsequence.generate_state#numpy.random.SeedSequence.generate_state \"numpy.random.SeedSequence.generate_state\")(n_words[, dtype]) | Return the requested number of words for PRNG seeding. |\n| [`spawn`](numpy.random.seedsequence.spawn#numpy.random.SeedSequence.spawn \"numpy.random.SeedSequence.spawn\")(n_children) | Spawn a number of child [`SeedSequence`](#numpy.random.SeedSequence \"numpy.random.SeedSequence\") s by extending the [`spawn_key`](numpy.random.seedsequence.spawn_key#numpy.random.SeedSequence.spawn_key \"numpy.random.SeedSequence.spawn_key\"). |\n\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n 0.\n\n Note\n\n New code should use the `gamma` method of a `default_rng()` instance instead; please see the [Quick Start](../index#random-quick-start).\n\n Parameters \n \n**shape**float or array_like of floats\n\nThe shape of the gamma distribution. Must be non-negative.\n\n \n**scale**float or array_like of floats, optional\n\nThe scale of the gamma distribution. Must be non-negative. Default is equal to 1.\n\n \n**size**int or tuple of ints, optional\n\nOutput shape. If the given shape is, e.g., `(m, n, k)`, then `m * n * k` samples are drawn. If size is `None` (default), a single value is returned if `shape` and `scale` are both scalars. Otherwise, `np.broadcast(shape, scale).size` samples are drawn.\n\n Returns \n \n**out**ndarray or scalar\n\nDrawn samples from the parameterized gamma distribution.\n\n See also\n\n [`scipy.stats.gamma`](https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.gamma.html#scipy.stats.gamma \"(in SciPy v1.8.1)\")\n\nprobability density function, distribution or cumulative density function, etc.\n\n [`random.Generator.gamma`](numpy.random.generator.gamma#numpy.random.Generator.gamma \"numpy.random.Generator.gamma\")\n\nwhich should be used for new code.\n\n #### Notes\n\n The probability density for the Gamma distribution is\n\n \\[p(x) = x^{k-1}\\frac{e^{-x/\\theta}}{\\theta^k\\Gamma(k)},\\] where \\(k\\) is the shape and \\(\\theta\\) the scale, and \\(\\Gamma\\) is the Gamma function.\n\n The Gamma distribution is often used to model the times to failure of electronic components, and arises naturally in processes for which the waiting times between Poisson distributed events are relevant.\n\n #### References\n\n 1 \nWeisstein, . âGamma Distribution.â From MathWorldâA Wolfram Web Resource. >> shape, scale = 2., 2. # mean=4, std=2*sqrt(2)\n>>> s = np.random.gamma(shape, scale, 1000)\n\n```\n Display the histogram of the samples, along with the probability density function:\n\n \n```\n>>> import matplotlib.pyplot as plt\n>>> import scipy.special as sps \n>>> count, bins, ignored = plt.hist(s, 50, density=True)\n>>> y = bins**(shape-1)*(np.exp(-bins/scale) / \n... (sps.gamma(shape)*scale**shape))\n>>> plt.plot(bins, y, linewidth=2, color='r') \n>>> plt.show()\n\n```\n ![../../../_images/numpy-random-RandomState-gamma-1.png] \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n 0.\n\n \n**size**int or tuple of ints, optional\n\nOutput shape. If the given shape is, e.g., `(m, n, k)`, then `m * n * k` samples are drawn. If size is `None` (default), a single value is returned if `df` is a scalar. Otherwise, `np.array(df).size` samples are drawn.\n\n Returns \n \n**out**ndarray or scalar\n\nDrawn samples from the parameterized standard Studentâs t distribution.\n\n See also\n\n [`random.Generator.standard_t`](numpy.random.generator.standard_t#numpy.random.Generator.standard_t \"numpy.random.Generator.standard_t\")\n\nwhich should be used for new code.\n\n #### Notes\n\n The probability density function for the t distribution is\n\n \\[P(x, df) = \\frac{\\Gamma(\\frac{df+1}{2})}{\\sqrt{\\pi df} \\Gamma(\\frac{df}{2})}\\Bigl( 1+\\frac{x^2}{df} \\Bigr)^{-(df+1)/2}\\] The t test is based on an assumption that the data come from a Normal distribution. The t test provides a way to test whether the sample mean (that is the mean calculated from the data) is a good estimate of the true mean.\n\n The derivation of the t-distribution was first published in 1908 by while working for the Guinness Brewery in Dublin. Due to proprietary issues, he had to publish under a pseudonym, and so he used the name Student.\n\n #### References\n\n [1](#id3) \nDalgaard, Peter, âIntroductory Statistics With Râ, Springer, 2002.\n\n 2 \nWikipedia, âStudentâs t-distributionâ [https://en.wikipedia.org/wiki/Studentâs_t-distribution](https://en.wikipedia.org/wiki/Student's_t-distribution)\n\n #### Examples\n\n From Dalgaard page 83 [[1]](#r89f5270d198b-1), suppose the daily energy intake for 11 women in kilojoules (kJ) is:\n\n \n```\n>>> intake = np.array([5260., 5470, 5640, 6180, 6390, 6515, 6805, 7515, \\\n... 7515, 8230, 8770])\n\n```\n Does their energy intake deviate systematically from the recommended value of 7725 kJ? Our null hypothesis will be the absence of deviation, and the alternate hypothesis will be the presence of an effect that could be either positive or negative, hence making our test 2-tailed.\n\n Because we are estimating the mean and we have N=11 values in our sample, we have N-1=10 degrees of freedom. We set our significance level to 95% and compute the t statistic using the empirical mean and empirical standard deviation of our intake. We use a ddof of 1 to base the computation of our empirical standard deviation on an unbiased estimate of the variance (note: the final estimate is not unbiased due to the concave nature of the square root).\n\n \n```\n>>> np.mean(intake)\n6753.636363636364\n>>> intake.std(ddof=1)\n1142.1232221373727\n>>> t = (np.mean(intake)-7725)/(intake.std(ddof=1)/np.sqrt(len(intake)))\n>>> t\n-2.8207540608310198\n\n```\n We draw 1000000 samples from Studentâs t distribution with the adequate degrees of freedom.\n\n \n```\n>>> import matplotlib.pyplot as plt\n>>> s = np.random.standard_t(10, size=1000000)\n>>> h = plt.hist(s, bins=100, density=True)\n\n```\n Does our t statistic land in one of the two critical regions found at both tails of the distribution?\n\n \n```\n>>> np.sum(np.abs(t) < np.abs(s)) / float(len(s))\n0.018318 #random < 0.05, statistic is in critical region\n\n```\n The probability value for this 2-tailed test is about 1.83%, which is lower than the 5% pre-determined significance threshold.\n\n Therefore, the probability of observing values as extreme as our intake conditionally on the null hypothesis being true is too low, and we reject the null hypothesis of no deviation.\n\n ![../../../_images/numpy-random-RandomState-standard_t-1.png] \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n., âFast Random Integer Generation in an Intervalâ, ACM Transactions on Modeling and Computer Simulation 29 (1), 2019, .\n\n #### Examples\n\n \n```\n>>> rng = np.random.default_rng()\n>>> rng.integers(2, size=10)\narray([1, 0, 0, 0, 1, 1, 0, 0, 1, 0]) # random\n>>> rng.integers(1, size=10)\narray([0, 0, 0, 0, 0, 0, 0, 0, 0, 0])\n\n```\n Generate a 2 x 4 array of ints between 0 and 4, inclusive:\n\n \n```\n>>> rng.integers(5, size=(2, 4))\narray([[4, 0, 2, 1],\n [3, 2, 2, 0]]) # random\n\n```\n Generate a 1 x 3 array with 3 different upper bounds\n\n \n```\n>>> rng.integers(1, [3, 5, 10])\narray([2, 2, 9]) # random\n\n```\n Generate a 1 by 3 array with 3 different lower bounds\n\n \n```\n>>> rng.integers([1, 5, 7], 10)\narray([9, 8, 7]) # random\n\n```\n Generate a 2 by 4 array using broadcasting with dtype of uint8\n\n \n```\n>>> rng.integers([1, 3, 5, 7], [[10], [20]], dtype=np.uint8)\narray([[ 8, 6, 9, 7],\n [ 1, 16, 9, 12]], dtype=uint8) # random\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n a\\) multiply the output of [`random`](../index#module-numpy.random \"numpy.random\") by `(b-a)` and add `a`:\n\n \n```\n(b - a) * random() + a\n\n```\n Parameters \n \n**size**int or tuple of ints, optional\n\nOutput shape. If the given shape is, e.g., `(m, n, k)`, then `m * n * k` samples are drawn. Default is None, in which case a single value is returned.\n\n \n**dtype**dtype, optional\n\nDesired dtype of the result, only [`float64`](../../arrays.scalars#numpy.float64 \"numpy.float64\") and [`float32`](../../arrays.scalars#numpy.float32 \"numpy.float32\") are supported. Byteorder must be native. The default value is np.float64.\n\n \n**out**ndarray, optional\n\nAlternative output array in which to place the result. If size is not None, it must have the same shape as the provided size and must match the type of the output values.\n\n Returns \n \n**out**float or ndarray of floats\n\nArray of random floats of shape `size` (unless `size=None`, in which case a single float is returned).\n\n #### Examples\n\n \n```\n>>> rng = np.random.default_rng()\n>>> rng.random()\n0.47108547995356098 # random\n>>> type(rng.random())\n\n>>> rng.random((5,))\narray([ 0.30220482, 0.86820401, 0.1654503 , 0.11659149, 0.54323428]) # random\n\n```\n Three-by-two array of random numbers from [-5, 0):\n\n \n```\n>>> 5 * rng.random((3, 2)) - 5\narray([[-3.99149989, -0.52338984], # random\n [-2.99091858, -0.79479508],\n [-1.23204345, -1.75224494]])\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n a\\) multiply the output of [`random_sample`](#numpy.random.RandomState.random_sample \"numpy.random.RandomState.random_sample\") by `(b-a)` and add `a`:\n\n \n```\n(b - a) * random_sample() + a\n\n```\n Note\n\n New code should use the `random` method of a `default_rng()` instance instead; please see the [Quick Start](../index#random-quick-start).\n\n Parameters \n \n**size**int or tuple of ints, optional\n\nOutput shape. If the given shape is, e.g., `(m, n, k)`, then `m * n * k` samples are drawn. Default is None, in which case a single value is returned.\n\n Returns \n \n**out**float or ndarray of floats\n\nArray of random floats of shape `size` (unless `size=None`, in which case a single float is returned).\n\n See also\n\n [`random.Generator.random`](numpy.random.generator.random#numpy.random.Generator.random \"numpy.random.Generator.random\")\n\nwhich should be used for new code.\n\n #### Examples\n\n \n```\n>>> np.random.random_sample()\n0.47108547995356098 # random\n>>> type(np.random.random_sample())\n\n>>> np.random.random_sample((5,))\narray([ 0.30220482, 0.86820401, 0.1654503 , 0.11659149, 0.54323428]) # random\n\n```\n Three-by-two array of random numbers from [-5, 0):\n\n \n```\n>>> 5 * np.random.random_sample((3, 2)) - 5\narray([[-3.99149989, -0.52338984], # random\n [-2.99091858, -0.79479508],\n [-1.23204345, -1.75224494]])\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n>> rng = np.random.default_rng()\n>>> rng.choice(5, 3)\narray([0, 3, 4]) # random\n>>> #This is equivalent to rng.integers(0,5,3)\n\n```\n Generate a non-uniform random sample from np.arange(5) of size 3:\n\n \n```\n>>> rng.choice(5, 3, p=[0.1, 0, 0.3, 0.6, 0])\narray([3, 3, 0]) # random\n\n```\n Generate a uniform random sample from np.arange(5) of size 3 without replacement:\n\n \n```\n>>> rng.choice(5, 3, replace=False)\narray([3,1,0]) # random\n>>> #This is equivalent to rng.permutation(np.arange(5))[:3]\n\n```\n Generate a uniform random sample from a 2-D array along the first axis (the default), without replacement:\n\n \n```\n>>> rng.choice([[0, 1, 2], [3, 4, 5], [6, 7, 8]], 2, replace=False)\narray([[3, 4, 5], # random\n [0, 1, 2]])\n\n```\n Generate a non-uniform random sample from np.arange(5) of size 3 without replacement:\n\n \n```\n>>> rng.choice(5, 3, replace=False, p=[0.1, 0, 0.3, 0.6, 0])\narray([2, 3, 0]) # random\n\n```\n Any of the above can be repeated with an arbitrary array-like instead of just integers. For instance:\n\n \n```\n>>> aa_milne_arr = ['pooh', 'rabbit', 'piglet', 'Christopher']\n>>> rng.choice(aa_milne_arr, 5, p=[0.5, 0.1, 0.1, 0.3])\narray(['pooh', 'pooh', 'pooh', 'Christopher', 'piglet'], # random\n dtype='>> rng = np.random.default_rng()\n>>> rng.permutation(10)\narray([1, 7, 4, 3, 0, 9, 2, 5, 8, 6]) # random\n\n```\n \n```\n>>> rng.permutation([1, 4, 9, 12, 15])\narray([15, 1, 9, 4, 12]) # random\n\n```\n \n```\n>>> arr = np.arange(9).reshape((3, 3))\n>>> rng.permutation(arr)\narray([[6, 7, 8], # random\n [0, 1, 2],\n [3, 4, 5]])\n\n```\n \n```\n>>> rng.permutation(\"abc\")\nTraceback (most recent call last):\n ...\nnumpy.AxisError: axis 0 is out of bounds for array of dimension 0\n\n```\n \n```\n>>> arr = np.arange(9).reshape((3, 3))\n>>> rng.permutation(arr, axis=1)\narray([[0, 2, 1], # random\n [3, 5, 4],\n [6, 8, 7]])\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n>> rng = np.random.default_rng()\n>>> arr = np.arange(10)\n>>> arr\narray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])\n>>> rng.shuffle(arr)\n>>> arr\narray([2, 0, 7, 5, 1, 4, 8, 9, 3, 6]) # random\n\n```\n \n```\n>>> arr = np.arange(9).reshape((3, 3))\n>>> arr\narray([[0, 1, 2],\n [3, 4, 5],\n [6, 7, 8]])\n>>> rng.shuffle(arr)\n>>> arr\narray([[3, 4, 5], # random\n [6, 7, 8],\n [0, 1, 2]])\n\n```\n \n```\n>>> arr = np.arange(9).reshape((3, 3))\n>>> arr\narray([[0, 1, 2],\n [3, 4, 5],\n [6, 7, 8]])\n>>> rng.shuffle(arr, axis=1)\n>>> arr\narray([[2, 0, 1], # random\n [5, 3, 4],\n [8, 6, 7]])\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n>> test = np.array([0, 1, 2, 5, 0])\n>>> states = [0, 2]\n>>> mask = np.in1d(test, states)\n>>> mask\narray([ True, False, True, False, True])\n>>> test[mask]\narray([0, 2, 0])\n>>> mask = np.in1d(test, states, invert=True)\n>>> mask\narray([False, True, False, True, False])\n>>> test[mask]\narray([1, 5])\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n>> np.intersect1d([1, 3, 4, 3], [3, 1, 2, 1])\narray([1, 3])\n\n```\n To intersect more than two arrays, use functools.reduce:\n\n \n```\n>>> from functools import reduce\n>>> reduce(np.intersect1d, ([1, 3, 4, 3], [3, 1, 2, 1], [6, 3, 4, 2]))\narray([3])\n\n```\n To return the indices of the values common to the input arrays along with the intersected values:\n\n \n```\n>>> x = np.array([1, 1, 2, 3, 4])\n>>> y = np.array([2, 1, 4, 6])\n>>> xy, x_ind, y_ind = np.intersect1d(x, y, return_indices=True)\n>>> x_ind, y_ind\n(array([0, 2, 4]), array([1, 0, 2]))\n>>> xy, x[x_ind], y[y_ind]\n(array([1, 2, 4]), array([1, 2, 4]), array([1, 2, 4]))\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n>> element = 2*np.arange(4).reshape((2, 2))\n>>> element\narray([[0, 2],\n [4, 6]])\n>>> test_elements = [1, 2, 4, 8]\n>>> mask = np.isin(element, test_elements)\n>>> mask\narray([[False, True],\n [ True, False]])\n>>> element[mask]\narray([2, 4])\n\n```\n The indices of the matched values can be obtained with [`nonzero`](numpy.nonzero#numpy.nonzero \"numpy.nonzero\"):\n\n \n```\n>>> np.nonzero(mask)\n(array([0, 1]), array([1, 0]))\n\n```\n The test can also be inverted:\n\n \n```\n>>> mask = np.isin(element, test_elements, invert=True)\n>>> mask\narray([[ True, False],\n [False, True]])\n>>> element[mask]\narray([0, 6])\n\n```\n Because of how [`array`](numpy.array#numpy.array \"numpy.array\") handles sets, the following does not work as expected:\n\n \n```\n>>> test_set = {1, 2, 4, 8}\n>>> np.isin(element, test_set)\narray([[False, False],\n [False, False]])\n\n```\n Casting the set to a list gives the expected result:\n\n \n```\n>>> np.isin(element, list(test_set))\narray([[False, True],\n [ True, False]])\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n>> a = np.array([1, 2, 3, 2, 4, 1])\n>>> b = np.array([3, 4, 5, 6])\n>>> np.setdiff1d(a, b)\narray([1, 2])\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n>> a = np.array([1, 2, 3, 2, 4])\n>>> b = np.array([2, 3, 5, 7, 5])\n>>> np.setxor1d(a,b)\narray([1, 4, 5, 7])\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n>> np.union1d([-1, 0, 1], [-2, 0, 2])\narray([-2, -1, 0, 1, 2])\n\n```\n To find the union of more than two arrays, use functools.reduce:\n\n \n```\n>>> from functools import reduce\n>>> reduce(np.union1d, ([1, 3, 4, 3], [3, 1, 2, 1], [6, 3, 4, 2]))\narray([1, 2, 3, 4, 6])\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n>> np.sort_complex([5, 3, 6, 2, 1])\narray([1.+0.j, 2.+0.j, 3.+0.j, 5.+0.j, 6.+0.j])\n\n```\n \n```\n>>> np.sort_complex([1 + 2j, 2 - 1j, 3 - 2j, 3 - 3j, 3 + 5j])\narray([1.+2.j, 2.-1.j, 3.-3.j, 3.-2.j, 3.+5.j])\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n*)[[source]](https://github.com/numpy/numpy/blob/v1.23.0/numpy/lib/nanfunctions.py#L561-L615)\n \nReturn the indices of the maximum values in the specified axis ignoring NaNs. For all-NaN slices `ValueError` is raised. Warning: the results cannot be trusted if a slice contains only NaNs and -Infs.\n\n Parameters \n \n**a**array_like\n\nInput data.\n\n \n**axis**int, optional\n\nAxis along which to operate. By default flattened input is used.\n\n \n**out**array, optional\n\nIf provided, the result will be inserted into this array. It should be of the appropriate shape and dtype.\n\n New in version 1.22.0.\n\n \n**keepdims**bool, optional\n\nIf 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.\n\n New in version 1.22.0.\n\n Returns \n \n**index_array**ndarray\n\nAn array of indices or a single index value.\n\n See also\n\n \n[`argmax`](numpy.argmax#numpy.argmax \"numpy.argmax\"), [`nanargmin`](numpy.nanargmin#numpy.nanargmin \"numpy.nanargmin\")\n\n #### Examples\n\n \n```\n>>> a = np.array([[np.nan, 4], [2, 3]])\n>>> np.argmax(a)\n0\n>>> np.nanargmax(a)\n1\n>>> np.nanargmax(a, axis=0)\narray([1, 0])\n>>> np.nanargmax(a, axis=1)\narray([1, 1])\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n*)[[source]](https://github.com/numpy/numpy/blob/v1.23.0/numpy/lib/nanfunctions.py#L501-L554)\n \nReturn the indices of the minimum values in the specified axis ignoring NaNs. For all-NaN slices `ValueError` is raised. Warning: the results cannot be trusted if a slice contains only NaNs and Infs.\n\n Parameters \n \n**a**array_like\n\nInput data.\n\n \n**axis**int, optional\n\nAxis along which to operate. By default flattened input is used.\n\n \n**out**array, optional\n\nIf provided, the result will be inserted into this array. It should be of the appropriate shape and dtype.\n\n New in version 1.22.0.\n\n \n**keepdims**bool, optional\n\nIf 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.\n\n New in version 1.22.0.\n\n Returns \n \n**index_array**ndarray\n\nAn array of indices or a single index value.\n\n See also\n\n \n[`argmin`](numpy.argmin#numpy.argmin \"numpy.argmin\"), [`nanargmax`](numpy.nanargmax#numpy.nanargmax \"numpy.nanargmax\")\n\n #### Examples\n\n \n```\n>>> a = np.array([[np.nan, 4], [2, 3]])\n>>> np.argmin(a)\n0\n>>> np.nanargmin(a)\n2\n>>> np.nanargmin(a, axis=0)\narray([1, 1])\n>>> np.nanargmin(a, axis=1)\narray([1, 0])\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n>> x = np.arange(6).reshape(2,3)\n>>> x\narray([[0, 1, 2],\n [3, 4, 5]])\n>>> np.argwhere(x>1)\narray([[0, 2],\n [1, 0],\n [1, 1],\n [1, 2]])\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n>> x = np.arange(-2, 3)\n>>> x\narray([-2, -1, 0, 1, 2])\n>>> np.flatnonzero(x)\narray([0, 1, 3, 4])\n\n```\n Use the indices of the non-zero elements as an index array to extract these elements:\n\n \n```\n>>> x.ravel()[np.flatnonzero(x)]\narray([-2, -1, 1, 2])\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n>> arr = np.arange(12).reshape((3, 4))\n>>> arr\narray([[ 0, 1, 2, 3],\n [ 4, 5, 6, 7],\n [ 8, 9, 10, 11]])\n>>> condition = np.mod(arr, 3)==0\n>>> condition\narray([[ True, False, False, True],\n [False, False, True, False],\n [False, True, False, False]])\n>>> np.extract(condition, arr)\narray([0, 3, 6, 9])\n\n```\n If `condition` is boolean:\n\n \n```\n>>> arr[condition]\narray([0, 3, 6, 9])\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n>> np.count_nonzero(np.eye(4))\n4\n>>> a = np.array([[0, 1, 7, 0],\n... [3, 0, 2, 19]])\n>>> np.count_nonzero(a)\n5\n>>> np.count_nonzero(a, axis=0)\narray([1, 1, 2, 1])\n>>> np.count_nonzero(a, axis=1)\narray([2, 3])\n>>> np.count_nonzero(a, axis=1, keepdims=True)\narray([[2],\n [3]])\n\n```\n \n\n © 2005â2022 NumPy Developers \nLicensed under the 3-clause BSD License. \n\n 0 ; then take j\n* if g = 0 ; then take i\n\n averaged_inverted_cdf:\n\nmethod 2 of H&F [[1]](#r08bde0ebf37b-1). This method give discontinuous results:\n\n * if g > 0 ; then take j\n* if g = 0 ; then average between bounds\n\n closest_observation:\n\nmethod 3 of H&F [[1]](#r08bde0ebf37b-1). This method give discontinuous results:\n\n * if g > 0 ; then take j\n* if g = 0 and index is odd ; then take j\n* if g = 0 and index is even ; then take i\n\n interpolated_inverted_cdf:\n\nmethod 4 of H&F [[1]](#r08bde0ebf37b-1). This method give continuous results using:\n\n * alpha = 0\n* beta = 1\n\n hazen:\n\nmethod 5 of H&F [[1]](#r08bde0ebf37b-1). This method give continuous results using:\n\n * alpha = 1/2\n* beta = 1/2\n\n weibull:\n\nmethod 6 of H&F [[1]](#r08bde0ebf37b-1). This method give continuous results using:\n\n * alpha = 0\n* beta = 0\n\n linear:\n\nmethod 7 of H&F [[1]](#r08bde0ebf37b-1). This method give continuous results using:\n\n * alpha = 1\n* beta = 1\n\n median_unbiased:\n\nmethod 8 of H&F [[1]](#r08bde0ebf37b-1). This method is probably the best method if the sample distribution function is unknown (see reference). This method give continuous results using:\n\n * alpha = 1/3\n* beta = 1/3\n\n normal_unbiased:\n\nmethod 9 of H&F [[1]](#r08bde0ebf37b-1). This method is probably the best method if the sample distribution function is known to be normal. This method give continuous results using:\n\n * alpha = 3/8\n* beta = 3/8\n\n lower:\n\nNumPy method kept for backwards compatibility. Takes `i` as the interpolation point.\n\n higher:\n\nNumPy method kept for backwards compatibility. Takes `j` as the interpolation point.\n\n nearest:\n\nNumPy method kept for backwards compatibility. Takes `i` or `j`, whichever is nearest.\n\n midpoint:\n\nNumPy method kept for backwards compatibility. Uses `(i + j) / 2`.\n\n #### References\n\n \n1([1](#id1),[2](#id2),[3](#id3),[4](#id4),[5](#id5),[6](#id6),[7](#id7),[8](#id8),[9](#id9),[10](#id10))\n \n and