ararpy 0.1.35__tar.gz → 0.1.37__tar.gz

{ararpy-0.1.35 → ararpy-0.1.37}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ararpy
-Version: 0.1.35
+Version: 0.1.37
 Summary: A project for Ar-Ar geochronology
 Home-page: https://github.com/wuyangchn/ararpy.git
 Author: Yang Wu

{ararpy-0.1.35 → ararpy-0.1.37}/ararpy/__init__.py

@@ -16,10 +16,10 @@ from . import calc, smp, files, thermo, test
 """ Information """
 
 name = 'ararpy'
-version = '0.1.35'
+version = '0.1.37'
 __version__ = version
 full_version = version
-last_update = '2025-12-02'
+last_update = '2025-12-12'
 
 """ ArArPy Functions """
 
@@ -141,6 +141,5 @@ RawData.get_sequence = smp.raw.get_sequence
 RawData.to_sample = smp.initial.from_raw_data
 RawData.get_unknown = lambda _raw: smp.raw.get_sequence(_raw, True, 'is_unknown', unique=False)
 RawData.get_blank = lambda _raw: smp.raw.get_sequence(_raw, True, 'is_blank', unique=False)
-RawData.get_air = lambda _raw: smp.raw.get_sequence(_raw, True, 'is_air', unique=False)
 Sequence.get_data_df = lambda _seq: pd.DataFrame(_seq.data)
 Sequence.get_flag_df = lambda _seq: pd.DataFrame(_seq.flag)

{ararpy-0.1.35 → ararpy-0.1.37}/ararpy/calc/basic.py

@@ -57,6 +57,18 @@ def get_datetime(t_year: int, t_month: int, t_day: int, t_hour: int, t_min: int,
     return ts - base
 
 
+def get_timestring(timestamp: int = 0, base=None):
+    """
+    :param timestamp: timestamp (utz)
+    :param base: base time [y, m, d, h, m]
+    :return:
+    """
+    if base is None:
+        base = [1970, 1, 1, 0, 0]
+    ts = timestamp + datetime(*base, tzinfo=timezone.utc).timestamp()
+    return datetime.fromtimestamp(ts, tz=timezone.utc).isoformat(timespec='seconds')
+
+
 def merge_dicts(a: dict, b: dict):
     """
     a and b, two dictionary. Return updated a

{ararpy-0.1.35 → ararpy-0.1.37}/ararpy/calc/raw_funcs.py

@@ -30,8 +30,8 @@ def get_raw_data_regression_results(points_data, unselected: list = None):
 
     """
     def power(a0, a1):
-        return regression.power(a0, a1)
-        # raise ValueError("Deprecated regression")
+        # return regression.power(a0, a1)
+        raise ValueError("Deprecated regression")
     # if unselected is None:
     #     unselected = []
     # linesData = []
@@ -42,9 +42,9 @@ def get_raw_data_regression_results(points_data, unselected: list = None):
         power, regression.average]
     # size = 50
     # lines_x = [(max(x + un_x) - 0) / size * i for i in range(size + 1)]
+    x, y = transpose(points_data, ignore=False)
     for i in range(len(reg_handler)):
         try:
-            x, y = transpose(points_data, ignore=False)
             res = reg_handler[i](a0=y, a1=x)
             # line_data = transpose([lines_x, res[7](lines_x)])
             line_results = res[0:4]

{ararpy-0.1.35 → ararpy-0.1.37}/ararpy/calc/regression.py

@@ -16,7 +16,7 @@ import traceback
 import numpy as np
 import pandas as pd
 from scipy.stats import distributions
-from scipy.optimize import fsolve
+from scipy.optimize import minimize_scalar
 import warnings
 from scipy.optimize import minimize
 warnings.simplefilter(action="ignore", category=RuntimeWarning)
@@ -495,22 +495,25 @@ def linest(a0: list, a1: list, *args):
     # calculate Y values base on the fitted formula
     estimate_y = np.matmul(x, beta)
     resid = (estimate_y - y) ** 2
-    reg = (estimate_y - np.mean(estimate_y)) ** 2
-    ssresid = resid.sum()
-    ssreg = reg.sum()
-    sstotal = ssreg + ssresid
+    reg = (estimate_y - np.mean(y)) ** 2
+    ssresid = resid.sum()  # 残差平方和
+    ssreg = reg.sum()  # 回归平方和
+    sstotal = ((y - np.mean(y)) ** 2).sum()
+    r2 = ssreg / sstotal if sstotal != 0 else np.inf
+
     df = m - n
-    m_ssresid = ssresid / df
-    se_beta = (m_ssresid * np.diagonal(inv_xtx)) ** .5
-    beta = beta.transpose()[0]
+    m_ssresid = ssresid / df  # 均方残差，与加权平均中的MSWD对应
+    cov_beta = m_ssresid * inv_xtx
+    se_beta = np.diagonal(cov_beta) ** .5
+
+    beta = beta.flatten()
     rse_beta = se_beta / beta
-    r2 = ssreg / sstotal if sstotal != 0 else np.inf
 
     def get_adjusted_y(*args):
         args = [[1] * len(args[0]), *args]
         return [sum([beta[i] * args[i][j] for i in range(len(beta))]) for j in range(len(args[0]))]
 
-    return beta[0], se_beta[0], rse_beta[0] * 100, r2, m_ssresid, beta, se_beta, get_adjusted_y, m_ssresid
+    return beta[0], se_beta[0], abs(rse_beta[0]) * 100, r2, m_ssresid, beta, cov_beta, get_adjusted_y, m_ssresid
 
 
 def average(a0: list, a1=None):
@@ -535,12 +538,12 @@ def average(a0: list, a1=None):
     m_ssresid = ssresid / df
     r2 = ssreg / sstotal if sstotal != 0 else 1  # r2 = ssreg / sstotal
 
-    k1 = pow(sum([(i - k0) ** 2 for i in a0]) / df, 0.5)  # standard deviation
-    k2 = k1 / k0 * 100 if k0 != 0 else 0  # relative standard error
+    k6 = [[sum([(i - k0) ** 2 for i in a0]) / df]]
+    k1 = pow(k6[0][0], 0.5)  # standard deviation
+    k2 = k1 / abs(k0) * 100 if k0 != 0 else 0  # relative standard error
     k3 = r2  # determination coefficient
-    k4 = 'MSWD'
+    k4 = m_ssresid  # 'MSWD'
     k5 = [k0]
-    k6 = [k1]
     k8 = m_ssresid
 
     def get_adjusted_y(x: list):
@@ -737,7 +740,7 @@ def quadratic(a0: list, a1: list):
     """
     # y = b + m1 * x + m2 * x ^ 2
     k = list(linest(a0, a1, [i ** 2 for i in a1]))
-    b, seb, rseb, r2, mswd, [b, m1, m2], [seb, sem1, sem2] = k[0:7]
+    [b, m1, m2] = k[5]
 
     def get_adjusted_y(x: list):
         return [b + m1 * _x + m2 * _x ** 2 for _x in x]
@@ -756,7 +759,7 @@ def polynomial(a0: list, a1: list, degree: int = 5):
     """
     # y = b + m1 * x + m2 * x ^ 2 + ... + m[n] * x ^ n
     k = list(linest(a0, *[[j ** (i + 1) for j in a1] for i in range(degree)]))
-    b, seb, rseb, r2, mswd, beta, se_beta = k[0:7]
+    beta = k[5]
 
     def get_adjusted_y(x: list):
         return [sum([beta[i] * _x ** i for i in range(degree + 1)]) for _x in x]
@@ -766,6 +769,7 @@ def polynomial(a0: list, a1: list, degree: int = 5):
     return k
 
 
+### Deprecated
 def logest(a0: list, a1: list):
     """
     :param a0: known_y's, y = b * m ^ x
@@ -775,15 +779,19 @@ def logest(a0: list, a1: list):
     # y = b * m ^ x, Microsoft Excel LOGEST function, ln(y) = ln(b) + ln(m) * x
     a0 = [np.log(i) for i in a0]  # ln(y)
     linest_res = linest(a0, a1)
-    lnb, selnb, rseb, r2, mswd, [lnb, lnm], [selnb, selnm] = linest_res[0:7]
+    lnb, selnb, rseb, r2, mswd, beta, cov_beta = linest_res[0:7]
+    lnb, lnm = beta
+    selnb, selnm = np.diagonal(cov_beta) ** .5
+
     b = np.exp(lnb)
     m = np.exp(lnm)
     sem = np.exp(lnm) * selnm
     seb = np.exp(lnb) * selnb  # Excel.Logest function do not consider the error propagation
-    rseb = seb / b * 100
+    rseb = seb / abs(b) * 100
     return b, seb, rseb, r2, mswd, m, sem
 
 
+### Deprecated
 def power(a0: list, a1: list):
     """
     :param a0: known_y's, y = a * x ^ b + c
@@ -841,7 +849,9 @@ def power(a0: list, a1: list):
         raise IndexError
 
     f = linest(a0, [_x ** b for _x in a1])
-    a, sea, c, sec = f[5][1], f[6][1], f[0], f[1]
+    beta, cov_beta = f[5:7]
+    c, a = beta
+    sec, sea = np.diagonal(cov_beta) ** .5
 
     calculated_y = [_pow_func(i, a, b, c) for i in a1]
     resid = [(calculated_y[i] - a0[i]) ** 2 for i in range(len(a0))]
@@ -862,104 +872,193 @@ def power(a0: list, a1: list):
     errfx = pow(sum([i ** 2 for i in a1]) / (dp * sum([i ** 2 for i in a1]) - sum(a1) ** 2), 0.5)
     # seb = errfz * sey = errfz * ssresid / df -> se_intercept = sey * errfx = seb / errfz * errfx
     se_intercept = sec / errfz * errfx
-    rse_intercept = se_intercept / intercept * 100
+    rse_intercept = se_intercept / abs(intercept) * 100
+
+
+    exp_beta = [a, b, c]
+    exp_cov_beta = [
+        [cov_beta[1][1], 0, cov_beta[1][0]],
+        [0,              0,              0],
+        [cov_beta[0][1], 0, cov_beta[0][0]],
+    ]
 
     return intercept, se_intercept, rse_intercept, r2, 'mswd', [a, b, c], 'se', \
            lambda x: [_pow_func(i, a, b, c) for i in x], m_ssresid
 
 
 def exponential(a0: list, a1: list):
-    """
-    :param a0: known_y's, y = a * b ^ x + c
-    :param a1: known_x's
-    :return: intercept | standard error of intercept | relative error | R2 | MSWD | [m, c, b] | [sem, sec, seb]
-    """
+    try:
+        k = _exponential(a0, a1, newton_minimize_1d)
+        if k[2] > 100:
+            raise ValueError
+        if abs(k[0] - min(a0)) > 5 * (max(a0) - min(a0)):
+            raise ValueError
+    except Exception as e:
+        print(f"newton_minimize_1d failed, using grad minimize")
+        k = _exponential(a0, a1, grad_minimize)
+    return k
 
-    def _exp_func(x, a, b, c):
-        return a * b ** x + c
 
-    def _residuals(params):
-        a, b, c = params
-        return [_exp_func(xi, a, b, c) - yi for xi, yi in zip(a1, a0)]
+def _exponential(a0, a1, method):
 
-    def _sum_squared_error(params):
-        return sum(r**2 for r in _residuals(params))
+    X = np.array(a1)
+    Y = np.array(a0)
+    y = np.array([a0]).transpose()
 
-    def _get_ac(b):
-        f = linest(a0, [b ** xi for xi in a1])
-        return f[5][1], b, f[0]
+    def _exp_func(xi, a, b, c):
+        return a * np.exp(b * xi) + c
+
+    @np.vectorize
+    def _get_s(b):
+        x = np.concatenate(([np.ones(len(a1))], [np.exp(b * np.array(a1))]), axis=0).transpose()
+        try:
+            inv_xtx = np.linalg.inv(np.matmul(x.transpose(), x))
+        except np.linalg.LinAlgError:
+            raise np.linalg.LinAlgError(f"The determinant of the given matrix must not be zero ")
+        beta = np.matmul(inv_xtx, np.matmul(x.transpose(), y))
+        c, a = beta.flatten()
+        reg_y = _exp_func(X, a, b, c)
+        resid = (reg_y - Y) ** 2
+        ssresid = sum(resid)
+        return ssresid
+
+    # 1阶
+    ini_f1 = linest(Y, X)
+    y_range = max(Y) - min(Y)
+    ini_b = ini_f1[5][1] / max(y_range, 1e-12)
+    # 2阶
+    ini_f2 = quadratic(Y, X)
+    ini_b *= np.sign(ini_f1[5][1]) * np.sign(ini_f2[5][2])
+
+    b, count = method(_get_s, ini_b)
+
+    x = np.concatenate(([np.ones(len(a1))], [np.exp(b * np.array(a1))]), axis=0).transpose()
+
+    m, n = x.shape  # number of data, number of unknown x
+    try:
+        inv_xtx = np.linalg.inv(np.matmul(x.transpose(), x))
+    except np.linalg.LinAlgError:
+        raise np.linalg.LinAlgError(f"The determinant of the given matrix must not be zero ")
+    beta = np.matmul(inv_xtx, np.matmul(x.transpose(), y))
+    estimate_y = np.matmul(x, beta)
+    resid = (estimate_y - y) ** 2
+    reg = (estimate_y - np.mean(y)) ** 2
+    ssresid = resid.sum()  # 残差平方和
+    ssreg = reg.sum()  # 回归平方和
+    sstotal = ((y - np.mean(y)) ** 2).sum()
+    r2 = ssreg / sstotal if sstotal != 0 else 1
 
-    def _get_init():
-        f = linest(np.log(np.array(a0)), np.array(a1))
-        return np.exp(f[0]), np.exp(f[5][1]), 0
+    df = m - n
+    m_ssresid = ssresid / df  # 均方残差，与加权平均中的MSWD对应
+    cov_beta = m_ssresid * inv_xtx
 
-    try:
-        a, b, c = _get_init()
-        # a, b, c = minimize(_sum_squared_error, [a, b, c], method="Nelder-Mead").x  # 优化方法
-        count = 0
-        step = 0.01
-        while count < 100:
-            a, b, c = _get_ac(b)
-            s = _sum_squared_error([a, b, c])
-            b_left, b_right = b - step * b, b + step * b
-            s_left = _sum_squared_error(_get_ac(b_left))
-            s_right = _sum_squared_error(_get_ac(b_right))
-            if s_left > s > s_right:
-                b = b_right
-                continue
-            elif s_left < s < s_right:
-                b = b_left
-                continue
-            elif s_left < s_right:
-                b = (b + b_left) / 2
-            else:
-                b = (b + b_right) / 2
-            count += 1
-            step = step * 0.5
-            if step < 0.000001:
-                break
+    sc, sa = np.diagonal(cov_beta) ** .5
+    c, a = beta.flatten()
+    intercept = a + c
+    se_intercept = pow(sa ** 2 + sc ** 2 + 2 * cov_beta[0][1] , 0.5)
 
-    except RuntimeError:
-        raise RuntimeError
-    except np.linalg.LinAlgError:
-        raise np.linalg.LinAlgError
-    except TypeError:
-        raise TypeError
-    except IndexError:
-        raise IndexError
+    exp_beta = [a, b, c]
+    exp_cov_beta = [
+        [cov_beta[1][1], 0, cov_beta[1][0]],
+        [0,              0,              0],
+        [cov_beta[0][1], 0, cov_beta[0][0]],
+    ]
 
-    f = linest(a0, [b ** xi for xi in a1])
-    a, sea, c, sec = f[5][1], f[6][1], f[0], f[1]
+    # print(f"{b = }, {a = }, {c = }, {count = }, {ssresid = }, {r2 = }")
 
-    calculated_y = [_exp_func(i, a, b, c) for i in a1]
-    resid = [(calculated_y[i] - a0[i]) ** 2 for i in range(len(a0))]
-    reg = [(i - sum(calculated_y) / len(calculated_y)) ** 2 for i in calculated_y]
-    ssresid = sum(resid)
-    ssreg = sum(reg)
-    sstotal = ssreg + ssresid
-    dp = len(a1)
-    df = dp - 1
-    m_ssresid = ssresid / df
-    r2 = ssreg / sstotal if sstotal != 0 else 1
+    return intercept, se_intercept, se_intercept / abs(intercept) * 100, r2, m_ssresid, exp_beta, exp_cov_beta, \
+           lambda x: [_exp_func(xi, a, b, c) for xi in x], m_ssresid
 
-    z = [b ** xi for xi in a1]
-    intercept = a + c
-    se_intercept_1 = np.sqrt(sea ** 2 + sec ** 2)
-    # calculate error of intercept
-    errfz = pow(sum([i ** 2 for i in z]) / (dp * sum([i ** 2 for i in z]) - sum(z) ** 2), 0.5)
-    errfx = pow(sum([i ** 2 for i in a1]) / (dp * sum([i ** 2 for i in a1]) - sum(a1) ** 2), 0.5)
-    # seb = errfz * sey = errfz * ssresid / df -> se_intercept = sey * errfx = seb / errfz * errfx
-    se_intercept = sec / errfz * errfx
-    rse_intercept = se_intercept / intercept * 100
 
-    return intercept, se_intercept, rse_intercept, r2, 'mswd', [a, b, c], 'se', \
-           lambda x: [_exp_func(i, a, b, c) for i in x], m_ssresid
+def newton_minimize_1d(func, x0, h=1e-5, tol=1e-8, max_iter=30):
+    x = x0
+    for i in range(max_iter):
+        fx = func(x)
+        if not np.isfinite(fx):
+            raise ValueError("Newton Minimize: Function returned non-finite value at x={}".format(x))
+
+        # 一阶导数（中心差分）
+        f_plus = func(x + h)
+        f_minus = func(x - h)
+        if not (np.isfinite(f_plus) and np.isfinite(f_minus)):
+            raise ValueError("Newton Minimize: Non-finite values in derivative computation")
+        df = (f_plus - f_minus) / (2 * h)
+        d2f = (f_plus - 2 * fx + f_minus) / (h * h)
+
+        # 牛顿步长
+        if abs(d2f) < 1e-12:  # 避免除零或平坦区域
+            raise ValueError("Newton Minimize: Second derivative too small, stopping.")
+
+        step = df / d2f
+        x_new = x - step
+
+        if abs(step) < tol:
+            x = x_new
+            break
+
+        x = x_new
+
+    if i + 1 == max_iter:
+        raise ValueError("Newton Minimize: Over iteration max_iter={}".format(max_iter))
+
+    return x, i + 1
+
+
+def grad_minimize(func, x, lr=1e-5, tol=1e-8, max_iter=1000):
+
+    for i in range(max_iter):
+        f_plus = func(x + lr)
+        f_minus = func(x - lr)
+        if not (np.isfinite(f_plus) and np.isfinite(f_minus)):
+            raise ValueError("Newton Minimize: Non-finite values in derivative computation")
+        g = (f_plus - f_minus) / (2 * lr)
+        x_new = x - lr * g
+        if abs(func(x_new) - func(x)) < tol:
+            break
+        x = x_new
+    return x, i+1
 
 
 """ line functions """
 
 
-def linear_eq(x: list, beta: list):
+def linest_var(beta: list, cov: list, x: float):
+    """ y = b0 * x^0 + b1 * x^1 + ... + bn * x^n
+    Parameters
+    ----------
+
+    Returns
+    -------
+
+    """
+    beta = np.array(beta, dtype=np.float64)
+    cov_matrix = np.array(cov, dtype=np.float64)
+    g = np.array([x ** k for k in range(len(beta))]).reshape(-1, 1)
+    y = np.dot(g.T, beta.reshape(-1, 1))[0, 0]
+    var = np.matmul(np.matmul(g.T, cov_matrix), g)[0, 0]
+    return y, var
+
+
+def quadratic_var(beta: list, cov: list, x: float):
+    """ y = b0 * x^0 + b1 * x^1 + b2 * x^2
+    Parameters
+    ----------
+    beta : coefficients
+    x :
+
+    Returns
+    -------
+
+    """
+    beta = np.array(beta, dtype=np.float64)
+    cov_matrix = np.array(cov, dtype=np.float64)
+    g = np.array([x ** k for k in range(len(beta))]).reshape(-1, 1)
+    y = np.dot(g.T, beta.reshape(-1, 1))[0, 0]
+    var = np.matmul(np.matmul(g.T, cov_matrix), g)[0, 0]
+    return y, var
+
+
+def average_var(beta: list, cov: list, x: float):
     """ y = b0 * x^0 + b1 * x^1 + ... + bn * x^n
     Parameters
     ----------
@@ -970,21 +1069,29 @@ def linear_eq(x: list, beta: list):
     -------
 
     """
-    return [np.prod([beta, [_x ** i for i in range(len(beta))]], axis=0).sum() for _x in x]
+    y, = beta
+    var = np.array(cov, dtype=np.float64)[0, 0]
+    return y, var
 
 
-def exponential_eq(x: list, beta: list):
-    """ y = a * b ^ x + c
+def exponential_var(beta: list, cov: list, x: float):
+    """ y = a * exp(bx) + c
     Parameters
     ----------
     beta : coefficients, [a, b, c]
-    x :
+    cov : covariance [[], [], []]
 
     Returns
     -------
 
     """
-    return [beta[0] * beta[1] ** _x + beta[0] for _x in x]
+    cov_matrix = np.array(cov)
+    a, b, c = beta
+    k = np.exp(b*x)
+    g = np.array([k, a*x*k, 1]).reshape(-1, 1)
+    y = a * k + c
+    var = np.matmul(np.matmul(g.T, cov_matrix), g)[0, 0]
+    return y, var
 
 
 def power_eq(x: list, beta: list):

{ararpy-0.1.35 → ararpy-0.1.37}/ararpy/files/calc_file.py

@@ -493,40 +493,41 @@ def open_full_xls(file_path: str, sample_name: str = ''):
         res['Inverse Isochron Table'], rows, [4, 5, 6, 7, 10])
     total_param = arr.partial(
         res['Sample Parameters'], rows, [
-            # 1, 2,  # 0-1
-            -1, -1, -1, -1,  # 2-5
-            -1, -1, -1, -1,  # 6-9
-            -1, -1, -1, -1, -1, -1,  # 10-15
-            -1, -1, -1, -1,  # 16-19
-            -1, -1,  # 20-21
-            23, 24, -1, -1, -1, -1,  # 22-27
-            -1, -1,  # 28-29
-            22, -1, -1, -1,  # 30-33
-            -1, -1,  # 34-35
-            -1, -1,  # 36-37
-            -1, -1,  # 38-39
-            -1, -1,  # 40-41
-            -1, -1,  # 42-43
-            -1, -1,  # 44-45
-            -1, -1,  # 46-47
-            -1, -1,  # 48-49
-            -1, -1,  # 50-51
-            -1, -1,  # 52-53
-            -1, -1,  # 54-55
-            -1, -1,  # 56-57
-            -1, -1,  # 58-59
-            -1, -1, -1, -1, -1, -1, -1, -1, -1,  # 60-68
-            10, 11, 12, 13,  # 69-72
-            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,  # 73-84
-            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,  # 85-94
-            -1, -1, -1, -1,  # 95-98
-            -1, -1, -1, -1,  # 99-102
-            -1, -1, -1, -1,  # 103-106
-            -1, -1, -1, -1,  # 107-110
-            -1, -1, -1, -1,  # 111-114
-            -1, -1, -1, -1, -1, -1, -1, -1,  # 115-122
-            -1, -1, -1, -1, -1, -1, -1, -1,  # 123-130
-            -1, -1, -1, -1, -1,  # 131-135
+            # 1, 2, -1, # 0-2
+            -1, -1, -1, -1,  # 3-6
+            -1, -1, -1, -1,  # 7-10
+            -1, -1, -1, -1, -1, -1,  # 11-16
+            -1, -1, -1, -1,  # 17-20
+            -1, -1,  # 21-22
+            23, 24, -1, -1, -1, -1,  # 23-28
+            -1, -1,  # 29-30
+            22, -1, -1, -1,  # 31-34
+            -1, -1,  # 35-36
+            -1, -1,  # 37-38
+            -1, -1,  # 39-40
+            -1, -1,  # 41-42
+            -1, -1,  # 43-44
+            -1, -1,  # 45-46
+            -1, -1,  # 47-48
+            -1, -1,  # 49-50
+            -1, -1,  # 51-52
+            -1, -1,  # 53-54
+            -1, -1,  # 55-56
+            -1, -1,  # 57-58
+            -1, -1,  # 59-60
+            -1, -1, -1, -1, -1, -1, -1, -1, -1,  # 61-69
+            10, 11, 12, 13,  # 70-73
+            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,  # 74-85
+            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,  # 86-95
+            -1, -1, -1, -1,  # 96-99
+            -1, -1, -1, -1,  # 100-103
+            -1, -1, -1, -1,  # 104-107
+            -1, -1, -1, -1,  # 108-111
+            -1, -1, -1, -1,  # 112-115
+            -1, -1, -1, -1, -1, -1, -1, -1,  # 116-123
+            -1, -1, -1, -1, -1, -1, -1, -1,  # 124-131
+            -1, -1, -1, -1, -1,  # 132-136
+            -1, -1, -1, -1,  # 137-140
         ])
 
     month_convert = {'Jan': '01', 'Feb': '02', 'Mar': '03', 'Apr': '04', 'May': '05', 'Jun': '06',