Update

Author: pyrootcpp

highpymath/__init__.py

@@ -277,6 +277,137 @@ def linear(a: any = None, b: any = None, c: any = None, search_a: bool = False,
         if isinstance(b, int):
             b = float(b)
         _result = _linear_base_c(a=a, b=b)
+    if return_int:
+        _result = int(_result)
+    elif return_float:
+        _result = float(_result)
+    if return_string:
+        _result = str(_result)
+    return _result
+
+def sin(a: any, return_int: bool = False, return_string: bool = False):
+    """
+    Create the Sinus of a Number.
+    """
+    from .highpymath import sin as _sin
+    return_float = True
+    if return_int:
+        return_float = False
+    if not isinstance(a, (int, float)):
+        raise MathValueError("a must be a number")
+    if isinstance(a, int):
+        a = float(a)
+    _result = _sin(a=a)
+    if return_int:
+        _result = int(_result)
+    elif return_float:
+        _result = float(_result)
+    if return_string:
+        _result = str(_result)
+    return _result
+
+def cos(a: any, return_int: bool = False, return_string: bool = False):
+    """
+    Create the Cosinus of a Number.
+    """
+    from .highpymath import cos as _cos
+    return_float = True
+    if return_int:
+        return_float = False
+    if not isinstance(a, (int, float)):
+        raise MathValueError("a must be a number")
+    if isinstance(a, int):
+        a = float(a)
+    _result = _cos(a=a)
+    if return_int:
+        _result = int(_result)
+    elif return_float:
+        _result = float(_result)
+    if return_string:
+        _result = str(_result)
+    return _result
+
+def tan(a: any, return_int: bool = False, return_string: bool = False):
+    """
+    Create the Tanus of a Number.
+    """
+    from .highpymath import tan as _tan
+    return_float = True
+    if return_int:
+        return_float = False
+    if not isinstance(a, (int, float)):
+        raise MathValueError("a must be a number")
+    if isinstance(a, int):
+        a = float(a)
+    _result = _tan(a=a)
+    if return_int:
+        _result = int(_result)
+    elif return_float:
+        _result = float(_result)
+    if return_string:
+        _result = str(_result)
+    return _result
+
+def asin(a: any, return_int: bool = False, return_string: bool = False):
+    """
+    Create the Arcus Sinus of a Number.
+    """
+    from .highpymath import asin as _asin
+    return_float = True
+    if return_int:
+        return_float = False
+    if not isinstance(a, (int, float)):
+        raise MathValueError("a must be a number")
+    if isinstance(a, int):
+        a = float(a)
+    _result = _asin(a=a)
+    if return_int:
+        _result = int(_result)
+    elif return_float:
+        _result = float(_result)
+    if return_string:
+        _result = str(_result)
+    return _result
+
+def acos(a: any, return_int: bool = False, return_string: bool = False):
+    """
+    Create the Arcus Cosinus of a Number.
+    """
+    from .highpymath import acos as _acos
+    return_float = True
+    if return_int:
+        return_float = False
+    if not isinstance(a, (int, float)):
+        raise MathValueError("a must be a number")
+    if isinstance(a, int):
+        a = float(a)
+    _result = _acos(a=a)
+    if return_int:
+        _result = int(_result)
+    elif return_float:
+        _result = float(_result)
+    if return_string:
+        _result = str(_result)
+    return _result
+
+def atan(a: any, use_leibniz: bool = False, return_int: bool = False, return_string: bool = False):
+    """
+    Create the Arcus Tanus of a Number.
+    """
+    from .highpymath import atan as _atan1
+    from .highpymath import arctan as _atan2
+    return_float = True
+    if return_int:
+        return_float = False
+    if use_leibniz:
+        _atan = _atan2
+    else:
+        _atan = _atan1
+    if not isinstance(a, (int, float)):
+        raise MathValueError("a must be a number")
+    if isinstance(a, int):
+        a = float(a)
+    _result = _atan(a=a)
     if return_int:
         _result = int(_result)
     elif return_float:

src/lib.rs

@@ -110,6 +110,55 @@ fn linear_base_a(b: PyFloat, c: PyFloat) -> PyResult<PyFloat> {
     Ok(c - b)
 }
 
+#[pyfunction]
+fn sin(a: PyFloat) -> PyResult<PyFloat> {
+    Ok(a.sin())
+}
+
+#[pyfunction]
+fn cos(a: PyFloat) -> PyResult<PyFloat> {
+    Ok(a.cos())
+}
+
+#[pyfunction]
+fn tan(a: PyFloat) -> PyResult<PyFloat> {
+    Ok(a.tan())
+}
+
+#[pyfunction]
+fn asin(a: PyFloat) -> PyResult<PyFloat> {
+    Ok(a.asin())
+}
+
+#[pyfunction]
+fn acos(a: PyFloat) -> PyResult<PyFloat> {
+    Ok(a.acos())
+}
+
+#[pyfunction]
+fn atan(a: PyFloat) -> PyResult<PyFloat> {
+    Ok(a.atan())
+}
+
+#[pyfunction]
+fn arctan(x: PyFloat) -> PyResult<PyFloat> {
+    /// Berechne den arcus tangens Wert mit der Leibniz-Reihe
+    let mut result: PyFloat = 0.0;
+    let mut term: PyFloat = x;  // Startterm x^1 / 1
+    let mut i: PyInt = 1;
+
+    while term.abs() > 1e-15 {
+        if i % 2 == 1 {
+            result += term;  // Addiere ungerade Terme
+        } else {
+            result -= term;  // Subtrahiere gerade Terme
+        }
+        i += 1;
+        term = term * x * x / ((2 * i - 1) as PyFloat) * ((2 * i - 2) as PyFloat);  // Update term zu x^(2i+1) / (2i+1)
+    }
+    Ok(result)
+}
+
 /// A Python module implemented in Rust.
 #[pymodule]
 fn highpymath(m: &PyModule) -> PyResult<()> {
@@ -125,6 +174,13 @@ fn highpymath(m: &PyModule) -> PyResult<()> {
     m.add_function(wrap_pyfunction!(linear_base_c, m)?)?;
     m.add_function(wrap_pyfunction!(linear_base_b, m)?)?;
     m.add_function(wrap_pyfunction!(linear_base_a, m)?)?;
+    m.add_function(wrap_pyfunction!(sin, m)?)?;
+    m.add_function(wrap_pyfunction!(cos, m)?)?;
+    m.add_function(wrap_pyfunction!(tan, m)?)?;
+    m.add_function(wrap_pyfunction!(asin, m)?)?;
+    m.add_function(wrap_pyfunction!(acos, m)?)?;
+    m.add_function(wrap_pyfunction!(atan, m)?)?;
+    m.add_function(wrap_pyfunction!(arctan, m)?)?;
     m.add("MathValueError", m.py().get_type::<MathValueError>())?;
     Ok(())
 }