Merge pull request #218 from bluescarni/pr/notebook_ruff

Run ruff on all notebooks

Author: bluescarni

doc/notebooks/Batch mode overview.ipynb

@@ -67,15 +67,15 @@
     "\n",
     "# Create the integrator object.\n",
     "ta = hy.taylor_adaptive(\n",
-    "                        # Definition of the ODE system:\n",
-    "                        # x' = v\n",
-    "                        # v' = -9.8 * sin(x)\n",
-    "                        sys = [(x, v),\n",
-    "                         (v, -9.8 * hy.sin(x))],\n",
-    "                        # Initial conditions for x and v.\n",
-    "                        state = [0.05, 0.025],\n",
-    "                        # Set the tolerance to 1e-9\n",
-    "                        tol = 1e-9)\n",
+    "    # Definition of the ODE system:\n",
+    "    # x' = v\n",
+    "    # v' = -9.8 * sin(x)\n",
+    "    sys=[(x, v), (v, -9.8 * hy.sin(x))],\n",
+    "    # Initial conditions for x and v.\n",
+    "    state=[0.05, 0.025],\n",
+    "    # Set the tolerance to 1e-9\n",
+    "    tol=1e-9,\n",
+    ")\n",
     "\n",
     "ta"
    ]
@@ -117,8 +117,8 @@
    ],
    "source": [
     "# Integrate forth to t = 10 and then back to t = 0.\n",
-    "ta.propagate_until(t = 10.)\n",
-    "ta.propagate_until(t = 0.)\n",
+    "ta.propagate_until(t=10.0)\n",
+    "ta.propagate_until(t=0.0)\n",
     "\n",
     "ta"
    ]
@@ -163,7 +163,7 @@
    "outputs": [],
    "source": [
     "# Create an nbody system with 6 particles.\n",
-    "sys = hy.model.nbody(n = 6)"
+    "sys = hy.model.nbody(n=6)"
    ]
   },
   {
@@ -184,6 +184,7 @@
    "source": [
     "# Create an initial state vector (6 values per body).\n",
     "import numpy as np\n",
+    "\n",
     "sv = np.zeros(36)"
    ]
   },

doc/notebooks/Box control for Formation Flying Satellites.ipynb

@@ -72,9 +72,7 @@
     "\n",
     "x, v = hy.make_vars(\"x\", \"v\")\n",
     "\n",
-    "ta = hy.taylor_adaptive([(x, v),\n",
-    "                         (v, -x)],\n",
-    "                        state = [0., 1.])"
+    "ta = hy.taylor_adaptive([(x, v), (v, -x)], state=[0.0, 1.0])"
    ]
   },
   {
@@ -106,7 +104,7 @@
     }
    ],
    "source": [
-    "ta.step(write_tc = True)"
+    "ta.step(write_tc=True)"
    ]
   },
   {
@@ -227,7 +225,7 @@
     }
    ],
    "source": [
-    "ta.update_d_output(t = 0.5)"
+    "ta.update_d_output(t=0.5)"
    ]
   },
   {
@@ -455,7 +453,7 @@
     "ta.time = 0\n",
     "\n",
     "# Propagate and return the continuous output.\n",
-    "c_out = ta.propagate_until(10., c_output=True)[4]"
+    "c_out = ta.propagate_until(10.0, c_output=True)[4]"
    ]
   },
   {
@@ -533,10 +531,10 @@
    ],
    "source": [
     "# Print the state vector at t = 5.\n",
-    "print(\"State vector at t=5: {}\\n\".format(c_out(5.)))\n",
+    "print(\"State vector at t=5: {}\\n\".format(c_out(5.0)))\n",
     "\n",
     "# Print the state vectors at a few different times.\n",
-    "print(\"State vectors at t=[1,2,3,4,5]:\\n{}\\n\".format(c_out([1,2,3,4,5])))"
+    "print(\"State vectors at t=[1,2,3,4,5]:\\n{}\\n\".format(c_out([1, 2, 3, 4, 5])))"
    ]
   },
   {
@@ -574,7 +572,7 @@
     "\n",
     "# Compare it to the exact solution.\n",
     "fig = plt.figure(figsize=(12, 6))\n",
-    "plt.semilogy(t_grid, abs(x_c_out[:,0] - np.sin(t_grid)))\n",
+    "plt.semilogy(t_grid, abs(x_c_out[:, 0] - np.sin(t_grid)))\n",
     "plt.xlabel(\"Time\")\n",
     "plt.ylabel(\"Absolute error\");"
    ]

doc/notebooks/Comparing coordinate systems.ipynb

@@ -118,15 +118,17 @@
     "    # event triggered and print the value of x.\n",
     "    ta.update_d_output(time)\n",
     "    print(\"Value of x when v is zero: {}\".format(ta.d_output[0]))\n",
-    "    \n",
+    "\n",
     "    # Add the event time to zero_vel_times.\n",
     "    zero_vel_times.append(time)\n",
     "\n",
+    "\n",
     "ev = hy.nt_event(\n",
-    "        # The left-hand side of the event equation\n",
-    "        v,\n",
-    "        # The callback.\n",
-    "        callback = cb)"
+    "    # The left-hand side of the event equation\n",
+    "    v,\n",
+    "    # The callback.\n",
+    "    callback=cb,\n",
+    ")"
    ]
   },
   {
@@ -192,9 +194,10 @@
     "    ((x, v), (v, -9.8 * hy.sin(x))),\n",
     "    # Initial conditions\n",
     "    # for x and v.\n",
-    "    [-0.05, 0.],\n",
+    "    [-0.05, 0.0],\n",
     "    # Non-terminal events.\n",
-    "    nt_events = [ev])"
+    "    nt_events=[ev],\n",
+    ")"
    ]
   },
   {
@@ -247,7 +250,7 @@
     "t_grid = np.linspace(0, 5, 1000)\n",
     "\n",
     "# Propagate over the time grid.\n",
-    "x_hist = ta.propagate_grid(t_grid)[5][:,0]\n",
+    "x_hist = ta.propagate_grid(t_grid)[5][:, 0]\n",
     "\n",
     "# Display the time evolution for the x variable.\n",
     "fig = plt.figure(figsize=(12, 6))\n",
@@ -258,7 +261,7 @@
     "# Put vertical lines in correspondence of\n",
     "# the detected events.\n",
     "for ev_time in zero_vel_times:\n",
-    "    plt.axvline(x = ev_time, linestyle='--', color='gray')"
+    "    plt.axvline(x=ev_time, linestyle=\"--\", color=\"gray\")"
    ]
   },
   {
@@ -329,13 +332,15 @@
     "# Redefine ev to detect only events\n",
     "# in the positive direction.\n",
     "ev = hy.nt_event(\n",
-    "        v, callback = lambda ta, time, d_sgn: zero_vel_times.append(time),\n",
-    "        # Specify the direction.\n",
-    "        direction = hy.event_direction.positive)\n",
+    "    v,\n",
+    "    callback=lambda ta, time, d_sgn: zero_vel_times.append(time),\n",
+    "    # Specify the direction.\n",
+    "    direction=hy.event_direction.positive,\n",
+    ")\n",
     "\n",
     "# Reset zero_vel_times and the integrator.\n",
     "zero_vel_times.clear()\n",
-    "ta = hy.taylor_adaptive(((x, v), (v, -9.8 * hy.sin(x))), [-0.05, 0.], nt_events = [ev])"
+    "ta = hy.taylor_adaptive(((x, v), (v, -9.8 * hy.sin(x))), [-0.05, 0.0], nt_events=[ev])"
    ]
   },
   {
@@ -367,7 +372,7 @@
    ],
    "source": [
     "# Propagate over the time grid.\n",
-    "x_hist = ta.propagate_grid(t_grid)[5][:,0]\n",
+    "x_hist = ta.propagate_grid(t_grid)[5][:, 0]\n",
     "\n",
     "# Display the time evolution for the x variable.\n",
     "fig = plt.figure(figsize=(12, 6))\n",
@@ -378,7 +383,7 @@
     "# Put vertical lines in correspondence of\n",
     "# the detected events.\n",
     "for ev_time in zero_vel_times:\n",
-    "    plt.axvline(x = ev_time, linestyle='--', color='gray')"
+    "    plt.axvline(x=ev_time, linestyle=\"--\", color=\"gray\")"
    ]
   },
   {
@@ -447,8 +452,13 @@
    "outputs": [],
    "source": [
     "# Define two close non-terminal events.\n",
-    "ev0 = hy.nt_event(v, lambda ta, time, d_sgn: print(\"Event 0 triggering at t={}\".format(time)))\n",
-    "ev1 = hy.nt_event(v * v - 1e-12,  lambda ta, time, d_sgn: print(\"Event 1 triggering at t={}\".format(time)))"
+    "ev0 = hy.nt_event(\n",
+    "    v, lambda ta, time, d_sgn: print(\"Event 0 triggering at t={}\".format(time))\n",
+    ")\n",
+    "ev1 = hy.nt_event(\n",
+    "    v * v - 1e-12,\n",
+    "    lambda ta, time, d_sgn: print(\"Event 1 triggering at t={}\".format(time)),\n",
+    ")"
    ]
   },
   {
@@ -506,10 +516,12 @@
    ],
    "source": [
     "# Reset the integrator.\n",
-    "ta = hy.taylor_adaptive(((x, v), (v, -9.8 * hy.sin(x))), [-0.05, 0.], nt_events = [ev0, ev1])\n",
+    "ta = hy.taylor_adaptive(\n",
+    "    ((x, v), (v, -9.8 * hy.sin(x))), [-0.05, 0.0], nt_events=[ev0, ev1]\n",
+    ")\n",
     "\n",
     "# Propagate for a few time units.\n",
-    "ta.propagate_until(5.)"
+    "ta.propagate_until(5.0)"
    ]
   },
   {
@@ -580,6 +592,7 @@
     "# Clear up zero_vel_times.\n",
     "zero_vel_times.clear()\n",
     "\n",
+    "\n",
     "# Callback for the terminal event.\n",
     "def t_cb(ta, d_sgn):\n",
     "    # NOTE: the value of the drag coefficient\n",
@@ -596,13 +609,15 @@
     "    # Do not stop the integration.\n",
     "    return True\n",
     "\n",
+    "\n",
     "# Define a terminal event that turns air drag on/off\n",
     "# whenever the velocity goes to zero.\n",
     "t_ev = hy.t_event(\n",
-    "        # The event equation.\n",
-    "        v,\n",
-    "        # The callback.\n",
-    "        callback = t_cb)"
+    "    # The event equation.\n",
+    "    v,\n",
+    "    # The callback.\n",
+    "    callback=t_cb,\n",
+    ")"
    ]
   },
   {
@@ -657,14 +672,18 @@
    "outputs": [],
    "source": [
     "# Construct the damped pendulum integrator.\n",
-    "ta = hy.taylor_adaptive([(x, v),\n",
-    "                        # NOTE: alpha is represented as\n",
-    "                        # the first (and only) runtime\n",
-    "                        # parameter: par[0].\n",
-    "                        (v, -9.8 * hy.sin(x) - hy.par[0] * v)],\n",
-    "                        [0.05, 0.025],\n",
-    "                        # The list of terminal events.\n",
-    "                        t_events = [t_ev])"
+    "ta = hy.taylor_adaptive(\n",
+    "    [\n",
+    "        (x, v),\n",
+    "        # NOTE: alpha is represented as\n",
+    "        # the first (and only) runtime\n",
+    "        # parameter: par[0].\n",
+    "        (v, -9.8 * hy.sin(x) - hy.par[0] * v),\n",
+    "    ],\n",
+    "    [0.05, 0.025],\n",
+    "    # The list of terminal events.\n",
+    "    t_events=[t_ev],\n",
+    ")"
    ]
   },
   {
@@ -746,7 +765,7 @@
     "t_grid = np.linspace(ta.time, 10, 1000)\n",
     "\n",
     "# Propagate over the time grid.\n",
-    "x_hist = ta.propagate_grid(t_grid)[5][:,0]\n",
+    "x_hist = ta.propagate_grid(t_grid)[5][:, 0]\n",
     "\n",
     "# Display the time evolution for the x variable.\n",
     "fig = plt.figure(figsize=(12, 6))\n",
@@ -757,7 +776,7 @@
     "# Put vertical lines in correspondence of\n",
     "# the detected events.\n",
     "for ev_time in zero_vel_times:\n",
-    "    plt.axvline(x = ev_time, linestyle='--', color='gray')\n",
+    "    plt.axvline(x=ev_time, linestyle=\"--\", color=\"gray\")\n",
     "\n",
     "print(\"Final time: {}\".format(ta.time))"
    ]