PyPyNum 1.16.0__tar.gz → 1.16.1__tar.gz

{pypynum-1.16.0 → pypynum-1.16.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PyPyNum
-Version: 1.16.0
+Version: 1.16.1
 Summary: PyPyNum is a Python library for math & science computations, covering algebra, calculus, stats, with data structures like matrices, vectors, tensors. It offers numerical tools, programs, and supports computational ops, functions, processing, simulation, & visualization in data science & ML, crucial for research, engineering, & data processing.
 Home-page: https://github.com/PythonSJL/PyPyNum
 Author: Shen Jiayi
@@ -234,7 +234,7 @@ processing.</font><font color = red>[Python>=3.4]</font>
 [![Downloads](https://static.pepy.tech/badge/pypynum/month)](https://pepy.tech/project/pypynum)
 [![Downloads](https://static.pepy.tech/badge/pypynum/week)](https://pepy.tech/project/pypynum)
 
-## Version -> 1.16.0 | PyPI -> https://pypi.org/project/PyPyNum/ | Gitee -> https://www.gitee.com/PythonSJL/PyPyNum | GitHub -> https://github.com/PythonSJL/PyPyNum
+## PyPyNum | Version -> 1.16.1 | PyPI -> https://pypi.org/project/PyPyNum/ | Gitee -> https://www.gitee.com/PythonSJL/PyPyNum | GitHub -> https://github.com/PythonSJL/PyPyNum
 
 ![LOGO](PyPyNum.png)
 
@@ -327,72 +327,70 @@ Python interpreter and run it!
 ```
 !=!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=
 
-The submodule 'consts' has added
-a large number of mathematical
-and scientific constants,
-currently totaling 128.
+Fixed and improved the basic
+operation function of 'Array'.
 
-This module defines a collection
-of constants representing
-various physical, mathematical,
-and unit conversion factors.
-
-These constants are commonly
-used in scientific and
-engineering calculations.
+!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=
 
-If you want to know information
-about each constant, you can
-execute 'help(consts)' to
-obtain it.
+We will remove 'Tensor' in
+future versions. Because its
+computational functions have
+already been implemented in
+'Array'. The current version
+will throw 'FutureWarning' as a
+warning.
 
 !=!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=
 
+Fixed the calculation error of
+'mp_euler_gamma', which was
+caused when modifying the
+iteration stop condition
+previously.
 
-<<< Here are the newly added functions >>>
+!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=
 
+<<< Here are the newly added functions >>>
 
-PyPyNum
-├── special
-│   └── FUNCTION
-│       ├── qbinomial(n: typing.Union[int, float, complex], m: typing.Union[int, float, complex], q: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]
-│       │   # Calculate the q-binomial coefficient of n and m with parameter q.
-│       ├── qfactorial(n: typing.Union[int, float, complex], q: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]
-│       │   # Compute the q-factorial of n with parameter q.
-│       ├── qgamma(n: typing.Union[int, float, complex], q: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]
-│       │   # Calculate the q-gamma function of n with parameter q.
-│       └── qpochhammer(a: typing.Union[int, float, complex], q: typing.Union[int, float, complex], n: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]
-│           # Compute the q-Pochhammer symbol for given a, q, and n.
-├── multiprec
-│   └── FUNCTION
-│       ├── mp_catalan(sigfigs: int) -> decimal.Decimal
-│           # Calculate the Catalan's constant with a specified number of significant figures using multiprecision arithmetic.
-├── seqs
-│   └── FUNCTION
-│       ├── padovan(n: int, single: bool) -> typing.Union[int, list]
-│       │   # Generate the Padovan sequence up to the nth term.
-│       ├── pelllucas(n: int, single: bool) -> typing.Union[int, list]
-│       │   # Generate the Pell-Lucas sequence up to the nth term.
-│       ├── perrin(n: int, single: bool) -> typing.Union[int, list]
-│       │   # Generate the Perrin sequence up to the nth term.
-│       └── sylvester(n: int, single: bool) -> typing.Union[int, list]
-│           # Generate the Sylvester sequence up to the nth term.
-├── tools
-│   └── FUNCTION
-│       ├── lcsubseq(x: typing.Union[list, tuple, str], y: typing.Union[list, tuple, str]) -> list
-│       │   # Find the longest common subsequence between two sequences x and y.
-│       └── lcsubstr(x: typing.Union[list, tuple, str], y: typing.Union[list, tuple, str]) -> list
-│           # Find the longest common substring between two sequences x and y.
-├── matrices
-│   ├── CLASS
-│   │   └── Matrix(pypynum.arrays.Array)/__init__(self: Any, data: Any, check: Any) -> Any
-│   │       # Initialize a Matrix object from a given data array.
-│   └── FUNCTION
-│       ├── perm_mat(num_rows: int, num_cols: int, row_swaps: typing.Union[list, tuple], col_swaps: typing.Union[list, tuple], rtype: typing.Callable) -> typing.Any
-│       │   # Create a permutation matrix based on specified row and column swaps.
-│       └── perm_mat_indices(num_rows: int, num_cols: int, row_swaps: typing.Union[list, tuple], col_swaps: typing.Union[list, tuple]) -> tuple
-│           # Compute the indices for a permutation matrix based on specified row and column swaps.
 
+cos_sim(seq1: Union[list, tuple, str], seq2: Union[list, tuple, str], is_vector: bool = False) -> float
+    Introduction
+    ==========
+    Calculate the cosine similarity between two sequences.
+
+    The cosine similarity is a measure of similarity between two non-zero vectors. It is defined as the cosine of the
+    angle between them, which is computed as the dot product of the vectors divided by the product of their magnitudes.
+    This function supports both numerical vectors and frequency distributions of sequences.
+
+    Example
+    ==========
+    >>> cos_sim("hello world", "world hello")
+    0.9999999999999998
+    >>>
+    :param seq1: First sequence to compare.
+    :param seq2: Second sequence to compare.
+    :param is_vector: A boolean indicating whether the input sequences are numerical vectors. Default is False.
+    :return: The cosine similarity between the two sequences, ranging from -1 to 1.
+
+
+replace(seq: Union[list, tuple], old: Union[list, tuple], new: Union[list, tuple], count: int = -1) -> Union[list, tuple]
+    Introduction
+    ==========
+    Replace occurrences of the subsequence 'old' in 'seq' with 'new'.
+
+    This function is designed to handle sequences such as lists or tuples and replace specified subsequences
+    with new ones. It also allows limiting the number of replacements.
+
+    Example
+    ==========
+    >>> replace([1, 2, 3, 4, 2, 3], [2, 3], [5, 6])
+    [1, 5, 6, 4, 5, 6]
+    >>>
+    :param seq: The sequence in which to replace the subsequence.
+    :param old: The subsequence to be replaced.
+    :param new: The subsequence to replace with.
+    :param count: The maximum number of replacements to perform. Default is -1 (unlimited).
+    :return: The modified sequence with replacements.
 
 !=!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=
 
@@ -439,15 +437,16 @@ PyPyNum
 │       ├── asarray(data: Any) -> Any
 │       ├── aslist(data: Any) -> Any
 │       ├── boolarray(data: Any) -> Any
-│       ├── fill(shape: Any, sequence: Any, repeat: Any, pad: Any, rtype: Any) -> Any
-│       ├── full(shape: Any, fill_value: Any, rtype: Any) -> Any
-│       ├── full_like(a: Any, fill_value: Any, rtype: Any) -> Any
+│       ├── fill(shape: typing.Union[list, tuple], sequence: typing.Union[list, tuple], repeat: bool, pad: typing.Any, rtype: typing.Callable) -> typing.Any
+│       ├── full(shape: typing.Union[list, tuple], fill_value: typing.Any, rtype: typing.Callable) -> typing.Any
+│       ├── full_like(a: typing.Any, fill_value: typing.Any, rtype: typing.Callable) -> typing.Any
 │       ├── get_shape(data: Any) -> Any
 │       ├── is_valid_array(_array: Any, _shape: Any) -> Any
-│       ├── ones(shape: Any, rtype: Any) -> Any
-│       ├── ones_like(a: Any, rtype: Any) -> Any
-│       ├── zeros(shape: Any, rtype: Any) -> Any
-│       └── zeros_like(a: Any, rtype: Any) -> Any
+│       ├── ones(shape: typing.Union[list, tuple], rtype: typing.Callable) -> typing.Any
+│       ├── ones_like(a: typing.Any, rtype: typing.Callable) -> typing.Any
+│       ├── tensorproduct(tensors: pypynum.arrays.Array) -> pypynum.arrays.Array
+│       ├── zeros(shape: typing.Union[list, tuple], rtype: typing.Callable) -> typing.Any
+│       └── zeros_like(a: typing.Any, rtype: typing.Callable) -> typing.Any
 ├── chars
 │   ├── CLASS
 │   └── FUNCTION
@@ -870,8 +869,7 @@ PyPyNum
 │   │   └── Tensor(pypynum.arrays.Array)/__init__(self: Any, data: Any, check: Any) -> Any
 │   └── FUNCTION
 │       ├── ten(data: list) -> pypynum.tensors.Tensor
-│       ├── tensor_and_number(tensor: Any, operator: Any, number: Any) -> Any
-│       └── tensorproduct(tensors: pypynum.tensors.Tensor) -> pypynum.tensors.Tensor
+│       └── tensor_and_number(tensor: Any, operator: Any, number: Any) -> Any
 ├── test
 │   ├── CLASS
 │   └── FUNCTION
@@ -882,6 +880,7 @@ PyPyNum
 │   ├── CLASS
 │   └── FUNCTION
 │       ├── classify(array: typing.Union[list, tuple]) -> dict
+│       ├── cos_sim(seq1: typing.Union[list, tuple, str], seq2: typing.Union[list, tuple, str], is_vector: bool) -> float
 │       ├── dedup(iterable: typing.Union[list, tuple, str]) -> typing.Union[list, tuple, str]
 │       ├── fast_pow(a: typing.Any, n: int, init: typing.Any, mul: typing.Callable) -> typing.Any
 │       ├── frange(start: typing.Union[int, float], stop: typing.Union[int, float], step: float) -> list
@@ -894,6 +893,7 @@ PyPyNum
 │       ├── primality(n: int, iter_num: int) -> bool
 │       ├── prime_factors(integer: int, dictionary: bool, pollard_rho: bool) -> typing.Union[list, dict]
 │       ├── primes(limit: int) -> list
+│       ├── replace(seq: typing.Union[list, tuple], old: typing.Union[list, tuple], new: typing.Union[list, tuple], count: int) -> typing.Union[list, tuple]
 │       ├── semiprimes(limit: int) -> list
 │       ├── split(iterable: typing.Union[list, tuple, str], key: typing.Union[list, tuple], retain: bool) -> list
 │       └── twinprimes(limit: int) -> list

{pypynum-1.16.0 → pypynum-1.16.1}/PyPyNum.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PyPyNum
-Version: 1.16.0
+Version: 1.16.1
 Summary: PyPyNum is a Python library for math & science computations, covering algebra, calculus, stats, with data structures like matrices, vectors, tensors. It offers numerical tools, programs, and supports computational ops, functions, processing, simulation, & visualization in data science & ML, crucial for research, engineering, & data processing.
 Home-page: https://github.com/PythonSJL/PyPyNum
 Author: Shen Jiayi
@@ -234,7 +234,7 @@ processing.</font><font color = red>[Python>=3.4]</font>
 [![Downloads](https://static.pepy.tech/badge/pypynum/month)](https://pepy.tech/project/pypynum)
 [![Downloads](https://static.pepy.tech/badge/pypynum/week)](https://pepy.tech/project/pypynum)
 
-## Version -> 1.16.0 | PyPI -> https://pypi.org/project/PyPyNum/ | Gitee -> https://www.gitee.com/PythonSJL/PyPyNum | GitHub -> https://github.com/PythonSJL/PyPyNum
+## PyPyNum | Version -> 1.16.1 | PyPI -> https://pypi.org/project/PyPyNum/ | Gitee -> https://www.gitee.com/PythonSJL/PyPyNum | GitHub -> https://github.com/PythonSJL/PyPyNum
 
 ![LOGO](PyPyNum.png)
 
@@ -327,72 +327,70 @@ Python interpreter and run it!
 ```
 !=!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=
 
-The submodule 'consts' has added
-a large number of mathematical
-and scientific constants,
-currently totaling 128.
+Fixed and improved the basic
+operation function of 'Array'.
 
-This module defines a collection
-of constants representing
-various physical, mathematical,
-and unit conversion factors.
-
-These constants are commonly
-used in scientific and
-engineering calculations.
+!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=
 
-If you want to know information
-about each constant, you can
-execute 'help(consts)' to
-obtain it.
+We will remove 'Tensor' in
+future versions. Because its
+computational functions have
+already been implemented in
+'Array'. The current version
+will throw 'FutureWarning' as a
+warning.
 
 !=!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=
 
+Fixed the calculation error of
+'mp_euler_gamma', which was
+caused when modifying the
+iteration stop condition
+previously.
 
-<<< Here are the newly added functions >>>
+!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=
 
+<<< Here are the newly added functions >>>
 
-PyPyNum
-├── special
-│   └── FUNCTION
-│       ├── qbinomial(n: typing.Union[int, float, complex], m: typing.Union[int, float, complex], q: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]
-│       │   # Calculate the q-binomial coefficient of n and m with parameter q.
-│       ├── qfactorial(n: typing.Union[int, float, complex], q: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]
-│       │   # Compute the q-factorial of n with parameter q.
-│       ├── qgamma(n: typing.Union[int, float, complex], q: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]
-│       │   # Calculate the q-gamma function of n with parameter q.
-│       └── qpochhammer(a: typing.Union[int, float, complex], q: typing.Union[int, float, complex], n: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]
-│           # Compute the q-Pochhammer symbol for given a, q, and n.
-├── multiprec
-│   └── FUNCTION
-│       ├── mp_catalan(sigfigs: int) -> decimal.Decimal
-│           # Calculate the Catalan's constant with a specified number of significant figures using multiprecision arithmetic.
-├── seqs
-│   └── FUNCTION
-│       ├── padovan(n: int, single: bool) -> typing.Union[int, list]
-│       │   # Generate the Padovan sequence up to the nth term.
-│       ├── pelllucas(n: int, single: bool) -> typing.Union[int, list]
-│       │   # Generate the Pell-Lucas sequence up to the nth term.
-│       ├── perrin(n: int, single: bool) -> typing.Union[int, list]
-│       │   # Generate the Perrin sequence up to the nth term.
-│       └── sylvester(n: int, single: bool) -> typing.Union[int, list]
-│           # Generate the Sylvester sequence up to the nth term.
-├── tools
-│   └── FUNCTION
-│       ├── lcsubseq(x: typing.Union[list, tuple, str], y: typing.Union[list, tuple, str]) -> list
-│       │   # Find the longest common subsequence between two sequences x and y.
-│       └── lcsubstr(x: typing.Union[list, tuple, str], y: typing.Union[list, tuple, str]) -> list
-│           # Find the longest common substring between two sequences x and y.
-├── matrices
-│   ├── CLASS
-│   │   └── Matrix(pypynum.arrays.Array)/__init__(self: Any, data: Any, check: Any) -> Any
-│   │       # Initialize a Matrix object from a given data array.
-│   └── FUNCTION
-│       ├── perm_mat(num_rows: int, num_cols: int, row_swaps: typing.Union[list, tuple], col_swaps: typing.Union[list, tuple], rtype: typing.Callable) -> typing.Any
-│       │   # Create a permutation matrix based on specified row and column swaps.
-│       └── perm_mat_indices(num_rows: int, num_cols: int, row_swaps: typing.Union[list, tuple], col_swaps: typing.Union[list, tuple]) -> tuple
-│           # Compute the indices for a permutation matrix based on specified row and column swaps.
 
+cos_sim(seq1: Union[list, tuple, str], seq2: Union[list, tuple, str], is_vector: bool = False) -> float
+    Introduction
+    ==========
+    Calculate the cosine similarity between two sequences.
+
+    The cosine similarity is a measure of similarity between two non-zero vectors. It is defined as the cosine of the
+    angle between them, which is computed as the dot product of the vectors divided by the product of their magnitudes.
+    This function supports both numerical vectors and frequency distributions of sequences.
+
+    Example
+    ==========
+    >>> cos_sim("hello world", "world hello")
+    0.9999999999999998
+    >>>
+    :param seq1: First sequence to compare.
+    :param seq2: Second sequence to compare.
+    :param is_vector: A boolean indicating whether the input sequences are numerical vectors. Default is False.
+    :return: The cosine similarity between the two sequences, ranging from -1 to 1.
+
+
+replace(seq: Union[list, tuple], old: Union[list, tuple], new: Union[list, tuple], count: int = -1) -> Union[list, tuple]
+    Introduction
+    ==========
+    Replace occurrences of the subsequence 'old' in 'seq' with 'new'.
+
+    This function is designed to handle sequences such as lists or tuples and replace specified subsequences
+    with new ones. It also allows limiting the number of replacements.
+
+    Example
+    ==========
+    >>> replace([1, 2, 3, 4, 2, 3], [2, 3], [5, 6])
+    [1, 5, 6, 4, 5, 6]
+    >>>
+    :param seq: The sequence in which to replace the subsequence.
+    :param old: The subsequence to be replaced.
+    :param new: The subsequence to replace with.
+    :param count: The maximum number of replacements to perform. Default is -1 (unlimited).
+    :return: The modified sequence with replacements.
 
 !=!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=
 
@@ -439,15 +437,16 @@ PyPyNum
 │       ├── asarray(data: Any) -> Any
 │       ├── aslist(data: Any) -> Any
 │       ├── boolarray(data: Any) -> Any
-│       ├── fill(shape: Any, sequence: Any, repeat: Any, pad: Any, rtype: Any) -> Any
-│       ├── full(shape: Any, fill_value: Any, rtype: Any) -> Any
-│       ├── full_like(a: Any, fill_value: Any, rtype: Any) -> Any
+│       ├── fill(shape: typing.Union[list, tuple], sequence: typing.Union[list, tuple], repeat: bool, pad: typing.Any, rtype: typing.Callable) -> typing.Any
+│       ├── full(shape: typing.Union[list, tuple], fill_value: typing.Any, rtype: typing.Callable) -> typing.Any
+│       ├── full_like(a: typing.Any, fill_value: typing.Any, rtype: typing.Callable) -> typing.Any
 │       ├── get_shape(data: Any) -> Any
 │       ├── is_valid_array(_array: Any, _shape: Any) -> Any
-│       ├── ones(shape: Any, rtype: Any) -> Any
-│       ├── ones_like(a: Any, rtype: Any) -> Any
-│       ├── zeros(shape: Any, rtype: Any) -> Any
-│       └── zeros_like(a: Any, rtype: Any) -> Any
+│       ├── ones(shape: typing.Union[list, tuple], rtype: typing.Callable) -> typing.Any
+│       ├── ones_like(a: typing.Any, rtype: typing.Callable) -> typing.Any
+│       ├── tensorproduct(tensors: pypynum.arrays.Array) -> pypynum.arrays.Array
+│       ├── zeros(shape: typing.Union[list, tuple], rtype: typing.Callable) -> typing.Any
+│       └── zeros_like(a: typing.Any, rtype: typing.Callable) -> typing.Any
 ├── chars
 │   ├── CLASS
 │   └── FUNCTION
@@ -870,8 +869,7 @@ PyPyNum
 │   │   └── Tensor(pypynum.arrays.Array)/__init__(self: Any, data: Any, check: Any) -> Any
 │   └── FUNCTION
 │       ├── ten(data: list) -> pypynum.tensors.Tensor
-│       ├── tensor_and_number(tensor: Any, operator: Any, number: Any) -> Any
-│       └── tensorproduct(tensors: pypynum.tensors.Tensor) -> pypynum.tensors.Tensor
+│       └── tensor_and_number(tensor: Any, operator: Any, number: Any) -> Any
 ├── test
 │   ├── CLASS
 │   └── FUNCTION
@@ -882,6 +880,7 @@ PyPyNum
 │   ├── CLASS
 │   └── FUNCTION
 │       ├── classify(array: typing.Union[list, tuple]) -> dict
+│       ├── cos_sim(seq1: typing.Union[list, tuple, str], seq2: typing.Union[list, tuple, str], is_vector: bool) -> float
 │       ├── dedup(iterable: typing.Union[list, tuple, str]) -> typing.Union[list, tuple, str]
 │       ├── fast_pow(a: typing.Any, n: int, init: typing.Any, mul: typing.Callable) -> typing.Any
 │       ├── frange(start: typing.Union[int, float], stop: typing.Union[int, float], step: float) -> list
@@ -894,6 +893,7 @@ PyPyNum
 │       ├── primality(n: int, iter_num: int) -> bool
 │       ├── prime_factors(integer: int, dictionary: bool, pollard_rho: bool) -> typing.Union[list, dict]
 │       ├── primes(limit: int) -> list
+│       ├── replace(seq: typing.Union[list, tuple], old: typing.Union[list, tuple], new: typing.Union[list, tuple], count: int) -> typing.Union[list, tuple]
 │       ├── semiprimes(limit: int) -> list
 │       ├── split(iterable: typing.Union[list, tuple, str], key: typing.Union[list, tuple], retain: bool) -> list
 │       └── twinprimes(limit: int) -> list

{pypynum-1.16.0 → pypynum-1.16.1}/pypynum/README.md

@@ -20,7 +20,7 @@ processing.</font><font color = red>[Python>=3.4]</font>
 [![Downloads](https://static.pepy.tech/badge/pypynum/month)](https://pepy.tech/project/pypynum)
 [![Downloads](https://static.pepy.tech/badge/pypynum/week)](https://pepy.tech/project/pypynum)
 
-## Version -> 1.16.0 | PyPI -> https://pypi.org/project/PyPyNum/ | Gitee -> https://www.gitee.com/PythonSJL/PyPyNum | GitHub -> https://github.com/PythonSJL/PyPyNum
+## PyPyNum | Version -> 1.16.1 | PyPI -> https://pypi.org/project/PyPyNum/ | Gitee -> https://www.gitee.com/PythonSJL/PyPyNum | GitHub -> https://github.com/PythonSJL/PyPyNum
 
 ![LOGO](PyPyNum.png)
 
@@ -113,72 +113,70 @@ Python interpreter and run it!
 ```
 !=!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=
 
-The submodule 'consts' has added
-a large number of mathematical
-and scientific constants,
-currently totaling 128.
+Fixed and improved the basic
+operation function of 'Array'.
 
-This module defines a collection
-of constants representing
-various physical, mathematical,
-and unit conversion factors.
-
-These constants are commonly
-used in scientific and
-engineering calculations.
+!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=
 
-If you want to know information
-about each constant, you can
-execute 'help(consts)' to
-obtain it.
+We will remove 'Tensor' in
+future versions. Because its
+computational functions have
+already been implemented in
+'Array'. The current version
+will throw 'FutureWarning' as a
+warning.
 
 !=!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=
 
+Fixed the calculation error of
+'mp_euler_gamma', which was
+caused when modifying the
+iteration stop condition
+previously.
 
-<<< Here are the newly added functions >>>
+!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=
 
+<<< Here are the newly added functions >>>
 
-PyPyNum
-├── special
-│   └── FUNCTION
-│       ├── qbinomial(n: typing.Union[int, float, complex], m: typing.Union[int, float, complex], q: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]
-│       │   # Calculate the q-binomial coefficient of n and m with parameter q.
-│       ├── qfactorial(n: typing.Union[int, float, complex], q: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]
-│       │   # Compute the q-factorial of n with parameter q.
-│       ├── qgamma(n: typing.Union[int, float, complex], q: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]
-│       │   # Calculate the q-gamma function of n with parameter q.
-│       └── qpochhammer(a: typing.Union[int, float, complex], q: typing.Union[int, float, complex], n: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]
-│           # Compute the q-Pochhammer symbol for given a, q, and n.
-├── multiprec
-│   └── FUNCTION
-│       ├── mp_catalan(sigfigs: int) -> decimal.Decimal
-│           # Calculate the Catalan's constant with a specified number of significant figures using multiprecision arithmetic.
-├── seqs
-│   └── FUNCTION
-│       ├── padovan(n: int, single: bool) -> typing.Union[int, list]
-│       │   # Generate the Padovan sequence up to the nth term.
-│       ├── pelllucas(n: int, single: bool) -> typing.Union[int, list]
-│       │   # Generate the Pell-Lucas sequence up to the nth term.
-│       ├── perrin(n: int, single: bool) -> typing.Union[int, list]
-│       │   # Generate the Perrin sequence up to the nth term.
-│       └── sylvester(n: int, single: bool) -> typing.Union[int, list]
-│           # Generate the Sylvester sequence up to the nth term.
-├── tools
-│   └── FUNCTION
-│       ├── lcsubseq(x: typing.Union[list, tuple, str], y: typing.Union[list, tuple, str]) -> list
-│       │   # Find the longest common subsequence between two sequences x and y.
-│       └── lcsubstr(x: typing.Union[list, tuple, str], y: typing.Union[list, tuple, str]) -> list
-│           # Find the longest common substring between two sequences x and y.
-├── matrices
-│   ├── CLASS
-│   │   └── Matrix(pypynum.arrays.Array)/__init__(self: Any, data: Any, check: Any) -> Any
-│   │       # Initialize a Matrix object from a given data array.
-│   └── FUNCTION
-│       ├── perm_mat(num_rows: int, num_cols: int, row_swaps: typing.Union[list, tuple], col_swaps: typing.Union[list, tuple], rtype: typing.Callable) -> typing.Any
-│       │   # Create a permutation matrix based on specified row and column swaps.
-│       └── perm_mat_indices(num_rows: int, num_cols: int, row_swaps: typing.Union[list, tuple], col_swaps: typing.Union[list, tuple]) -> tuple
-│           # Compute the indices for a permutation matrix based on specified row and column swaps.
 
+cos_sim(seq1: Union[list, tuple, str], seq2: Union[list, tuple, str], is_vector: bool = False) -> float
+    Introduction
+    ==========
+    Calculate the cosine similarity between two sequences.
+
+    The cosine similarity is a measure of similarity between two non-zero vectors. It is defined as the cosine of the
+    angle between them, which is computed as the dot product of the vectors divided by the product of their magnitudes.
+    This function supports both numerical vectors and frequency distributions of sequences.
+
+    Example
+    ==========
+    >>> cos_sim("hello world", "world hello")
+    0.9999999999999998
+    >>>
+    :param seq1: First sequence to compare.
+    :param seq2: Second sequence to compare.
+    :param is_vector: A boolean indicating whether the input sequences are numerical vectors. Default is False.
+    :return: The cosine similarity between the two sequences, ranging from -1 to 1.
+
+
+replace(seq: Union[list, tuple], old: Union[list, tuple], new: Union[list, tuple], count: int = -1) -> Union[list, tuple]
+    Introduction
+    ==========
+    Replace occurrences of the subsequence 'old' in 'seq' with 'new'.
+
+    This function is designed to handle sequences such as lists or tuples and replace specified subsequences
+    with new ones. It also allows limiting the number of replacements.
+
+    Example
+    ==========
+    >>> replace([1, 2, 3, 4, 2, 3], [2, 3], [5, 6])
+    [1, 5, 6, 4, 5, 6]
+    >>>
+    :param seq: The sequence in which to replace the subsequence.
+    :param old: The subsequence to be replaced.
+    :param new: The subsequence to replace with.
+    :param count: The maximum number of replacements to perform. Default is -1 (unlimited).
+    :return: The modified sequence with replacements.
 
 !=!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=
 
@@ -225,15 +223,16 @@ PyPyNum
 │       ├── asarray(data: Any) -> Any
 │       ├── aslist(data: Any) -> Any
 │       ├── boolarray(data: Any) -> Any
-│       ├── fill(shape: Any, sequence: Any, repeat: Any, pad: Any, rtype: Any) -> Any
-│       ├── full(shape: Any, fill_value: Any, rtype: Any) -> Any
-│       ├── full_like(a: Any, fill_value: Any, rtype: Any) -> Any
+│       ├── fill(shape: typing.Union[list, tuple], sequence: typing.Union[list, tuple], repeat: bool, pad: typing.Any, rtype: typing.Callable) -> typing.Any
+│       ├── full(shape: typing.Union[list, tuple], fill_value: typing.Any, rtype: typing.Callable) -> typing.Any
+│       ├── full_like(a: typing.Any, fill_value: typing.Any, rtype: typing.Callable) -> typing.Any
 │       ├── get_shape(data: Any) -> Any
 │       ├── is_valid_array(_array: Any, _shape: Any) -> Any
-│       ├── ones(shape: Any, rtype: Any) -> Any
-│       ├── ones_like(a: Any, rtype: Any) -> Any
-│       ├── zeros(shape: Any, rtype: Any) -> Any
-│       └── zeros_like(a: Any, rtype: Any) -> Any
+│       ├── ones(shape: typing.Union[list, tuple], rtype: typing.Callable) -> typing.Any
+│       ├── ones_like(a: typing.Any, rtype: typing.Callable) -> typing.Any
+│       ├── tensorproduct(tensors: pypynum.arrays.Array) -> pypynum.arrays.Array
+│       ├── zeros(shape: typing.Union[list, tuple], rtype: typing.Callable) -> typing.Any
+│       └── zeros_like(a: typing.Any, rtype: typing.Callable) -> typing.Any
 ├── chars
 │   ├── CLASS
 │   └── FUNCTION
@@ -656,8 +655,7 @@ PyPyNum
 │   │   └── Tensor(pypynum.arrays.Array)/__init__(self: Any, data: Any, check: Any) -> Any
 │   └── FUNCTION
 │       ├── ten(data: list) -> pypynum.tensors.Tensor
-│       ├── tensor_and_number(tensor: Any, operator: Any, number: Any) -> Any
-│       └── tensorproduct(tensors: pypynum.tensors.Tensor) -> pypynum.tensors.Tensor
+│       └── tensor_and_number(tensor: Any, operator: Any, number: Any) -> Any
 ├── test
 │   ├── CLASS
 │   └── FUNCTION
@@ -668,6 +666,7 @@ PyPyNum
 │   ├── CLASS
 │   └── FUNCTION
 │       ├── classify(array: typing.Union[list, tuple]) -> dict
+│       ├── cos_sim(seq1: typing.Union[list, tuple, str], seq2: typing.Union[list, tuple, str], is_vector: bool) -> float
 │       ├── dedup(iterable: typing.Union[list, tuple, str]) -> typing.Union[list, tuple, str]
 │       ├── fast_pow(a: typing.Any, n: int, init: typing.Any, mul: typing.Callable) -> typing.Any
 │       ├── frange(start: typing.Union[int, float], stop: typing.Union[int, float], step: float) -> list
@@ -680,6 +679,7 @@ PyPyNum
 │       ├── primality(n: int, iter_num: int) -> bool
 │       ├── prime_factors(integer: int, dictionary: bool, pollard_rho: bool) -> typing.Union[list, dict]
 │       ├── primes(limit: int) -> list
+│       ├── replace(seq: typing.Union[list, tuple], old: typing.Union[list, tuple], new: typing.Union[list, tuple], count: int) -> typing.Union[list, tuple]
 │       ├── semiprimes(limit: int) -> list
 │       ├── split(iterable: typing.Union[list, tuple, str], key: typing.Union[list, tuple], retain: bool) -> list
 │       └── twinprimes(limit: int) -> list

{pypynum-1.16.0 → pypynum-1.16.1}/pypynum/__init__.py

@@ -68,7 +68,7 @@ from .ufuncs import *
 from .utils import *
 from .vectors import *
 
-__version__ = "1.16.0"
+__version__ = "1.16.1"
 print("PyPyNum", "Version -> " + __version__, "PyPI -> https://pypi.org/project/PyPyNum/",
       "Gitee -> https://www.gitee.com/PythonSJL/PyPyNum", "GitHub -> https://github.com/PythonSJL/PyPyNum", sep=" | ")
 for _ in list(globals().keys()):

{pypynum-1.16.0 → pypynum-1.16.1}/pypynum/arrays.py

@@ -1,4 +1,4 @@
-from .types import ShapeError
+from .types import Any, Callable, ShapeError, arr
 
 ArrayError = ShapeError("The shape of the array is invalid")
 MatchError = ShapeError("The shapes of the two arrays do not match")
@@ -6,7 +6,7 @@ MatchError = ShapeError("The shapes of the two arrays do not match")
 
 class Array:
     """
-    It is the base class of vectors, matrices, and tensors, supporting operations and many statistical functions.
+    It is the base class of vectors and matrices, supporting operations and many statistical functions.
     :param data: An array in the form of a list
     :param check: Check the rationality of the input array
     """
@@ -41,12 +41,6 @@ class Array:
         _max = max([_.count("[") for _ in _then])
         return "\n".join([(_max - _.count("[")) * " " + _ + "\n" * (_.count("]") - 1) for _ in _then]).strip()
 
-    def __add__(self, other):
-        return Array(self.copy().data + other.copy().data)
-
-    def __radd__(self, other):
-        return self + other
-
     def __getitem__(self, item):
         def get_item_recursive(result, indices):
             if indices == ():
@@ -104,11 +98,44 @@ class Array:
     def __hash__(self):
         return hash(repr(self.data))
 
+    def __add__(self, other):
+        if isinstance(other, Array):
+            if self.shape != other.shape:
+                raise MatchError
+            return fill(self.shape, [t1 + t2 for t1, t2 in zip(self.flatten(), other.flatten())], rtype=type(self))
+        elif isinstance(other, (int, float, complex)):
+            from .ufuncs import add
+            return add(self, other)
+        else:
+            raise ValueError("Another must be an array or number")
+
+    def __sub__(self, other):
+        if isinstance(other, Array):
+            if self.shape != other.shape:
+                raise MatchError
+            return fill(self.shape, [t1 - t2 for t1, t2 in zip(self.flatten(), other.flatten())], rtype=type(self))
+        elif isinstance(other, (int, float, complex)):
+            from .ufuncs import subtract
+            return subtract(self, other)
+        else:
+            raise ValueError("Another must be an array or number")
+
+    def __mul__(self, other):
+        if isinstance(other, Array):
+            if self.shape != other.shape:
+                raise MatchError
+            return fill(self.shape, [t1 * t2 for t1, t2 in zip(self.flatten(), other.flatten())], rtype=type(self))
+        elif isinstance(other, (int, float, complex)):
+            from .ufuncs import multiply
+            return multiply(self, other)
+        else:
+            raise ValueError("Another must be an array or number")
+
     def __truediv__(self, other):
         if isinstance(other, Array):
             if self.shape != other.shape:
                 raise MatchError
-            return type(self)(fill(self.shape, [t1 / t2 for t1, t2 in zip(self.flatten(), other.flatten())]))
+            return fill(self.shape, [t1 / t2 for t1, t2 in zip(self.flatten(), other.flatten())], rtype=type(self))
         elif isinstance(other, (int, float, complex)):
             from .ufuncs import divide
             return divide(self, other)
@@ -119,7 +146,7 @@ class Array:
         if isinstance(other, Array):
             if self.shape != other.shape:
                 raise MatchError
-            return type(self)(fill(self.shape, [t1 // t2 for t1, t2 in zip(self.flatten(), other.flatten())]))
+            return fill(self.shape, [t1 // t2 for t1, t2 in zip(self.flatten(), other.flatten())], rtype=type(self))
         elif isinstance(other, (int, float, complex)):
             from .ufuncs import floor_divide
             return floor_divide(self, other)
@@ -130,7 +157,7 @@ class Array:
         if isinstance(other, Array):
             if self.shape != other.shape:
                 raise MatchError
-            return type(self)(fill(self.shape, [t1 % t2 for t1, t2 in zip(self.flatten(), other.flatten())]))
+            return fill(self.shape, [t1 % t2 for t1, t2 in zip(self.flatten(), other.flatten())], rtype=type(self))
         elif isinstance(other, (int, float, complex)):
             from .ufuncs import modulo
             return modulo(self, other)
@@ -145,6 +172,14 @@ class Array:
         else:
             raise ValueError("Exponential and modulus must both be arrays or numbers")
 
+    __radd__ = __add__
+    __rsub__ = __sub__
+    __rmul__ = __mul__
+    __rtruediv__ = __truediv__
+    __rfloordiv__ = __floordiv__
+    __rmod__ = __mod__
+    __rpow__ = __pow__
+
     def __gt__(self, other):
         return self.comparison(other, lambda x, y: x > y)
 
@@ -185,7 +220,7 @@ class Array:
         return data
 
     def reshape(self, shape, repeat=True, pad=0):
-        return type(self)(fill(shape, self.flatten(), repeat, pad))
+        return fill(shape, self.flatten(), repeat, pad, type(self))
 
     def copy(self):
         from copy import deepcopy
@@ -291,7 +326,7 @@ def asarray(data):
     return Array(aslist(data))
 
 
-def full(shape, fill_value, rtype=Array):
+def full(shape: arr, fill_value: Any, rtype: Callable = Array) -> Any:
     def inner(data):
         return fill_value if len(data) == 0 else [(inner(data[1:])) for _ in range(data[0])]
 
@@ -301,7 +336,7 @@ def full(shape, fill_value, rtype=Array):
     return result if rtype is list else rtype(result)
 
 
-def full_like(a, fill_value, rtype=Array):
+def full_like(a: Any, fill_value: Any, rtype: Callable = Array) -> Any:
     def inner(data):
         return [inner(item) for item in data] if isinstance(data, list) else fill_value
 
@@ -313,23 +348,23 @@ def full_like(a, fill_value, rtype=Array):
     return result if rtype is list else rtype(result)
 
 
-def zeros(shape, rtype=Array):
+def zeros(shape: arr, rtype: Callable = Array) -> Any:
     return full(shape, 0, rtype)
 
 
-def zeros_like(a, rtype=Array):
+def zeros_like(a: Any, rtype: Callable = Array) -> Any:
     return full_like(a, 0, rtype)
 
 
-def ones(shape, rtype=Array):
+def ones(shape: arr, rtype: Callable = Array) -> Any:
     return full(shape, 1, rtype)
 
 
-def ones_like(a, rtype=Array):
+def ones_like(a: Any, rtype: Callable = Array) -> Any:
     return full_like(a, 1, rtype)
 
 
-def fill(shape, sequence=None, repeat=True, pad=0, rtype=Array):
+def fill(shape: arr, sequence: arr = None, repeat: bool = True, pad: Any = 0, rtype: Callable = Array) -> Any:
     pointer = -1
     length = 1
     for item in shape:
@@ -353,6 +388,21 @@ def fill(shape, sequence=None, repeat=True, pad=0, rtype=Array):
     return result if rtype is list else rtype(result)
 
 
+def tensorproduct(*tensors: Array) -> Array:
+    if not all([isinstance(tensor, Array) for tensor in tensors]):
+        raise TypeError("All inputs must be tensors")
+    if len(tensors) == 1:
+        return tensors[0].copy()
+
+    def mul(a, b):
+        return Array(fill(a.shape + b.shape, [i * j for i in a.flatten() for j in b.flatten()], rtype=list), False)
+
+    first = tensors[0]
+    for second in tensors[1:]:
+        first = mul(first, second)
+    return first
+
+
 class BoolArray(Array):
     def __init__(self, data=None, check=True):
         from .ufuncs import apply

{pypynum-1.16.0 → pypynum-1.16.1}/pypynum/multiprec.py

@@ -415,8 +415,8 @@ def mp_euler_gamma(sigfigs: int = 28) -> Decimal:
     fact_k = Decimal(1)
     harmonic_sum = Decimal(0)
     temp = None
-    while i_n != temp:
-        temp = i_n
+    while j_n != temp:
+        temp = j_n
         term = (n_power_k / fact_k) ** 2
         i_n += term * harmonic_sum
         j_n += term

{pypynum-1.16.0 → pypynum-1.16.1}/pypynum/tensors.py

@@ -12,6 +12,9 @@ class Tensor(Array):
     """
 
     def __init__(self, data, check=True):
+        from warnings import warn
+        warn("The 'Tensor' class is deprecated and will be removed in a future version. "
+             "Please use the 'Array' class instead for similar functionality.", FutureWarning)
         super().__init__(data, check)
 
     def __add__(self, other):
@@ -80,19 +83,4 @@ def ten(data: list) -> Tensor:
     return Tensor(data)
 
 
-def tensorproduct(*tensors: Tensor) -> Tensor:
-    if not all([isinstance(tensor, Tensor) for tensor in tensors]):
-        raise TypeError("All inputs must be tensors")
-    if len(tensors) == 1:
-        return tensors[0].copy()
-
-    def mul(a, b):
-        return Tensor(fill(a.shape + b.shape, [i * j for i in a.flatten() for j in b.flatten()], rtype=list), False)
-
-    first = tensors[0]
-    for second in tensors[1:]:
-        first = mul(first, second)
-    return first
-
-
 del Array

{pypynum-1.16.0 → pypynum-1.16.1}/pypynum/tools.py

@@ -545,6 +545,116 @@ def lcsubstr(x: ite, y: ite) -> list:
     return list(x[end_idx - max_len:end_idx])
 
 
+def cos_sim(seq1: ite, seq2: ite, is_vector: bool = False) -> float:
+    """
+    Introduction
+    ==========
+    Calculate the cosine similarity between two sequences.
+
+    The cosine similarity is a measure of similarity between two non-zero vectors. It is defined as the cosine of the
+    angle between them, which is computed as the dot product of the vectors divided by the product of their magnitudes.
+    This function supports both numerical vectors and frequency distributions of sequences.
+
+    Example
+    ==========
+    >>> cos_sim("hello world", "world hello")
+    0.9999999999999998
+    >>>
+    :param seq1: First sequence to compare.
+    :param seq2: Second sequence to compare.
+    :param is_vector: A boolean indicating whether the input sequences are numerical vectors. Default is False.
+    :return: The cosine similarity between the two sequences, ranging from -1 to 1.
+    """
+    from .maths import freq
+    if is_vector:
+        dot_product = sum([a * b for a, b in zip(seq1, seq2)])
+        magnitude_seq1 = sum([a ** 2 for a in seq1]) ** 0.5
+        magnitude_seq2 = sum([b ** 2 for b in seq2]) ** 0.5
+    else:
+        freq1 = freq(seq1)
+        freq2 = freq(seq2)
+        dot_product = sum([freq1.get(k, 0) * freq2.get(k, 0) for k in set(freq1) | set(freq2)])
+        magnitude_seq1 = sum([v ** 2 for v in freq1.values()]) ** 0.5
+        magnitude_seq2 = sum([v ** 2 for v in freq2.values()]) ** 0.5
+    if magnitude_seq1 * magnitude_seq2 == 0:
+        return 0.0
+    return dot_product / (magnitude_seq1 * magnitude_seq2)
+
+
+def replace(seq: arr, old: arr, new: arr, count: int = -1) -> arr:
+    """
+    Introduction
+    ==========
+    Replace occurrences of the subsequence 'old' in 'seq' with 'new'.
+
+    This function is designed to handle sequences such as lists or tuples and replace specified subsequences
+    with new ones. It also allows limiting the number of replacements.
+
+    Example
+    ==========
+    >>> replace([1, 2, 3, 4, 2, 3], [2, 3], [5, 6])
+    [1, 5, 6, 4, 5, 6]
+    >>>
+    :param seq: The sequence in which to replace the subsequence.
+    :param old: The subsequence to be replaced.
+    :param new: The subsequence to replace with.
+    :param count: The maximum number of replacements to perform. Default is -1 (unlimited).
+    :return: The modified sequence with replacements.
+    """
+    if not isinstance(seq, (list, tuple)):
+        raise TypeError("Parameter 'seq' must be a list or a tuple, got {}".format(type(seq)))
+    if not isinstance(old, (list, tuple)):
+        raise TypeError("Parameter 'old' must be a list or a tuple, got {}".format(type(old)))
+    if not isinstance(new, (list, tuple)):
+        raise TypeError("Parameter 'new' must be a list or a tuple, got {}".format(type(new)))
+    if not old:
+        raise ValueError("Parameter 'old' must not be empty")
+    if not isinstance(count, int) or count < 0 and count != -1:
+        raise ValueError("Parameter 'count' must be a non-negative integer or -1, got {}".format(count))
+    if count == 0:
+        return seq[:]
+    old_len = len(old)
+    table = [0] * old_len
+    pos, cnd = 1, 0
+    while pos < old_len:
+        if old[pos] == old[cnd]:
+            cnd += 1
+            table[pos] = cnd
+            pos += 1
+        elif cnd > 0:
+            cnd = table[cnd - 1]
+        else:
+            table[pos] = 0
+            pos += 1
+    result = []
+    i, j = 0, 0
+    replaced = 0
+    seq_len = len(seq)
+    while i < seq_len:
+        if j == old_len:
+            result.extend(new)
+            replaced += 1
+            j = 0
+            if count != -1 and replaced == count:
+                result.extend(seq[i:])
+                break
+        elif seq[i] == old[j]:
+            i += 1
+            j += 1
+        else:
+            if j != 0:
+                result.extend(old[:j])
+                j = table[j - 1]
+            else:
+                result.append(seq[i])
+                i += 1
+    if j == old_len:
+        result.extend(new)
+    elif j > 0:
+        result.extend(old[:j])
+    return tuple(result) if isinstance(seq, tuple) else result
+
+
 def fast_pow(a: Any, n: int, init: Any = 1, mul: Callable = None) -> Any:
     """
     Introduction
@@ -553,7 +663,6 @@ def fast_pow(a: Any, n: int, init: Any = 1, mul: Callable = None) -> Any:
 
     It is a versatile tool that can be used with any data type supporting multiplication, including the ability to
     perform matrix exponentiation by setting an initial matrix and a matrix multiplication function.
-
     For instance, to compute the matrix power of a 2x2 matrix, you can define the matrix as the base 'a',
     set an identity matrix as the 'init', and provide a function for matrix multiplication as 'mul'.
 

{pypynum-1.16.0 → pypynum-1.16.1}/setup.py

@@ -220,7 +220,7 @@ LICENSE = """
 
 setup(
     name="PyPyNum",
-    version="1.16.0",
+    version="1.16.1",
     packages=find_packages(),
     url="https://github.com/PythonSJL/PyPyNum",
     license=LICENSE,