pmagpy-cli 4.2.120__tar.gz → 4.3.8__tar.gz

{pmagpy-cli-4.2.120 → pmagpy-cli-4.3.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pmagpy-cli
-Version: 4.2.120
+Version: 4.3.8
 Summary: Analysis tools for paleo/rock magnetic data
 Home-page: https://github.com/PmagPy/PmagPy
 Author: PmagPy team
@@ -166,6 +166,6 @@ This code and the PmagPy cookbook (http://earthref.org/PmagPy/cookbook) are comp
 
 
 
-This code can be freely used, modified, and shared. It is licensed under a 3-clause BSD license. See [license.txt](https://github.com/ltauxe/PmagPy/blob/master/license.txt) for details.
+This code can be freely used, modified, and shared. It is licensed under a 3-clause BSD license. See [license.txt](https://github.com/PmagPy/PmagPy/blob/master/license.txt) for details.
 
 

{pmagpy-cli-4.2.120 → pmagpy-cli-4.3.8}/README.md

@@ -86,4 +86,4 @@ This code and the PmagPy cookbook (http://earthref.org/PmagPy/cookbook) are comp
 
 ## Licensing
 
-This code can be freely used, modified, and shared. It is licensed under a 3-clause BSD license. See [license.txt](https://github.com/ltauxe/PmagPy/blob/master/license.txt) for details.
+This code can be freely used, modified, and shared. It is licensed under a 3-clause BSD license. See [license.txt](https://github.com/PmagPy/PmagPy/blob/master/license.txt) for details.

{pmagpy-cli-4.2.120 → pmagpy-cli-4.3.8}/SPD/lib/__init__.py

@@ -6,7 +6,6 @@
 #  Author: Lori Jonestrask (mintblue87@gmail.com) .
 
 
-from __future__ import absolute_import
 __all__ = ['lib_additivity_check_statistics', 'lib_curvature', 'lib_ptrm_statistics', 'lib_directional_statistics', 'lib_IZZI_MD', 'lib_arai_plot_statistics', 'lib_tail_check_statistics']
 
 #print "initializing in /lib"

{pmagpy-cli-4.2.120 → pmagpy-cli-4.3.8}/SPD/lib/leastsq_jacobian.py

@@ -1,7 +1,5 @@
-from __future__ import division
 from builtins import map
 from builtins import range
-from past.utils import old_div
 import numpy
 from scipy import optimize
 
@@ -14,9 +12,9 @@ Y = [ 34., 10.,   6., -14.,  27., -10.]
 def AraiCurvature(x=X, y=Y):
     # ensure all values are floats, then norm them by largest value
     x = numpy.array(list(map(float, x)))
-    x =old_div(x, max(x))
+    x = x / max(x)
     y = numpy.array(list(map(float, y)))
-    y =old_div(y, max(y))
+    y = y /max(y)
     # if all x or all y values are identical, there is no curvature (it is a line)
     if len(set(x)) == 1 or len(set(y)) == 1:
         return -999., None, None, -999.
@@ -24,9 +22,9 @@ def AraiCurvature(x=X, y=Y):
     #print "best_a, best_b, r", best_a, best_b, r
     SSE = get_SSE(best_a, best_b, r, x, y)
     if best_a <= numpy.mean(x) and best_b <= numpy.mean(y):
-        k = old_div(-1., r)
+        k = -1. / r
     else:
-        k = old_div(1., r)
+        k = 1. / r
     return k, best_a, best_b, SSE
 
 def do_circlefit(x, y):
@@ -50,7 +48,7 @@ def do_circlefit(x, y):
     Svvv = sum(v**3)
     # Solving the linear system                                                    
     A = numpy.array([ [ Suu, Suv ], [Suv, Svv]])
-    B = old_div(numpy.array([ Suuu + Suvv, Svvv + Suuv ]),2.0)
+    B = numpy.array([ Suuu + Suvv, Svvv + Suuv ]) /2.0
     uc, vc = numpy.linalg.solve(A, B)
 
     xc_1 = x_m + uc
@@ -80,8 +78,8 @@ def do_circlefit(x, y):
         df2b_dc    = numpy.empty((len(c), x.size))
 
         Ri = calc_R(xc, yc)
-        df2b_dc[0] = old_div((xc - x),Ri)                   # dR/dxc
-        df2b_dc[1] = old_div((yc - y),Ri)                   # dR/dyc
+        df2b_dc[0] = (xc - x) / Ri                   # dR/dxc
+        df2b_dc[1] = (yc - y) / Ri                   # dR/dyc
         df2b_dc    = df2b_dc - df2b_dc.mean(axis=1)[:, numpy.newaxis]
 
         return df2b_dc

{pmagpy-cli-4.2.120 → pmagpy-cli-4.3.8}/SPD/lib/lib_IZZI_MD.py

@@ -1,8 +1,6 @@
 #!/usr/bin/env python
 
-from __future__ import division
 from builtins import range
-from past.utils import old_div
 from numpy import *
 
 
@@ -12,7 +10,7 @@ def rect_area(three_points):
    xB,yB=three_points[1][0],three_points[1][1]
    xC,yC=three_points[2][0],three_points[2][1]
    #area=abs((xB*yA-xA*yB)+(xC*yB-xB*yC)+(xA*yC-xC*yA))/2
-   area=old_div(abs((xB*yA-xA*yB)+(xC*yB-xB*yC)+(xA*yC-xC*yA)),2)
+   area = abs((xB*yA-xA*yB)+(xC*yB-xB*yC)+(xA*yC-xC*yA)) / 2
    return area
 
 
@@ -74,7 +72,7 @@ def get_IZZI_MD(X_arai,Y_arai,Step,start,end):
                 C=array([X_IZZI_MD[i+2],Y_IZZI_MD[i+2]])
                 area=rect_area([A,B,C])
 
-                slope_A_C=old_div((C[1]-A[1]),(C[0]-A[0]))
+                slope_A_C = (C[1]-A[1]) / (C[0]-A[0])
                 intercept_A_C=A[1]-(slope_A_C*A[0])
                 #print 'slope_A_C,intercept_A_C', slope_A_C,intercept_A_C
                 #raw_input()
@@ -93,5 +91,5 @@ def get_IZZI_MD(X_arai,Y_arai,Step,start,end):
 
         if total_ZI_curve == 0:
            return 0
-        IZZI_MD=old_div(total_Z_area,total_ZI_curve)
+        IZZI_MD = total_Z_area / total_ZI_curve
         return(IZZI_MD)

{pmagpy-cli-4.2.120 → pmagpy-cli-4.3.8}/SPD/lib/lib_additivity_check_statistics.py

@@ -1,7 +1,5 @@
 #!/usr/bin/env python
 
-from __future__ import division
-from past.utils import old_div
 import numpy
 
 
@@ -25,7 +23,7 @@ def get_delta_AC(n_add, add_checks, x_int):
         #print "x_int", x_int
         #print "(abs(incl_add_checks)", (abs(incl_add_checks))
         #print "( max(abs(incl_add_checks) ) ", ( max(abs(incl_add_checks) ) )
-        delta_AC = ( old_div(max(abs(incl_add_checks) ), abs(x_int)))  * 100.
+        delta_AC = (max(abs(incl_add_checks)) / abs(x_int))  * 100.
         #print delta_AC
     else:
         incl_add_checks = 0

{pmagpy-cli-4.2.120 → pmagpy-cli-4.3.8}/SPD/lib/lib_arai_plot_statistics.py

@@ -1,9 +1,7 @@
 #! /usr/bin/env python
 
 #from scipy import *
-from __future__ import division
 from builtins import range
-from past.utils import old_div
 import numpy
 
 
@@ -17,7 +15,7 @@ def York_Regression(x_segment, y_segment, x_mean, y_mean, n, lab_dc_field, steps
     """
     x_err = x_segment - x_mean
     y_err = y_segment - y_mean
-    york_b = -1* numpy.sqrt(old_div(sum(y_err**2), sum(x_err**2)) )  # averaged slope
+    york_b = -1* numpy.sqrt(sum(y_err**2) / sum(x_err**2))  # averaged slope
 
     b = numpy.sign(sum(x_err * y_err)) * numpy.std(y_segment, ddof=1)/numpy.std(x_segment, ddof=1) # ddof is degrees of freedom
     if b == 0:
@@ -25,33 +23,33 @@ def York_Regression(x_segment, y_segment, x_mean, y_mean, n, lab_dc_field, steps
     else:
         york_b = b
 
-    york_sigma= numpy.sqrt( old_div((2 * sum(y_err**2) - 2*york_b* sum(x_err*y_err)), ( (n-2) * sum(x_err**2) )) )
+    york_sigma= numpy.sqrt((2 * sum(y_err**2) - 2*york_b* sum(x_err*y_err)) / ((n-2) * sum(x_err**2)))
     if york_sigma == 0: # prevent divide by zero
         york_sigma = 1e-10
-    beta_Coe = abs(old_div(york_sigma,york_b))
+    beta_Coe = abs(york_sigma / york_b)
     # y_T is the intercept of the extrepolated line
     # through the center of mass (see figure 7 in Coe (1978))
     y_T = y_mean - (york_b* x_mean)
-    x_T = old_div((-1 * y_T), york_b)  # x intercept
+    x_T = (-1 * y_T) / york_b  # x intercept
     # # calculate the extrarpolated data points for f and fvds
-    x_tag = old_div((y_segment - y_T ), york_b) # returns array of y points minus the y intercept, divided by slope
+    x_tag = (y_segment - y_T ) / york_b # returns array of y points minus the y intercept, divided by slope
     y_tag = york_b*x_segment + y_T
 
     # intersect of the dashed square and the horizontal dahed line  next to delta-y-5 in figure 7, Coe (1978)
-    x_prime = old_div((x_segment+x_tag), 2)
-    y_prime = old_div((y_segment+y_tag), 2)
+    x_prime = (x_segment+x_tag) / 2.
+    y_prime = (y_segment+y_tag) / 2.
 
     delta_x_prime = abs(max(x_prime) - min(x_prime)) # TRM length of best fit line
     delta_y_prime = abs(max(y_prime) - min(y_prime)) # NRM length of best fit line
 
-    f_Coe = old_div(delta_y_prime, abs(y_T))
+    f_Coe = delta_y_prime / abs(y_T)
     if delta_y_prime:
-        g_Coe =  1 - (old_div(sum((y_prime[:-1]-y_prime[1:])**2), delta_y_prime ** 2))  # gap factor
+        g_Coe =  1 - (sum((y_prime[:-1]-y_prime[1:])**2) / (delta_y_prime ** 2))  # gap factor
     else:
         g_Coe = float('nan')
-    g_lim = old_div((float(n) - 2), (float(n) - 1))
+    g_lim = (float(n) - 2) / (float(n) - 1)
     q_Coe = abs(york_b)*f_Coe*g_Coe/york_sigma
-    w_Coe = old_div(q_Coe, numpy.sqrt(n - 2))
+    w_Coe = q_Coe / numpy.sqrt(n - 2)
     count_IZ = steps_Arai.count('IZ')
     count_ZI = steps_Arai.count('ZI')
     B_lab = lab_dc_field * 1e6
@@ -76,11 +74,11 @@ def get_vds(zdata, delta_y_prime, start, end):
     last_vector = numpy.linalg.norm(zdata[-1])
     vector_diffs.append(last_vector)
     vds = sum(vector_diffs)
-    f_vds = abs(old_div(delta_y_prime, vds)) # fvds varies, because of delta_y_prime, but vds does not.
+    f_vds = abs(delta_y_prime / vds) # fvds varies, because of delta_y_prime, but vds does not.
     vector_diffs_segment = vector_diffs[start:end]
     partial_vds = sum(vector_diffs_segment)
     max_diff = max(vector_diffs_segment)
-    GAP_MAX = old_div(max_diff, partial_vds) #
+    GAP_MAX = max_diff / partial_vds #
     return {'max_diff': max_diff, 'vector_diffs': vector_diffs, 'specimen_vds': vds,
             'specimen_fvds': f_vds, 'vector_diffs_segment': vector_diffs_segment,
             'partial_vds': partial_vds, 'GAP-MAX': GAP_MAX}
@@ -99,10 +97,10 @@ def get_SCAT_box(slope, x_mean, y_mean, beta_threshold = .1):
     # get lines that pass through mass center, with opposite slope
     slope1 =  slope + (2* slope_err_threshold)
     line1_y_int = y - (slope1 * x)
-    line1_x_int = -1 * (old_div(line1_y_int, slope1))
+    line1_x_int = -1 * (line1_y_int / slope1)
     slope2 = slope - (2 * slope_err_threshold)
     line2_y_int = y - (slope2 * x)
-    line2_x_int = -1 * (old_div(line2_y_int, slope2))
+    line2_x_int = -1 * (line2_y_int / slope2)
         # l1_y_int and l2_x_int form the bottom line of the box
         # l2_y_int and l1_x_int form the top line of the box
 #    print "_diagonal line1:", (0, line2_y_int), (line2_x_int, 0), (x, y)
@@ -114,13 +112,13 @@ def get_SCAT_box(slope, x_mean, y_mean, beta_threshold = .1):
     x_max = high_bound[1][0]#
     y_max = high_bound[0][1]
     # function for low_bound
-    low_slope = old_div((low_bound[0][1] - low_bound[1][1]), (low_bound[0][0] - low_bound[1][0])) #
+    low_slope = (low_bound[0][1] - low_bound[1][1]) / (low_bound[0][0] - low_bound[1][0]) #
     low_y_int = low_bound[0][1]
     def low_bound(x):
         y = low_slope * x + low_y_int
         return y
     # function for high_bound
-    high_slope = old_div((high_bound[0][1] - high_bound[1][1]), (high_bound[0][0] - high_bound[1][0])) # y_0-y_1/x_0-x_1
+    high_slope = (high_bound[0][1] - high_bound[1][1]) / (high_bound[0][0] - high_bound[1][0]) # y_0-y_1/x_0-x_1
     high_y_int = high_bound[0][1]
     def high_bound(x):
         y = high_slope * x + high_y_int
@@ -226,7 +224,7 @@ def get_FRAC(vds, vector_diffs_segment):
             raise ValueError('vector diffs should not be negative')
     if vds == 0:
         raise ValueError('attempting to divide by zero. vds should be a positive number')
-    FRAC = old_div(sum(vector_diffs_segment), vds)
+    FRAC = sum(vector_diffs_segment) / vds
     return FRAC
 
 def get_R_corr2(x_avg, y_avg, x_segment, y_segment): #
@@ -238,7 +236,7 @@ def get_R_corr2(x_avg, y_avg, x_segment, y_segment): #
     yd = y_segment - y_avg # detrend y_segment
     if sum(xd**2) * sum(yd**2) == 0: # prevent divide by zero error
         return float('nan')
-    rcorr = old_div(sum((xd * yd))**2, (sum(xd**2) * sum(yd**2)))
+    rcorr = sum((xd * yd))**2 / (sum(xd**2) * sum(yd**2))
     return rcorr
 
 def get_R_det2(y_segment, y_avg, y_prime):
@@ -249,7 +247,7 @@ def get_R_det2(y_segment, y_avg, y_prime):
     numerator = sum((numpy.array(y_segment) - numpy.array(y_prime))**2)
     denominator = sum((numpy.array(y_segment) - y_avg)**2)
     if denominator: # prevent divide by zero error
-        R_det2 = 1 - (old_div(numerator, denominator))
+        R_det2 = 1 - (numerator / denominator)
         return R_det2
     else:
         return float('nan')
@@ -259,7 +257,7 @@ def get_b_wiggle(x, y, y_int):
     if x == 0:
         b_wiggle = 0
     else:
-        b_wiggle = old_div((y_int - y), x)
+        b_wiggle = (y_int - y) / x
     return b_wiggle
 
 def get_Z(x_segment, y_segment, x_int, y_int, slope):
@@ -271,7 +269,7 @@ def get_Z(x_segment, y_segment, x_int, y_int, slope):
     first_time = True
     for num, x in enumerate(x_segment):
         b_wiggle = get_b_wiggle(x, y_segment[num], y_int)
-        z = old_div((x * abs(b_wiggle - abs(slope)) ), abs(x_int))
+        z = (x * abs(b_wiggle - abs(slope)) ) / abs(x_int)
         Z += z
         first_time = False
     return Z
@@ -285,10 +283,10 @@ def get_Zstar(x_segment, y_segment, x_int, y_int, slope, n):
     first_time = True
     for num, x in enumerate(x_segment):
         b_wiggle = get_b_wiggle(x, y_segment[num], y_int)
-        result = 100 * ( old_div((x * abs(b_wiggle - abs(slope)) ), abs(y_int)) )
+        result = 100 * ((x * abs(b_wiggle - abs(slope)) ) / abs(y_int))
         total += result
         first_time = False
-    Zstar = (old_div(1., (n - 1.))) * total
+    Zstar = (1. / (n - 1.)) * total
     return Zstar
 
 
@@ -303,7 +301,7 @@ def get_normed_points(point_array, norm): # good to go
     #floated_array = []
     #for p in point_array: # need to make sure each point is a float
         #floated_array.append(float(p))
-    points = old_div(numpy.array(point_array), norm)
+    points = numpy.array(point_array) / norm
     return points
 
 def get_xy_array(x_segment, y_segment):

{pmagpy-cli-4.2.120 → pmagpy-cli-4.3.8}/SPD/lib/lib_curvature.py

@@ -1,10 +1,8 @@
 #!/usr/bin/env python 
 
-from __future__ import division
 from builtins import zip
 from builtins import map
 from builtins import range
-from past.utils import old_div
 import numpy
 from numpy import *
 
@@ -29,9 +27,9 @@ def AraiCurvature(x=x,y=y):
     """
     # makes sure all values are floats, then norms them by largest value
     X = numpy.array(list(map(float, x)))
-    X = old_div(X, max(X))
+    X = X / max(X)
     Y = numpy.array(list(map(float, y)))
-    Y = old_div(Y, max(Y))
+    Y = Y / max(Y)
     XY = numpy.array(list(zip(X, Y)))
                   
     #Provide the intitial estimate
@@ -47,9 +45,9 @@ def AraiCurvature(x=x,y=y):
     best_r = E2[2]
 
     if best_a <= numpy.mean(X) and best_b <= numpy.mean(Y):
-        k = old_div(-1.,best_r)
+        k = -1. / best_r
     else:
-        k = old_div(1.,best_r)
+        k = 1. / best_r
 
     SSE = get_SSE(best_a, best_b, best_r, X, Y)
     return k, best_a, best_b, SSE
@@ -73,12 +71,12 @@ def TaubinSVD(XY):
     centroid = [numpy.mean(XY[:,0]), numpy.mean(XY[:,1])]
     Z = X * X + Y * Y  
     Zmean = numpy.mean(Z)
-    Z0 = old_div((Z - Zmean), (2. * numpy.sqrt(Zmean)))
+    Z0 = (Z - Zmean) / (2. * numpy.sqrt(Zmean))
     ZXY = numpy.array([Z0, X, Y]).T
     U, S, V = numpy.linalg.svd(ZXY, full_matrices=False) # 
     V = V.transpose()
     A = V[:,2]
-    A[0] = old_div(A[0], (2. * numpy.sqrt(Zmean)))
+    A[0] = A[0] / (2. * numpy.sqrt(Zmean))
     A = numpy.concatenate([A, [(-1. * Zmean * A[0])]], axis=0)
     a, b = (-1 * A[1:3]) / A[0] / 2 + centroid 
     r = numpy.sqrt(A[1]*A[1]+A[2]*A[2]-4*A[0]*A[3])/abs(A[0])/2;
@@ -97,7 +95,7 @@ def VarCircle(XY, Par):  # must have at least 4 sets of xy points or else divisi
     Dx = XY[:,0] - Par[0]
     Dy = XY[:,1] - Par[1]
     D = numpy.sqrt(Dx * Dx + Dy * Dy) - Par[2]
-    result = old_div(numpy.dot(D, D),(n-3))
+    result = numpy.dot(D, D) / (n-3)
     return result
 
 
@@ -126,10 +124,10 @@ def LMA(XY,ParIni):
 
     anew = ParIni[0] + Xshift
     bnew = ParIni[1] + Yshift
-    Anew = old_div(1.,(2.*ParIni[2]))                                                                              
+    Anew = 1. / (2.*ParIni[2])
     aabb = anew*anew + bnew*bnew    
     Fnew = (aabb - ParIni[2]*ParIni[2])*Anew 
-    Tnew = numpy.arccos(old_div(-anew,numpy.sqrt(aabb))) 
+    Tnew = numpy.arccos(-anew / numpy.sqrt(aabb))
     if bnew > 0:
         Tnew = 2*numpy.pi - Tnew
     VarNew = VarCircle(XY,ParIni) 
@@ -147,7 +145,7 @@ def LMA(XY,ParIni):
         H = numpy.sqrt(1+4*Aold*Fold);                                                                 
         aold = -H*numpy.cos(Told)/(Aold+Aold) - Xshift;
         bold = -H*numpy.sin(Told)/(Aold+Aold) - Yshift;
-        Rold = old_div(1,abs(Aold+Aold)); 
+        Rold = 1 / abs(Aold+Aold);
 
         DD = 1 + 4*Aold*Fold; 
         D = numpy.sqrt(DD);  
@@ -195,20 +193,20 @@ def LMA(XY,ParIni):
                                               
 #             Cholesly decomposition                                     
                                                                        
-            G11 = numpy.sqrt(H11 + VarLambda);
-            G12 = old_div(H12,G11)                                                                              
-            G13 = old_div(H13,G11)
+            G11 = numpy.sqrt(H11 + VarLambda)
+            G12 = H12 / G11
+            G13 = H13 / G11
             G22 = numpy.sqrt(H22 + VarLambda - G12*G12);                                                              
-            G23 = old_div((H23 - G12*G13),G22);                                             
+            G23 = (H23 - G12*G13) / G22;
             G33 = numpy.sqrt(H33 + VarLambda - G13*G13 - G23*G23);                
                                                                                    
-            D1 = old_div(F1,G11);                                            
-            D2 = old_div((F2 - G12*D1),G22);                                                              
-            D3 = old_div((F3 - G13*D1 - G23*D2),G33);                
+            D1 = F1 / G11
+            D2 = (F2 - G12*D1) / G22
+            D3 = (F3 - G13*D1 - G23*D2) / G33
 
-            dT = old_div(D3,G33);  
-            dF = old_div((D2 - G23*dT),G22) 
-            dA = old_div((D1 - G12*dF - G13*dT),G11) 
+            dT = D3 / G33
+            dF = (D2 - G23*dT) / G22
+            dA = (D1 - G12*dF - G13*dT) / G11
                                                                                    
 #            updating the parameters
                                                                                             
@@ -223,12 +221,12 @@ def LMA(XY,ParIni):
                 H = numpy.sqrt(1+4*Aold*Fold);                               
                 aTemp = -H*numpy.cos(Told)/(Aold+Aold) + dX;                                     
                 bTemp = -H*numpy.sin(Told)/(Aold+Aold) + dY;                                      
-                rTemp = old_div(1,abs(Aold+Aold));                                       
+                rTemp = 1 / abs(Aold+Aold)
                                                                              
-                Anew = old_div(1,(rTemp + rTemp));                         
+                Anew = 1 / (rTemp + rTemp)
                 aabb = aTemp*aTemp + bTemp*bTemp;                          
                 Fnew = (aabb - rTemp*rTemp)*Anew;                             
-                Tnew = numpy.arccos(old_div(-aTemp,numpy.sqrt(aabb)));                                       
+                Tnew = numpy.arccos(-aTemp / numpy.sqrt(aabb))
                 if bTemp > 0:
                     Tnew = 2*numpy.pi - Tnew;           
                 VarNew = VarOld;                                         
@@ -259,15 +257,15 @@ def LMA(XY,ParIni):
                 Gi = 2*ADF/DEN; 
                 GG = GG + Gi*Gi;
                                    
-            VarNew = old_div(GG,(n-3));    
+            VarNew = GG / (n-3)
          
             H = numpy.sqrt(1+4*Anew*Fnew);               
             anew = -H*numpy.cos(Tnew)/(Anew+Anew) - Xshift;  
             bnew = -H*numpy.sin(Tnew)/(Anew+Anew) - Yshift;  
-            Rnew = old_div(1,abs(Anew+Anew)); 
+            Rnew = 1 / abs(Anew+Anew)
 
             if VarNew <= VarOld: 
-                progress = old_div((abs(anew-aold) + abs(bnew-bold) + abs(Rnew-Rold)),(Rnew+Rold));      
+                progress = (abs(anew-aold) + abs(bnew-bold) + abs(Rnew-Rold)) / (Rnew+Rold)
                 if progress < epsilon: 
                     Aold = Anew;          
                     Fold = Fnew;      
@@ -288,7 +286,7 @@ def LMA(XY,ParIni):
     H = numpy.sqrt(1+4*Aold*Fold);                                                                                        
     result_a = -H*numpy.cos(Told)/(Aold+Aold) - Xshift;                                                      
     result_b = -H*numpy.sin(Told)/(Aold+Aold) - Yshift;                                                 
-    result_r = old_div(1,abs(Aold+Aold));       
+    result_r = 1 / abs(Aold+Aold)
 
     return result_a, result_b, result_r
 

{pmagpy-cli-4.2.120 → pmagpy-cli-4.3.8}/SPD/lib/lib_directional_statistics.py

@@ -1,9 +1,6 @@
 #! /usr/bin/env python
 
-from __future__ import division
-from __future__ import print_function
 from builtins import range
-from past.utils import old_div
 import numpy
 import math
 
@@ -57,7 +54,7 @@ def tauV(T):
         tr += tau  # tr totals tau values
     if tr != 0:
         for i in range(3):
-            evalues[i]=old_div(evalues[i], tr)  # convention is norming eigenvalues so they sum to 1.
+            evalues[i] = evalues[i] / tr  # convention is norming eigenvalues so they sum to 1.
     else:
         return t,V  # if eigenvalues add up to zero, no sorting is needed
 # sort evalues,evectors      
@@ -93,7 +90,7 @@ def get_PD_direction(X1_prime, X2_prime, X3_prime, PD):
         dot = -1
     elif dot > 1:
         dot = 1
-    if numpy.arccos(dot) > old_div(numpy.pi, 2.):
+    if numpy.arccos(dot) > numpy.pi / 2.:
         #print 'numpy.arccos(dot) {} > numpy.pi / 2. {}'.format(numpy.arccos(dot), numpy.pi / 2)
         #print 'correcting PD direction'
         PD = -1. * numpy.array(PD)
@@ -105,15 +102,15 @@ def cart2dir(cart):
     converts a direction to cartesian coordinates
     """
     cart=numpy.array(cart)
-    rad=old_div(numpy.pi,180.) # constant to convert degrees to radians
+    rad = numpy.pi / 180. # constant to convert degrees to radians
     if len(cart.shape)>1:
         Xs,Ys,Zs=cart[:,0],cart[:,1],cart[:,2]
     else: #single vector
         Xs,Ys,Zs=cart[0],cart[1],cart[2]
     Rs=numpy.sqrt(Xs**2 + Ys**2 + Zs**2) # calculate resultant vector length                 
     try:
-        Decs=(old_div(numpy.arctan2(Ys,Xs),rad))%360. # calculate declination taking care of correct quadrants (arctan2) and making modulo 360.
-        Incs=old_div(numpy.arcsin(old_div(Zs,Rs)),rad) # calculate inclination (converting to degrees) #                             
+        Decs=(numpy.arctan2(Ys,Xs) / rad)%360. # calculate declination taking care of correct quadrants (arctan2) and making modulo 360.
+        Incs = numpy.arcsin(Zs / Rs) / rad # calculate inclination (converting to degrees) #
     except:
         print('trouble in cart2dir') # most likely division by zero somewhere
         return numpy.zeros(3)
@@ -146,14 +143,14 @@ def get_MAD(tau):
     for t in tau:
         if isinstance(t, complex):
             return -999
-    MAD = math.degrees(numpy.arctan(numpy.sqrt(old_div((tau[1] + tau[2]), tau[0]))) )
+    MAD = math.degrees(numpy.arctan(numpy.sqrt((tau[1] + tau[2]) / tau[0])))
     return MAD
 
 def dir2cart(d): # from pmag.py
     """converts list or array of vector directions, in degrees, to array of cartesian coordinates, in x,y,z form """
     ints = numpy.ones(len(d)).transpose() # get an array of ones to plug into dec,inc pairs             
     d = numpy.array(d)
-    rad = old_div(numpy.pi, 180.)
+    rad = numpy.pi / 180.
     if len(d.shape) > 1: # array of vectors                                                         
         decs, incs = d[:,0] * rad, d[:,1] * rad
         if d.shape[1] == 3: ints = d[:,2] # take the given lengths                  
@@ -202,7 +199,7 @@ def get_angle_difference(v1, v2):
     """returns angular difference in degrees between two vectors.  takes in cartesian coordinates."""
     v1 = numpy.array(v1)
     v2 = numpy.array(v2)
-    angle=numpy.arccos(old_div((numpy.dot(v1, v2) ), (numpy.sqrt(math.fsum(v1**2)) * numpy.sqrt(math.fsum(v2**2)))))    
+    angle=numpy.arccos((numpy.dot(v1, v2)) / (numpy.sqrt(math.fsum(v1**2)) * numpy.sqrt(math.fsum(v2**2))))
     return math.degrees(angle)
 
 def get_alpha(anc_fit, free_fit): 
@@ -215,7 +212,7 @@ def get_DANG(mass_center, free_best_fit_vector):
     return DANG
 
 def get_NRM_dev(dang, x_avg, y_int):
-    NRM_dev = old_div((numpy.sin(numpy.deg2rad(dang)) * numpy.linalg.norm(x_avg)), abs(y_int))
+    NRM_dev = (numpy.sin(numpy.deg2rad(dang)) * numpy.linalg.norm(x_avg)) / abs(y_int)
     NRM_dev *= 100.
     return NRM_dev
 
@@ -237,5 +234,5 @@ def get_ptrms_angle(ptrms_best_fit_vector, B_lab_vector):
     """
     gives angle between principal direction of the ptrm data and the b_lab vector.  this is NOT in SPD, but taken from Ron Shaar's old thellier_gui.py code.  see PmagPy on github
     """
-    ptrms_angle = math.degrees(math.acos(old_div(numpy.dot(ptrms_best_fit_vector,B_lab_vector),(numpy.sqrt(sum(ptrms_best_fit_vector**2)) * numpy.sqrt(sum(B_lab_vector**2))))))  # from old thellier_gui.py code  
+    ptrms_angle = math.degrees(math.acos(numpy.dot(ptrms_best_fit_vector,B_lab_vector) / (numpy.sqrt(sum(ptrms_best_fit_vector**2)) * numpy.sqrt(sum(B_lab_vector**2)))))  # from old thellier_gui.py code
     return ptrms_angle

{pmagpy-cli-4.2.120 → pmagpy-cli-4.3.8}/SPD/lib/lib_leastsquares.py

@@ -1,9 +1,6 @@
 #!/usr/bin/env python
 
-from __future__ import division
-from __future__ import print_function
 from builtins import map
-from past.utils import old_div
 from numpy import *
 from scipy      import optimize
 
@@ -26,9 +23,9 @@ def do_circlefit(x=x, y=y):
 
     # ensure all values are floats, then norm them by largest value
     x = array(list(map(float, x)))
-    x = old_div(x, max(x))
+    x = x / max(x)
     y = array(list(map(float, y)))
-    y = old_div(y, max(y))
+    y = y / max(y)
     
 
     # coordinates of the barycenter
@@ -52,7 +49,7 @@ def do_circlefit(x=x, y=y):
 
     # Solving the linear system
     A = array([ [ Suu, Suv ], [Suv, Svv]])
-    B = old_div(array([ Suuu + Suvv, Svvv + Suuv ]),2.0)
+    B = array([ Suuu + Suvv, Svvv + Suuv ]) / 2.0
     uc, vc = linalg.solve(A, B)
 
     xc_1 = x_m + uc