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

pmagpy/pmag.py

@@ -5,7 +5,6 @@ import string
 import sys
 import time
 
-from past.utils import old_div
 import numpy as np
 from numpy import random
 from numpy import linalg
@@ -1398,7 +1397,7 @@ def dia_vgp(*args):  # new function interface by J.Holmes, SIO, 6/1/2011
             plong = plong - 2 * np.pi
 
     dm = np.rad2deg(a95 * (np.sin(p) / np.cos(dip)))
-    dp = np.rad2deg(a95 * (old_div((1 + 3 * (np.cos(p)**2)), 2)))
+    dp = np.rad2deg(a95 * ((1 + 3 * (np.cos(p)**2)) / 2))
     plat = np.rad2deg(plat)
     plong = np.rad2deg(plong)
     return plong.tolist(), plat.tolist(), dp.tolist(), dm.tolist()
@@ -3153,20 +3152,19 @@ def domean(data, start, end, calculation_type):
             dot = -1
         if dot > 1:
             dot = 1
-        if np.arccos(dot) > old_div(np.pi, 2.):
+        if np.arccos(dot) > (np.pi / 2.):
             for k in range(3):
                 v1[k] = -v1[k]
 #   get right direction along principal component
 #
         s1 = np.sqrt(t[0])
         Dir = cart2dir(v1)
-        MAD = old_div(np.arctan(old_div(np.sqrt(t[1] + t[2]), s1)), rad)
+        MAD = np.arctan(np.sqrt(t[1] + t[2]) / s1) / rad
         if np.iscomplexobj(MAD):
             MAD = MAD.real
     if calculation_type == "DE-BFP":
         Dir = cart2dir(v3)
-        MAD = old_div(
-            np.arctan(np.sqrt(old_div(t[2], t[1]) + old_div(t[2], t[0]))), rad)
+        MAD = (np.arctan(np.sqrt((t[2] / t[1]) + (t[2] / t[0]))) / rad)
         if np.iscomplexobj(MAD):
             MAD = MAD.real
 #
@@ -3409,12 +3407,12 @@ def PintPars(datablock, araiblock, zijdblock, start, end, accept, **kwargs):
 # avoid false positives - set 3 degree slope difference here too
         if b_diff > 3 * np.pi / 180.:
             nf = n_zi + n_iz - 2.  # degrees of freedom
-            svar = old_div(((n_zi - 1.) * bzi_sig**2 +
-                            (n_iz - 1.) * biz_sig**2), nf)
-            T = old_div((b_diff), np.sqrt(
-                svar * (old_div(1.0, n_zi) + old_div(1.0, n_iz))))  # student's t
+            svar = ((n_zi - 1.) * bzi_sig**2 +
+                            (n_iz - 1.) * biz_sig**2) / nf
+            T = (b_diff) / np.sqrt(
+                svar * ((1.0 / n_zi) + (1.0 / n_iz)))  # student's t
             ttest = tcalc(nf, .05)  # t-test at 95% conf.
-            Trat = old_div(T, ttest)
+            Trat = T / ttest
             if Trat > 1 and Trat > Frat:
                 ZigZag = Trat  # fails zigzag on directions
                 methcode = "SM-TTEST"
@@ -3523,7 +3521,7 @@ def PintPars(datablock, araiblock, zijdblock, start, end, accept, **kwargs):
     NRM = zijdblock[0][3]     # NRM
 
     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 = dir2cart(DIR)
         zdata.append(np.array([cart[0], cart[1], cart[2]]))
         if k > 0:
@@ -3538,12 +3536,11 @@ def PintPars(datablock, araiblock, zijdblock, start, end, accept, **kwargs):
     # calculate the vds within the chosen segment
     vector_diffs_segment = vector_diffs[zstart:zend]
     # FRAC calculation
-    FRAC = old_div(sum(vector_diffs_segment), vds)
+    FRAC = sum(vector_diffs_segment) / vds
     pars[frac_key] = FRAC
 
     # gap_max calculation
-    max_FRAC_gap = max(
-        old_div(vector_diffs_segment, sum(vector_diffs_segment)))
+    max_FRAC_gap = max(vector_diffs_segment / sum(vector_diffs_segment))
     pars[gmax_key] = max_FRAC_gap
 
     # ---------------------------------------------------------------------
@@ -4505,15 +4502,15 @@ def fisher_mean(data):
         
     Examples
     --------
-    >>> data = [[-45,150],[-40,150],[-38,145]]
+    >>> data = [[150,-45],[151,-46],[145,-38],[146,-41]
     >>> pmag.fisher_mean(data)
-    {'dec': 138.94545436727873,
-     'inc': 31.699974714611297,
-     'n': 3,
-     'r': 2.9946002939178036,
-     'k': 370.39053043910616,
-     'alpha95': 6.414731246264079,
-     'csd': 4.20876891770567}    
+    {'dec': 147.87247771265734,
+    'inc': -42.52872729473035,
+    'n': 4,
+    'r': 3.9916088992115832,
+    'k': 357.52162626162925,
+    'alpha95': 4.865886096375297,
+    'csd': 4.283846101842065}   
     """
     N, fpars = len(data), {}
     
@@ -4521,6 +4518,11 @@ def fisher_mean(data):
         return {'dec': data[0][0], 
                 'inc': data[0][1]}
     
+    # use only dec, inc values even if intensity values are provided
+    # so that calculations are on unit vectors
+    for i in range(N):
+        data[i] = data[i][:2]
+
     X = np.array(dir2cart(data))
     Xbar = X.sum(axis=0)
     R = np.linalg.norm(Xbar)
@@ -4946,7 +4948,7 @@ def dolnp(data, direction_type_key):
             R = np.sqrt(E[0]**2 + E[1]**2 + E[2]**2)
             for c in E:
                 # set initial direction as mean of lines
-                V.append(old_div(c, R))
+                V.append(c / R)
         XV = calculate_best_fit_vectors(L, E, V, n_planes)
 # calculating overall mean direction and R
         U = E[:]
@@ -4955,7 +4957,7 @@ def dolnp(data, direction_type_key):
                 U[c] = U[c] + dir[c]
         R = np.sqrt(U[0]**2 + U[1]**2 + U[2]**2)
         for c in range(3):
-            U[c] = old_div(U[c], R)
+            U[c] = U[c] / R
 # get dec and inc of solution points on gt circles
         dirV = cart2dir(U)
 # calculate modified Fisher stats fo fit
@@ -4964,10 +4966,10 @@ def dolnp(data, direction_type_key):
         if NP < 1.1:
             NP = 1.1
         if n_total - R != 0:
-            K = old_div((NP - 1.), (n_total - R))
-            fac = (20.**(old_div(1., (NP - 1.))) - 1.)
+            K = (NP - 1.) / (n_total - R)
+            fac = (20.**(1. / (NP - 1.)) - 1.)
             fac = fac * (NP - 1.) / K
-            a = 1. - old_div(fac, R)
+            a = 1. - (fac / R)
             a95 = a
             if abs(a) > 1.0:
                 a95 = 1.
@@ -5005,7 +5007,7 @@ def vclose(L, V):
         lam = lam + V[k] * L[k]
     beta = np.sqrt(1. - lam**2)
     for k in range(3):
-        X.append((old_div((V[k] - lam * L[k]), beta)))
+        X.append(((V[k] - lam * L[k]) / beta))
     return X
 
 
@@ -5038,7 +5040,7 @@ def calculate_best_fit_vectors(L, E, V, n_planes):
                 U[c] = U[c] - XV[k][c]
             R = np.sqrt(U[0]**2 + U[1]**2 + U[2]**2)
             for c in range(3):
-                V[c] = old_div(U[c], R)
+                V[c] = U[c] / R
             XX = vclose(L[k], V)
             ang = XX[0] * XV[k][0] + XX[1] * XV[k][1] + XX[2] * XV[k][2]
             angles.append(np.arccos(ang) * 180. / np.pi)
@@ -6060,24 +6062,21 @@ def binglookup(w1i,w2i):
     w1, w2 = 0., 0.
     wstart, incr = 0.01, 0.02
     if w1i < wstart:
-        w1 = '%4.2f' % (wstart + incr/2.)
         w1 = round((wstart + incr/2.),2)
     if w2i < wstart:
-        w2 = '%4.2f' % (wstart + incr/2.)
         w2 = round((wstart + incr/2.),2)
     wnext = wstart + incr
     while wstart < 0.5:
         if w1i >= wstart and w1i < wnext:
-            w1 = '%4.2f' % (wstart + incr/2.)
             w1 = round((wstart + incr/2.),2)
         if w2i >= wstart and w2i < wnext:
-            w2 = '%4.2f' % (wstart + incr/2.)
             w2 = round((wstart + incr/2.),2)
         wstart += incr
         wnext += incr
     wnext = wstart + incr
-    k1=k1_df.loc[k1_df['w2']==w2][str(w1)].values[0]
-    k2=k2_df.loc[k2_df['w2']==w2][str(w1)].values[0]
+    w1 = '%4.2f' % w1
+    k1=k1_df.loc[k1_df['w2']==w2][w1].values[0]
+    k2=k2_df.loc[k2_df['w2']==w2][w1].values[0]
     return k1,k2
 
 def binglookup_old(w1i, w2i):
@@ -6092,13 +6091,13 @@ def binglookup_old(w1i, w2i):
     if w1i < wstart:
         w1 = '%4.2f' % (wstart + incr/2.)
     if w2i < wstart:
-        w2 = '%4.2f' % (wstart + old_div(incr, 2.))
+        w2 = '%4.2f' % (wstart + (incr / 2.))
     wnext = wstart + incr
     while wstart < 0.5:
         if w1i >= wstart and w1i < wnext:
-            w1 = '%4.2f' % (wstart + old_div(incr, 2.))
+            w1 = '%4.2f' % (wstart + (incr / 2.))
         if w2i >= wstart and w2i < wnext:
-            w2 = '%4.2f' % (wstart + old_div(incr, 2.))
+            w2 = '%4.2f' % (wstart + (incr / 2.))
         wstart += incr
         wnext += incr
     wnext = wstart + incr
@@ -6113,7 +6112,7 @@ def cdfout(data, file):
     f = open(file, "w")
     data.sort()
     for j in range(len(data)):
-        y = old_div(float(j), float(len(data)))
+        y = float(j) / float(len(data))
         out = str(data[j]) + ' ' + str(y) + '\n'
         f.write(out)
     f.close()
@@ -6177,7 +6176,7 @@ def dobingham(di_block):
 #  now for Bingham ellipses.
 #
     fac1, fac2 = -2 * N * (k1) * (w3 - w1), -2 * N * (k2) * (w3 - w2)
-    sig31, sig32 = np.sqrt(old_div(1., fac1)), np.sqrt(old_div(1., fac2))
+    sig31, sig32 = np.sqrt(1. / fac1), np.sqrt(1. / fac2)
     bpars["Zeta"], bpars["Eta"] = 2.45 * sig31 * \
         180. / np.pi, 2.45 * sig32 * 180. / np.pi
     return bpars
@@ -6264,7 +6263,9 @@ def doreverse_list(decs, incs):
 
 def doincfish(inc):
     """
-    Calculates Fisher mean inclination from inclination-only data.
+    Calculates Fisher mean inclination from inclination-only data. This function uses
+    the method of McFadden and Reid (1982), and incorporates asymmetric confidence limits
+    after McElhinny and McFadden (2000).
 
     Parameters
     ----------
@@ -6278,20 +6279,25 @@ def doincfish(inc):
         'inc' : estimated Fisher mean
         'r' : estimated Fisher R value
         'k' : estimated Fisher kappa
-        'alpha95' : estimated fisher alpha_95
+        'alpha95': estimated confidence limit
+        'upper_confidence_limit' : estimated upper confidence limit of inclination
+        'lower_confidence_limit' : estimated lower confidence limit of inclination
         'csd' : estimated circular standard deviation
 
     Examples
     --------
-    >>> pmag.doincfish([60,62,0,10])
-    {'n': 4,
-     'ginc': 33.0,
-     'inc': 39.85999999999957,
-     'r': 2.9999543668915347,
-     'k': 2.999863106921461,
-     'alpha95': 57.453002724988956,
-     'csd': 46.76643881682904}
+    >>> pmag.doincfish([62.4, 61.6, 50.2, 65.2, 53.2, 61.4, 74.0, 60.0, 52.6, 71.8])
+    {'n': 10,
+     'ginc': 61.239999999999995,
+     'inc': 62.18,
+     'r': 9.828974184785405,
+     'k': 52.623634558953846,
+     'upper_confidence_limit': 66.49823541535572,
+     'lower_confidence_limit': 55.9733682324565,
+     'alpha95': 5.2624335914496125,
+     'csd': 11.165922232016465}
     """
+
     abinc = []
     for i in inc:
         abinc.append(abs(i))
@@ -6303,13 +6309,14 @@ def doincfish(inc):
     if MI < 30:
         fpars['inc'] = MI
         fpars['k'] = 0
-        fpars['alpha95'] = 0
+        fpars['upper_confidence_limit'] = 0
+        fpars['lower_confidence_limit'] = 0
         fpars['csd'] = 0
         fpars['r'] = 0
         print('WARNING: mean inc < 30, returning gaussian mean')
         return fpars
     inc = np.array(inc)
-    coinc = np.deg2rad(90. - np.abs(inc)) # sum over all incs (but take only positive inc)
+    coinc = np.deg2rad(90. - np.abs(inc))  # sum over all incs (but take only positive inc)
     SCOi = np.cos(coinc).sum()
     SSOi = np.sin(coinc).sum()
     min_misfit,min_curvature = np.inf,0.
@@ -6322,25 +6329,30 @@ def doincfish(inc):
     if len(idx_zeros)==0:
         idx_zeros = np.argmin(abs(misfit))
         print("No zeros found to fitness function of McFadden and Reed 1982, returning absolute minimum which is at %.3f instead.\nThis likely indicates that your inclinations are too steep for this method you may wish to consider an alternate technique."%misfit[idx_zeros])
-    ML_zeros = np.array(Oo[[idx_zeros]])
+    ML_zeros = np.array(Oo[idx_zeros])
     ML_matrix = (np.ones([len(coinc),1]) @ ML_zeros.reshape(1,ML_zeros.shape[0])).T
-#    print(coinc.shape,ML_zeros.shape,ML_matrix.shape)
-    U = 0.5*N*((1/(np.cos(ML_zeros)**2))-(np.cos(ML_matrix-coinc).sum(axis=1)/(N-np.cos(ML_matrix-coinc).sum(axis=1))))
-#    print("Found Zeros: ", ML_zeros, "Second Derivative: ", U)
+    #    print(coinc.shape,ML_zeros.shape,ML_matrix.shape)
+    U = 0.5 * N * ((1 / (np.cos(ML_zeros) ** 2)) - (
+                np.cos(ML_matrix - coinc).sum(axis=1) / (N - np.cos(ML_matrix - coinc).sum(axis=1))))
+    #    print("Found Zeros: ", ML_zeros, "Second Derivative: ", U)
     Oo = ML_zeros[np.argmin(U)]
     C = np.cos(Oo-coinc).sum()
     S = np.sin(Oo-coinc).sum()
-    k = old_div((N - 1.), (2. * (N - C)))
+    k = (N - 1.) / (2. * (N - C))
     Imle = 90. - np.rad2deg(Oo)
-    fpars["inc"] = Imle
-    fpars["r"], R = 2. * C - N, 2 * C - N
+    fpars["inc"] = Imle[0]
+    fpars["r"], R = (2. * C - N), (2 * C - N)
     fpars["k"] = k
-    f = fcalc(2, N - 1)
-    a95 = 1. - (0.5) * (old_div(S, C))**2 - (old_div(f, (2. * C * k)))
-#    b=20.**(1./(N-1.)) -1.
-#    a=1.-b*(N-R)/R
-    a95=np.rad2deg(np.arccos(a95))
-    csd = old_div(81., np.sqrt(k))
+    f = fcalc(2, N - 1)  # the 'g' of MM2000
+    a95 = np.rad2deg(np.arccos(1. - (0.5) * (S / C) ** 2 - (f * (N - C)) / (C * (N - 1))))
+    # calculating the upper and lower confidence intervals
+    lower_confidence_limit = Imle[0] + (180 * S) / (np.pi * C) - a95
+    upper_confidence_limit = Imle[0] + (180 * S) / (np.pi * C) + a95
+    csd = 81. / np.sqrt(k)
+
+    # the upper and lower confidence intervals as values
+    fpars["upper_confidence_limit"] = upper_confidence_limit
+    fpars["lower_confidence_limit"] = lower_confidence_limit
     fpars["alpha95"] = a95
     fpars["csd"] = csd
     return fpars
@@ -6408,7 +6420,7 @@ def dokent(data, NN, distribution_95=False):
     T = Tmatrix(X)
     for i in range(3):
         for j in range(3):
-            T[i][j] = old_div(T[i][j], float(NN))
+            T[i][j] = T[i][j] / float(NN)
 #
 # compute B=H'TH
 #
@@ -6451,7 +6463,7 @@ def dokent(data, NN, distribution_95=False):
         xmu += xg[i][2]
         sigma1 = sigma1 + xg[i][0]**2
         sigma2 = sigma2 + xg[i][1]**2
-    xmu = old_div(xmu, float(N))
+    xmu = xmu / float(N)
     sigma1 = sigma1/float(N)
     sigma2 = sigma2/float(N)
     
@@ -6822,7 +6834,7 @@ def check_F(AniSpec):
     s[3] = float(AniSpec["anisotropy_s4"])
     s[4] = float(AniSpec["anisotropy_s5"])
     s[5] = float(AniSpec["anisotropy_s6"])
-    chibar = old_div((s[0] + s[1] + s[2]), 3.)
+    chibar = (s[0] + s[1] + s[2]) / 3.
     tau, Vdir = doseigs(s)
     t2sum = 0
     for i in range(3):
@@ -6897,8 +6909,7 @@ def doaniscorr(PmagSpecRec, AniSpec):
         M = np.array(X)
         H = np.dot(M, chi_inv)
         cDir = cart2dir(H)
-        Hunit = [old_div(H[0], cDir[2]), old_div(H[1], cDir[2]), old_div(
-            H[2], cDir[2])]  # unit vector parallel to Banc
+        Hunit = [(H[0] / cDir[2]), (H[1] / cDir[2]), (H[2] / cDir[2])]  # unit vector parallel to Banc
         Zunit = [0, 0, -1.]  # unit vector parallel to lab field
         Hpar = np.dot(chi, Hunit)  # unit vector applied along ancient field
         Zpar = np.dot(chi, Zunit)  # unit vector applied along lab field
@@ -6983,8 +6994,8 @@ def vgp_di(plat, plong, slat, slong):
     cosp = np.cos(thetaS) * np.cos(thetaP) + np.sin(thetaS) * \
         np.sin(thetaP) * np.cos(delphi)
     thetaM = np.arccos(cosp)
-    cosd = old_div((np.cos(thetaP) - np.cos(thetaM) *
-                    np.cos(thetaS)), (np.sin(thetaM) * np.sin(thetaS)))
+    cosd = (np.cos(thetaP) - np.cos(thetaM) *
+                    np.cos(thetaS)) / (np.sin(thetaM) * np.sin(thetaS))
     C = abs(1. - cosd**2)
     if C != 0:
         dec = -np.arctan(cosd/np.sqrt(abs(C))) + (np.pi/2.)
@@ -7080,7 +7091,7 @@ def dimap(D, I):
 
 # CALCULATE THE X,Y COORDINATES FOR THE EQUAL AREA PROJECTION
     # from Collinson 1983
-    R = old_div(np.sqrt(1. - X[2]), (np.sqrt(X[0]**2 + X[1]**2)))
+    R = np.sqrt(1. - X[2]) / (np.sqrt(X[0]**2 + X[1]**2))
     XY[1], XY[0] = X[0] * R, X[1] * R
 
 # RETURN XY[X,Y]
@@ -7267,14 +7278,14 @@ def adjust_ages(AgesIn):
                 AgesOut.append(agerec[0] * 1e3 / factor)
             if "Years" in agerec[1].split():
                 if agerec[1] == "Years BP":
-                    AgesOut.append(old_div(agerec[0], factor))
+                    AgesOut.append(agerec[0] / factor)
                 if agerec[1] == "Years Cal BP":
-                    AgesOut.append(old_div(agerec[0], factor))
+                    AgesOut.append(agerec[0] / factor)
                 if agerec[1] == "Years AD (+/-)":
                     # convert to years BP first
-                    AgesOut.append(old_div((1950 - agerec[0]), factor))
+                    AgesOut.append((1950 - agerec[0]) / factor)
                 if agerec[1] == "Years Cal AD (+/-)":
-                    AgesOut.append(old_div((1950 - agerec[0]), factor))
+                    AgesOut.append((1950 - agerec[0]) / factor)
     return AgesOut, age_unit
 #
 
@@ -8496,12 +8507,12 @@ def dohext(nf, sigma, s):
     tau, Vdir = doseigs(s)
     for i in range(3):
         t2sum += tau[i]**2
-    chibar = old_div((s[0] + s[1] + s[2]), 3.)
+    chibar = (s[0] + s[1] + s[2]) / 3.
     hpars['F_crit'] = '%s' % (fcalc(5, nf))
     hpars['F12_crit'] = '%s' % (fcalc(2, nf))
     hpars["F"] = 0.4 * (t2sum - 3 * chibar**2) / (sigma**2)
-    hpars["F12"] = 0.5 * (old_div((tau[0] - tau[1]), sigma))**2
-    hpars["F23"] = 0.5 * (old_div((tau[1] - tau[2]), sigma))**2
+    hpars["F12"] = 0.5 * ((tau[0] - tau[1]) / sigma)**2
+    hpars["F23"] = 0.5 * ((tau[1] - tau[2]) / sigma)**2
     hpars["v1_dec"] = Vdir[0][0]
     hpars["v1_inc"] = Vdir[0][1]
     hpars["v2_dec"] = Vdir[1][0]
@@ -8512,11 +8523,11 @@ def dohext(nf, sigma, s):
     hpars["t2"] = tau[1]
     hpars["t3"] = tau[2]
     hpars["e12"] = np.arctan(
-        old_div((f * sigma), (2 * abs(tau[0] - tau[1])))) * 180. / np.pi
+        (f * sigma) / (2 * abs(tau[0] - tau[1]))) * 180. / np.pi
     hpars["e23"] = np.arctan(
-        old_div((f * sigma), (2 * abs(tau[1] - tau[2])))) * 180. / np.pi
+        (f * sigma) / (2 * abs(tau[1] - tau[2]))) * 180. / np.pi
     hpars["e13"] = np.arctan(
-        old_div((f * sigma), (2 * abs(tau[0] - tau[2])))) * 180. / np.pi
+        (f * sigma) / (2 * abs(tau[0] - tau[2]))) * 180. / np.pi
     return hpars
 #
 #
@@ -8635,12 +8646,12 @@ def dok15_s(k15):
     A, B = design(15)  # get design matrix for 15 measurements
     sbar = np.dot(B, k15)  # get mean s
     t = (sbar[0] + sbar[1] + sbar[2])  # trace
-    bulk = old_div(t, 3.)  # bulk susceptibility
+    bulk = t / 3.  # bulk susceptibility
     Kbar = np.dot(A, sbar)  # get best fit values for K
     dels = k15 - Kbar  # get deltas
-    dels, sbar = old_div(dels, t), old_div(sbar, t)  # normalize by trace
+    dels, sbar = dels / t, sbar / t  # normalize by trace
     So = sum(dels**2)
-    sigma = np.sqrt(old_div(So, 9.))  # standard deviation
+    sigma = np.sqrt(So / 9.)  # standard deviation
     return sbar, sigma, bulk
 #
 
@@ -9812,14 +9823,13 @@ def magsyn(gh, sv, b, date, itype, alt, colat, elong):
         two = b2 * ct * ct
         three = one + two
         rho = np.sqrt(three)
-        r = np.sqrt(alt * (alt + 2.0 * rho) +
-                    old_div((a2 * one + b2 * two), three))
-        cd = old_div((alt + rho), r)
+        r = np.sqrt(alt * (alt + 2.0 * rho) + (a2 * one + b2 * two) / three)
+        cd = (alt + rho) / r
         sd = (a2 - b2) / rho * ct * st / r
         one = ct
         ct = ct * cd - st * sd
         st = st * cd + one * sd
-    ratio = old_div(6371.2, r)
+    ratio = 6371.2 / r
     rr = ratio * ratio
 #
 # compute Schmidt quasi-normal coefficients p and x(=q)
@@ -9838,7 +9848,7 @@ def magsyn(gh, sv, b, date, itype, alt, colat, elong):
         fm = m
         if k != 2:  # else go to 4
             if m == n:   # else go to 3
-                one = np.sqrt(1.0 - old_div(0.5, fm))
+                one = np.sqrt(1.0 - (0.5 / fm))
                 j = k - n - 1
                 p[k] = one * st * p[j]
                 q[k] = one * (st * q[j] + ct * p[j])
@@ -9848,8 +9858,8 @@ def magsyn(gh, sv, b, date, itype, alt, colat, elong):
                 # 3
                 gm = m * m
                 one = np.sqrt(fn * fn - gm)
-                two = old_div(np.sqrt(gn * gn - gm), one)
-                three = old_div((fn + gn), one)
+                two = np.sqrt(gn * gn - gm) / one
+                three = (fn + gn) / one
                 i = k - n
                 j = i - n + 1
                 p[k] = three * ct * p[i] - two * p[j]
@@ -11209,8 +11219,8 @@ def get_tilt(dec_geo, inc_geo, dec_tilt, inc_tilt):
     # cartesian coordites of Geographic D
     GCart = dir2cart([dec_geo, inc_geo, 1.])
     TCart = dir2cart([dec_tilt, inc_tilt, 1.])  # cartesian coordites of Tilt D
-    X = old_div((TCart[1] - GCart[1]), (GCart[0] - TCart[0]))
-    SCart[1] = np.sqrt(old_div(1, (X**2 + 1.)))
+    X = (TCart[1] - GCart[1]) / (GCart[0] - TCart[0])
+    SCart[1] = np.sqrt(1 / (X**2 + 1.))
     SCart[0] = SCart[1] * X
     SDir = cart2dir(SCart)
     DipDir = (SDir[0] - 90.) % 360.
@@ -11222,8 +11232,7 @@ def get_tilt(dec_geo, inc_geo, dec_tilt, inc_tilt):
         SCart[1]  # cosine of angle between two
     d = np.arccos(cosd)
     cosTheta = GCart[0] * TCart[0] + GCart[1] * TCart[1] + GCart[2] * TCart[2]
-    Dip = (old_div(180., np.pi)) * \
-        np.arccos(-(old_div((cosd**2 - cosTheta), np.sin(d)**2)))
+    Dip = (180. / np.pi) * np.arccos(-((cosd**2 - cosTheta) / np.sin(d)**2))
     if Dip > 90:
         Dip = -Dip
     return DipDir, Dip
@@ -11881,16 +11890,15 @@ def linreg(x, y):
         xy += x[i] * y[i]
         xsum += x[i]
         ysum += y[i]
-        xsig = np.sqrt(old_div((xx - old_div(xsum**2, n)), (n - 1.)))
-        ysig = np.sqrt(old_div((yy - old_div(ysum**2, n)), (n - 1.)))
-    linpars['slope'] = old_div(
-        (xy - (xsum * ysum / n)), (xx - old_div((xsum**2), n)))
-    linpars['b'] = old_div((ysum - linpars['slope'] * xsum), n)
-    linpars['r'] = old_div((linpars['slope'] * xsig), ysig)
+        xsig = np.sqrt((xx - (xsum**2 / n)) / (n - 1.))
+        ysig = np.sqrt((yy - (ysum**2 / n)) / (n - 1.))
+    linpars['slope'] = (xy - (xsum * ysum / n)) / (xx - (xsum**2) / n)
+    linpars['b'] = (ysum - linpars['slope'] * xsum) / n
+    linpars['r'] = (linpars['slope'] * xsig) / ysig
     for i in range(n):
         a = y[i] - linpars['b'] - linpars['slope'] * x[i]
         sum += a
-    linpars['sigma'] = old_div(sum, (n - 2.))
+    linpars['sigma'] = sum /(n - 2.)
     linpars['n'] = n
     return linpars
 

pmagpy/pmagplotlib.py

@@ -31,7 +31,7 @@ if has_cartopy:
     from cartopy.feature import NaturalEarthFeature, LAND, COASTLINE, OCEAN, LAKES, BORDERS
 has_basemap, Basemap = pmag.import_basemap()
 
-
+import os
 import matplotlib
 from matplotlib import cm as color_map
 from matplotlib import pyplot as plt
@@ -1597,7 +1597,7 @@ def plot_teq(fignum, araiblock, s, pars):
     plt.text(-1.1, 1.15, s)
 
 
-def save_plots(Figs, filenames, **kwargs):
+def save_plots(Figs, filenames, dir_path=None, **kwargs):
     """
     Parameters
     ----------
@@ -1606,6 +1606,9 @@ def save_plots(Figs, filenames, **kwargs):
     filenames : dict
         dictionary of filenames, e.g. {'eqarea': 'mc01a_eqarea.svg', ...}
         dict keys should correspond with Figs
+    dir_path : str
+        string of directory name where plots will be saved to
+    kwargs: other keyword arguments
     """
     saved = []
     for key in list(Figs.keys()):
@@ -1624,11 +1627,11 @@ def save_plots(Figs, filenames, **kwargs):
             else:
                 fname = fname.replace('/', '-') # flatten file name
             if 'dpi' in list(kwargs.keys()):
-                plt.savefig(fname, dpi=kwargs['dpi'])
+                plt.savefig(os.path.join(dir_path, fname), dpi=kwargs['dpi'])
             elif isServer:
                 plt.savefig(fname, dpi=240)
             else:
-                plt.savefig(fname)
+                plt.savefig(os.path.join(dir_path, fname))
             if verbose:
                 print(Figs[key], " saved in ", fname)
             saved.append(fname)
@@ -1638,7 +1641,6 @@ def save_plots(Figs, filenames, **kwargs):
             print('could not save: ', Figs[key], filenames[key])
             print("output file format not supported ")
     return saved
-#
 
 
 def plot_evec(fignum, Vs, symsize, title):

pmagpy/spline.py

@@ -19,12 +19,9 @@ Uses "searchsorted" from the Numeric module, aka "binarysearch" in older
 versions.
 
 """
-from __future__ import division
-from __future__ import absolute_import
 
 from builtins import range
 
-from past.utils import old_div
 from . import func
 #from Numeric import *
 import numpy
@@ -55,8 +52,7 @@ class Spline(func.FuncOps):
         u        = numpy.zeros(n-1, 'f')
 
         if self.use_low_slope:
-            u[0] = (old_div(3.0,(x_vals[1]-x_vals[0]))) * \
-               (old_div((y_vals[1]-y_vals[0]),
+            u[0] = (3.0 / (x_vals[1]-x_vals[0])) * (((y_vals[1]-y_vals[0])
                 (x_vals[1]-x_vals[0]))-self.low_slope)
             y2_vals[0] = -0.5
         else:
@@ -64,27 +60,22 @@ class Spline(func.FuncOps):
             y2_vals[0] = 0.0   # natural spline
 
         for i in range(1, n-1):
-            sig = old_div((x_vals[i]-x_vals[i-1]), \
-              (x_vals[i+1]-x_vals[i-1]))
+            sig = (x_vals[i]-x_vals[i-1]) / (x_vals[i+1]-x_vals[i-1])
             p   = sig*y2_vals[i-1]+2.0
-            y2_vals[i] = old_div((sig-1.0),p)
-            u[i] = old_div((y_vals[i+1]-y_vals[i]), \
-               (x_vals[i+1]-x_vals[i])) - \
-               old_div((y_vals[i]-y_vals[i-1]), \
-               (x_vals[i]-x_vals[i-1]))
-            u[i] = old_div((6.0*u[i]/(x_vals[i+1]-x_vals[i-1]) -
-                sig*u[i-1]), p)
+            y2_vals[i] = (sig-1.0) / p
+            u[i] = (y_vals[i+1]-y_vals[i]) / (x_vals[i+1]-x_vals[i]) - \
+               (y_vals[i]-y_vals[i-1]) / (x_vals[i]-x_vals[i-1])
+            u[i] = (6.0*u[i]/(x_vals[i+1]-x_vals[i-1]) - sig*u[i-1]) / p
 
         if self.use_high_slope:
             qn = 0.5
-            un = (old_div(3.0,(x_vals[n-1]-x_vals[n-2]))) * \
-             (self.high_slope - old_div((y_vals[n-1]-y_vals[n-2]),
-              (x_vals[n-1]-x_vals[n-2])))
+            un = (3.0 / (x_vals[n-1]-x_vals[n-2])) * \
+             (self.high_slope - (y_vals[n-1]-y_vals[n-2]) / (x_vals[n-1]-x_vals[n-2]))
         else:
             qn = 0.0
             un = 0.0    # natural spline
 
-        y2_vals[n-1] = old_div((un-qn*u[n-2]),(qn*y2_vals[n-1]+1.0))
+        y2_vals[n-1] = (un-qn*u[n-2]) / (qn*y2_vals[n-1]+1.0)
 
         rng = list(range(n-1))
         rng.reverse()
@@ -119,8 +110,8 @@ class Spline(func.FuncOps):
         if h == 0.0:
             raise BadInput
 
-        a = old_div((self.x_vals[pos] - x), h)
-        b = old_div((x - self.x_vals[pos-1]), h)
+        a = (self.x_vals[pos] - x) / h
+        b = (x - self.x_vals[pos-1]) / h
         return (a*self.y_vals[pos-1] + b*self.y_vals[pos] + \
             ((a*a*a - a)*self.y2_vals[pos-1] + \
              (b*b*b - b)*self.y2_vals[pos]) * h*h/6.0)
@@ -157,8 +148,8 @@ class LinInt(func.FuncOps):
         if h == 0.0:
             raise BadInput
 
-        a = old_div((self.x_vals[pos] - x), h)
-        b = old_div((x - self.x_vals[pos-1]), h)
+        a = (self.x_vals[pos] - x) /  h
+        b = (x - self.x_vals[pos-1]) /  h
         return a*self.y_vals[pos-1] + b*self.y_vals[pos]
 
 def spline_interpolate(x1, y1, x2):