Merge pull request #60 from alexfikl/ruff

Enable linting with ruff

Author: Wrzlprmft

.editorconfig

@@ -7,6 +7,7 @@ root = true
 [*]
 end_of_line = lf
 insert_final_newline = true
+trim_trailing_whitespace = false
 
 # Matches multiple files with brace expansion notation
 # Set default charset

.github/workflows/ci.yml

@@ -14,6 +14,20 @@ concurrency:
   cancel-in-progress: true
 
 jobs:
+  typos:
+    name: Spelling (typos)
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v4
+    - uses: crate-ci/typos@master
+
+  ruff:
+    name: Linting (ruff)
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v4
+    - uses: chartboost/ruff-action@v1
+
   test:
     name: Unittest (${{ matrix.os }}-${{ matrix.compiler }}-py${{ matrix.python-version }})
     runs-on: ${{ matrix.os }}

docs/conf.py

@@ -1,58 +1,62 @@
-import sys
 import os
+import sys
 from unittest.mock import MagicMock as Mock
+
 from setuptools_scm import get_version
 
+
 MOCK_MODULES = [
-	'numpy', 'numpy.testing', 'numpy.random',
-	'scipy',
-	'symengine', 'symengine.printing', 'symengine.lib.symengine_wrapper',
-	'jitcxde_common.helpers','jitcxde_common.numerical','jitcxde_common.symbolic','jitcxde_common.transversal'
+	"numpy", "numpy.testing", "numpy.random",
+	"scipy",
+	"symengine", "symengine.printing", "symengine.lib.symengine_wrapper",
+	"jitcxde_common.helpers", "jitcxde_common.numerical", "jitcxde_common.symbolic", "jitcxde_common.transversal"
 	]
 sys.modules.update((mod_name, Mock()) for mod_name in MOCK_MODULES)
 
-class GroupHandler_mock(object): pass
-sys.modules['jitcxde_common.transversal'] = Mock(GroupHandler=GroupHandler_mock)
+class GroupHandler_mock:
+	pass
+
+sys.modules["jitcxde_common.transversal"] = Mock(GroupHandler=GroupHandler_mock)
 
 sys.path.insert(0,os.path.abspath("../examples"))
 sys.path.insert(0,os.path.abspath("../jitcdde"))
 
-needs_sphinx = '1.3'
+needs_sphinx = "1.3"
 
 extensions = [
-    'sphinx.ext.autodoc',
-    'sphinx.ext.autosummary',
-    'sphinx.ext.mathjax',
-    'numpydoc',
+    "sphinx.ext.autodoc",
+    "sphinx.ext.autosummary",
+    "sphinx.ext.mathjax",
+    "numpydoc",
 ]
 
-source_suffix = '.rst'
+source_suffix = ".rst"
 
-master_doc = 'index'
+master_doc = "index"
 
-project = u'JiTCDDE'
-copyright = u'2016, Gerrit Ansmann'
+project = "JiTCDDE"
+copyright = "2016, Gerrit Ansmann"
 
-release = version = get_version(root='..', relative_to=__file__)
+release = version = get_version(root="..", relative_to=__file__)
 
 default_role = "any"
 
 add_function_parentheses = True
 
 add_module_names = False
 
-html_theme = 'nature'
-pygments_style = 'colorful'
-htmlhelp_basename = 'JiTCDDEdoc'
+html_theme = "nature"
+pygments_style = "colorful"
+htmlhelp_basename = "JiTCDDEdoc"
 
 numpydoc_show_class_members = False
-autodoc_member_order = 'bysource'
+autodoc_member_order = "bysource"
 
 def on_missing_reference(app, env, node, contnode):
-	if node['reftype'] == 'any':
+	if node["reftype"] == "any":
 		return contnode
 	else:
 		return None
 
 def setup(app):
-	app.connect('missing-reference', on_missing_reference)
+	app.connect("missing-reference", on_missing_reference)

docs/index.rst

@@ -47,7 +47,7 @@ After every successful integration step, the state and derivative of the integra
 Whenever the derivative :math:`(f)` is evaluated, the required past states :math:`\left ( y(t-τ_1), y(t-τ_2), … \right )` are obtained through piece-wise cubic `Hermite interpolation <http://en.wikipedia.org/wiki/Hermite_interpolation>`_, using previously stored pairs of state and derivative (“anchor”).
 In some extreme cases, they may also be extrapolated.
 
-Note that unlike most other DDE softwares, JiTCDDE stores and accesses the initial past in exactly this way, i.e., as anchor points.
+Note that unlike most other DDE software, JiTCDDE stores and accesses the initial past in exactly this way, i.e., as anchor points.
 Thus, if you want to have maximum control, you have to initiate the past in exactly this way, i.e., you have to give at least two such anchor points (via `add_past_point`).
 If you do not want or need this, there are utility function available that automatically determine the anchors from a given function (`past_from_function`) or just set it to a fixed value (`constant_past`).
 You can also use the `get_state` method to obtain a representation of the past that you can dissect and modify using `CubicHermiteSpline <https://chspy.readthedocs.io/en/latest/>`_.
@@ -78,7 +78,7 @@ To make this happen, you have four options:
 
 * `integrate_blindly` integrates the system for some time with a fixed step size, ignoring the error estimate. You have to take care that all parameters are reasonable. This is a good choice if you have a lot of different delays or time- or state-dependent delays. The time you integrate with this should be larger than your largest delay.
 
-* Carefully choose the initial past such that the derivative for the last anchor is identical to the value of :math:`f` as determined with the anchors, i.e., there is no initial discontinuity to begin with. To find such initial conditions, you usally have to solve a non-linear equation system. This is the ideal case for short integrations as elaborated in the next subsection.
+* Carefully choose the initial past such that the derivative for the last anchor is identical to the value of :math:`f` as determined with the anchors, i.e., there is no initial discontinuity to begin with. To find such initial conditions, you usually have to solve a non-linear equation system. This is the ideal case for short integrations as elaborated in the next subsection.
 
 
 .. _short_integrations:
@@ -173,7 +173,7 @@ Calculating Lyapunov exponents with `jitcdde_lyap`
 It works just like `jitcdde`, except that it generates and integrates additional differential equations for the separation functions.
 After every call of `integrate`, the separation functions are orthonormalised, and the “local” Lyapunov exponents for this integration step are returned alongside with the system’s state.
 These can then be further processed to obtain the Lyapunov exponents.
-The separation functions are intialised with random data, and you have to take care of the preiterations that the separation functions require to align themselves.
+The separation functions are initialised with random data, and you have to take care of the preiterations that the separation functions require to align themselves.
 
 The method employed here is similar to Farmer’s [F82]_, which in turn is an adaption of the method described by Benettin et al. [BGGS80]_ to delayed systems.
 As the state of delayed systems is also defined by their recent past, one has to consider the past of tangent vectors (as used in Benettin et. al.) as well, which are called separation functions.

examples/data_input.py

@@ -1,8 +1,13 @@
 import numpy as np
-from jitcdde import y, t, jitcdde_input, input
-from chspy import CubicHermiteSpline
 from matplotlib import pyplot as plt
 
+from chspy import CubicHermiteSpline
+
+from jitcdde import input, jitcdde_input, t, y  # noqa: A004
+
+
+rng = np.random.default_rng()
+
 # Defining Input
 # --------------
 
@@ -11,7 +16,7 @@
 input_times = np.linspace(0, 70, 20)
 max_time = input_times[-1]
 
-input_data = np.random.normal(size=(20,2))
+input_data = rng.normal(size=(20,2))
 input_spline = CubicHermiteSpline.from_data(input_times,input_data)
 
 fig,axes = plt.subplots()

examples/kuramoto_network.py

@@ -1,5 +1,4 @@
 #!/usr/bin/python3
-# -*- coding: utf-8 -*-
 
 """
 Suppose, we want to implement a network of :math:`n=100` delay-coupled Kuramoto oscillators, governed by the following differential equations:
@@ -35,16 +34,19 @@
 
 if __name__ == "__main__":
 	# example-start
-	from jitcdde import jitcdde, y, t
-	from numpy import pi, arange, random, max
+	import numpy as np
 	from symengine import sin
+
+	from jitcdde import jitcdde, t, y
 
+
+	rng = np.random.default_rng()
 	n = 100
 	ω = 1
 	c = 42
 	q = 0.05
-	A = random.choice( [1,0], size=(n,n), p=[q,1-q] )
-	τ = random.uniform( pi/5, 2*pi, size=(n,n) )
+	A = rng.choice( [1,0], size=(n,n), p=[q,1-q] )
+	τ = rng.uniform( np.pi/5, 2*np.pi, size=(n,n) )
 
 	def kuramotos():
 		for i in range(n):
@@ -54,11 +56,11 @@ def kuramotos():
 						if A[j,i]
 					)
 
-	I = jitcdde(kuramotos,n=n,verbose=False,delays=τ.flatten())
-	I.set_integration_parameters(rtol=0,atol=1e-5)
+	solver = jitcdde(kuramotos,n=n,verbose=False,delays=τ.flatten())
+	solver.set_integration_parameters(rtol=0,atol=1e-5)
 
-	I.constant_past( random.uniform(0,2*pi,n), time=0.0 )
-	I.integrate_blindly( max(τ) , 0.1 )
+	solver.constant_past( rng.uniform(0,2*np.pi,n), time=0.0 )
+	solver.integrate_blindly( np.max(τ) , 0.1 )
 
-	for time in I.t + arange(0,400,0.2):
-		print(*I.integrate(time) % (2*pi))
+	for time in solver.t + np.arange(0,400,0.2):
+		print(*solver.integrate(time) % (2*np.pi))

examples/laminar_chaos.py

@@ -2,9 +2,11 @@
 This is an example implementing laminar chaos as discovered by: https://doi.org/10.1103/PhysRevLett.120.084102
 """
 
-from jitcdde import t, y, jitcdde
-from symengine import sin
 import numpy as np
+from symengine import sin
+
+from jitcdde import jitcdde, t, y
+
 
 T = 200
 A = 0.9/2/np.pi

examples/mackey_glass.py

@@ -1,8 +1,7 @@
 #!/usr/bin/python3
-# -*- coding: utf-8 -*-
 
 """
-Suppose we want to integrate the Mackey–Glass delay differential equation: :math:`\\dot{y} = f(y)` with :math:`y∈ℝ`, 
+Suppose we want to integrate the Mackey–Glass delay differential equation: :math:`\\dot{y} = f(y)` with :math:`y∈ℝ`,
 
 .. math::
 
@@ -17,7 +16,7 @@
 
 Amongst our imports were the symbols for the state (`y`) and time (`t`), which have to be used to write down the differential equation such that JiTCDDE can process it.
 Using them, we can write down the right-hand side of the differential equation as a list of expressions.
-As it is one-dimensional, the list contains only one element. 
+As it is one-dimensional, the list contains only one element.
 We can then initiate JiTCDDE:
 
 .. literalinclude:: ../examples/mackey_glass.py
@@ -57,8 +56,9 @@
 
 
 if __name__ == "__main__":
-	from jitcdde import jitcdde, y, t
 	import numpy
+
+	from jitcdde import jitcdde, t, y
 
 	τ = 15
 	n = 10

examples/mackey_glass_jump.py

@@ -1,14 +1,15 @@
 #!/usr/bin/python3
-# -*- coding: utf-8 -*-
 
 """
 This is a very simple example implementing the Mackey–Glass system with an additional jump.
 See https://github.com/neurophysik/jitcdde/issues/23 for details.
 """
 
-from jitcdde import jitcdde, y, t
 import numpy
 
+from jitcdde import jitcdde, t, y
+
+
 τ = 15
 n = 10
 β = 0.25

examples/mackey_glass_lyap.py

@@ -1,5 +1,4 @@
 #!/usr/bin/python3
-# -*- coding: utf-8 -*-
 
 """
 For instance, we can calculate and print the Lyapunov exponents for the Mackey–Glass system as follows (central changes to the example from `example` highlighted):
@@ -14,9 +13,10 @@
 """
 
 if __name__ == "__main__":
-	from jitcdde import jitcdde_lyap, y, t
 	import numpy
 	from scipy.stats import sem
+
+	from jitcdde import jitcdde_lyap, t, y
 
 	τ = 15
 	n = 10
@@ -46,4 +46,4 @@
 	for i in range(n_lyap):
 		Lyap = numpy.average(lyaps[400:,i], weights=weights[400:])
 		stderr = sem(lyaps[400:,i]) # Note that this only an estimate
-		print("%i. Lyapunov exponent: % .4f +/- %.4f" % (i+1,Lyap,stderr))
+		print(f"{i+1}. Lyapunov exponent: {Lyap:.4f} +/- {stderr:.4f}")