Update

pyrootcpp · pyrootcpp · commit 0839f4f25755 · 2024-06-24T17:08:12.000+02:00
diff --git a/highpymath/__init__.py b/highpymath/__init__.py
@@ -1,6 +1,6 @@
 from .highpymath import MathValueError as _mve
 
-__all__ = ['sum', 'sub', 'mul', 'div', 'MathValueError', 'exp', 'sqrt', 'log', 'reciprocal', 'factorial', 'linear', 'cpi']
+__all__ = ['sum', 'sub', 'mul', 'div', 'MathValueError', 'exp', 'sqrt', 'log', 'reciprocal', 'factorial', 'calc_pi', 'calc_e']
 
 class MathValueError(_mve):
     """
@@ -229,62 +229,6 @@ def factorial(a: int, return_int: bool = False, return_string: bool = False):
         _result = str(_result)
     return _result
 
-def linear(a: any = None, b: any = None, c: any = None, search_a: bool = False, search_b: bool = False, search_c: bool = False, return_int: bool = False, return_string: bool = False):
-    """
-    Solve the Linear Function from type: a + b = c
-    """
-    from .highpymath import linear_base_a as _linear_base_a
-    from .highpymath import linear_base_b as _linear_base_b
-    from .highpymath import linear_base_c as _linear_base_c
-    return_float = True
-    if return_int:
-        return_float = False
-    if search_a and search_b and search_c:
-        raise MathValueError("You need to specify one of the 3 arguments")
-    if search_a and search_b:
-        raise MathValueError("You need to specify one of the 3 arguments")
-    if search_a and search_c:
-        raise MathValueError("You need to specify one of the 3 arguments")
-    if search_b and search_c:
-        raise MathValueError("You need to specify one of the 3 arguments")
-    if search_a:
-        if not isinstance(b, (int, float)):
-            raise MathValueError("b must be a number")
-        if not isinstance(c, (int, float)):
-            raise MathValueError("c must be a number")
-        if isinstance(b, int):
-            b = float(b)
-        if isinstance(c, int):
-            c = float(c)
-        _result = _linear_base_a(b=b, c=c)
-    elif search_b:
-        if not isinstance(a, (int, float)):
-            raise MathValueError("a must be a number")
-        if not isinstance(c, (int, float)):
-            raise MathValueError("c must be a number")
-        if isinstance(a, int):
-            a = float(a)
-        if isinstance(c, int):
-            c = float(c)
-        _result = _linear_base_b(a=a, c=c)
-    elif search_c:
-        if not isinstance(a, (int, float)):
-            raise MathValueError("a must be a number")
-        if not isinstance(b, (int, float)):
-            raise MathValueError("b must be a number")
-        if isinstance(a, int):
-            a = float(a)
-        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.
@@ -435,15 +379,19 @@ def calc_pi(return_int: bool = False, return_string: bool = False):
 
 pi = calc_pi()
 
-def calc_e(max: int = 1000, return_int: bool = True, return_string: bool = False):
+def calc_e(max: int = 20, return_int: bool = False, return_string: bool = False):
     """
     Calculate the euler number.
     """
-    from .highpymath import calc_e as _calc_e
+    from .highpymath import factorial as _fact
     return_float = True
     if return_int:
         return_float = False
-    _result = _calc_e(max=max)
+    _result = 0
+    i = 0
+    while i < max:
+        _result += 1 / _fact(i)
+        i += 1
     if return_int:
         _result = int(_result)
     elif return_float:
@@ -452,4 +400,152 @@ def calc_e(max: int = 1000, return_int: bool = True, return_string: bool = False
         _result = str(_result)
     return _result
 
-e = calc_e()
+e = calc_e()
+
+class equation:
+    """
+    Class to Solve equations.
+    """
+    @staticmethod
+    def quadratic(a: any, b: any, c: any = None, use_pq: bool = False, return_int: bool = False, return_string: bool = False) -> tuple:
+        """
+        Function to Solve a Quadratic Equation.
+        Attention:
+        - If you use use_pq = True, a will be used as p and b will be used as q.
+        - If you use use_pq = False, a will be used as a, b will be used as b and c will be used as c.
+        """
+        from .highpymath import quadratic_base as _base
+        from .highpymath import quadratic_pq as _pq
+        return_float = True
+        if return_int:
+            return_float = False
+        if not isinstance(a, (int, float)):
+            raise MathValueError("a must be a Number")
+        if not isinstance(b, (int, float)):
+            raise MathValueError("b must be a Number")
+        if not use_pq and c is None:
+            raise MathValueError("c is set as None, but you don't use pq")
+        if not use_pq and not isinstance(c, (int, float)):
+            raise MathValueError("c must be a Number")
+        if isinstance(a, int):
+            a = float(a)
+        if isinstance(b, int):
+            b = float(b)
+        if not use_pq and isinstance(c, int):
+            c = float(c)
+        if use_pq:
+            p = a
+            q = b
+        if not use_pq:
+            _result = _base(a=a, b=b, c=c)
+        else:
+            _result = _pq(p=p, q=q)
+        _result1 = _result[0]
+        _result2 = _result[1]
+        if return_int:
+            _result1 = int(_result1)
+            _result2 = int(_result2)
+        elif return_float:
+            _result1 = float(_result1)
+            _result2 = float(_result2)
+        if return_string:
+            _result1 = str(_result1)
+            _result2 = str(_result2)
+        return _result1, _result2
+    
+    @staticmethod
+    def linear(a: any = None, b: any = None, c: any = None, search_a: bool = False, search_b: bool = False, search_c: bool = False, return_int: bool = False, return_string: bool = False):
+        """
+        Solve the Linear Function from type: a + b = c
+        """
+        from .highpymath import linear_base_a as _linear_base_a
+        from .highpymath import linear_base_b as _linear_base_b
+        from .highpymath import linear_base_c as _linear_base_c
+        return_float = True
+        if return_int:
+            return_float = False
+        if search_a and search_b and search_c:
+            raise MathValueError("You need to specify one of the 3 arguments")
+        if search_a and search_b:
+            raise MathValueError("You need to specify one of the 3 arguments")
+        if search_a and search_c:
+            raise MathValueError("You need to specify one of the 3 arguments")
+        if search_b and search_c:
+            raise MathValueError("You need to specify one of the 3 arguments")
+        if search_a:
+            if not isinstance(b, (int, float)):
+                raise MathValueError("b must be a number")
+            if not isinstance(c, (int, float)):
+                raise MathValueError("c must be a number")
+            if isinstance(b, int):
+                b = float(b)
+            if isinstance(c, int):
+                c = float(c)
+            _result = _linear_base_a(b=b, c=c)
+        elif search_b:
+            if not isinstance(a, (int, float)):
+                raise MathValueError("a must be a number")
+            if not isinstance(c, (int, float)):
+                raise MathValueError("c must be a number")
+            if isinstance(a, int):
+                a = float(a)
+            if isinstance(c, int):
+                c = float(c)
+            _result = _linear_base_b(a=a, c=c)
+        elif search_c:
+            if not isinstance(a, (int, float)):
+                raise MathValueError("a must be a number")
+            if not isinstance(b, (int, float)):
+                raise MathValueError("b must be a number")
+            if isinstance(a, int):
+                a = float(a)
+            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
+
+equation = equation()
+
+__all__.append('equation')
+
+def sqrt2(base: any, return_int: bool = False, return_string: bool = False):
+    """
+    Calculate the Square Root of a Number.
+    """
+    from .highpymath import sqrt2 as _sqrt2
+    return_float = True
+    if return_int:
+        return_float = False
+    _result = _sqrt2(base=base)
+    if return_int:
+        _result = int(_result)
+    elif return_float:
+        _result = float(_result)
+    if return_string:
+        _result = str(_result)
+    return _result
+
+__all__.append('sqrt2')
+
+def exp2(base: any, return_int: bool = False, return_string: bool = False):
+    """
+    Calculate the Exponentiation of a Number.
+    """
+    from .highpymath import exp2 as _exp2
+    return_float = True
+    if return_int:
+        return_float = False
+    _result = _exp2(base=base)
+    if return_int:
+        _result = int(_result)
+    elif return_float:
+        _result = float(_result)
+    if return_string:
+        _result = str(_result)
+    return _result
diff --git a/src/lib.rs b/src/lib.rs
@@ -53,6 +53,12 @@ fn exp(base: PyFloat, power: PyFloat) -> PyResult<PyFloat> {
     Ok(base.powf(power))
 }
 
+#[pyfunction]
+fn exp2(base: PyFloat) -> PyResult<PyFloat> {
+    let _result = base.powf(2.0);
+    Ok(_result)
+}
+
 #[pyfunction]
 fn sqrt(base: PyFloat, power: PyFloat) -> PyResult<PyFloat> {
     if base < 0.0 && power % 2.0 == 0.0 {
@@ -62,6 +68,11 @@ fn sqrt(base: PyFloat, power: PyFloat) -> PyResult<PyFloat> {
     }
 }
 
+#[pyfunction]
+fn sqrt2(base: PyFloat) -> PyResult<PyFloat> {
+    Ok(base.sqrt())
+}
+
 #[pyfunction]
 fn log(base: PyFloat, power: PyFloat) -> PyResult<PyFloat> {
     if base <= 0.0 || base == 1.0 {
@@ -174,28 +185,61 @@ fn calc_pi() -> PyResult<PyFloat> {
     Ok(_pi)
 }
 
-fn facto(n: PyUInt) -> PyUInt {
-    let mut result = 1;
-    for i in 1..=n {
-        let new_result = result * i;
-        if new_result < result {  // Überlaufprüfung
-            panic!("Integer overflow during factorial calculation");
+#[pyfunction]
+fn quadratic_base(a: PyFloat, b: PyFloat, c: PyFloat) -> PyResult<(PyFloat, PyFloat)> {
+    if a == 0.0 {
+        return Err(MathValueError::new_err("Coefficient 'a' must not be zero"));
+    }
+    let discriminant = b.powf(2.0) - 4.0 * a * c;
+    if discriminant.is_nan() || discriminant.is_infinite() {
+        return Err(MathValueError::new_err("Discriminant calculation resulted in an invalid number"));
+    }
+    if discriminant < 0.0 {
+        let sqrt_discriminant = (-discriminant).sqrt();
+        let _result1 = (-b / (2.0 * a)) + (sqrt_discriminant / (2.0 * a));
+        let _result2 = (-b / (2.0 * a)) - (sqrt_discriminant / (2.0 * a));
+        if _result1.is_nan() || _result1.is_infinite() || _result2.is_nan() || _result2.is_infinite() {
+            return Err(MathValueError::new_err("Result calculation resulted in an invalid number"));
         }
-        result = new_result;
+        Ok((_result1, _result2))
+    } else {
+        let sqrt_discriminant = discriminant.sqrt();
+        let _result1 = (-b + sqrt_discriminant) / (2.0 * a);
+        let _result2 = (-b - sqrt_discriminant) / (2.0 * a);
+        if _result1.is_nan() || _result1.is_infinite() || _result2.is_nan() || _result2.is_infinite() {
+            return Err(MathValueError::new_err("Result calculation resulted in an invalid number"));
+        }
+        Ok((_result1, _result2))
     }
-    result
 }
 
 #[pyfunction]
-fn calc_e(max: PyInt) -> PyResult<PyFloat> {
-    let mut result: PyFloat = 0.0;
-    for i in 0..max {
-        let factorial_result = facto(i as PyUInt);  // Typkonvertierung, falls notwendig
-        result += 1.0 / factorial_result as PyFloat;  // Korrekte Typumwandlung
+fn quadratic_pq(p: PyFloat, q: PyFloat) -> PyResult<(PyFloat, PyFloat)> {
+    let discriminant = (p / 2.0).powf(2.0) - q;
+    if discriminant.is_nan() || discriminant.is_infinite() {
+        return Err(MathValueError::new_err("Discriminant calculation resulted in an invalid number"));
+    }
+    if discriminant < 0.0 {
+        let sqrt_discriminant = (-discriminant).sqrt();
+        let _result1 = -(p / 2.0) + sqrt_discriminant;
+        let _result2 = -(p / 2.0) - sqrt_discriminant;
+        if _result1.is_nan() || _result1.is_infinite() || _result2.is_nan() || _result2.is_infinite() {
+            return Err(MathValueError::new_err("Result calculation resulted in an invalid number"));
+        }
+        Ok((_result1, _result2))
+    } else {
+        let sqrt_discriminant = discriminant.sqrt();
+        let _result1 = -(p / 2.0) + sqrt_discriminant;
+        let _result2 = -(p / 2.0) - sqrt_discriminant;
+        if _result1.is_nan() || _result1.is_infinite() || _result2.is_nan() || _result2.is_infinite() {
+            return Err(MathValueError::new_err("Result calculation resulted in an invalid number"));
+        }
+        Ok((_result1, _result2))
     }
-    Ok(result)
 }
 
+// ... bestehender Code ...
+
 /// A Python module implemented in Rust.
 #[pymodule]
 fn highpymath(m: &PyModule) -> PyResult<()> {
@@ -204,7 +248,9 @@ fn highpymath(m: &PyModule) -> PyResult<()> {
     m.add_function(wrap_pyfunction!(mul, m)?)?;
     m.add_function(wrap_pyfunction!(div, m)?)?;
     m.add_function(wrap_pyfunction!(exp, m)?)?;
+    m.add_function(wrap_pyfunction!(exp2, m)?)?;
     m.add_function(wrap_pyfunction!(sqrt, m)?)?;
+    m.add_function(wrap_pyfunction!(sqrt2, m)?)?;
     m.add_function(wrap_pyfunction!(log, m)?)?;
     m.add_function(wrap_pyfunction!(factorial, m)?)?;
     m.add_function(wrap_pyfunction!(reciprocal, m)?)?;
@@ -219,7 +265,8 @@ fn highpymath(m: &PyModule) -> PyResult<()> {
     m.add_function(wrap_pyfunction!(atan, m)?)?;
     m.add_function(wrap_pyfunction!(arctan, m)?)?;
     m.add_function(wrap_pyfunction!(calc_pi, m)?)?;
-    m.add_function(wrap_pyfunction!(calc_e, m)?)?;
+    m.add_function(wrap_pyfunction!(quadratic_base, m)?)?;
+    m.add_function(wrap_pyfunction!(quadratic_pq, m)?)?;
     m.add("MathValueError", m.py().get_type::<MathValueError>())?;
     Ok(())
 }
