py-num-math 1.0.0__tar.gz

py_num_math-1.0.0/LICENCE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2026 Diouf Tech
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+Quote Diouf Tech in any of your work using this package, or PayPal us :
+https://www.paypal.com/paypalme/mathgamepy
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

py_num_math-1.0.0/PKG-INFO

@@ -0,0 +1,28 @@
+Metadata-Version: 2.4
+Name: py_num_math
+Version: 1.0.0
+Summary: Python package for mathematical numerical tools.
+Home-page: https://www.paypal.com/paypalme/mathgamepy
+Author: Aliou Diouf
+Author-email: aliou.diouf5@gmail.com
+License: Diouf Tech
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: License :: Free To Use But Restricted
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Operating System :: POSIX :: Linux
+Description-Content-Type: text/markdown
+License-File: LICENCE.txt
+Requires-Dist: flake8
+Requires-Dist: pytest
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: summary
+
+Python package for mathematical numerical tools.

py_num_math-1.0.0/README.md

@@ -0,0 +1,90 @@
+# pymath
+
+
+## Python Mathematics
+
+Math utilities in Python
+
+A package for numerical Mathematics in Python
+
+## Author
+* Aliou Diouf,
+* Graduated from University, Paul Sabatier Toulouse 3, in
+* Applied Mathematics, speciality Scientific Computing:
+* Numerical Analysis, PDE, Software Engineering, Images processing, Signal processing,
+  Aerospace, HR, English...
+
+* CEO and Founder of Diouf Tech, a STEM company headquartered in Paris
+
+* E-mail: aliou.diouf5@gmail.com
+* My LinkedIn: https://www.linkedin.com/in/aliou-diouf-7b980441b/
+* My personal Facebook: https://www.facebook.com/aliou.diouf.587/
+
+## Our product
+
+* https://www.mathgame-py.com
+
+## Company: Diouf Tech
+
+* PayPal: https://www.paypal.com/paypalme/mathgamepy
+* Facebook page: https://www.facebook.com/profile.php?id=100086476192955
+* address: 149, Avenue du Maine, 75014 Paris, France
+* Location: France
+* Target: Worldwide
+
+## Test and Deploy
+
+* Tests: pymath/tests
+* All tests must pass. However, some tests may be environment (computer, OS, Python...) precision dependant.
+
+* If you need consultant, feel free to e-mail: aliou.diouf5@gmail.com
+* For deployment, we are AWS-oriented
+* We prefer empty EC2 server. We can scale it over the time according to usage
+
+***
+
+# This README
+
+Describes pymath idea, goal, context, usages ...
+
+## Suggestions
+
+Read it entirely.
+
+## pymath
+pymath stands for Python Mathematics.
+
+## Description
+A package for numerical Mathematics in Python, can be used in numerical simulations.
+
+## Visuals
+Diouf Tech logo.
+
+## Installation
+* pip install pymath
+* Locally: pip install .
+
+## Usages
+* import pymath
+* from pymath.src.dir_name.file_name import the_function_you_want
+* For tests: pytest
+
+## Support
+E-mail to: aliou.diouf5@gmail.com
+
+## Roadmap
+Under development
+
+## Contributing
+* We cannot invite people without financial support.
+* We prefer financial support:
+* PayPal: https://www.paypal.com/paypalme/mathgamepy
+
+## Authors and acknowledgment
+Aliou Diouf (aliou.diouf5@gmail.com)
+
+## License
+Diouf Tech License.
+
+## Project status
+Ongoing

py_num_math-1.0.0/py_num_math.egg-info/PKG-INFO

@@ -0,0 +1,28 @@
+Metadata-Version: 2.4
+Name: py_num_math
+Version: 1.0.0
+Summary: Python package for mathematical numerical tools.
+Home-page: https://www.paypal.com/paypalme/mathgamepy
+Author: Aliou Diouf
+Author-email: aliou.diouf5@gmail.com
+License: Diouf Tech
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: License :: Free To Use But Restricted
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Operating System :: POSIX :: Linux
+Description-Content-Type: text/markdown
+License-File: LICENCE.txt
+Requires-Dist: flake8
+Requires-Dist: pytest
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: summary
+
+Python package for mathematical numerical tools.

py_num_math-1.0.0/py_num_math.egg-info/SOURCES.txt

@@ -0,0 +1,25 @@
+LICENCE.txt
+README.md
+setup.py
+py_num_math.egg-info/PKG-INFO
+py_num_math.egg-info/SOURCES.txt
+py_num_math.egg-info/dependency_links.txt
+py_num_math.egg-info/requires.txt
+py_num_math.egg-info/top_level.txt
+pymath/__init__.py
+pymath/src/dot_prod/dot_prod.py
+pymath/src/fibonacci/fibonacci.py
+pymath/src/finite_diff/finite_diff.py
+pymath/src/matrices/rectangular_matrices.py
+pymath/src/matrices/square_matrices.py
+pymath/src/norms/norm_lp.py
+pymath/src/num_seq/num_seq.py
+pymath/src/vectors/vectors.py
+pymath/tests/dot_prod/test_dot_prod.py
+pymath/tests/fibonacci/test_fibonacci.py
+pymath/tests/finite_diff/test_finite_diff.py
+pymath/tests/matrices/test_rectangular_matrices.py
+pymath/tests/matrices/test_square_matrices.py
+pymath/tests/norms/test_norm_lp.py
+pymath/tests/num_seq/test_num_seq.py
+pymath/tests/vectors/test_vectors.py

py_num_math-1.0.0/py_num_math.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

py_num_math-1.0.0/py_num_math.egg-info/requires.txt

@@ -0,0 +1,2 @@
+flake8
+pytest

py_num_math-1.0.0/py_num_math.egg-info/top_level.txt

@@ -0,0 +1 @@
+pymath

py_num_math-1.0.0/pymath/src/dot_prod/dot_prod.py

@@ -0,0 +1,13 @@
+"""
+Dot product without external library
+Aliou Diouf, graduated from Toulouse University, in Applied Mathematics,
+President and Founder of Diouf Tech, A STEM company headquartered in Paris
+Our product: www.mathgame-py.com
+https://www.paypal.com/paypalme/mathgamepy
+"""
+
+
+def dot_prod(x, y):
+    """Dot product between x and y, where x and y are vectors"""
+
+    return sum([x_i * y_i for x_i, y_i in zip(x, y)])

py_num_math-1.0.0/pymath/src/fibonacci/fibonacci.py

@@ -0,0 +1,37 @@
+"""
+Fibonacci without library
+Author: Aliou Diouf - Master degree from University, Paul Sabatier Toulouse 3,
+in Applied Mathematics, speciality Scientific Computing (Numerical Analysis,
+PDE, Software Engineering, Images&Signal processing, Aerospace, HR, English...)
+CEO and Founder of Diouf Tech, a STEM company headquartered in Paris (75014)
+Products: www.mathgame-py.com, https://www.paypal.com/paypalme/mathgamepy
+Facebook page: https://www.facebook.com/profile.php?id=100086476192955
+My personal Facebook: https://www.facebook.com/aliou.diouf.587/
+My LinkedIn: https://www.linkedin.com/in/aliou-diouf-7b980441b/
+My PyPI packages: https://pypi.org/project/py-ci-cd,
+                  https://pypi.org/project/pymeshing
+                  https://pypi.org/project/passwordworld
+"""
+
+
+def fib(p):
+    """
+    Yields the p terms of Fibonacci sequence, from F1.
+    Note:
+        F0 = 0
+        F1 = 1
+    """
+
+    # Initialization (F0 = 0, F1 = 1, first terms of the sequence)
+    fnm2 = 0
+    fnm1 = 1
+
+    # Yield F1. F0 is 0, it is not useful to yield it.
+    yield fnm1
+
+    # F2, F3, ..., Fn
+    for i in range(2, p+1):
+        fn = fnm1 + fnm2
+        fnm2, fnm1 = fnm1, fn
+
+        yield fn

py_num_math-1.0.0/pymath/src/finite_diff/finite_diff.py

@@ -0,0 +1,46 @@
+"""
+Finite differences
+Source: https://en.wikipedia.org/wiki/Finite_difference_method
+Author: Aliou Diouf - Master degree from University, Paul Sabatier Toulouse 3,
+in Applied Mathematics, speciality Scientific Computing (Numerical Analysis,
+PDE, Software Engineering, Images&Signal processing, Aerospace, HR, English...)
+CEO and Founder of Diouf Tech, a STEM company headquartered in Paris (75014)
+Products: www.mathgame-py.com, https://www.paypal.com/paypalme/mathgamepy
+Facebook page: https://www.facebook.com/profile.php?id=100086476192955
+My personal Facebook: https://www.facebook.com/aliou.diouf.587/
+My LinkedIn: https://www.linkedin.com/in/aliou-diouf-7b980441b/
+My PyPI packages: https://pypi.org/project/py-ci-cd,
+                  https://pypi.org/project/pymeshing
+                  https://pypi.org/project/passwordworld
+"""
+
+
+def first_der_finite_difference_backwarded(f, x0, h):
+    """
+    Approximation of first derivative of f in x0 using
+    finite difference method backwarded (or left)
+    """
+    return (f(x0) - f(x0 - h)) / h
+
+
+def first_der_finite_difference_centred(f, x0, h):
+    """
+    Approximation of first derivative of f in x0 using
+    finite difference method centred
+    """
+    return (f(x0 + h) - f(x0 - h)) / (2 * h)
+
+
+def first_der_finite_difference_forwarded(f, x0, h):
+    """
+    Approximation of first derivative of f in x0 using
+    finite difference method forwarded (or right)
+    """
+    return (f(x0 + h) - f(x0)) / h
+
+
+def sec_der_finite_difference(f, x0, h):
+    """
+    Approximation of second derivative of f in x0 with finite difference method
+    """
+    return (f(x0 + h) - 2 * f(x0) + f(x0 - h)) / h ** 2

py_num_math-1.0.0/pymath/src/matrices/rectangular_matrices.py

@@ -0,0 +1,37 @@
+"""
+Rectangular matrices
+A rectangular matrix is a list of m list(s) of n element(s)
+m > 0, n > 0
+You can use numpy. However, the goal here is to do not use external library
+Author: Aliou Diouf - Master degree from University, Paul Sabatier Toulouse 3,
+in Applied Mathematics, speciality Scientific Computing (Numerical Analysis,
+PDE, Software Engineering, Images&Signal processing, Aerospace, HR, English...)
+CEO and Founder of Diouf Tech, a STEM company headquartered in Paris (75014)
+Products: www.mathgame-py.com, https://www.paypal.com/paypalme/mathgamepy
+Facebook page: https://www.facebook.com/profile.php?id=100086476192955
+My personal Facebook: https://www.facebook.com/aliou.diouf.587/
+My LinkedIn: https://www.linkedin.com/in/aliou-diouf-7b980441b/
+My PyPI packages: https://pypi.org/project/py-ci-cd,
+                  https://pypi.org/project/pymeshing
+                  https://pypi.org/project/passwordworld
+"""
+
+
+def zero_matrix(m, n):
+    """Zero matrix"""
+
+    return [[0] * n for _ in range(m)]
+
+
+def sum_matrices(m1, m2):
+    """Sum of matrices"""
+
+    # c1, c2: respectively coeff for m1, m2; l1: line of m1, l2: line of m2
+    return [[c1 + c2 for c1, c2 in zip(l1, l2)] for l1, l2 in zip(m1, m2)]
+
+
+def substraction_matrices(m1, m2):
+    """Substraction matrices: m1 - m2"""
+
+    # c1, c2: respectively coeff for m1, m2; l1: line of m1, l2: line of m2
+    return [[c1 - c2 for c1, c2 in zip(l1, l2)] for l1, l2 in zip(m1, m2)]

py_num_math-1.0.0/pymath/src/matrices/square_matrices.py

@@ -0,0 +1,75 @@
+"""
+Square matrices -  A list of n list(s) of n element(s), n > 0
+You can use numpy. However, the goal here is to do not use external library
+Author: Aliou Diouf - Master degree from University, Paul Sabatier Toulouse 3,
+in Applied Mathematics, speciality Scientific Computing (Numerical Analysis,
+PDE, Software Engineering, Images&Signal processing, Aerospace, HR, English...)
+CEO and Founder of Diouf Tech, a STEM company headquartered in Paris (75014)
+Products: www.mathgame-py.com, https://www.paypal.com/paypalme/mathgamepy
+Facebook page: https://www.facebook.com/profile.php?id=100086476192955
+My personal Facebook: https://www.facebook.com/aliou.diouf.587/
+My LinkedIn: https://www.linkedin.com/in/aliou-diouf-7b980441b/
+My PyPI packages: https://pypi.org/project/py-ci-cd,
+                  https://pypi.org/project/pymeshing
+                  https://pypi.org/project/passwordworld
+"""
+
+
+def print_matrix(matrix):
+    """
+    Prints a matrix in an human-readable way.
+    Here matrix is square of size n
+    """
+
+    n = len(matrix)
+
+    for i in range(n):
+        for j in range(n-1):
+            print(matrix[i][j], end='    ')
+        print(matrix[i][-1], end='\n')
+
+    return 'ok'
+
+
+def zero_matrix(n):
+    """n x n zero matrix"""
+
+    return [[0] * n for _ in range(n)]
+
+
+def identity_matrix(n):
+    """Identity matrix"""
+
+    return [[1 if j == i else 0 for j in range(n)] for i in range(n)]
+
+
+def diagonal_matrix(coeff):
+    """Diagonal matrix. Coeff is the vector of coefficients in the diagonal"""
+
+    n = len(coeff)
+
+    return [[coeff[i] if j == i else 0.00 for j in range(n)] for i in range(n)]
+
+
+def tridiagonal_matrix(lower, diag, upper):
+    r"""
+    Tridiagonal matrix. lower, diag and upper are respectively the vectors
+    of coefficients under the diagonal, on the diagonal, upper the diagonal
+    /!\ In industrial application you do not fill tridiagonaal matrix.
+    Search for Thomas algorithm
+    """
+
+    n = len(diag)
+    tridiag = zero_matrix(n)
+
+    tridiag[0][0] = diag[0]
+    tridiag[0][1] = upper[0]
+    tridiag[n-1][n-2] = lower[-1]
+    tridiag[n-1][n-1] = diag[n-1]
+
+    for i in range(1, n-1):
+        tridiag[i][i-1] = lower[i-1]
+        tridiag[i][i] = diag[i]
+        tridiag[i][i+1] = upper[i]
+
+    return tridiag

py_num_math-1.0.0/pymath/src/norms/norm_lp.py

@@ -0,0 +1,20 @@
+"""
+Norm Lp
+Author: Aliou Diouf - Master degree from University, Paul Sabatier Toulouse 3,
+in Applied Mathematics, speciality Scientific Computing (Numerical Analysis,
+PDE, Software Engineering, Images&Signal processing, Aerospace, HR, English...)
+CEO and Founder of Diouf Tech, a STEM company headquartered in Paris (75014)
+Products: www.mathgame-py.com, https://www.paypal.com/paypalme/mathgamepy
+Facebook page: https://www.facebook.com/profile.php?id=100086476192955
+My personal Facebook: https://www.facebook.com/aliou.diouf.587/
+My LinkedIn: https://www.linkedin.com/in/aliou-diouf-7b980441b/
+My PyPI packages: https://pypi.org/project/py-ci-cd,
+                  https://pypi.org/project/pymeshing
+                  https://pypi.org/project/passwordworld
+"""
+
+
+def norm_lp(vect, p):
+    """Norm Lp of a vect, where vect is a vector of length n"""
+
+    return sum([abs(v_i) ** p for v_i in vect]) ** 1/p

py_num_math-1.0.0/pymath/src/num_seq/num_seq.py

@@ -0,0 +1,74 @@
+"""
+Numerical sequences
+Author: Aliou Diouf - Master degree from University, Paul Sabatier Toulouse 3,
+in Applied Mathematics, speciality Scientific Computing (Numerical Analysis,
+PDE, Software Engineering, Images&Signal processing, Aerospace, HR, English...)
+CEO and Founder of Diouf Tech, a STEM company headquartered in Paris (75014)
+Products: www.mathgame-py.com, https://www.paypal.com/paypalme/mathgamepy
+Facebook page: https://www.facebook.com/profile.php?id=100086476192955
+My personal Facebook: https://www.facebook.com/aliou.diouf.587/
+My LinkedIn: https://www.linkedin.com/in/aliou-diouf-7b980441b/
+My PyPI packages: https://pypi.org/project/py-ci-cd,
+                  https://pypi.org/project/pymeshing
+                  https://pypi.org/project/passwordworld
+"""
+
+
+def arithmetic_seq_gen(ap, p, d, n):
+    """
+    Arithmetic sequence (or progression) in general, with common difference d
+    n is the number of the term to compute
+    """
+
+    return ap + (n - p) * d
+
+
+def arithmetic_seq_a0(a0, d, n):
+    """
+    Arithmetic sequence in the special case "ap = a0", with common difference d
+    n is the number of the term to compute
+    """
+
+    return a0 + n * d
+
+
+def arithmetic_seq_a1(a1, d, n):
+    """
+    Arithmetic sequence in the special case "ap = a1", with common difference d
+    n is the number of the term to compute
+    """
+
+    return a1 + (n - 1) * d
+
+
+def sum_arithmetic_seq(first_term, last_term, nb_term):
+    """Sum of rithmetic sequence"""
+
+    return (first_term + last_term) * nb_term / 2
+
+
+def geometric_seq_gen(ap, p, r, n):
+    """
+    Geometric sequence (or progression) in general, with common ratio r
+    n is the number of the term to compute
+    """
+
+    return ap * r ** (n - p)
+
+
+def geometric_seq_a0(a0, r, n):
+    """
+    Geometric sequence in the special case "ap = a0", with common ratio r
+    n is the number of the term to compute
+    """
+
+    return a0 * r ** n
+
+
+def geometric_seq_a1(a1, r, n):
+    """
+    Geometric sequence in the special case "ap = a1", with common ratio r
+    n is the number of the term to compute
+    """
+
+    return a1 * r ** (n - 1)

py_num_math-1.0.0/pymath/src/vectors/vectors.py

@@ -0,0 +1,51 @@
+"""
+Vector
+A rectangular matrix is a list of m list(s) of n element(s)
+m > 0, n > 0
+You can use numpy. However, the goal here is to do not use external library
+Author: Aliou Diouf - Master degree from University, Paul Sabatier Toulouse 3,
+in Applied Mathematics, speciality Scientific Computing (Numerical Analysis,
+PDE, Software Engineering, Images&Signal processing, Aerospace, HR, English...)
+CEO and Founder of Diouf Tech, a STEM company headquartered in Paris (75014)
+Products: www.mathgame-py.com, https://www.paypal.com/paypalme/mathgamepy
+Facebook page: https://www.facebook.com/profile.php?id=100086476192955
+My personal Facebook: https://www.facebook.com/aliou.diouf.587/
+My LinkedIn: https://www.linkedin.com/in/aliou-diouf-7b980441b/
+My PyPI packages: https://pypi.org/project/py-ci-cd,
+                  https://pypi.org/project/pymeshing
+                  https://pypi.org/project/passwordworld
+"""
+from random import uniform
+
+
+def zero_vector(n):
+    """Vector on n zeros"""
+
+    return [0] * n
+
+
+def sum_vectors(vector1, vector2):
+    """Sum of two vectors of length n"""
+
+    return [v1 + v2 for v1, v2 in zip(vector1, vector2)]
+
+
+def substraction_vectors(vector1, vector2):
+    """Substraction vectors: vector1 - vector2, of length n"""
+
+    return [v1 - v2 for v1, v2 in zip(vector1, vector2)]
+
+
+def unit_vector(n, i):
+    """Unit vector where 1 is at position i <= n"""
+
+    vect = zero_vector(n)
+    vect[i] = 1
+
+    return vect
+
+
+def random_vector(n, min_val, max_val):
+    """Random vector of length n"""
+
+    return [uniform(min_val, max_val) for _ in range(n)]

py_num_math-1.0.0/pymath/tests/dot_prod/test_dot_prod.py

@@ -0,0 +1,27 @@
+"""
+Test dot_prod module
+Aliou Diouf, graduated from Toulouse University, in Applied Mathematics,
+President and Founder of Diouf Tech, A STEM company headquartered in Paris
+Our product: www.mathgame-py.com
+https://www.paypal.com/paypalme/mathgamepy
+"""
+
+from pymath.src.dot_prod.dot_prod import dot_prod
+
+
+def test_dot_prod():
+    """Tests dot_prod function from dot_prod module"""
+
+    n = 3
+
+    x = [0] * n
+    y = [1] * n
+    assert dot_prod(x, y) == 0
+
+    x = [1, 0, 0]
+    y = [0, 1, 0]
+    assert dot_prod(x, y) == 0
+
+    x = [1] * n
+    y = [1] * n
+    assert dot_prod(x, y) == n

py_num_math-1.0.0/pymath/tests/fibonacci/test_fibonacci.py

@@ -0,0 +1,46 @@
+#!/usr/bin/env python
+"""
+Fibonacci without library
+Author: Aliou Diouf - Master degree from University, Paul Sabatier Toulouse 3,
+in Applied Mathematics, speciality Scientific Computing (Numerical Analysis,
+PDE, Software Engineering, Images&Signal processing, Aerospace, HR, English...)
+CEO and Founder of Diouf Tech, a STEM company headquartered in Paris (75014)
+Products: www.mathgame-py.com, https://www.paypal.com/paypalme/mathgamepy
+Facebook page: https://www.facebook.com/profile.php?id=100086476192955
+My personal Facebook: https://www.facebook.com/aliou.diouf.587/
+My LinkedIn: https://www.linkedin.com/in/aliou-diouf-7b980441b/
+My PyPI packages: https://pypi.org/project/py-ci-cd,
+                  https://pypi.org/project/pymeshing
+                  https://pypi.org/project/passwordworld
+"""
+
+from pymath.src.fibonacci.fibonacci import fib
+
+
+# Just an example
+p = 17
+
+# Just printing the Fibonacci terms
+for f in fib(p):
+    print(f)
+print('fn = ', f)
+
+
+# Now we aim to compute the mean of phi, Where phi = Fn / F_{n-1}, n > 1.
+# Let denote this mean of phi phi_mean.
+
+# Let p a big number.
+# The bigger is p, the closer to golden ratio is the mean of phi.
+# This corresponds also to "Law of large numbers".
+p = 100000
+
+# Initialization in order to sum to get the mean of phi
+s = 0
+fnm1 = 1
+
+for f in fib(p):
+    phi = f / fnm1
+    s += phi
+    fnm1 = f
+
+print('phi_mean = ', s / p)

py_num_math-1.0.0/pymath/tests/finite_diff/test_finite_diff.py

@@ -0,0 +1,116 @@
+"""
+Tests finite_diff module
+Source: https://en.wikipedia.org/wiki/Finite_difference_method
+Author: Aliou Diouf - Master degree from University, Paul Sabatier Toulouse 3,
+in Applied Mathematics, speciality Scientific Computing (Numerical Analysis,
+PDE, Software Engineering, Images&Signal processing, Aerospace, HR, English...)
+CEO and Founder of Diouf Tech, a STEM company headquartered in Paris (75014)
+Products: www.mathgame-py.com, https://www.paypal.com/paypalme/mathgamepy
+Facebook page: https://www.facebook.com/profile.php?id=100086476192955
+My personal Facebook: https://www.facebook.com/aliou.diouf.587/
+My LinkedIn: https://www.linkedin.com/in/aliou-diouf-7b980441b/
+My PyPI packages: https://pypi.org/project/py-ci-cd,
+                  https://pypi.org/project/pymeshing
+                  https://pypi.org/project/passwordworld
+"""
+from pymath.src.finite_diff.finite_diff import (
+    first_der_finite_difference_backwarded,
+    first_der_finite_difference_centred,
+    first_der_finite_difference_forwarded,
+    sec_der_finite_difference
+)
+from math import cos, sin
+from random import uniform
+
+
+# If epsilon is too low, your criterion to validate a test would be too strict.
+# So, tests would not pass
+epsilon = 0.1  # If too low tests will fail, approximation has limit
+
+# If h is too high, you would get good time computing but not good accuracy
+# If h is too low, you woulg get good accuracy, but high computing time
+h = 1.e-3
+
+maxi = 1000
+mini = - maxi
+
+
+def for_first_der(num_method):
+    """The test process called inside all tests"""
+
+    f = cos
+    x0 = uniform(mini, maxi)
+
+    fprime = num_method(f, x0, h)
+
+    # fprime(cos) = -sin
+    if sin(x0) == 0.0:
+        assert abs(fprime + sin(x0)) < epsilon
+    else:
+        assert abs(fprime + sin(x0)) / abs(sin(x0)) < epsilon
+
+    f = sin
+    x0 = uniform(mini, maxi)
+
+    fprime = num_method(f, x0, h)
+
+    # fprime(sin) = cos
+    print(fprime, cos(x0))
+    if cos(x0) == 0.0:
+        assert abs(fprime - cos(x0)) < epsilon
+    else:
+        assert abs(fprime - cos(x0)) / abs(cos(x0)) < epsilon
+
+
+def test_first_der_finite_difference_backwarded():
+    """
+    It tests: Approximation of first derivative of f in x0 using
+    finite difference method backwarded (or left)
+    """
+    for_first_der(first_der_finite_difference_backwarded)
+
+
+def test_first_der_finite_difference_centred():
+    """
+    It tests: Approximation of first derivative of f in x0 using
+    finite difference method centred
+    """
+    for_first_der(first_der_finite_difference_centred)
+
+
+def test_first_der_finite_difference_forwarded():
+    """
+    It tests: Approximation of first derivative of f in x0 using
+    finite difference method forwarded (or right)
+    """
+    for_first_der(first_der_finite_difference_forwarded)
+
+
+def test_sec_der_finite_difference():
+    """
+    It tests:
+    Approximation of second derivative of f in x0 with finite difference method
+    """
+
+    f = cos
+    x0 = uniform(mini, maxi)
+
+    fsec = sec_der_finite_difference(f, x0, h)
+    print(fsec, -cos(x0))
+
+    # Second derivative of cos is -cos
+    if cos(x0) == 0.0:
+        assert abs(fsec + cos(x0)) < epsilon
+    else:
+        assert abs(fsec + cos(x0)) / abs(cos(x0)) < epsilon
+
+    f = sin
+    x0 = uniform(mini, maxi)
+
+    fsec = sec_der_finite_difference(f, x0, h)
+
+    # Second derivative of sin is -sin
+    if sin(x0) == 0.0:
+        assert abs(fsec + sin(x0)) < epsilon
+    else:
+        assert abs(fsec + sin(x0)) / abs(sin(x0)) < epsilon

py_num_math-1.0.0/pymath/tests/matrices/test_rectangular_matrices.py

@@ -0,0 +1,72 @@
+"""
+Tests rectangular matrices
+A rectangular matrix is a list of m list(s) of n element(s)
+m > 0, n > 0
+You can use numpy. However, the goal here is to do not use external library
+Author: Aliou Diouf - Master degree from University, Paul Sabatier Toulouse 3,
+in Applied Mathematics, speciality Scientific Computing (Numerical Analysis,
+PDE, Software Engineering, Images&Signal processing, Aerospace, HR, English...)
+CEO and Founder of Diouf Tech, a STEM company headquartered in Paris (75014)
+Products: www.mathgame-py.com, https://www.paypal.com/paypalme/mathgamepy
+Facebook page: https://www.facebook.com/profile.php?id=100086476192955
+My personal Facebook: https://www.facebook.com/aliou.diouf.587/
+My LinkedIn: https://www.linkedin.com/in/aliou-diouf-7b980441b/
+My PyPI packages: https://pypi.org/project/py-ci-cd,
+                  https://pypi.org/project/pymeshing
+                  https://pypi.org/project/passwordworld
+"""
+from pymath.src.matrices.rectangular_matrices import zero_matrix, \
+    sum_matrices, substraction_matrices
+
+
+def test_zero_matrix():
+    """Tests zero_matrix"""
+
+    assert zero_matrix(1, 2) == [[0, 0]]
+    assert zero_matrix(2, 1) == [[0], [0]]
+    assert zero_matrix(2, 3) == [[0, 0, 0], [0, 0, 0]]
+    assert zero_matrix(3, 2) == [[0, 0], [0, 0], [0, 0]]
+
+
+def test_sum_matrices():
+    """Tests sum_matrices"""
+
+    m1 = [[1, 1]]
+    m2 = [[2, 2]]
+    assert sum_matrices(m1, m2) == [[3, 3]]
+
+    m1 = [[1], [1]]
+    m2 = [[2], [2]]
+    assert sum_matrices(m1, m2) == [[3], [3]]
+
+    m1 = [[1, 1, 1], [1, 1, 1]]
+    m2 = [[2, 2, 2], [2, 2, 2]]
+    assert sum_matrices(m1, m2) == [[3, 3, 3], [3, 3, 3]]
+
+    m1 = [[1, 1], [1, 1], [1, 1]]
+    m2 = [[2, 2], [2, 2], [2, 2]]
+    assert sum_matrices(m1, m2) == [[3, 3], [3, 3], [3, 3]]
+
+
+def test_substraction_matrices():
+    """Tests substraction_matrices"""
+
+    m1 = [[1, 1]]
+    m2 = [[2, 2]]
+    assert substraction_matrices(m1, m2) == [[-1, -1]]
+    assert substraction_matrices(m2, m1) == [[1, 1]]
+
+    m1 = [[1], [1]]
+    m2 = [[2], [2]]
+    assert substraction_matrices(m1, m2) == [[-1], [-1]]
+    assert substraction_matrices(m2, m1) == [[1], [1]]
+
+    m1 = [[1, 1, 1], [1, 1, 1]]
+    m2 = [[2, 2, 2], [2, 2, 2]]
+    assert substraction_matrices(m1, m2) == [[-1, -1, -1], [-1, -1, -1]]
+    assert substraction_matrices(m2, m1) == [[1, 1, 1], [1, 1, 1]]
+
+    m1 = [[1, 1], [1, 1], [1, 1]]
+    m2 = [[2, 2], [2, 2], [2, 2]]
+    assert substraction_matrices(m1, m2) == [[-1, -1], [-1, -1], [-1, -1]]
+    assert substraction_matrices(m2, m1) == [[1, 1], [1, 1], [1, 1]]

py_num_math-1.0.0/pymath/tests/matrices/test_square_matrices.py

@@ -0,0 +1,63 @@
+"""
+A test of square_matrices module
+You can use numpy. However, the goal here is to do not use external library
+Author: Aliou Diouf - Master degree from University, Paul Sabatier Toulouse 3,
+in Applied Mathematics, speciality Scientific Computing (Numerical Analysis,
+PDE, Software Engineering, Images&Signal processing, Aerospace, HR, English...)
+CEO and Founder of Diouf Tech, a STEM company headquartered in Paris (75014)
+Products: www.mathgame-py.com, https://www.paypal.com/paypalme/mathgamepy
+Facebook page: https://www.facebook.com/profile.php?id=100086476192955
+My personal Facebook: https://www.facebook.com/aliou.diouf.587/
+My LinkedIn: https://www.linkedin.com/in/aliou-diouf-7b980441b/
+My PyPI packages: https://pypi.org/project/py-ci-cd,
+                  https://pypi.org/project/pymeshing
+                  https://pypi.org/project/passwordworld
+"""
+from pymath.src.matrices.square_matrices import print_matrix, \
+    zero_matrix, identity_matrix, diagonal_matrix, tridiagonal_matrix
+
+
+def test_print_matrix():
+    """Test print_matrix"""
+
+    matrix = [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]]
+    assert print_matrix(matrix) == 'ok'
+
+
+def test_zero_matrix():
+    """n x n zero matrix"""
+
+    assert zero_matrix(1) == [[0]]
+    assert zero_matrix(2) == [[0, 0], [0, 0]]
+    assert zero_matrix(3) == [[0, 0, 0], [0, 0, 0], [0, 0, 0]]
+    assert zero_matrix(4) == [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0],
+                              [0, 0, 0, 0]]
+
+
+def test_identity_matrix():
+    """Identity matrix"""
+
+    assert identity_matrix(1) == [[1]]
+    assert identity_matrix(2) == [[1, 0], [0, 1]]
+    assert identity_matrix(3) == [[1, 0, 0], [0, 1, 0], [0, 0, 1]]
+    assert identity_matrix(4) == [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0],
+                                  [0, 0, 0, 1]]
+
+
+def test_diagonal_matrix():
+    """Tests diagonal_matrix"""
+
+    assert diagonal_matrix(range(1, 2)) == [[1]]
+    assert diagonal_matrix(range(1, 3)) == [[1, 0], [0, 2]]
+    assert diagonal_matrix(range(1, 4)) == [[1, 0, 0], [0, 2, 0], [0, 0, 3]]
+    assert diagonal_matrix(range(1, 5)) == [[1, 0, 0, 0], [0, 2, 0, 0],
+                                            [0, 0, 3, 0], [0, 0, 0, 4]]
+
+def test_tridiagonal_matrix():
+    """Tests tridiagonal_matrix"""
+
+    td = tridiagonal_matrix([1, 1, 1, 1, 1], [2, 2, 2, 2, 2], [1, 1, 1, 1, 1])
+    expected = [[2, 1, 0, 0, 0], [1, 2, 1, 0, 0], [0, 1, 2, 1, 0],
+                [0, 0, 1, 2, 1], [0, 0, 0, 1, 2]]
+    
+    assert td == expected

py_num_math-1.0.0/pymath/tests/norms/test_norm_lp.py

@@ -0,0 +1,26 @@
+"""
+Norm Lp
+Author: Aliou Diouf - Master degree from University, Paul Sabatier Toulouse 3,
+in Applied Mathematics, speciality Scientific Computing (Numerical Analysis,
+PDE, Software Engineering, Images&Signal processing, Aerospace, HR, English...)
+CEO and Founder of Diouf Tech, a STEM company headquartered in Paris (75014)
+Products: www.mathgame-py.com, https://www.paypal.com/paypalme/mathgamepy
+Facebook page: https://www.facebook.com/profile.php?id=100086476192955
+My personal Facebook: https://www.facebook.com/aliou.diouf.587/
+My LinkedIn: https://www.linkedin.com/in/aliou-diouf-7b980441b/
+My PyPI packages: https://pypi.org/project/py-ci-cd,
+                  https://pypi.org/project/pymeshing
+                  https://pypi.org/project/passwordworld
+"""
+from pymath.src.norms.norm_lp import norm_lp
+
+
+def test_norm_lp():
+    """Tests norm_lp"""
+
+    len_vect = 4  # Arbitrary
+    vect = [1] * len_vect
+    print(vect)
+
+    for p, expected in zip([1, 2], [4, 2]):
+        assert norm_lp(vect, p) == expected

py_num_math-1.0.0/pymath/tests/num_seq/test_num_seq.py

@@ -0,0 +1,71 @@
+"""
+Tests num_seq module
+Author: Aliou Diouf - Master degree from University, Paul Sabatier Toulouse 3,
+in Applied Mathematics, speciality Scientific Computing (Numerical Analysis,
+PDE, Software Engineering, Images&Signal processing, Aerospace, HR, English...)
+CEO and Founder of Diouf Tech, a STEM company headquartered in Paris (75014)
+Products: www.mathgame-py.com, https://www.paypal.com/paypalme/mathgamepy
+Facebook page: https://www.facebook.com/profile.php?id=100086476192955
+My personal Facebook: https://www.facebook.com/aliou.diouf.587/
+My LinkedIn: https://www.linkedin.com/in/aliou-diouf-7b980441b/
+My PyPI packages: https://pypi.org/project/py-ci-cd,
+                  https://pypi.org/project/pymeshing
+                  https://pypi.org/project/passwordworld
+"""
+
+from pymath.src.num_seq.num_seq import arithmetic_seq_gen, arithmetic_seq_a0, \
+    arithmetic_seq_a1, geometric_seq_gen, geometric_seq_a0, geometric_seq_a1
+from random import randint
+
+
+n_max = 10
+
+
+def test_arithmetic_seq_gen():
+    """Tests arithmetic_seq_gen"""
+
+    n = randint(0, n_max)
+    p = randint(0, n)
+
+    assert arithmetic_seq_gen(p, p, 1, n) == n
+
+
+def test_arithmetic_seq_a0():
+    """Tests arithmetic_seq_a0"""
+
+    n = randint(0, n_max)
+
+    assert arithmetic_seq_a0(0, 1, n) == n
+
+
+def test_arithmetic_seq_a1():
+    """Tests arithmetic_seq_a1"""
+
+    n = randint(1, n_max)
+
+    assert arithmetic_seq_a1(1, 1, n) == n
+
+
+def test_geometric_seq_gen():
+    """Tests geometric_seq_gen"""
+
+    n = randint(1, n_max)
+    p = randint(0, n)
+
+    assert geometric_seq_gen(2**p, p, 2, n) == 2 ** n
+
+
+def test_geometric_seq_a0():
+    """Tests geometric_seq_a0"""
+
+    n = randint(1, n_max)
+
+    assert geometric_seq_a0(1, 2, n) == 2 ** n
+
+
+def test_geometric_seq_a1():
+    """Tests geometric_seq_a1"""
+
+    n = randint(1, n_max)
+
+    assert geometric_seq_a1(2, 2, n) == 2 ** n

py_num_math-1.0.0/pymath/tests/vectors/test_vectors.py

@@ -0,0 +1,65 @@
+"""
+Vector
+A rectangular matrix is a list of m list(s) of n element(s)
+m > 0, n > 0
+You can use numpy. However, the goal here is to do not use external library
+Author: Aliou Diouf - Master degree from University, Paul Sabatier Toulouse 3,
+in Applied Mathematics, speciality Scientific Computing (Numerical Analysis,
+PDE, Software Engineering, Images&Signal processing, Aerospace, HR, English...)
+CEO and Founder of Diouf Tech, a STEM company headquartered in Paris (75014)
+Products: www.mathgame-py.com, https://www.paypal.com/paypalme/mathgamepy
+Facebook page: https://www.facebook.com/profile.php?id=100086476192955
+My personal Facebook: https://www.facebook.com/aliou.diouf.587/
+My LinkedIn: https://www.linkedin.com/in/aliou-diouf-7b980441b/
+My PyPI packages: https://pypi.org/project/py-ci-cd,
+                  https://pypi.org/project/pymeshing
+                  https://pypi.org/project/passwordworld
+"""
+from pymath.src.vectors.vectors import zero_vector, sum_vectors, \
+    substraction_vectors, unit_vector, random_vector
+
+
+def test_zero_vector():
+    """Tests zero_vector"""
+
+    assert zero_vector(1) == [0]
+    assert zero_vector(5) == [0, 0, 0, 0, 0]
+
+
+def test_sum_vectors():
+    """Tests sum_vectors"""
+
+    v1 = [1, 1, 1]
+    v2 = [2, 2, 2]
+
+    assert sum_vectors(v1, v2) == [3, 3, 3]
+
+
+def test_substraction_vectors():
+    """Tests substraction_vectors"""
+
+    v1 = [1, 1, 1]
+    v2 = [2, 2, 2]
+
+    assert substraction_vectors(v1, v2) == [-1, -1, -1]
+    assert substraction_vectors(v2, v1) == [1, 1, 1]
+
+
+def test_unit_vector():
+    """Tests unit_vector"""
+
+    assert unit_vector(3, 0) == [1, 0, 0]
+    assert unit_vector(3, 1) == [0, 1, 0]
+    assert unit_vector(3, 2) == [0, 0, 1]
+
+
+def test_random_vector():
+    """Tests random_vector"""
+
+    n, min_val, max_val = 4, -10, 10
+    rand_vect = random_vector(n, min_val, max_val)
+
+    assert len(rand_vect) == n
+
+    for _ in range(n):
+        assert rand_vect

py_num_math-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

py_num_math-1.0.0/setup.py

@@ -0,0 +1,29 @@
+from setuptools import setup
+
+
+setup(
+    name='py_num_math',
+    version='1.0.0',
+    description='Python package for mathematical numerical tools.',
+    long_description='Python package for mathematical numerical tools.',
+    long_description_content_type="text/markdown",
+    url='https://www.paypal.com/paypalme/mathgamepy',
+    author='Aliou Diouf',
+    author_email='aliou.diouf5@gmail.com',
+    license='Diouf Tech',
+    packages=[
+        'pymath', 'pymath.src', 'pymath.src.dot_prod', 'pymath.src.fibonacci',
+        'pymath.src.finite_diff', 'pymath.src.matrices', 'pymath.src.norms',
+        'pymath.src.num_seq', 'pymath.src.vectors',
+        'pymath.tests', 'pymath.tests.dot_prod', 'pymath.tests.fibonacci',
+        'pymath.tests.finite_diff', 'pymath.tests.matrices',
+        'pymath.tests.norms', 'pymath.tests.num_seq', 'pymath.tests.vectors',
+        ],
+    install_requires=['flake8', 'pytest'],
+    classifiers=[
+        'Development Status :: 5 - Production/Stable',
+        'License :: Free To Use But Restricted',
+        'Programming Language :: Python :: 3.14',
+        'Operating System :: POSIX :: Linux'
+    ]
+)