summaryrefslogtreecommitdiff
path: root/doc/source
diff options
context:
space:
mode:
Diffstat (limited to 'doc/source')
-rw-r--r--doc/source/conf.py1
-rw-r--r--doc/source/dev/development_environment.rst31
-rw-r--r--doc/source/reference/random/generator.rst14
-rw-r--r--doc/source/reference/random/index.rst24
-rw-r--r--doc/source/reference/random/new-or-different.rst22
-rw-r--r--doc/source/reference/routines.polynomials.rst4
-rw-r--r--doc/source/reference/ufuncs.rst4
-rw-r--r--doc/source/user/basics.subclassing.rst16
8 files changed, 73 insertions, 43 deletions
diff --git a/doc/source/conf.py b/doc/source/conf.py
index dcf60ada9..95865c024 100644
--- a/doc/source/conf.py
+++ b/doc/source/conf.py
@@ -161,6 +161,7 @@ html_theme = 'pydata_sphinx_theme'
html_logo = '_static/numpylogo.svg'
html_theme_options = {
+ "logo_link": "index",
"github_url": "https://github.com/numpy/numpy",
"twitter_url": "https://twitter.com/numpy_team",
}
diff --git a/doc/source/dev/development_environment.rst b/doc/source/dev/development_environment.rst
index 013414568..fb1b8cd6a 100644
--- a/doc/source/dev/development_environment.rst
+++ b/doc/source/dev/development_environment.rst
@@ -188,6 +188,35 @@ For more extensive information, see :ref:`testing-guidelines`
*Note: do not run the tests from the root directory of your numpy git repo without ``runtests.py``,
that will result in strange test errors.*
+Running Linting
+---------------
+Lint checks can be performed on newly added lines of Python code.
+
+Install all dependent packages using pip::
+
+ $ python -m pip install -r linter_requirements.txt
+
+To run lint checks before committing new code, run::
+
+ $ python runtests.py --lint uncommitted
+
+To check all changes in newly added Python code of current branch with target branch, run::
+
+ $ python runtests.py --lint main
+
+If there are no errors, the script exits with no message. In case of errors::
+
+ $ python runtests.py --lint main
+ ./numpy/core/tests/test_scalarmath.py:34:5: E303 too many blank lines (3)
+ 1 E303 too many blank lines (3)
+
+It is advisable to run lint checks before pushing commits to a remote branch
+since the linter runs as part of the CI pipeline.
+
+For more details on Style Guidelines:
+
+ - `Python Style Guide`_
+ - `C Style Guide`_
Rebuilding & cleaning the workspace
-----------------------------------
@@ -264,6 +293,8 @@ typically packaged as ``python-dbg``) is highly recommended.
.. _virtualenvwrapper: http://www.doughellmann.com/projects/virtualenvwrapper/
.. _Waf: https://code.google.com/p/waf/
.. _`match test names using python operators`: https://docs.pytest.org/en/latest/usage.html#specifying-tests-selecting-tests
+.. _`Python Style Guide`: https://www.python.org/dev/peps/pep-0008/
+.. _`C Style Guide`: https://numpy.org/neps/nep-0045-c_style_guide.html
Understanding the code & getting started
----------------------------------------
diff --git a/doc/source/reference/random/generator.rst b/doc/source/reference/random/generator.rst
index a359d2253..7934be98a 100644
--- a/doc/source/reference/random/generator.rst
+++ b/doc/source/reference/random/generator.rst
@@ -71,13 +71,13 @@ By default, `Generator.permuted` returns a copy. To operate in-place with
`Generator.permuted`, pass the same array as the first argument *and* as
the value of the ``out`` parameter. For example,
- >>> rg = np.random.default_rng()
+ >>> rng = np.random.default_rng()
>>> x = np.arange(0, 15).reshape(3, 5)
>>> x
array([[ 0, 1, 2, 3, 4],
[ 5, 6, 7, 8, 9],
[10, 11, 12, 13, 14]])
- >>> y = rg.permuted(x, axis=1, out=x)
+ >>> y = rng.permuted(x, axis=1, out=x)
>>> x
array([[ 1, 0, 2, 4, 3], # random
[ 6, 7, 8, 9, 5],
@@ -97,13 +97,13 @@ 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
- >>> rg = np.random.default_rng()
+ >>> rng = np.random.default_rng()
>>> x = np.arange(0, 15).reshape(3, 5)
>>> x
array([[ 0, 1, 2, 3, 4],
[ 5, 6, 7, 8, 9],
[10, 11, 12, 13, 14]])
- >>> rg.permutation(x, axis=1)
+ >>> rng.permutation(x, axis=1)
array([[ 1, 3, 2, 0, 4], # random
[ 6, 8, 7, 5, 9],
[11, 13, 12, 10, 14]])
@@ -116,7 +116,7 @@ how `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` to the above example of `Generator.permutation`:
- >>> rg.permuted(x, axis=1)
+ >>> rng.permuted(x, axis=1)
array([[ 1, 0, 2, 4, 3], # random
[ 5, 7, 6, 9, 8],
[10, 14, 12, 13, 11]])
@@ -131,9 +131,9 @@ Shuffling non-NumPy sequences
a sequence that is not a NumPy array, it shuffles that sequence in-place.
For example,
- >>> rg = np.random.default_rng()
+ >>> rng = np.random.default_rng()
>>> a = ['A', 'B', 'C', 'D', 'E']
- >>> rg.shuffle(a) # shuffle the list in-place
+ >>> rng.shuffle(a) # shuffle the list in-place
>>> a
['B', 'D', 'A', 'E', 'C'] # random
diff --git a/doc/source/reference/random/index.rst b/doc/source/reference/random/index.rst
index 13ce7c40c..69d597874 100644
--- a/doc/source/reference/random/index.rst
+++ b/doc/source/reference/random/index.rst
@@ -84,10 +84,10 @@ different
.. code-block:: python
try:
- rg_integers = rg.integers
+ rng_integers = rng.integers
except AttributeError:
- rg_integers = rg.randint
- a = rg_integers(1000)
+ rng_integers = rng.randint
+ a = rng_integers(1000)
Seeds can be passed to any of the BitGenerators. The provided value is mixed
via `SeedSequence` to spread a possible sequence of seeds across a wider
@@ -97,8 +97,8 @@ is wrapped with a `Generator`.
.. code-block:: python
from numpy.random import Generator, PCG64
- rg = Generator(PCG64(12345))
- rg.standard_normal()
+ rng = Generator(PCG64(12345))
+ rng.standard_normal()
Here we use `default_rng` to create an instance of `Generator` to generate a
random float:
@@ -146,10 +146,10 @@ As a convenience NumPy provides the `default_rng` function to hide these
details:
>>> from numpy.random import default_rng
->>> rg = default_rng(12345)
->>> print(rg)
+>>> rng = default_rng(12345)
+>>> print(rng)
Generator(PCG64)
->>> print(rg.random())
+>>> print(rng.random())
0.22733602246716966
One can also instantiate `Generator` directly with a `BitGenerator` instance.
@@ -158,16 +158,16 @@ To use the default `PCG64` bit generator, one can instantiate it directly and
pass it to `Generator`:
>>> from numpy.random import Generator, PCG64
->>> rg = Generator(PCG64(12345))
->>> print(rg)
+>>> rng = Generator(PCG64(12345))
+>>> print(rng)
Generator(PCG64)
Similarly to use the older `MT19937` bit generator (not recommended), one can
instantiate it directly and pass it to `Generator`:
>>> from numpy.random import Generator, MT19937
->>> rg = Generator(MT19937(12345))
->>> print(rg)
+>>> rng = Generator(MT19937(12345))
+>>> print(rng)
Generator(MT19937)
What's New or Different
diff --git a/doc/source/reference/random/new-or-different.rst b/doc/source/reference/random/new-or-different.rst
index 6cab0f729..a81543926 100644
--- a/doc/source/reference/random/new-or-different.rst
+++ b/doc/source/reference/random/new-or-different.rst
@@ -58,18 +58,18 @@ And in more detail:
from numpy.random import Generator, PCG64
import numpy.random
- rg = Generator(PCG64())
- %timeit -n 1 rg.standard_normal(100000)
+ rng = Generator(PCG64())
+ %timeit -n 1 rng.standard_normal(100000)
%timeit -n 1 numpy.random.standard_normal(100000)
.. ipython:: python
- %timeit -n 1 rg.standard_exponential(100000)
+ %timeit -n 1 rng.standard_exponential(100000)
%timeit -n 1 numpy.random.standard_exponential(100000)
.. ipython:: python
- %timeit -n 1 rg.standard_gamma(3.0, 100000)
+ %timeit -n 1 rng.standard_gamma(3.0, 100000)
%timeit -n 1 numpy.random.standard_gamma(3.0, 100000)
@@ -94,9 +94,9 @@ And in more detail:
.. ipython:: python
- rg = Generator(PCG64(0))
- rg.random(3, dtype='d')
- rg.random(3, dtype='f')
+ rng = Generator(PCG64(0))
+ rng.random(3, dtype='d')
+ rng.random(3, dtype='f')
* Optional ``out`` argument that allows existing arrays to be filled for
select distributions
@@ -112,7 +112,7 @@ And in more detail:
.. ipython:: python
existing = np.zeros(4)
- rg.random(out=existing[:2])
+ rng.random(out=existing[:2])
print(existing)
* Optional ``axis`` argument for methods like `~.Generator.choice`,
@@ -121,9 +121,9 @@ And in more detail:
.. ipython:: python
- rg = Generator(PCG64(123456789))
+ rng = Generator(PCG64(123456789))
a = np.arange(12).reshape((3, 4))
a
- rg.choice(a, axis=1, size=5)
- rg.shuffle(a, axis=1) # Shuffle in-place
+ rng.choice(a, axis=1, size=5)
+ rng.shuffle(a, axis=1) # Shuffle in-place
a
diff --git a/doc/source/reference/routines.polynomials.rst b/doc/source/reference/routines.polynomials.rst
index da481ae4c..ecfb012f0 100644
--- a/doc/source/reference/routines.polynomials.rst
+++ b/doc/source/reference/routines.polynomials.rst
@@ -118,9 +118,9 @@ example, consider a simple linear fit to the following data:
.. ipython:: python
- rg = np.random.default_rng()
+ rng = np.random.default_rng()
x = np.arange(10)
- y = np.arange(10) + rg.standard_normal(10)
+ y = np.arange(10) + rng.standard_normal(10)
With the legacy polynomial module, a linear fit (i.e. polynomial of degree 1)
could be applied to these data with `~numpy.polyfit`:
diff --git a/doc/source/reference/ufuncs.rst b/doc/source/reference/ufuncs.rst
index 06fbe28dd..c919ec9b8 100644
--- a/doc/source/reference/ufuncs.rst
+++ b/doc/source/reference/ufuncs.rst
@@ -628,8 +628,8 @@ Math operations
for large calculations. If your arrays are large, complicated
expressions can take longer than absolutely necessary due to the
creation and (later) destruction of temporary calculation
- spaces. For example, the expression ``G = a * b + c`` is equivalent to
- ``t1 = A * B; G = T1 + C; del t1``. It will be more quickly executed
+ spaces. For example, the expression ``G = A * B + C`` is equivalent to
+ ``T1 = A * B; G = T1 + C; del T1``. It will be more quickly executed
as ``G = A * B; add(G, C, G)`` which is the same as
``G = A * B; G += C``.
diff --git a/doc/source/user/basics.subclassing.rst b/doc/source/user/basics.subclassing.rst
index 8ffa31688..1b7880986 100644
--- a/doc/source/user/basics.subclassing.rst
+++ b/doc/source/user/basics.subclassing.rst
@@ -223,8 +223,8 @@ where our object creation housekeeping usually goes.
new ndarray instance of its own class. In practice this means that
we, the authors of the code, will need to make a call to
``ndarray.__new__(MySubClass,...)``, a class-hierarchy prepared call to
- ``super(MySubClass, cls).__new__(cls, ...)``, or do view casting of an
- existing array (see below)
+ ``super().__new__(cls, ...)``, or do view casting of an existing array
+ (see below)
* For view casting and new-from-template, the equivalent of
``ndarray.__new__(MySubClass,...`` is called, at the C level.
@@ -240,7 +240,7 @@ The following code allows us to look at the call sequences and arguments:
class C(np.ndarray):
def __new__(cls, *args, **kwargs):
print('In __new__ with class %s' % cls)
- return super(C, cls).__new__(cls, *args, **kwargs)
+ return super().__new__(cls, *args, **kwargs)
def __init__(self, *args, **kwargs):
# in practice you probably will not need or want an __init__
@@ -312,9 +312,8 @@ Simple example - adding an extra attribute to ndarray
# ndarray input arguments. This will call the standard
# ndarray constructor, but return an object of our type.
# It also triggers a call to InfoArray.__array_finalize__
- obj = super(InfoArray, subtype).__new__(subtype, shape, dtype,
- buffer, offset, strides,
- order)
+ obj = super().__new__(subtype, shape, dtype,
+ buffer, offset, strides, order)
# set the new 'info' attribute to the value passed
obj.info = info
# Finally, we must return the newly created object:
@@ -486,8 +485,7 @@ following.
if out_no:
info['outputs'] = out_no
- results = super(A, self).__array_ufunc__(ufunc, method,
- *args, **kwargs)
+ results = super().__array_ufunc__(ufunc, method, *args, **kwargs)
if results is NotImplemented:
return NotImplemented
@@ -600,7 +598,7 @@ some print statements:
print(' self is %s' % repr(self))
print(' arr is %s' % repr(out_arr))
# then just call the parent
- return super(MySubClass, self).__array_wrap__(self, out_arr, context)
+ return super().__array_wrap__(self, out_arr, context)
We run a ufunc on an instance of our new array:
View Lorry Controller Status