Black

dolo/algos/ergodic.py

@@ -4,6 +4,7 @@
 # from multipledispatch import dispatch
 # multimethod = dispatch()
 from dolo.misc.multimethod import multimethod
+
 # from numba import generated_jit
 import xarray
 
@@ -17,6 +18,7 @@
 
 # @generated_jit(nopython=True)
 
+
 @jit
 def trembling_hand(A: "N*n1*...*nd", x: "N*d", w: "float"):
 

dolo/algos/improved_time_iteration.py

@@ -120,7 +120,6 @@ def d_filt_dx(π, M_ij, S_ij, n_m, N, n_x, dumdr):
 
 
 class Operator(LinearOperator):
-
     """Special Linear Operator"""
 
     def __init__(self, M_ij, S_ij, dumdr):

dolo/algos/invert.py

@@ -6,6 +6,7 @@
 
 import numpy
 
+
 @jit
 def swaplines_tensor(i, j, M):
     n0, n1, n2 = M.shape
@@ -15,6 +16,7 @@ def swaplines_tensor(i, j, M):
             M[i, k, l] = M[j, k, l]
             M[j, k, l] = t
 
+
 @jit
 def swaplines_matrix(i, j, M):
     n = M.shape[1]
@@ -23,6 +25,7 @@ def swaplines_matrix(i, j, M):
         M[i, k] = M[j, k]
         M[j, k] = t
 
+
 @jit
 def swaplines_vector(i, j, M):
     n = M.shape[0]
@@ -34,11 +37,12 @@ def swaplines_vector(i, j, M):
 @jit(cache=True)
 def swaplines(i, j, M):
     if M.ndim == 1:
-        return swaplines_vector(i,j,M)
+        return swaplines_vector(i, j, M)
     elif M.ndim == 2:
-        return swaplines_matrix(i,j,M)
+        return swaplines_matrix(i, j, M)
     elif M.ndim == 3:
-        return swaplines_tensor(i,j,M)
+        return swaplines_tensor(i, j, M)
+
 
 @jit
 def substract_tensor(i, j, c, M):
@@ -48,28 +52,32 @@ def substract_tensor(i, j, c, M):
         for l in range(n2):
             M[i, k, l] = M[i, k, l] - c * M[j, k, l]
 
+
 @jit
 def substract_matrix(i, j, c, M):
     # Li <- Li - c*Lj
     n = M.shape[0]
     for k in range(n):
         M[i, k] = M[i, k] - c * M[j, k]
 
+
 @jit
 def substract_vector(i, j, c, M):
     # Li <- Li - c*Lj
     # n = M.shape[0]
     M[i] = M[i] - c * M[j]
 
+
 @jit
-def substract(i,j,c,M):
+def substract(i, j, c, M):
     if M.ndim == 1:
-        return substract_vector(i,j,c,M)
+        return substract_vector(i, j, c, M)
     elif M.ndim == 2:
-        return substract_matrix(i,j,c,M)
+        return substract_matrix(i, j, c, M)
     elif M.ndim == 3:
-        return substract_tensor(i,j,c,M)
-
+        return substract_tensor(i, j, c, M)
+
+
 # @overload(substract)
 # def substract_jit(i, j, c, M):
 #     if M.ndim == 1:
@@ -79,6 +87,7 @@ def substract(i,j,c,M):
 #     elif M.ndim == 3:
 #         return substract_tensor
 
+
 @jit
 def divide_tensor(i, c, M):
     # Li <- Li - c*Lj
@@ -87,26 +96,29 @@ def divide_tensor(i, c, M):
         for l in range(n2):
             M[i, k, l] /= c
 
+
 @jit
 def divide_matrix(i, c, M):
     # Li <- Li - c*Lj
     n = M.shape[0]
     for k in range(n):
         M[i, k] /= c
 
+
 @jit
 def divide_vector(i, c, M):
     # Li <- Li - c*Lj
     M[i] /= c
 
+
 @jit
 def divide(i, c, M):
     if M.ndim == 1:
-        return divide_vector(i,c,M)
+        return divide_vector(i, c, M)
     elif M.ndim == 2:
-        return divide_matrix(i,c,M)
+        return divide_matrix(i, c, M)
     elif M.ndim == 3:
-        return divide_tensor(i,c,M)
+        return divide_tensor(i, c, M)
 
 
 # def divide(i, c, M):

dolo/algos/perfect_foresight.py

@@ -22,7 +22,7 @@ def _shocks_to_epsilons(model, shocks, T):
     # value arrays are not the same length
     if isinstance(shocks, dict):
         epsilons = np.zeros((T + 1, n_e))
-        for (i, k) in enumerate(model.symbols["exogenous"]):
+        for i, k in enumerate(model.symbols["exogenous"]):
             if k in shocks:
                 this_shock = shocks[k]
                 epsilons[: len(this_shock), i] = this_shock

dolo/algos/time_iteration.py

@@ -54,7 +54,6 @@ def time_iteration(
     # obsolete
     with_complementarities=None,
 ) -> TimeIterationResult:
-
     """Finds a global solution for ``model`` using backward time-iteration.
 
 

dolo/compiler/eval_formula.py

@@ -40,7 +40,7 @@ def eval_formula(expr: str, dataframe=None, context=None):
 
         import pandas as pd
 
-        for (k, t) in variables:
+        for k, t in variables:
             dd[stringify_symbol((k, t))] = dataframe[k].shift(t)
         dd["t_"] = pd.Series(dataframe.index, index=dataframe.index)
 

dolo/compiler/objects.py

@@ -65,7 +65,7 @@ def max(self):
 #     signature = {'Mu': 'list(float)', 'Sigma': 'Matrix'}
 
 
-#%%
+# %%
 
 
 @language_element

dolo/misc/multimethod.py

@@ -231,9 +231,7 @@ class multidispatch(multimethod):
 get_type = multimethod(type)
 get_type.__doc__ = """Return a generic `subtype` which checks subscripts."""
 for atomic in (Iterator, str, bytes):
-    get_type[
-        atomic,
-    ] = type
+    get_type[atomic,] = type
 
 
 @multimethod  # type: ignore[no-redef]

dolo/numeric/discretization/discretization.py

@@ -2,7 +2,6 @@
 Discretization of continuous processes as markov chain
 """
 
-
 import scipy as sp
 import scipy.stats
 import numpy as np

dolo/numeric/discretization/quadrature.py

@@ -3,6 +3,7 @@
 import numpy
 from dolo.numeric.misc import cartesian
 
+
 # Credits : both routines below are ported from the Compecon Toolbox
 # by Paul L Fackler and Mario J. Miranda.
 # It is downloadable at http://www4.ncsu.edu/~pfackler/compecon/toolbox.html

dolo/numeric/distribution.py

@@ -550,7 +550,7 @@ def ppf(self, quantiles):
         # Probability associated with each point in grid (nodes)
 
 
-#%
+# %
 
 
 ###

dolo/numeric/extern/lmmcp.py

@@ -418,7 +418,7 @@ def Phi3MCPPFB(x, Fx, lb, ub, lambda1, lambda2, n, Indexset):
 
 def DPhi3MCPPFB(x, Fx, DFx, lb, ub, lambda1, lambda2, n, Indexset):
 
-    #% we evaluate an element of the C-subdifferential of operator Phi3MCPPFB
+    # % we evaluate an element of the C-subdifferential of operator Phi3MCPPFB
     null = 1e-8
     beta_l = np.zeros(n)
     beta_u = np.zeros(n)

dolo/numeric/matrix_equations.py

@@ -4,6 +4,7 @@
 
 TOL = 1e-10
 
+
 # credits : second_order_solver is adapted from Sven Schreiber's port of Uhlig's Toolkit.
 def second_order_solver(FF, GG, HH, eigmax=1.0 + 1e-6):
 

dolo/numeric/optimize/newton.py

@@ -82,7 +82,6 @@ def serial_solve(A, B, diagnose=True):
 
 
 def newton(f, x, verbose=False, tol=1e-6, maxit=5, jactype="serial"):
-
     """Solve nonlinear system using safeguarded Newton iterations
 
 

dolo/numeric/processes.py

@@ -291,7 +291,7 @@ def simulate(self, N, T, i0=0, m0=None, stochastic=True):
         return self.values[inds]
 
 
-#%%
+# %%
 
 
 @language_element

dolo/tests/test_complementarity_problems.py

@@ -17,9 +17,9 @@ def josephy(x):
 def Djosephy(x):
     # Local Variables: x, DFx, n
     # Function calls: Djosephy, zeros, length
-    #%
-    #%   Computes the Jacobian DF(x) of the NCP-example by Josephy
-    #%
+    # %
+    # %   Computes the Jacobian DF(x) of the NCP-example by Josephy
+    # %
     n = len(x)
     DFx = np.zeros((n, n))
     DFx[0, 0] = 6.0 * x[0] + 2.0 * x[1]

dolo/tests/test_iid_processes.py

@@ -5,6 +5,7 @@
 from dolo.numeric.distribution import *
 from dolo.numeric.processes import ConstantProcess
 
+
 ## Polynomial
 def f(x):
     return x**2

dolo/tests/test_serial_ncpsolve.py

@@ -19,9 +19,9 @@ def josephy(x):
 def Djosephy(x):
     # Local Variables: x, DFx, n
     # Function calls: Djosephy, zeros, length
-    #%
-    #%   Computes the Jacobian DF(x) of the NCP-example by Josephy
-    #%
+    # %
+    # %   Computes the Jacobian DF(x) of the NCP-example by Josephy
+    # %
     n = len(x)
     DFx = np.zeros((n, n))
     DFx[0, 0] = 6.0 * x[0] + 2.0 * x[1]