pmagpy 4.2.122__py3-none-any.whl → 4.2.125__py3-none-any.whl

SPD/lib/lib_ptrm_statistics.py

@@ -1,8 +1,5 @@
 #!/usr/bin/env python
 
-from __future__ import division
-from __future__ import absolute_import
-from past.utils import old_div
 import numpy
 from . import lib_directional_statistics as lib_direct
 
@@ -55,7 +52,7 @@ def get_max_ptrm_check(ptrm_checks_included_temps, ptrm_checks_all_temps, ptrm_x
         if ptrm_orig == 0:
             check_percents.append(0)
         else:
-            check_percents.append((old_div(abs(diff), ptrm_orig)) * 100)
+            check_percents.append((abs(diff) / ptrm_orig) * 100)
     max_diff = max(abs_diffs)
     check_percent = max(check_percents)
     sum_diffs = abs(sum(diffs))
@@ -68,7 +65,7 @@ def get_delta_CK(max_ptrm_check, x_int):
     Input: max_ptrm_check, x intercept.
     Output: delta_CK (max ptrm check normed by x intercept)
     """
-    return abs(old_div(max_ptrm_check, x_int)) * 100.
+    return abs(max_ptrm_check / x_int) * 100.
 
 def get_DRAT(delta_x_prime, delta_y_prime, max_ptrm_check):
     """
@@ -79,7 +76,7 @@ def get_DRAT(delta_x_prime, delta_y_prime, max_ptrm_check):
         length best fit line
     """
     L = numpy.sqrt(delta_x_prime**2 + delta_y_prime**2)
-    DRAT = (old_div(max_ptrm_check, L)) * 100
+    DRAT = (max_ptrm_check / L) * 100
     return DRAT, L
 
 def get_length_best_fit_line(delta_x_prime, delta_y_prime):
@@ -91,7 +88,7 @@ def get_max_DEV(delta_x_prime, max_ptrm_check):
     input: delta_x_prime, max_ptrm_check
     output: max_DEV (maximum ptrm check diff normed by TRM line
     """
-    return (old_div(max_ptrm_check, delta_x_prime)) * 100.
+    return (max_ptrm_check / delta_x_prime) * 100.
 
 def get_CDRAT(L, sum_ptrm_checks, sum_abs_ptrm_checks):
     """
@@ -99,8 +96,8 @@ def get_CDRAT(L, sum_ptrm_checks, sum_abs_ptrm_checks):
         sum of absolute value of ptrm check diffs
     output: CDRAT (uses sum of diffs), CDRAT_prime (uses sum of absolute diffs)
     """
-    CDRAT = (old_div(sum_ptrm_checks, L)) * 100.
-    CDRAT_prime = (old_div(sum_abs_ptrm_checks, L)) * 100.
+    CDRAT = (sum_ptrm_checks / L) * 100.
+    CDRAT_prime = (sum_abs_ptrm_checks / L) * 100.
     return CDRAT, CDRAT_prime
 
 def get_DRATS(sum_ptrm_checks, sum_abs_ptrm_checks, x_Arai, end):
@@ -109,8 +106,8 @@ def get_DRATS(sum_ptrm_checks, sum_abs_ptrm_checks, x_Arai, end):
         x_Arai set of points, end.
     output: DRATS (uses sum of diffs), DRATS_prime (uses sum of absolute diffs)
     """
-    DRATS = (old_div(sum_ptrm_checks, x_Arai[end])) * 100.
-    DRATS_prime = (old_div(sum_abs_ptrm_checks, x_Arai[end])) * 100.
+    DRATS = (sum_ptrm_checks / x_Arai[end]) * 100.
+    DRATS_prime = (sum_abs_ptrm_checks / x_Arai[end]) * 100.
     return DRATS, DRATS_prime
 
 def get_mean_DRAT(sum_ptrm_checks, sum_abs_ptrm_checks, n_pTRM, L):
@@ -121,8 +118,8 @@ def get_mean_DRAT(sum_ptrm_checks, sum_abs_ptrm_checks, n_pTRM, L):
     """
     if not n_pTRM:
         return float('nan'), float('nan')
-    mean_DRAT = ((old_div(1., n_pTRM)) * (old_div(sum_ptrm_checks, L))) * 100
-    mean_DRAT_prime = ((old_div(1., n_pTRM)) * (old_div(sum_abs_ptrm_checks, L))) * 100
+    mean_DRAT = ((1. / n_pTRM) * (sum_ptrm_checks / L)) * 100
+    mean_DRAT_prime = ((1. / n_pTRM) * (sum_abs_ptrm_checks / L)) * 100
     return mean_DRAT, mean_DRAT_prime
 
 def get_mean_DEV(sum_ptrm_checks, sum_abs_ptrm_checks, n_pTRM, delta_x_prime):
@@ -132,8 +129,8 @@ def get_mean_DEV(sum_ptrm_checks, sum_abs_ptrm_checks, n_pTRM, delta_x_prime):
     """
     if not n_pTRM:
         return float('nan'), float('nan')
-    mean_DEV = ((old_div(1., n_pTRM)) * (old_div(sum_ptrm_checks, delta_x_prime))) * 100
-    mean_DEV_prime= ((old_div(1., n_pTRM)) * (old_div(sum_abs_ptrm_checks, delta_x_prime))) * 100
+    mean_DEV = ((1. / n_pTRM) * (sum_ptrm_checks / delta_x_prime)) * 100
+    mean_DEV_prime= ((1. / n_pTRM) * (sum_abs_ptrm_checks / delta_x_prime)) * 100
     return mean_DEV, mean_DEV_prime
 
 def get_delta_pal_vectors(PTRMS, PTRM_Checks, NRM):
@@ -144,12 +141,10 @@ def get_delta_pal_vectors(PTRMS, PTRM_Checks, NRM):
     PTRMS_cart = []
     Checks_cart = []
     for num, ptrm in enumerate(PTRMS):
-        #ptrm_cart = lib_direct.dir2cart([PTRMS[num][1], PTRMS[num][2], old_div(PTRMS[num][3], NRM)])
         ptrm_cart = lib_direct.dir2cart([PTRMS[num][1], PTRMS[num][2], PTRMS[num][3]/NRM])
         PTRMS_cart.append(ptrm_cart)
     for num, check in enumerate(PTRM_Checks):
-        #check_cart = lib_direct.dir2cart([PTRM_Checks[num][1], PTRM_Checks[num][2], old_div(PTRM_Checks[num][3], NRM)])
-        check_cart = lib_direct.dir2cart([float(PTRM_Checks[num][1]), float(PTRM_Checks[num][2]), float(PTRM_Checks[num][3])/ NRM])
+        check_cart = lib_direct.dir2cart([float(PTRM_Checks[num][1]), float(PTRM_Checks[num][2]), float(PTRM_Checks[num][3]) / NRM])
         Checks_cart.append(check_cart)
     return PTRMS_cart, Checks_cart, TRM_1
 
@@ -206,7 +201,7 @@ def get_b_star(x_star, y_err, y_mean, y_segment):
     #print x_star
     x_star_mean = numpy.mean(x_star)
     x_err = x_star - x_star_mean
-    b_star = -1* numpy.sqrt( old_div(sum(numpy.array(y_err)**2), sum(numpy.array(x_err)**2)) )  # averaged slope
+    b_star = -1* numpy.sqrt(sum(numpy.array(y_err)**2) / sum(numpy.array(x_err)**2))  # averaged slope
     #print "y_segment", y_segment
     b_star = numpy.sign(sum(x_err * y_err)) * numpy.std(y_segment, ddof=1) / numpy.std(x_star, ddof=1)
     #print "b_star (should be same as corr_slope)"
@@ -219,7 +214,7 @@ def get_delta_pal(b, b_star):
     input: b, b_star (actual and corrected slope)
     output: delta_pal
     """
-    delta_pal = numpy.abs(old_div((b - b_star), b)) * 100
+    delta_pal = numpy.abs((b - b_star) / b) * 100
     return delta_pal
 
 # check delta pal

SPD/lib/lib_tail_check_statistics.py

@@ -1,6 +1,4 @@
 #!/usr/bin/env python
-from __future__ import division
-from past.utils import old_div
 import numpy
 
 # int_ptrm_tail_n
@@ -51,7 +49,7 @@ def get_DRAT_tail(max_check, L):
     """
     if max_check == 0:
         return float('nan')
-    DRAT_tail = (old_div(max_check, L)) * 100.
+    DRAT_tail = (max_check / L) * 100.
     return DRAT_tail
 
 # dtr
@@ -62,7 +60,7 @@ def get_delta_TR(tail_check_max, y_int):
     """
     if tail_check_max == 0 or numpy.isnan(tail_check_max):
         return float('nan')
-    delta_TR = (old_div(tail_check_max, abs(y_int))) * 100.
+    delta_TR = (tail_check_max / abs(y_int)) * 100.
     return delta_TR
 
 # md
@@ -73,5 +71,5 @@ def get_MD_VDS(tail_check_max, vds):
     """
     if tail_check_max == 0 or numpy.isnan(tail_check_max):
         return float('nan')
-    MD_VDS = (old_div(tail_check_max, vds)) * 100
+    MD_VDS = (tail_check_max / vds) * 100
     return MD_VDS

SPD/lib/new_lib_curvature.py

@@ -1,10 +1,6 @@
 #!/usr/bin/env python
 
-from __future__ import division
-from __future__ import print_function
-from __future__ import absolute_import
 from builtins import range
-from past.utils import old_div
 import numpy
 from . import lib_curvature as lib_k
 
@@ -56,19 +52,19 @@ c IEEE Transactions on Instrumentation and Measurement."""
     E = 0.5 * (n * syx2 - sy * sx2 + n * sy3 - sy * sy2)
     # values check out up to here
 
-    xo = old_div((D * C - B * E), (A * C - B**2))
-    yo = old_div((A * E - B * D), (A * C - B**2))
+    xo = (D * C - B * E) / (A * C - B**2)
+    yo = (A * E - B * D) / (A * C - B**2)
     print("xo", xo)
     print("yo", yo)
 
     r = 0
     for z in range(n):
-        r = r + old_div(numpy.sqrt( (x[z]-xo)**2 + (y[z]-yo)**2 ), n)
+        r = r + numpy.sqrt( (x[z]-xo)**2 + (y[z]-yo)**2 ) / n
 
     if xo <= numpy.mean(x) and yo <= numpy.mean(y):
-        k = old_div(-1.,r)
+        k = -1. / r
     else:
-        k = old_div(1.,r)
+        k = 1. / r
 
     SSE = lib_k.get_SSE(xo, yo, r, x, y)
     print("r", r)

SPD/new_lj_thellier_gui_spd.py

@@ -1,11 +1,7 @@
-from __future__ import division
-from __future__ import print_function
-from __future__ import absolute_import
 #============================================================================================
 from builtins import input
 from builtins import range
 from builtins import object
-from past.utils import old_div
 global CURRENT_VRSION
 CURRENT_VRSION = "v.2.03"
 #import matplotlib
@@ -428,17 +424,17 @@ class Arai_GUI(object):
           # > 5% : WARNING
           # > 10%: ERROR
 
-          slopes=old_div(M_NLT,B_NLT) #  B = B_anc / B_lab ??
+          slopes = M_NLT / B_NLT #  B = B_anc / B_lab ??
 
           if len(trmblock)==2:
-              if old_div(max(slopes),min(slopes))<1.05:
+              if max(slopes) / min(slopes) < 1.05:
                   print("-I- 2 NLT measurement for specimen %s. [max(M/B)/ [min(M/B)] < 1.05.\n"%s)
-              elif old_div(max(slopes),min(slopes))<1.1:
-                  print("-W- WARNING: 2 NLT measurement for specimen %s. [max(M/B)]/ [min(M/B)] is %.2f  (   > 1.05 and  < 1.1 ). More NLT mrasurements may be required.\n" %(s,old_div(max(slopes),min(slopes))))
-                  #print("-I- NLT meaurements specime %s: B,M="%s,B_NLT,M_NLT)
+              elif max(slopes) / min(slopes) < 1.1:
+                  print("-W- WARNING: 2 NLT measurement for specimen %s. [max(M/B)]/ [min(M/B)] is %.2f  (   > 1.05 and  < 1.1 ). More NLT measurements may be required.\n" %(s, (max(slopes) / min(slopes))))
+                  #print("-I- NLT measurements specimen %s: B,M="%s,B_NLT,M_NLT)
               else:
-                  print("-E- ERROR: 2 NLT measurement for specimen %s. [max(M/B)]/ [min(M/B)] is %.2f  ( > 1.1 ). More NLT mrasurements may be required  !\n" %(s,old_div(max(slopes),min(slopes))))
-                  #print("-I- NLT meaurements specime %s: B,M="%s,B_NLT,M_NLT)
+                  print("-E- ERROR: 2 NLT measurement for specimen %s. [max(M/B)]/ [min(M/B)] is %.2f  ( > 1.1 ). More NLT measurements may be required  !\n" %(s, (max(slopes) / min(slopes))))
+                  #print("-I- NLT measurements specimen %s: B,M="%s,B_NLT,M_NLT)
 
           # NLT procedure following Shaar et al (2010)
 
@@ -457,8 +453,8 @@ class Arai_GUI(object):
                   M_lab=popt[0]*math.tanh(labfield*popt[1])
 
                   # Now  fit tanh function to the normalized curve
-                  M_NLT_norm=old_div(M_NLT,M_lab)
-                  popt, pcov = curve_fit(tan_h, B_NLT, M_NLT_norm,p0=(old_div(popt[0],M_lab),popt[1]))
+                  M_NLT_norm = M_NLT / M_lab
+                  popt, pcov = curve_fit(tan_h, B_NLT, M_NLT_norm, p0 = ((popt[0] / M_lab), popt[1]))
                   Data[s]['NLT_parameters']={}
                   Data[s]['NLT_parameters']['tanh_parameters']=(popt, pcov)
                   Data[s]['NLT_parameters']['B_NLT']=B_NLT
@@ -474,13 +470,13 @@ class Arai_GUI(object):
                   # The maximum difference allowd is 5%
                   # if difference is larger than 5%: WARNING
 
-                  if old_div(max(slopes),min(slopes))<1.05:
+                  if max(slopes) / min(slopes) < 1.05:
                       print("-I- 2 NLT measurement for specimen %s. [max(M/B)/ [min(M/B)] < 1.05.\n"%s)
-                  elif old_div(max(slopes),min(slopes))<1.1:
-                      print("-W- WARNING: 2 NLT measurement for specimen %s. [max(M/B)]/ [min(M/B)] is %.2f  (   > 1.05 and  < 1.1 ). More NLT mrasurements may be required.\n" %(s,old_div(max(slopes),min(slopes))))
+                  elif max(slopes) / min(slopes) < 1.1:
+                      print("-W- WARNING: 2 NLT measurement for specimen %s. [max(M/B)]/ [min(M/B)] is %.2f  (   > 1.05 and  < 1.1 ). More NLT mrasurements may be required.\n" %(s, max(slopes) / min(slopes)))
                       #print "-I- NLT meaurements specime %s: B,M="%s,B_NLT,M_NLT
                   else:
-                      print("-E- ERROR: 2 NLT measurement for specimen %s. [max(M/B)]/ [min(M/B)] is %.2f  ( > 1.1 ). More NLT mrasurements may be required  !\n" %(s,old_div(max(slopes),min(slopes))))
+                      print("-E- ERROR: 2 NLT measurement for specimen %s. [max(M/B)]/ [min(M/B)] is %.2f  ( > 1.1 ). More NLT mrasurements may be required  !\n" %(s, max(slopes) / min(slopes)))
                       #print "-I- NLT meaurements specime %s: B,M="%s,B_NLT,M_NLT
 
       #print "done searching NLT data"
@@ -515,7 +511,7 @@ class Arai_GUI(object):
 ##                  continue
               try:
                   ancient_cooling_rate=float(self.Data_info["er_samples"][sample]['sample_cooling_rate'])
-                  ancient_cooling_rate=old_div(ancient_cooling_rate,(1e6*365*24*60)) # change to K/minute
+                  ancient_cooling_rate = ancient_cooling_rate / (1e6*365*24*60) # change to K/minute
               except:
                   print("-W- Cant find ancient cooling rate estimation for sample %s"%sample)
                   continue
@@ -550,20 +546,20 @@ class Arai_GUI(object):
               lab_fast_cr_moments=[]
               lan_cooling_rates=[]
               for pair in cooling_rate_data['pairs']:
-                    lan_cooling_rates.append(math.log(old_div(cooling_rate_data['lab_cooling_rate'],pair[0])))
+                    lan_cooling_rates.append(math.log(cooling_rate_data['lab_cooling_rate'] / pair[0]))
                     moments.append(pair[1])
                     if pair[0]==cooling_rate_data['lab_cooling_rate']:
                         lab_fast_cr_moments.append(pair[1])
               #print s, cooling_rate_data['alteration_check']
-              lan_cooling_rates.append(math.log(old_div(cooling_rate_data['lab_cooling_rate'],cooling_rate_data['alteration_check'][0])))
+              lan_cooling_rates.append(math.log(cooling_rate_data['lab_cooling_rate'] / cooling_rate_data['alteration_check'][0]))
               lab_fast_cr_moments.append(cooling_rate_data['alteration_check'][1])
               moments.append(cooling_rate_data['alteration_check'][1])
 
               lab_fast_cr_moment=numpy.mean(lab_fast_cr_moments)
-              moment_norm=old_div(numpy.array(moments),lab_fast_cr_moment)
+              moment_norm = numpy.array(moments) / lab_fast_cr_moment
               (a,b)=numpy.polyfit(lan_cooling_rates, moment_norm, 1)
               #ancient_cooling_rate=0.41
-              x0=math.log(old_div(lab_cooling_rate,ancient_cooling_rate))
+              x0=math.log(lab_cooling_rate / ancient_cooling_rate)
               y0=a*x0+b
               MAX=max(lab_fast_cr_moments)
               MIN=min(lab_fast_cr_moments)
@@ -580,7 +576,7 @@ class Arai_GUI(object):
               #print(MAX-MIN)
               #print(numpy.mean(MAX, MIN))
               try:
-                  alteration_check_perc=100*abs(old_div((MAX-MIN),numpy.mean(MAX,MIN)))
+                  alteration_check_perc=100*abs((MAX-MIN) / numpy.mean(MAX,MIN))
               except TypeError:
                   alteration_check_perc = 0
               #print s,alteration_check_perc
@@ -600,7 +596,7 @@ class Arai_GUI(object):
                   cooling_rate_data['CR_correction_factor']=-999
               if y0>1 and alteration_check_perc<=5:
                   cooling_rate_data['CR_correction_factor_flag']="calculated"
-                  cooling_rate_data['CR_correction_factor']=old_div(1,(y0))
+                  cooling_rate_data['CR_correction_factor'] = 1 / (y0)
 
               Data[s]['cooling_rate_data']= cooling_rate_data
               # at present not generated for my particular specimens
@@ -691,7 +687,7 @@ class Arai_GUI(object):
         NRM=zijdblock[0][3]  ## NRM before anything has been done to the sample
 
         for k in range(len(zijdblock)):
-            DIR=[zijdblock[k][1],zijdblock[k][2],old_div(zijdblock[k][3],NRM)]
+            DIR=[zijdblock[k][1],zijdblock[k][2], zijdblock[k][3] / NRM]
             cart=self.dir2cart(DIR)
             zdata.append(numpy.array([cart[0],cart[1],cart[2]]))
             if k>0:
@@ -747,8 +743,8 @@ class Arai_GUI(object):
 
         for k in range(len(zerofields)):
           index_infield=infield_temperatures.index(zerofields[k][0])
-          x_Arai.append(old_div(infields[index_infield][3],NRM))   #  from infields point: x = magnetic strength / NRM
-          y_Arai.append(old_div(zerofields[k][3],NRM))  # from corresponding zerofield point: y = magnetic strength / NRM
+          x_Arai.append(infields[index_infield][3] / NRM)   #  from infields point: x = magnetic strength / NRM
+          y_Arai.append(zerofields[k][3] / NRM)  # from corresponding zerofield point: y = magnetic strength / NRM
           t_Arai.append(zerofields[k][0])  # temperature.  .
           if zerofields[k][4]==1:
             steps_Arai.append('ZI')
@@ -788,8 +784,8 @@ class Arai_GUI(object):
                         ptrm_checks_starting_temperatures.append(starting_temperature)
 
                         index_zerofield=zerofield_temperatures.index(ptrm_checks[k][0])
-                        x_ptrm_check.append(old_div(ptrm_checks[k][3],NRM))
-                        y_ptrm_check.append(old_div(zerofields[index_zerofield][3],NRM))
+                        x_ptrm_check.append(ptrm_checks[k][3] / NRM)
+                        y_ptrm_check.append(zerofields[index_zerofield][3] / NRM)
                         ptrm_checks_temperatures.append(ptrm_checks[k][0])
                     except:
                         pass
@@ -805,8 +801,8 @@ class Arai_GUI(object):
                         ptrm_checks_starting_temperatures.append(starting_temperature)
 
                         index_zerofield=zerofield_temperatures.index(ptrm_checks[k][0])
-                        x_ptrm_check.append(old_div(ptrm_checks[k][3],NRM))
-                        y_ptrm_check.append(old_div(zerofields[index_zerofield][3],NRM))
+                        x_ptrm_check.append(ptrm_checks[k][3] / NRM)
+                        y_ptrm_check.append(zerofields[index_zerofield][3] / NRM)
                         ptrm_checks_temperatures.append(ptrm_checks[k][0])
                     except:
                         pass
@@ -854,8 +850,8 @@ class Arai_GUI(object):
                         tail_checks_starting_temperatures.append(starting_temperature)
 
                         index_infield=infield_temperatures.index(ptrm_tail[k][0])
-                        x_tail_check.append(old_div(infields[index_infield][3],NRM))
-                        y_tail_check.append(old_div(ptrm_tail[k][3],NRM) + old_div(zerofields[index_infield][3],NRM))
+                        x_tail_check.append(infields[index_infield][3] / NRM)
+                        y_tail_check.append((ptrm_tail[k][3] / NRM) + (zerofields[index_infield][3] / NRM))
                         tail_check_temperatures.append(ptrm_tail[k][0])
 
                         break
@@ -925,11 +921,11 @@ class Arai_GUI(object):
                     AC_starting_temperatures.append(starting_temperature)
 
                     index_zerofield=zerofield_temperatures.index(additivity_checks[k][0])
-                    x_AC.append(old_div(additivity_checks[k][3],NRM))
-                    y_AC.append(old_div(zerofields[index_zerofield][3],NRM))
+                    x_AC.append(additivity_checks[k][3] / NRM)
+                    y_AC.append(zerofields[index_zerofield][3] / NRM)
                     AC_temperatures.append(additivity_checks[k][0])
                     index_pTRMs=t_Arai.index(additivity_checks[k][0])
-                    AC.append(old_div(additivity_checks[k][3],NRM) - x_Arai[index_pTRMs])
+                    AC.append((additivity_checks[k][3] / NRM) - x_Arai[index_pTRMs])
                     # above is not using pTRM_star, but x_add_check -  pTRM(Ti)
                     #lj
                     # this is the intensity from the additivity checks araiblock normed by the initial nrm, - the equivalent ptrm value from the previous infield step (I think).  x_Arai is also taken directly from direction (intensity)
@@ -1063,15 +1059,15 @@ class Arai_GUI(object):
         """
 #        print "calling cart2dir(), not in anything"
         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
-        Decs=(old_div(numpy.arctan2(Ys,Xs),rad))%360. # calculate declination taking care of correct quadrants (arctan2) and making modulo 360.
+        Decs = (numpy.arctan2(Ys,Xs) / rad)%360. # calculate declination taking care of correct quadrants (arctan2) and making modulo 360.
         try:
-            Incs=old_div(numpy.arcsin(old_div(Zs,Rs)),rad) # calculate inclination (converting to degrees) #
+            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)
@@ -1084,7 +1080,7 @@ class Arai_GUI(object):
        # converts list or array of vector directions, in degrees, to array of cartesian coordinates, in x,y,z
         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
@@ -1346,8 +1342,8 @@ class Arai_GUI(object):
                     if Treat_I[i] == Treat_I[i-2] and dec2!=dec_initial and inc2!=inc_initial:
                         continue
                     if dec1!=dec2 and inc1!=inc2:
-                        zerofield=old_div((cart2+cart1),2)
-                        infield=old_div((cart2-cart1),2)
+                        zerofield = (cart2+cart1) / 2
+                        infield = (cart2-cart1) / 2
 
                         DIR_zerofield=self.cart2dir(zerofield)
                         DIR_infield=self.cart2dir(infield)

SPD/spd.py

@@ -15,11 +15,7 @@
 #
 #============================================================================================
 
-from __future__ import division
-from __future__ import print_function
-from __future__ import absolute_import
 from builtins import object
-from past.utils import old_div
 import sys
 import numpy
 import os
@@ -443,7 +439,7 @@ class PintPars(object):
     def get_gamma(self):
         B_lab_dir = [self.B_lab_dir[0], self.B_lab_dir[1], 1.]
         ind = self.t_Arai.index(self.tmax)
-        ptrm_dir = [self.PTRMS[ind][1], self.PTRMS[ind][2], old_div(self.PTRMS[ind][3], self.specimen_Data['NRM'])]
+        ptrm_dir = [self.PTRMS[ind][1], self.PTRMS[ind][2], self.PTRMS[ind][3] / self.specimen_Data['NRM']]
         ptrm_cart = lib_direct.dir2cart(ptrm_dir)
         gamma = lib_direct.get_gamma(B_lab_dir, ptrm_dir)
         self.pars['ptrm_dir'] = ptrm_dir

SPD/test_instance.py

@@ -1,7 +1,5 @@
 #!/usr/bin/env python
 
-from __future__ import print_function
-from __future__ import absolute_import
 import os
 from . import spd
 # K temps: [0.0, 100.0, 150.0, 200.0, 225.0, 250.0, 275.0, 300.0, 325.0, 350.0, 375.0, 400.0, 425.0, 450.0, 475.0, 500.0, 525.0, 550.0]

SPD/tests/__init__.py

@@ -6,7 +6,6 @@
 #  Author: Lori Jonestrask (mintblue87@gmail.com) .
 
 
-from __future__ import absolute_import
 __all__ = ['test_arai_plot_statistics', 'test_curvature', 'test_directional_statistics', 'test_ptrm_statistics', 'test_tail_check_statistics', 'test_additivity_check_statistics']
 
 from . import test_arai_plot_statistics

SPD/tests/test_additivity_check_statistics.py

@@ -1,7 +1,5 @@
 #!/usr/bin/env python
 
-from __future__ import division
-from past.utils import old_div
 import unittest
 #import sys
 #sys.path.append('/Users/nebula/Python')
@@ -36,7 +34,7 @@ class CheckAdditivity(unittest.TestCase):
 
     add_checks = [0, .2, .1, .6]
     x_int = 2.
-    ref_delta_AC = (old_div(.2, 2)) * 100.
+    ref_delta_AC = (.2 / 2) * 100.
 
     # think I additionally need the check diffs.  what I have is just x check values.
     # I believe it will be: pTRM of start temperature - pTRM of additivity check step.  then I can compare those values.  

SPD/tests/test_arai_plot_statistics.py

@@ -1,8 +1,5 @@
 #!/usr/bin/env python
 
-from __future__ import division
-from __future__ import absolute_import
-from past.utils import old_div
 import unittest
 import numpy
 import copy
@@ -277,8 +274,8 @@ class CheckR_corr2(unittest.TestCase):
     obj = copy.deepcopy(example)
     R_corr2 = obj.get_R_corr2()
     x_segment, y_segment = numpy.array([1., 5., 9.]), numpy.array([0., 2., 7.])
-    x_avg = old_div(sum(x_segment), len(x_segment))
-    y_avg = old_div(sum(y_segment), len(y_segment))
+    x_avg = sum(x_segment) / len(x_segment)
+    y_avg = sum(y_segment) / len(y_segment)
     ref_numerator = 28.**2
     ref_denominator = 32. * 26.
 
@@ -289,7 +286,7 @@ class CheckR_corr2(unittest.TestCase):
     def testSimpleInput(self):
         """should produce expected output with simple input"""
         r = lib_arai.get_R_corr2(self.x_avg, self.y_avg, self.x_segment, self.y_segment)
-        self.assertEqual((old_div(self.ref_numerator,self.ref_denominator)), r)
+        self.assertEqual((self.ref_numerator / self.ref_denominator), r)
 
 #    def testDivideByZero(self):
 #        """should raise ValueError when attempting to divide by zero"""
@@ -303,7 +300,7 @@ class CheckR_det2(unittest.TestCase): # acceptable working test
 
     def test_simple_input(self):
         result = lib_arai.get_R_det2(self.y_segment, self.y_avg, self.y_prime)
-        self.assertEqual((1 - old_div(.25,2.25)), result)
+        self.assertEqual((1 - .25 / 2.25), result)
 
 
 class CheckZigzag(unittest.TestCase):
@@ -312,7 +309,7 @@ class CheckZigzag(unittest.TestCase):
     y_int = 3.
     x_int = 5.
     n = len(x)
-    reference_b_wiggle = [0, .25, old_div(3.,5.)]
+    reference_b_wiggle = [0, .25, 3. / 5.]
 
     slope = 1.2
     Z = 1.3599999999999999

SPD/tests/test_directional_statistics.py

@@ -1,7 +1,5 @@
 #! /usr/bin/env python
 
-from __future__ import division
-from past.utils import old_div
 import unittest
 import numpy
 import copy
@@ -118,7 +116,7 @@ class CheckAlpha(unittest.TestCase):
 
     d1 = [-1., 2.]
     d2 = [3., 4.]
-    ref_alpha = numpy.arccos(old_div(5., (numpy.sqrt(5) * 5))) # 1.1071487177940904
+    ref_alpha = numpy.arccos(5. / (numpy.sqrt(5) * 5)) # 1.1071487177940904
     ref_alpha_degrees = math.degrees(ref_alpha)
 
     ref_real_alpha = 2.074709711008407
@@ -139,7 +137,7 @@ class CheckDang(unittest.TestCase):
     dot_product =7.5 # .5 + (-6.) + 15.
     mag1 = numpy.sqrt(14.)#(1 + 4 + 9)
     mag2 = numpy.sqrt(41.25)#(.25 + 16 + 25)
-    ref_Dang = math.degrees(numpy.arccos(old_div(7.5, (mag1 * mag2))))
+    ref_Dang = math.degrees(numpy.arccos(7.5 / (mag1 * mag2)))
 
     ref_real_DANG = 2.08192544535
    

SPD/tests/test_ptrm_statistics.py

@@ -2,9 +2,6 @@
 
 
 
-from __future__ import division
-from __future__ import print_function
-from past.utils import old_div
 import numpy
 import unittest
 #import sys
@@ -36,7 +33,7 @@ class CheckpTRMparams(unittest.TestCase):
     #    0., -.5,  -2.5, 2.
     ref_max_ptrm_check = 2.5
     ref_sum_ptrm_check = abs(-1.)
-    ref_check_percent = (old_div(2.5, 5.5)) * 100.
+    ref_check_percent = (2.5 / 5.5) * 100.
     ref_sum_abs_ptrm_check = 5.
 
     x_int = 8.5
@@ -71,26 +68,26 @@ class CheckpTRMparams(unittest.TestCase):
 
         
     def test_DRAT(self):
-        ref_DRAT = (old_div(self.ref_max_ptrm_check, self.ref_L)) * 100.
+        ref_DRAT = (self.ref_max_ptrm_check / self.ref_L) * 100.
         DRAT, L = lib_ptrm.get_DRAT(self.delta_y_prime, self.delta_x_prime, self.ref_max_ptrm_check)
         self.assertAlmostEqual(ref_DRAT, DRAT)
         self.assertAlmostEqual(self.ref_L, L)
 
     def test_max_DEV(self):
         result = lib_ptrm.get_max_DEV(self.delta_x_prime, self.ref_max_ptrm_check)
-        ref_max_DEV = (old_div(2.5, 8.)) * 100
+        ref_max_DEV = (2.5 / 8.) * 100
         self.assertAlmostEqual(ref_max_DEV, result)
         
     def test_CDRAT(self):
         CDRAT, CDRAT_prime = lib_ptrm.get_CDRAT(self.ref_L, self.ref_sum_ptrm_check, self.ref_sum_abs_ptrm_check)
-        ref_CDRAT, ref_CDRAT_prime = (old_div(1., self.ref_L)) * 100., (old_div(5., self.ref_L)) * 100
+        ref_CDRAT, ref_CDRAT_prime = (1. / self.ref_L) * 100., (5. / self.ref_L) * 100
         self.assertAlmostEqual(ref_CDRAT, CDRAT)
         self.assertAlmostEqual(ref_CDRAT_prime, CDRAT_prime)
         
     def test_DRATS(self):
         #ref_DRATS = .9
-        ref_DRATS = (old_div(1., 7.)) * 100.
-        ref_DRATS_prime = (old_div(5., 7.)) * 100.
+        ref_DRATS = (1. / 7.) * 100.
+        ref_DRATS_prime = (5. / 7.) * 100.
         end = 4
         DRATS, DRATS_prime = lib_ptrm.get_DRATS(self.ref_sum_ptrm_check, self.ref_sum_abs_ptrm_check, self.x_Arai, end)
         self.assertAlmostEqual(ref_DRATS, DRATS)
@@ -115,8 +112,8 @@ class CheckpTRMparams(unittest.TestCase):
         self.assertAlmostEqual(ref_mean_DRAT_prime, mean_DRAT_prime)
 
     def test_mean_DEV(self):
-        ref_mean_DEV = (old_div(1., 4.)) * ( old_div(1., 8.))  * 100
-        ref_mean_DEV_prime = (old_div(1., 4.)) * (old_div(5., 8.))  * 100
+        ref_mean_DEV = (1. / 4.) * (1. / 8.)  * 100
+        ref_mean_DEV_prime = (1. / 4.) * (5. / 8.)  * 100
         mean_DEV, mean_DEV_prime = lib_ptrm.get_mean_DEV(self.ref_sum_ptrm_check, self.ref_sum_abs_ptrm_check, self.ref_n, self.delta_x_prime)
         self.assertAlmostEqual(ref_mean_DEV, mean_DEV)
         self.assertAlmostEqual(ref_mean_DEV_prime, mean_DEV_prime)

SPD/tests/test_tail_check_statistics.py

@@ -1,7 +1,5 @@
 #!/usr/bin/env python                                                                                            
 
-from __future__ import division
-from past.utils import old_div
 import numpy
 import unittest
 import copy
@@ -51,19 +49,19 @@ class CheckTailSelection(unittest.TestCase):
         self.assertAlmostEqual(self.ref_tail_check_max, tail_check_max)
 
     def test_DRAT_tail(self):
-        ref_DRAT_tail = (old_div(.7, 3.)) * 100
+        ref_DRAT_tail = (.7 / 3.) * 100
         DRAT_tail = lib_tail.get_DRAT_tail(self.ref_tail_check_max, self.ref_L)
         self.assertAlmostEqual(ref_DRAT_tail, DRAT_tail)
         # max_tail_check / best_fit line  * 100
         
     def test_delta_TR(self):
-        ref_delta_TR = (old_div(.7, 4.5)) * 100.
+        ref_delta_TR = (.7 / 4.5) * 100.
         delta_TR = lib_tail.get_delta_TR(self.ref_tail_check_max, self.y_int)
         self.assertAlmostEqual(ref_delta_TR, delta_TR)
         
 
     def test_MD_VDS(self):
-        ref_MD_VDS = (old_div(self.ref_tail_check_max, self.vds)) * 100.
+        ref_MD_VDS = (self.ref_tail_check_max / self.vds) * 100.
         MD_VDS = lib_tail.get_MD_VDS(self.ref_tail_check_max, self.vds)
         self.assertAlmostEqual(ref_MD_VDS, MD_VDS)
         

dialogs/demag_interpretation_editor.py

@@ -211,8 +211,8 @@ class InterpretationEditorFrame(wx.Frame):
         self.display_sizer.Add(display_window_0, 1, wx.TOP | wx.EXPAND, 8)
         self.display_sizer.Add(display_window_1, 1, wx.TOP | wx.LEFT| wx.EXPAND, 8)
         self.display_sizer.Add(display_window_2, 1, wx.TOP | wx.LEFT| wx.EXPAND, 8)
-        self.name_sizer.Add(name_window, 1, wx.TOP, 5.5)
-        self.bounds_sizer.Add(bounds_window, 1, wx.TOP, 5.5)
+        self.name_sizer.Add(name_window, 1, wx.TOP, 5)
+        self.bounds_sizer.Add(bounds_window, 1, wx.TOP, 5)
         self.buttons_sizer.Add(buttons1_window, 1, wx.TOP, 0)
 
         #duplicate high levels plot
@@ -274,7 +274,7 @@ class InterpretationEditorFrame(wx.Frame):
         vbox1.Add(self.canvas,proportion=1,flag= wx.EXPAND,border=8)
 
         vbox2 = wx.BoxSizer(wx.VERTICAL)
-        vbox2.Add(self.search_bar,proportion=.5,flag= wx.EXPAND, border=8)
+        vbox2.Add(self.search_bar,proportion=0,flag= wx.EXPAND, border=8)
         vbox2.Add(self.logger,proportion=1,flag=wx.EXPAND,border=8)
 
         hbox2 = wx.BoxSizer(wx.HORIZONTAL)