ararpy 0.0.1a1__py3-none-any.whl

ararpy/calc/isochron.py

@@ -0,0 +1,194 @@
+#!/usr/bin/env python
+# -*- coding: UTF-8 -*-
+"""
+# ==========================================
+# Copyright 2023 Yang
+# ararpy - calc - data
+# ==========================================
+#
+# Get plot data, including isochron diagram data points, age spectra data
+#
+"""
+
+from math import atan, cos, sin
+from ..calc import arr
+import numpy as np
+
+
+def get_data(x: list, sx: list, y: list, sy: list, z: list, sz: list, f: int = 1):
+    """
+    Get isochron data based on isotopic values. Values of two x and y axes of isochron
+    plots are x / z and y / z.
+
+    Parameters
+    ----------
+    x :
+    sx :
+    y :
+    sy :
+    z :
+    sz :
+    f :
+
+    Returns
+    -------
+    2D lists  [X, sX, Y, sY, Ri]
+        X and Y are coordinate values of data points in x and y axes respectively.
+        sX and sY are corresponding errors. Ri is a list of error correlation factors.
+    """
+    if np.issubdtype(type(f), np.integer) and f > 1:
+        sx, sy, sz = np.divide([sx, sy, sz], f)
+    # x / z
+    k0, k1 = arr.div((x, sx), (z, sz))
+    # y / z
+    k2, k3 = arr.div((y, sy), (z, sz))
+    # ri
+    k4 = arr.cor(np.divide(sx, x), np.divide(sy, y), np.divide(sz, z))
+    return [k0, k1, k2, k3, k4]
+
+
+def get_3d_data(x1: list, sx1: list, x2: list, sx2: list,
+                x3: list, sx3: list, z: list, sz: list, f: int = 1):
+    """ Get values of three axes, x, y, z, based on the given isotopic values
+    x = x1 / z, y = x2 / z, z = x3 / z
+    Parameters
+    ----------
+    x1
+    sx1
+    x2
+    sx2
+    x3
+    sx3
+    z
+    sz
+    f
+
+    Returns
+    -------
+    list.
+    """
+    if np.issubdtype(type(f), np.integer) and f > 1:
+        sx1, sx2, sx3 = np.divide([sx1, sx2, sx3], f)
+    # x1 / z
+    k0, k1 = arr.div((x1, sx1), (z, sz))
+    # x2 / z
+    k2, k3 = arr.div((x2, sx2), (z, sz))
+    # x3 / z
+    k4, k5 = arr.div((x3, sx3), (z, sz))
+    # r1 between x and y
+    r1 = arr.cor(np.divide(sx1, x1), np.divide(sx2, x2), np.divide(sz, z))
+    # r2 between x and z
+    r2 = arr.cor(np.divide(sx1, x1), np.divide(sx3, x3), np.divide(sz, z))
+    # r3 between y and z
+    r3 = arr.cor(np.divide(sx2, x2), np.divide(sx3, x3), np.divide(sz, z))
+    return [k0, k1, k2, k3, k4, k5, r1, r2, r3]
+
+
+def get_ellipse(x: float, sx: float, y: float, sy: float, r: float):
+    """ Error ellipses of data points in isochrons. Get 24 points of a ellispse
+
+    Parameters
+    ----------
+    x
+    sx
+    y
+    sy
+    r
+
+    Returns
+    -------
+    list of 24 points. [[x1, y1], ..., [x24, y24]]
+    """
+    x, sx, y, sy, r = float(x), float(sx), float(y), float(sy), float(r)
+    Qxx = sx ** 2
+    Qxy = sx * sy * r
+    Qyy = sy ** 2
+    # Calculate the ellipse's short semi-axial and long semi-axial
+    k = pow((Qxx - Qyy) ** 2 + 4 * Qxy ** 2, 0.5)
+    Qee = (Qxx + Qyy + k) / 2
+    Qff = (Qxx + Qyy - k) / 2
+    e = pow(Qee, 0.5)  # long semi-axial
+    f = pow(Qff, 0.5)  # short semi-axial
+    phi_e = atan((Qee - Qxx) / Qxy) if Qxy != 0 else 0 if Qxx >= Qyy else np.pi / 2  # radian
+
+    # adjust
+    plt_sfactor = 1
+    if plt_sfactor == 1:
+        v = 2.279  # 68% confidence limit, 1 sigma
+    elif plt_sfactor == 2:
+        v = 5.991  # 95% confidence limit, 2 sigma, Isoplot R always gives ellipse with 95% confidence
+    else:
+        v = 1
+    e = e * pow(v, 0.5)
+    f = f * pow(v, 0.5)
+
+    ellipse_points = []
+    for i in range(24):
+        theta = i * 15 / 180 * np.pi
+        ellipse_points.append([
+            e * cos(theta) * cos(phi_e) - f * sin(theta) * sin(phi_e) + x,
+            e * cos(theta) * sin(phi_e) + f * sin(theta) * cos(phi_e) + y
+        ])
+
+    return ellipse_points
+
+
+def get_line_points(xscale, yscale, coeffs=None):
+    """
+
+    Parameters
+    ----------
+    xscale : x boundary, [min, max]
+    yscale : y boundary, [min, max]
+    coeffs : y = coeffs[0] + coeffs[1:] * [x]
+
+    Returns
+    -------
+    List of data points
+    """
+
+    if not isinstance(coeffs, list) or len(coeffs) < 2:
+        raise ValueError(f"Coeffs should be a list with length with 2.")
+    get_y = lambda x: coeffs[0] + coeffs[1] * x
+    get_x = lambda y: (y - coeffs[0]) / coeffs[1] if coeffs[1] != 0 else None
+    res = []
+    for point in [
+        [xscale[0], get_y(xscale[0])], [xscale[1], get_y(xscale[1])],
+        [get_x(yscale[0]), yscale[0]], [get_x(yscale[1]), yscale[1]],
+    ]:
+        if xscale[0] <= point[0] <= xscale[1] and yscale[0] <= point[1] <= yscale[1]:
+            res.append(point)
+    return res
+
+
+def get_set_data(total_data: list, set1_index: list, set2_index: list, unselected_index: list):
+    """
+
+    Parameters
+    ----------
+    total_data
+    set1_index
+    set2_index
+    unselected_index
+
+    Returns
+    -------
+
+    """
+    set_1, set_2, unslected = [], [], []
+    # Remove string and None type in data
+    none_index = []
+    for each in total_data:
+        none_index = none_index + [key for key, val in enumerate(each) if isinstance(val, (str, type(None)))]
+    none_index = list(set(none_index))
+    none_index.sort(reverse=True)
+    for each in total_data:
+        for i in none_index:
+            each.pop(i)
+    set1_index.sort()
+    set2_index.sort()
+    for col in total_data:
+        unslected.append([col[i] for i in unselected_index if i < len(col)])
+        set_1.append([col[i] for i in set1_index if i < len(col)])
+        set_2.append([col[i] for i in set2_index if i < len(col)])
+    return set_1, set_2, unslected

ararpy/calc/jvalue.py

@@ -0,0 +1,38 @@
+#!/usr/bin/env python
+# -*- coding: UTF-8 -*-
+"""
+# ==========================================
+# Copyright 2023 Yang
+# ararpy - calc - jvalue
+# ==========================================
+#
+#
+#
+"""
+import numpy as np
+
+
+def j_value(age: float, sage: float, r: float, sr: float, f: float, rsf: float):
+    """ Calculate J value according to the given age and the ratio
+
+    Parameters
+    ----------
+    age : age of the reference standard sample, in Ma
+    sage : 1 sigma error of age
+    r : 40/39 ratio of the reference standard standard sample
+    sr : 1 sigma error of 40/39 ratio
+    f : decay constant(lambda) of K
+    rsf : relative error of decay constant
+
+    Returns
+    -------
+    tuple of  J value and error
+    """
+    f = f * 1000000  # exchange to unit of Ma
+    rsf = f * rsf / 100  # exchange to absolute error
+    k0 = (np.exp(f * age) - 1) / r
+    v1 = rsf ** 2 * (age * np.exp(f * age) / r) ** 2
+    v2 = sage ** 2 * (f * np.exp(f * age) / r) ** 2
+    v3 = sr ** 2 * ((1 - np.exp(f * age)) / r ** 2) ** 2
+    k1 = pow(v1 + v2 + v3, 0.5)
+    return k0, k1

ararpy/calc/plot.py

@@ -0,0 +1,68 @@
+#!/usr/bin/env python
+# -*- coding: UTF-8 -*-
+"""
+# ==========================================
+# Copyright 2023 Yang
+# ararpy - calc - plot
+# ==========================================
+#
+#
+#
+"""
+import traceback
+
+import decimal
+from math import exp, log, cos, acos, ceil, sqrt, atan, sin, gamma
+from typing import List, Any
+from scipy.optimize import fsolve
+from scipy.stats import distributions
+import numpy as np
+
+math_e = 2.718281828459045
+math_pi = 3.141592653589793
+
+
+def get_axis_scale(data: list, count=6, increment=None, extra_count=0, min_interval=1):
+    """
+
+    Parameters
+    ----------
+    data
+    count
+    increment
+    extra_count
+    min_interval
+
+    Returns
+    -------
+
+    """
+    if len(data) == 0:
+        return 0, 1, 5, 0.2  # Default return
+    _max = float(np.ma.masked_invalid(data).max())
+    _min = float(np.ma.masked_invalid(data).min())
+    interval = (_max - _min) / count
+    if interval == 0:
+        interval = 10
+    mag = 10 ** int(log(interval, 10)) if interval >= 1 else 10 ** (int(log(interval, 10)) - 1)
+    if not increment:
+        increment = decimal.Decimal(
+            str(decimal.Decimal(int(interval / mag // min_interval) + min_interval) * decimal.Decimal(str(mag))))
+    else:
+        increment = decimal.Decimal(increment)
+    start = decimal.Decimal(0)
+    if _min < 0:
+        start = -increment
+        while start > _min:
+            start -= increment
+    else:
+        while start + increment < _min:
+            start += increment
+    count = 0
+    while count * increment + start < _max:
+        count += 1
+    end = decimal.Decimal(str(count + extra_count)) * decimal.Decimal(str(increment)) + start
+    start -= decimal.Decimal(extra_count) * decimal.Decimal(str(increment))
+    start = 0 if start < 0 <= _min else start
+    count = (end - start) / increment
+    return float(start), float(end), int(count), float(increment)

ararpy/calc/raw_funcs.py

@@ -0,0 +1,118 @@
+#!/usr/bin/env python
+# -*- coding: UTF-8 -*-
+"""
+# ==========================================
+# Copyright 2023 Yang
+# ararpy - calc - raw_funcs
+# ==========================================
+#
+#
+#
+"""
+import traceback
+import numpy as np
+from .arr import transpose, is_twoD
+from . import regression
+
+
+"""get regression results for raw data points"""
+
+
+def get_raw_data_regression_results(points_data, unselected: list = None):
+    """
+    Parameters
+    ----------
+    points_data : two dimensional list. like [[x1, y1], [x2, y2], ..., [xn, yn]]
+    unselected :
+
+    Returns
+    -------
+
+    """
+    if unselected is None:
+        unselected = []
+    linesData, linesResults = [], []
+    x, y = transpose(points_data)
+    un_x = transpose(unselected)[0] if is_twoD(unselected) else []
+    reg_handler = [
+        regression.linest, regression.quadratic, regression.exponential,
+        regression.power, regression.average]
+    size = 50
+    lines_x = [(max(x + un_x) - 0) / size * i for i in range(size + 1)]
+    for i in range(len(reg_handler)):
+        try:
+            res = reg_handler[i](a0=y, a1=x)
+            line_data = transpose([lines_x, res[7](lines_x)])
+            line_results = res[0:4]
+            if np.isin(np.inf, line_data) or np.isin(np.nan, line_data):
+                raise ZeroDivisionError(f"Infinite value or nan value.")
+            if abs(res[0] - min(y)) > 5 * (max(y) - min(y)):
+                raise ValueError
+        except RuntimeError:
+            line_data, line_results = [], ['RuntimeError', np.nan, np.nan, np.nan]
+        except np.linalg.LinAlgError:
+            line_data, line_results = [], ['MatrixError', np.nan, np.nan, np.nan]
+        except TypeError or IndexError:
+            line_data, line_results = [], ['NotEnoughPoints', np.nan, np.nan, np.nan]
+        except ZeroDivisionError:
+            line_data, line_results = [], [np.inf, np.nan, np.nan, np.nan]
+        except ValueError:
+            line_data, line_results = [], ['BadFitting', np.nan, np.nan, np.nan]
+        except:
+            line_data, line_results = [], [np.nan, np.nan, np.nan, np.nan]
+        linesData.append(line_data)
+        linesResults.append(line_results)
+    return linesData, linesResults
+
+#
+# def get_lines_data(sequenceData, only_isotope=None):
+#     def _get_scatter_x(a: list, nope=50):
+#         interval = (max(a) - 0) / nope
+#         return [interval * (i + 1) for i in range(nope)]
+#
+#     linesData, linesResults = [], []
+#     for i in range(5):
+#         try:
+#             if isinstance(only_isotope, int) and i != only_isotope:
+#                 raise IndexError
+#             _ = transpose(sequenceData[i])
+#             x, y = _[0], _[1]
+#             try:
+#                 line_res = regression.linest(a0=y, a1=x)
+#             except:
+#                 line_res = ['BadFitting', 'None', 'None', 'None', 'None', 'None', 'None', 'None', 'None']
+#             try:
+#                 quad_res = regression.quadratic(a0=y, a1=x)
+#             except:
+#                 quad_res = ['BadFitting', 'None', 'None', 'None', 'None', 'None', 'None', 'None', 'None']
+#             try:
+#                 exp_res = regression.exponential(a0=y, a1=x)
+#             except:
+#                 exp_res = ['BadFitting', 'None', 'None', 'None', 'None', 'None', 'None', 'None', 'None']
+#             try:
+#                 pow_res = regression.power(a0=y, a1=x)
+#             except:
+#                 pow_res = ['BadFitting', 'None', 'None', 'None', 'None', 'None', 'None', 'None', 'None']
+#             else:
+#                 if abs(pow_res[0]) > 10 * max(y):
+#                     pow_res = ['BadFitting', 'None', 'None', 'None', 'None', 'None', 'None', 'None', 'None']
+#                 elif pow_res[0] < 0:
+#                     pow_res = ['Negative', 'None', 'None', 'None', 'None', 'None', 'None', 'None', 'None']
+#             try:
+#                 ave_res = regression.average(a0=y)
+#             except:
+#                 ave_res = ['BadFitting', 'None', 'None', 'None', 'None', 'None', 'None', 'None', 'None']
+#
+#             lines_x = [_x for _x in [0] + _get_scatter_x(x)]
+#             linesData.append([])
+#             for index, res in enumerate([line_res, quad_res, exp_res, pow_res, ave_res]):
+#                 try:
+#                     linesData[i].append(transpose([lines_x, res[7](lines_x)]))
+#                 except Exception as e:
+#                     linesData[i].append([])
+#             linesResults.append([line_res[0:4], quad_res[0:4], exp_res[0:4], pow_res[0:4], ave_res[0:4]])
+#         except IndexError or ValueError:
+#             linesData.append([[], [], [], [], []])
+#             linesResults.append([[], [], [], [], []])
+#
+#     return linesData, linesResults