fix ruff issues

Author: hirish99

sumpy/recurrence.py

@@ -58,18 +58,20 @@
 THE SOFTWARE.
 """
 import math
-from typing import Any, TypeVar
+from typing import TYPE_CHECKING, Any, TypeVar
 
 import numpy as np
 import sympy as sp
 from sympy import Expr, Symbol
 
 from pytools import obj_array
 
-from sumpy.expansion.diff_op import (
-    DerivativeIdentifier,
-    LinearPDESystemOperator,
-)
+
+if TYPE_CHECKING:
+    from sumpy.expansion.diff_op import (
+        DerivativeIdentifier,
+        LinearPDESystemOperator,
+    )
 
 
 # similar to make_sym_vector in sumpy.symbolic, but returns an object array

sumpy/recurrence_qbx.py

@@ -34,7 +34,7 @@
 """
 
 import math
-from typing import Sequence
+from collections.abc import Sequence
 
 import numpy as np
 import sympy as sp
@@ -102,7 +102,9 @@ def recurrence_qbx_lp(sources, centers, normals, strengths, radius, pde, g_x_y,
     var_t = _make_sympy_vec("t", ndim)
 
     # ------------ 5. Compute recurrence
-    n_initial, order, recurrence = get_reindexed_and_center_origin_on_axis_recurrence(pde)
+    n_initial, order, recurrence = (
+        get_reindexed_and_center_origin_on_axis_recurrence(pde)
+    )
 
     # ------------ 6. Set order p = 5
     n_p = sources.shape[1]
@@ -126,11 +128,10 @@ def generate_lamb_expr(i, n_initial):
             lamb_expr_symb = lamb_expr_symb_deriv
         else:
             lamb_expr_symb = recurrence.subs(n, i)
-        #print("=============== ORDER = " + str(i))
-        #print(lamb_expr_symb)
-        return sp.lambdify(arg_list, lamb_expr_symb)#, sp.lambdify(arg_list, lamb_expr_symb_deriv)
+        # print("=============== ORDER = " + str(i))
+        # print(lamb_expr_symb)
+        return sp.lambdify(arg_list, lamb_expr_symb)
 
-    
     coord = [cts_r_s[j] for j in range(ndim)]
     interactions_on_axis = coord[0] * 0
     for i in range(p+1):
@@ -142,24 +143,29 @@ def generate_lamb_expr(i, n_initial):
         s_new_true = true_lamb_expr(*a)
         arg_max = np.argmax(abs(s_new-s_new_true)/abs(s_new_true))
         print((s_new-s_new_true).reshape(-1)[arg_max]/s_new_true.reshape(-1)[arg_max])
-        print("x:", coord[0].reshape(-1)[arg_max], "y:", coord[1].reshape(-1)[arg_max],
-              "s_recur:", s_new.reshape(-1)[arg_max], "s_true:", s_new_true.reshape(-1)[arg_max], "order: ", i) 
+        print("x:", coord[0].reshape(-1)[arg_max],
+              "y:", coord[1].reshape(-1)[arg_max],
+              "s_recur:", s_new.reshape(-1)[arg_max],
+              "s_true:", s_new_true.reshape(-1)[arg_max],
+              "order: ", i)
         """
 
         interactions_on_axis += s_new * radius**i/math.factorial(i)
 
         storage.pop(0)
         storage.append(s_new)
 
-
-    ### NEW CODE - COMPUTE OFF AXIS INTERACTIONS
-    start_order, t_recur_order, t_recur = get_reindexed_and_center_origin_off_axis_recurrence(pde)
+    # NEW CODE - COMPUTE OFF AXIS INTERACTIONS
+    start_order, t_recur_order, t_recur = (
+        get_reindexed_and_center_origin_off_axis_recurrence(pde)
+    )
     t_exp, t_exp_order, _ = get_off_axis_expression(pde, 8)
     storage_taylor_order = max(t_recur_order, t_exp_order+1)
 
     start_order = max(start_order, order)
 
     storage_taylor = [np.zeros((n_p, n_p))] * storage_taylor_order
+
     def gen_lamb_expr_t_recur(i, start_order):
         arg_list = []
         for j in range(t_recur_order, 0, -1):
@@ -178,7 +184,6 @@ def gen_lamb_expr_t_recur(i, start_order):
 
         return sp.lambdify(arg_list, lamb_expr_symb)
 
-
     def gen_lamb_expr_t_exp(i, t_exp_order, start_order):
         arg_list = []
         for j in range(t_exp_order, -1, -1):
@@ -197,7 +202,6 @@ def gen_lamb_expr_t_exp(i, t_exp_order, start_order):
 
         return sp.lambdify(arg_list, lamb_expr_symb)
 
-
     interactions_off_axis = 0
     for i in range(p+1):
         lamb_expr_t_recur = gen_lamb_expr_t_recur(i, start_order)
@@ -213,7 +217,7 @@ def gen_lamb_expr_t_exp(i, t_exp_order, start_order):
 
     ################
     # Compute True Interactions
-    '''
+    """
     storage_taylor_true = [np.zeros((n_p, n_p))] * storage_taylor_order
     def generate_true(i):
         arg_list = []
@@ -225,52 +229,65 @@ def generate_true(i):
             lamb_expr_symb_deriv = lamb_expr_symb_deriv.subs(var_t[j], 0)
         lamb_expr_symb = lamb_expr_symb_deriv
 
-        #print("=============== ORDER = " + str(i))
-        #print(lamb_expr_symb)
-        return sp.lambdify(arg_list, lamb_expr_symb)#, sp.lambdify(arg_list, lamb_expr_symb_deriv)
+        # print("=============== ORDER = " + str(i))
+        # print(lamb_expr_symb)
+        return sp.lambdify(arg_list, lamb_expr_symb)
 
     interactions_true = 0
     for i in range(p+1):
         lamb_expr_true = generate_true(i)
         a4 = [*coord]
         s_new_true = lamb_expr_true(*a4)
         interactions_true += s_new_true * radius**i/math.factorial(i)
-    '''
+    """
     ###############
 
-    #slope of line y = mx
+    # slope of line y = mx
     m = 100
     mask_on_axis = m*np.abs(coord[0]) >= np.abs(coord[1])
     mask_off_axis = m*np.abs(coord[0]) < np.abs(coord[1])
 
-    #print("-------------------------")
-
-    #percent_on = np.sum(mask_on_axis)/(mask_on_axis.shape[0]*mask_on_axis.shape[1])
-    #percent_off = 1-percent_on
-
-    #relerr_on = np.abs(interactions_on_axis[mask_on_axis]-interactions_true[mask_on_axis])/np.abs(interactions_on_axis[mask_on_axis])
-    #print("MAX ON AXIS ERROR(", percent_on, "):", np.max(relerr_on))
-    #print(np.mean(relerr_on))
-    #print("X:", coord[0][mask_on_axis].reshape(-1)[np.argmax(relerr_on)])
-    #print("Y:", coord[1][mask_on_axis].reshape(-1)[np.argmax(relerr_on)])
-
-    #print("-------------------------")
-
-    #if np.any(mask_off_axis):
-    #    relerr_off = np.abs(interactions_off_axis[mask_off_axis]-interactions_true[mask_off_axis])/np.abs(interactions_off_axis[mask_off_axis])
-    #    print("MAX OFF AXIS ERROR(", percent_off, "):", np.max(relerr_off))
-    #    print(np.mean(relerr_off))
-    #    print("X:", coord[0][mask_off_axis].reshape(-1)[np.argmax(relerr_off)])
-    #    print("Y:", coord[1][mask_off_axis].reshape(-1)[np.argmax(relerr_off)])
+    # print("-------------------------")
+
+    # percent_on = np.sum(mask_on_axis) / (
+    #     mask_on_axis.shape[0]*mask_on_axis.shape[1])
+    # percent_off = 1-percent_on
+
+    # relerr_on = (
+    #     np.abs(
+    #         interactions_on_axis[mask_on_axis]
+    #         - interactions_true[mask_on_axis])
+    #     / np.abs(interactions_on_axis[mask_on_axis]))
+    # print("MAX ON AXIS ERROR(", percent_on, "):", np.max(relerr_on))
+    # print(np.mean(relerr_on))
+    # print("X:", coord[0][mask_on_axis].reshape(-1)[np.argmax(relerr_on)])
+    # print("Y:", coord[1][mask_on_axis].reshape(-1)[np.argmax(relerr_on)])
+
+    # print("-------------------------")
+
+    # if np.any(mask_off_axis):
+    #     relerr_off = (
+    #         np.abs(
+    #             interactions_off_axis[mask_off_axis]
+    #             - interactions_true[mask_off_axis])
+    #         / np.abs(interactions_off_axis[mask_off_axis]))
+    #     print("MAX OFF AXIS ERROR(", percent_off, "):",
+    #           np.max(relerr_off))
+    #     print(np.mean(relerr_off))
+    #     print("X:",
+    #           coord[0][mask_off_axis].reshape(-1)[np.argmax(relerr_off)])
+    #     print("Y:",
+    #           coord[1][mask_off_axis].reshape(-1)[np.argmax(relerr_off)])
 
     interactions_total = np.zeros(coord[0].shape)
     interactions_total[mask_on_axis] = interactions_on_axis[mask_on_axis]
     interactions_total[mask_off_axis] = interactions_off_axis[mask_off_axis]
 
     exp_res = (interactions_total * strengths[None, :]).sum(axis=1)
-    #exp_res_true = (interactions_true * strengths[None, :]).sum(axis=1)
+    # exp_res_true = (interactions_true * strengths[None, :]).sum(axis=1)
 
-    #relerr_total = np.max(np.abs(exp_res-exp_res_true)/np.abs(exp_res_true))
-    #print("OVERALL ERROR:", relerr_total)
+    # relerr_total = np.max(
+    #     np.abs(exp_res-exp_res_true)/np.abs(exp_res_true))
+    # print("OVERALL ERROR:", relerr_total)
 
-    return exp_res
+    return exp_res