a little cleaning

Author: zingale

basic_numerics/roots/roots.py

@@ -1,6 +1,8 @@
-# use bisection, Newton's method, or secant method to find roots
-#
-# M. Zingale (2013-02-14)
+"""
+use bisection, Newton's method, or secant method to find roots
+
+ M. Zingale
+"""
 
 from __future__ import print_function
 
@@ -29,7 +31,7 @@ def hprime(x):
     return 2.0*x
 
 
-class root:
+class Root(object):
     """ simple class to manage root finding.  All method take in a
         function and desired tolerance """
 
@@ -39,7 +41,6 @@ def __init__(self, fun, tol, fprime=None):
 
         self.tol = tol
 
-
     def bisection(self, xl, xr):
         """ find the root using bisection.  xl and xr should bracket
             the root """
@@ -50,7 +51,7 @@ def bisection(self, xl, xr):
         # initial evaluations
         fl = self.f(xl)
         fr = self.f(xr)
-        
+
         xeval.append(xl)
         xeval.append(xr)
 
@@ -60,10 +61,10 @@ def bisection(self, xl, xr):
             return None
 
         err = abs(xr - xl)
-        while (err > self.tol):
+        while err > self.tol:
             xm = 0.5*(xl + xr)
             fm = self.f(xm)
-            
+
             xeval.append(xm)
 
             if fm*fl >= 0:
@@ -80,7 +81,6 @@ def bisection(self, xl, xr):
 
         return 0.5*(xl + xm), xeval
 
-
     def newton(self, x0):
         """ find the root via Newton's method.  x0 is the initial guess
             for the root """
@@ -91,15 +91,14 @@ def newton(self, x0):
         dx = -self.f(x0)/self.fprime(x0)
         xeval.append(x0)
         x = x0 + dx
-        
-        while (abs(dx) > self.tol):
-            dx = -self.f(x)/self.fprime(x)            
+
+        while abs(dx) > self.tol:
+            dx = -self.f(x)/self.fprime(x)
             xeval.append(x)
             x += dx
 
         return x, xeval
 
-
     def secant(self, xm1, x0):
         """ find the root via Newton's method.  xm1 and x0 are two
             initial guesses close to the root"""
@@ -111,29 +110,26 @@ def secant(self, xm1, x0):
 
         # loop.  xm1 will always carry the previous estimate for the
         # root
-        while (abs(dx) > self.tol):
+        while abs(dx) > self.tol:
             dx = -self.f(x)*(x - xm1)/(self.f(x) - self.f(xm1))
             xm1 = x
             x += dx
 
-
         return x
 
 
 def main():
-    r = root(h, 1.e-6, fprime=hprime)
+    """a simple test driver"""
+
+    r = Root(h, 1.e-6, fprime=hprime)
     #rootb, xeval = r.bisection(0.0, 10.0)
     rootn, xeval = r.newton(10.0)
     #roots = r.secant(10.0, 9.0)
-    
+
     #print "Bisection: ", rootb
     print("Newton:    ", rootn, xeval)
     #print "Secant:    ", roots
 
 
 if __name__ == "__main__":
     main()
-
-
-
-                

basic_numerics/roots/roots_plot.py

@@ -1,22 +1,23 @@
-# make plots using the root finding methods in roots.py
-#
-# M. Zingale (2013-02-14)
+"""
+make plots using the root finding methods in roots.py
+
+M. Zingale (2013-02-14)
+"""
 
 from __future__ import print_function
 
-import math
 import numpy
 import matplotlib as mpl
 import matplotlib.pyplot as plt
-from roots import *
+import roots
 from mpl_toolkits.axes_grid1.inset_locator import zoomed_inset_axes, mark_inset
 
 mpl.rcParams['xtick.labelsize'] = 16
 mpl.rcParams['ytick.labelsize'] = 16
 mpl.rcParams['mathtext.fontset'] = 'cm'
 mpl.rcParams['mathtext.rm'] = 'serif'
 
-r = root(f, 1.e-5, fprime=fprime)
+r = roots.Root(roots.f, 1.e-5, fprime=roots.fprime)
 
 xmin = 0.0
 xmax = 5.0
@@ -35,8 +36,8 @@
     plt.plot(xfine, r.f(xfine))
 
     plt.scatter(numpy.array(xeval[0:n+1]),
-                  r.f(numpy.array(xeval[0:n+1])),
-                  marker="x", s=25, color="r", zorder=100)
+                r.f(numpy.array(xeval[0:n+1])),
+                marker="x", s=25, color="r", zorder=100)
 
     plt.plot(xfine, r.fprime(x)*(xfine-x) + r.f(x), color="0.5")
 
@@ -45,16 +46,16 @@
     plt.plot([xintercept, xintercept], [0, r.f(xintercept)], color="0.5", ls=":")
 
     if n%2 == 0:
-        plt.text(x, r.f(x)-0.3, "{}".format(n), 
+        plt.text(x, r.f(x)-0.3, "{}".format(n),
                  color="r", fontsize="16",
                  verticalalignment="top", horizontalalignment="center", zorder=1000)
     else:
-        plt.text(x, r.f(x)+0.3, "{}".format(n), 
+        plt.text(x, r.f(x)+0.3, "{}".format(n),
                  color="r", fontsize="16",
                  verticalalignment="bottom", horizontalalignment="center", zorder=1000)
 
     F = plt.gcf()
-    plt.text(0.4, 0.02, "root approx = {}".format(x), 
+    plt.text(0.4, 0.02, "root approx = {}".format(x),
              transform = F.transFigure, color="k", fontsize="16")
 
     # axes through origin
@@ -94,12 +95,12 @@
     axins.plot([xintercept, xintercept], [0, r.f(xintercept)], color="0.5", ls=":")
 
     if n%2 == 0:
-        axins.text(x, r.f(x)-0.05, "{}".format(n), 
+        axins.text(x, r.f(x)-0.05, "{}".format(n),
                    color="r", fontsize="10",
                    verticalalignment="top", horizontalalignment="center",
                    clip_on=True, zorder=100)
     else:
-        axins.text(x, r.f(x)+0.05, "{}".format(n), 
+        axins.text(x, r.f(x)+0.05, "{}".format(n),
                    color="r", fontsize="10",
                    verticalalignment="bottom", horizontalalignment="center",
                    clip_on=True, zorder=100)