PyPyNum 1.16.1__py3-none-any.whl → 1.16.2__py3-none-any.whl

{PyPyNum-1.16.1.dist-info → PyPyNum-1.16.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PyPyNum
-Version: 1.16.1
+Version: 1.16.2
 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)
 
-## PyPyNum | Version -> 1.16.1 | PyPI -> https://pypi.org/project/PyPyNum/ | Gitee -> https://www.gitee.com/PythonSJL/PyPyNum | GitHub -> https://github.com/PythonSJL/PyPyNum
+## Version -> 1.16.2 | PyPI -> https://pypi.org/project/PyPyNum/ | Gitee -> https://www.gitee.com/PythonSJL/PyPyNum | GitHub -> https://github.com/PythonSJL/PyPyNum
 
 ![LOGO](PyPyNum.png)
 
@@ -247,6 +247,15 @@ The logo cannot be displayed on PyPI, it can be viewed in Gitee or GitHub.
 + Update versions periodically to add more practical features
 + If you need to contact, please add QQ number 2261748025 (Py𝙿𝚢𝚝𝚑𝚘𝚗-水晶兰), or through my email 2261748025@qq.com
 
+```
++++++++++++++++++++++++++++++++++++++++++
++ Tip:                                  +
++ Have suggestions or feature requests? +
++ Feel free to share them with us.      +
++ Your feedback is highly appreciated!  +
++++++++++++++++++++++++++++++++++++++++++
+```
+
 ### Name and Function Introduction of Submodules
 
 |   Submodule Name    |                       Function Introduction                        |
@@ -327,79 +336,69 @@ Python interpreter and run it!
 ```
 !=!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=
 
-Fixed and improved the basic
-operation function of 'Array'.
-
-!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=
-
-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 >>>
 
 
-cos_sim(seq1: Union[list, tuple, str], seq2: Union[list, tuple, str], is_vector: bool = False) -> float
+kmp_table(pattern: Union[list, tuple, str]) -> list
     Introduction
     ==========
-    Calculate the cosine similarity between two sequences.
+    Generate the KMP (Knuth-Morris-Pratt) table for a given pattern.
 
-    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.
+    The KMP table is used to efficiently find occurrences of a pattern within a sequence by avoiding unnecessary
+    comparisons after a mismatch. This table determines how many characters can be skipped after a mismatch.
 
     Example
-    ==========
-    >>> cos_sim("hello world", "world hello")
-    0.9999999999999998
+    ========
+    >>> kmp_table("AGCTGATCGTACGTAAGCTAGCTA")
+    [0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 2, 3, 4, 1, 2, 3, 4, 1]
     >>>
-    :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.
+    :param pattern: The pattern for which to generate the KMP table.
+    :return: A list representing the KMP table for the given pattern.
 
 
-replace(seq: Union[list, tuple], old: Union[list, tuple], new: Union[list, tuple], count: int = -1) -> Union[list, tuple]
+findall(seq: Union[list, tuple, str], pat: Union[list, tuple, str]) -> list
     Introduction
     ==========
-    Replace occurrences of the subsequence 'old' in 'seq' with 'new'.
+    Find all indices of the subsequence 'pat' in 'seq'.
 
-    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.
+    This function is designed to handle sequences such as lists, tuples, or strings and find all indices
+    of specified subsequences. It allows overlapping matches.
 
     Example
-    ==========
-    >>> replace([1, 2, 3, 4, 2, 3], [2, 3], [5, 6])
-    [1, 5, 6, 4, 5, 6]
+    ========
+    >>> findall([2, 1, 2, 1, 2, 1, 2, 1], [1, 2, 1, 2])
+    [1, 3]
     >>>
-    :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.
+    :param seq: The sequence in which to find the subsequence.
+    :param pat: The subsequence to be found.
+    :return: A list of starting indices where the subsequence is found.
+
+
+---------------------------------------------------------------------------------------
+| q-functions generalize classical math functions by introducing parameter q.         |
+| They are key in combinatorics and special functions, widely applied.                |
+| As q approaches 1, they revert to classical forms.                                  |
+| Examples include q-factorials, q-binomial coefficients, Jackson q-Bessel functions. |
+| These functions are crucial in fractals, chaotic systems, quantum groups.           |
+| They provide tools for solving complex mathematical challenges effectively.         |
+---------------------------------------------------------------------------------------
+
+
+Here are the 12 new q-functions added in the current version (adding the previous 4 makes a total of 16):
 
-!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=
 
-Other functions and classes have
-also undergone certain
-modifications, such as adding a
-"reduce" parameter to the "qr"
-function to determine whether to
-crop the matrix.
+qbeta(a: Union[int, float, complex], b: Union[int, float, complex], q: Union[int, float, complex]) -> Union[int, float, complex]
+qcos_large(x: Union[int, float, complex], q: Union[int, float, complex]) -> Union[int, float, complex]
+qcos_small(x: Union[int, float, complex], q: Union[int, float, complex]) -> Union[int, float, complex]
+qcosh_large(x: Union[int, float, complex], q: Union[int, float, complex]) -> Union[int, float, complex]
+qcosh_small(x: Union[int, float, complex], q: Union[int, float, complex]) -> Union[int, float, complex]
+qexp_large(z: Union[int, float, complex], q: Union[int, float, complex]) -> Union[int, float, complex]
+qexp_small(z: Union[int, float, complex], q: Union[int, float, complex]) -> Union[int, float, complex]
+qpi(q: Union[int, float, complex]) -> Union[int, float, complex]
+qsin_large(x: Union[int, float, complex], q: Union[int, float, complex]) -> Union[int, float, complex]
+qsin_small(x: Union[int, float, complex], q: Union[int, float, complex]) -> Union[int, float, complex]
+qsinh_large(x: Union[int, float, complex], q: Union[int, float, complex]) -> Union[int, float, complex]
+qsinh_small(x: Union[int, float, complex], q: Union[int, float, complex]) -> Union[int, float, complex]
 
 !=!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=
 ```
@@ -500,7 +499,7 @@ PyPyNum
 │       ├── gamma_pdf(x: Any, shape: Any, scale: Any) -> Any
 │       ├── geometric_pmf(k: Any, p: Any) -> Any
 │       ├── hypergeom_pmf(k: Any, mg: Any, n: Any, nt: Any) -> Any
-│       ├── inv_gauss_pdf(x: Any, mu: Any, lambda_: Any, alpha: Any) -> Any
+│       ├── invgauss_pdf(x: Any, mu: Any, lambda_: Any, alpha: Any) -> Any
 │       ├── levy_pdf(x: Any, c: Any) -> Any
 │       ├── log_logistic_cdf(x: Any, alpha: Any, beta: Any) -> Any
 │       ├── log_logistic_pdf(x: Any, alpha: Any, beta: Any) -> Any
@@ -646,7 +645,7 @@ PyPyNum
 │       ├── cosh(x: typing.Union[int, float]) -> typing.Union[int, float]
 │       ├── cot(x: typing.Union[int, float]) -> typing.Union[int, float]
 │       ├── coth(x: typing.Union[int, float]) -> typing.Union[int, float]
-│       ├── cov(x: typing.Union[list, tuple], y: typing.Union[list, tuple], dof: int) -> typing.Union[int, float, complex]
+│       ├── cov(x: typing.Union[list, tuple], y: typing.Union[list, tuple], ddof: int) -> typing.Union[int, float, complex]
 │       ├── crt(n: typing.Union[list, tuple], a: typing.Union[list, tuple]) -> int
 │       ├── csc(x: typing.Union[int, float]) -> typing.Union[int, float]
 │       ├── csch(x: typing.Union[int, float]) -> typing.Union[int, float]
@@ -694,13 +693,13 @@ PyPyNum
 │       ├── sinh(x: typing.Union[int, float]) -> typing.Union[int, float]
 │       ├── skew(data: typing.Union[list, tuple]) -> float
 │       ├── square_mean(numbers: typing.Union[list, tuple]) -> typing.Union[int, float, complex]
-│       ├── std(numbers: typing.Union[list, tuple], dof: int) -> typing.Union[int, float, complex]
+│       ├── std(numbers: typing.Union[list, tuple], ddof: int) -> typing.Union[int, float, complex]
 │       ├── sumprod(arrays: typing.Union[list, tuple]) -> typing.Union[int, float, complex]
 │       ├── tan(x: typing.Union[int, float]) -> typing.Union[int, float]
 │       ├── tanh(x: typing.Union[int, float]) -> typing.Union[int, float]
 │       ├── totient(n: int) -> int
 │       ├── upper_gamma(s: typing.Union[int, float, complex], x: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]
-│       ├── var(numbers: typing.Union[list, tuple], dof: int) -> typing.Union[int, float, complex]
+│       ├── var(numbers: typing.Union[list, tuple], ddof: int) -> typing.Union[int, float, complex]
 │       ├── xlogy(x: typing.Union[int, float, complex], y: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]
 │       └── zeta(alpha: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]
 ├── matrices
@@ -847,10 +846,22 @@ PyPyNum
 │       ├── hyp1f1(a0: typing.Union[int, float, complex], b0: typing.Union[int, float, complex], z: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]
 │       ├── hyp2f1(a0: typing.Union[int, float, complex], a1: typing.Union[int, float, complex], b0: typing.Union[int, float, complex], z: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]
 │       ├── hyppfq(a: typing.Union[list, tuple], b: typing.Union[list, tuple], z: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]
+│       ├── qbeta(a: typing.Union[int, float, complex], b: typing.Union[int, float, complex], q: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]
 │       ├── qbinomial(n: typing.Union[int, float, complex], m: typing.Union[int, float, complex], q: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]
+│       ├── qcos_large(x: typing.Union[int, float, complex], q: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]
+│       ├── qcos_small(x: typing.Union[int, float, complex], q: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]
+│       ├── qcosh_large(x: typing.Union[int, float, complex], q: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]
+│       ├── qcosh_small(x: typing.Union[int, float, complex], q: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]
+│       ├── qexp_large(z: typing.Union[int, float, complex], q: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]
+│       ├── qexp_small(z: typing.Union[int, float, complex], q: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]
 │       ├── qfactorial(n: typing.Union[int, float, complex], q: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]
 │       ├── qgamma(n: typing.Union[int, float, complex], q: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]
-│       └── qpochhammer(a: typing.Union[int, float, complex], q: typing.Union[int, float, complex], n: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]
+│       ├── qpi(q: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]
+│       ├── qpochhammer(a: typing.Union[int, float, complex], q: typing.Union[int, float, complex], n: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]
+│       ├── qsin_large(x: typing.Union[int, float, complex], q: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]
+│       ├── qsin_small(x: typing.Union[int, float, complex], q: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]
+│       ├── qsinh_large(x: typing.Union[int, float, complex], q: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]
+│       └── qsinh_small(x: typing.Union[int, float, complex], q: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]
 ├── stattest
 │   ├── CLASS
 │   └── FUNCTION
@@ -883,8 +894,10 @@ PyPyNum
 │       ├── 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
+│       ├── findall(seq: typing.Union[list, tuple, str], pat: typing.Union[list, tuple, str]) -> list
 │       ├── frange(start: typing.Union[int, float], stop: typing.Union[int, float], step: float) -> list
 │       ├── geomspace(start: typing.Union[int, float], stop: typing.Union[int, float], number: int) -> list
+│       ├── kmp_table(pattern: typing.Union[list, tuple, str]) -> list
 │       ├── lcsubseq(x: typing.Union[list, tuple, str], y: typing.Union[list, tuple, str]) -> list
 │       ├── lcsubstr(x: typing.Union[list, tuple, str], y: typing.Union[list, tuple, str]) -> list
 │       ├── levenshtein(x: typing.Union[list, tuple, str], y: typing.Union[list, tuple, str]) -> int

{PyPyNum-1.16.1.dist-info → PyPyNum-1.16.2.dist-info}/RECORD

@@ -1,13 +1,13 @@
 pypynum/PyPyNum.png,sha256=t96tJPWfHxT8kcXm_qZI2z5W36TgOqjCU9qdgbmlFws,11623
-pypynum/README.md,sha256=y4JBXggitGZ9Gy0b9fmCo4sZbLJ064DqYZ29J0lbVi8,83919
-pypynum/__init__.py,sha256=3ozuifHA8CK2c6h9uFuZo3xkTsYgixL4VZesQMeObkw,2640
-pypynum/arrays.py,sha256=GpU_smZ-9Bw897tWDGTTPMThQ_VfCvjfrIq6OGpuiDI,15492
-pypynum/chars.py,sha256=6XNmH0zYsv0pfadW3KoevrR8xQPIkles9oGikjS6R1I,2181
+pypynum/README.md,sha256=RQ25LQM5-mWR-7bvwgUn2TzuklWLomSeDABoL0QeN2A,87008
+pypynum/__init__.py,sha256=BqVO2tFYX-UWMao6Uy1Zl8snL6H2_GxNM6Chestl02Q,2640
+pypynum/arrays.py,sha256=81dlyUn1xNs1f4enpfQjXEJurjEMfQqaQMfMC3quR8U,15793
+pypynum/chars.py,sha256=HIqTmWl58GypJgVIlgSFVc2icI01NczfbRyu5QmuHz0,2178
 pypynum/ciphers.py,sha256=kC7wZk3FF-MCCvn2-1YxiaRa4ImDKxyyihJYc6Dyf5E,10008
 pypynum/consts.py,sha256=enetPwJevWgYXuGEasAb-tXMHpvL2xWKUe-B1gTwInk,8416
 pypynum/crandom.py,sha256=44GZ7o6y5PwgL-cZLkXUZaAUfiW6aadyRNfMdxTnH30,5111
 pypynum/dataproc.py,sha256=bJ2a1-S7TQj8V8vzXZ3ooP32fBe99NQU0orPGprEIdg,9231
-pypynum/dists.py,sha256=SGxZ08n4mRaqegHILoaJNH4jzPzk-fsE7kvN-EmegPQ,29697
+pypynum/dists.py,sha256=fz7hZZfHFWDHnxo7Li9eNkaj7cQtE6SuYGaitSRwHKc,29695
 pypynum/equations.py,sha256=_oywKzbrOPOOhD4yu83qqNiIOKQPbJJs6SghdkGbqUw,561
 pypynum/fft.py,sha256=AtG0tESykzEs4gDsXhcizW7qhQnmw0gjcWcXefBqzhs,1401
 pypynum/files.py,sha256=iLtTc5UTtUUWoh2sDJl5Yyy_rT8-Vi0pby5c2J95EqE,3397
@@ -18,7 +18,7 @@ pypynum/images.py,sha256=DPpsW_qdoKSrXz3w6DWaQDj9Y_u5l_JYWbNt47taJbs,12157
 pypynum/interp.py,sha256=wNMa6M_IRpSe026tuRxXfr244oBtgHOpCpYlGd4eyhA,4920
 pypynum/kernels.py,sha256=GMwWnjLWEprFXSEAIN8d6GZrC2KDx6qhJdbcLBoYOTg,15869
 pypynum/logics.py,sha256=EwvWFNND14__oWx7o-_oYIUubmVhp3DrvBcnRCWW8vc,10999
-pypynum/maths.py,sha256=McuOXRktbjcjZpTfWEoHnmFkeeQVacMoHyThqTIC27E,32808
+pypynum/maths.py,sha256=Q8TX1o3j5g-0VKS2kHiaxMKkvWXa20vGi1jhIuaJsXw,32820
 pypynum/matrices.py,sha256=useh4_Hlk3YBRTSTJK6SsErTRnDVblsqB0a7iw1mB_k,22439
 pypynum/multiprec.py,sha256=LCaj0pkZIXmPKodm2Jt5RdyTg20Q6Js-n7PGBzqMXhk,20111
 pypynum/networks.py,sha256=iSOvC9JW1h4AFGokGGOTkKie5hAYN_YT9H4f3apI9b8,3275
@@ -29,21 +29,21 @@ pypynum/pprinters.py,sha256=Qt9-V5SUyoOqC3lsUU5D5zSSM-MmcnFCUyUtLxhS4pE,2514
 pypynum/quats.py,sha256=tn1ZogMiV8FGYucZ3u8ynG6SFpPjhFAachVHxgBdDZk,8000
 pypynum/random.py,sha256=fGaJfwS0QUWV-qb8hldXpRUYJ-79n7Al0gEmPJMAwJc,2254
 pypynum/regs.py,sha256=mV1r1KkXAv07FmcTntaBF0rcwHBXUyXPvC9h6UOkhE0,2042
-pypynum/seqs.py,sha256=Hch8ebCrVFHUfKig54CVGzf3xXkVJlVbLsE0e7flOX4,11666
-pypynum/special.py,sha256=58pRacza__MwnovWFRemVglszF1wdUwgA4uyS25M47w,11643
+pypynum/seqs.py,sha256=Y60nSV32wcuY3zyY8h_l185BURkCJoa82BhZVgI3AMY,11681
+pypynum/special.py,sha256=cuucF1Z6CPRaBiffRKKbStfWaZkbOEqLPTIg7zRXLFQ,19748
 pypynum/stattest.py,sha256=nCAqFjaHVa9EOaWcmgWrhPuBoyLdoypkz6_YeM_AOd8,5511
 pypynum/symbols.py,sha256=u-Dig3OLs6qoLzxMpTAYJGq5uSWDMvgU13TAHKLyjMY,2768
 pypynum/tensors.py,sha256=F87npY9VbaCAr0OvTwsW1GAhEQPQAQTVlJzeVuf4zSg,3418
 pypynum/test.py,sha256=HY6TiQr9-wIadRoXElu8TJkVWKMxcahisyWBtew8B9c,8730
 pypynum/this.py,sha256=wT7DwodxqOQ7LoDaUtvskMkAb8CODL_56mtXPy12P54,3411
-pypynum/tools.py,sha256=PWE4eHVHcFrbKTz-ohiRPc1xo2_FvQj3LpfDvWe8mh0,23035
+pypynum/tools.py,sha256=bxIoWjjnjlasEYnhrk_2nItKGRndwPrk_f2lK7SLUQ4,25422
 pypynum/trees.py,sha256=b02t69vBjc3ibKaUAkWfBvMDdsugF4DpGC2-q4RsgEU,39779
 pypynum/types.py,sha256=v1lGIL_p0xgxL6mGX7uBQBHBa7UScKCsgPkW8Q6nzlk,3348
 pypynum/ufuncs.py,sha256=Lmr_ZVsswQqbGo2MB8gjd_lijRBOZIy2q2wQBOHvYxM,3549
 pypynum/utils.py,sha256=BhH_iSU44bS6tC3MMrDfIfGhIsQg9nMVlp6fl0-KcRA,21001
-pypynum/vectors.py,sha256=GGVk0YSLVm-hzJjm068W7tNRYu8NqPgOKtWHIOTn9yY,3212
-pypynum/zh_cn.py,sha256=YBmTCO0h-xMDEo9pfpaR1qvh0qaL811psoZDdBniuzE,13818
-PyPyNum-1.16.1.dist-info/METADATA,sha256=CjPWR4mVYBqmVNqYNTXXnA0dhosQvbClUg614eNIzZM,98298
-PyPyNum-1.16.1.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-PyPyNum-1.16.1.dist-info/top_level.txt,sha256=4wW_Xb4bRglmiMsdPAe9f75MkXhNpuN88H17g_Cr5u8,8
-PyPyNum-1.16.1.dist-info/RECORD,,
+pypynum/vectors.py,sha256=ANvmI1ftLZPIxO871YLuXUzV6CtvHXrGBf5YIqN_qUE,3390
+pypynum/zh_cn.py,sha256=raTXV7sa9zob3ZtnT263kNFL7NDm-0ZhTrqZIcc88Tk,13812
+PyPyNum-1.16.2.dist-info/METADATA,sha256=K1E_AqE4v-FaRxqCJB8fd4Z_O9jFBlMoPony-pEt_Fc,101387
+PyPyNum-1.16.2.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+PyPyNum-1.16.2.dist-info/top_level.txt,sha256=4wW_Xb4bRglmiMsdPAe9f75MkXhNpuN88H17g_Cr5u8,8
+PyPyNum-1.16.2.dist-info/RECORD,,

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)
 
-## PyPyNum | Version -> 1.16.1 | PyPI -> https://pypi.org/project/PyPyNum/ | Gitee -> https://www.gitee.com/PythonSJL/PyPyNum | GitHub -> https://github.com/PythonSJL/PyPyNum
+## Version -> 1.16.2 | PyPI -> https://pypi.org/project/PyPyNum/ | Gitee -> https://www.gitee.com/PythonSJL/PyPyNum | GitHub -> https://github.com/PythonSJL/PyPyNum
 
 ![LOGO](PyPyNum.png)
 
@@ -33,6 +33,15 @@ The logo cannot be displayed on PyPI, it can be viewed in Gitee or GitHub.
 + Update versions periodically to add more practical features
 + If you need to contact, please add QQ number 2261748025 (Py𝙿𝚢𝚝𝚑𝚘𝚗-水晶兰), or through my email 2261748025@qq.com
 
+```
++++++++++++++++++++++++++++++++++++++++++
++ Tip:                                  +
++ Have suggestions or feature requests? +
++ Feel free to share them with us.      +
++ Your feedback is highly appreciated!  +
++++++++++++++++++++++++++++++++++++++++++
+```
+
 ### Name and Function Introduction of Submodules
 
 |   Submodule Name    |                       Function Introduction                        |
@@ -113,79 +122,69 @@ Python interpreter and run it!
 ```
 !=!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=
 
-Fixed and improved the basic
-operation function of 'Array'.
-
-!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=
-
-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 >>>
 
 
-cos_sim(seq1: Union[list, tuple, str], seq2: Union[list, tuple, str], is_vector: bool = False) -> float
+kmp_table(pattern: Union[list, tuple, str]) -> list
     Introduction
     ==========
-    Calculate the cosine similarity between two sequences.
+    Generate the KMP (Knuth-Morris-Pratt) table for a given pattern.
 
-    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.
+    The KMP table is used to efficiently find occurrences of a pattern within a sequence by avoiding unnecessary
+    comparisons after a mismatch. This table determines how many characters can be skipped after a mismatch.
 
     Example
-    ==========
-    >>> cos_sim("hello world", "world hello")
-    0.9999999999999998
+    ========
+    >>> kmp_table("AGCTGATCGTACGTAAGCTAGCTA")
+    [0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 2, 3, 4, 1, 2, 3, 4, 1]
     >>>
-    :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.
+    :param pattern: The pattern for which to generate the KMP table.
+    :return: A list representing the KMP table for the given pattern.
 
 
-replace(seq: Union[list, tuple], old: Union[list, tuple], new: Union[list, tuple], count: int = -1) -> Union[list, tuple]
+findall(seq: Union[list, tuple, str], pat: Union[list, tuple, str]) -> list
     Introduction
     ==========
-    Replace occurrences of the subsequence 'old' in 'seq' with 'new'.
+    Find all indices of the subsequence 'pat' in 'seq'.
 
-    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.
+    This function is designed to handle sequences such as lists, tuples, or strings and find all indices
+    of specified subsequences. It allows overlapping matches.
 
     Example
-    ==========
-    >>> replace([1, 2, 3, 4, 2, 3], [2, 3], [5, 6])
-    [1, 5, 6, 4, 5, 6]
+    ========
+    >>> findall([2, 1, 2, 1, 2, 1, 2, 1], [1, 2, 1, 2])
+    [1, 3]
     >>>
-    :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.
+    :param seq: The sequence in which to find the subsequence.
+    :param pat: The subsequence to be found.
+    :return: A list of starting indices where the subsequence is found.
+
+
+---------------------------------------------------------------------------------------
+| q-functions generalize classical math functions by introducing parameter q.         |
+| They are key in combinatorics and special functions, widely applied.                |
+| As q approaches 1, they revert to classical forms.                                  |
+| Examples include q-factorials, q-binomial coefficients, Jackson q-Bessel functions. |
+| These functions are crucial in fractals, chaotic systems, quantum groups.           |
+| They provide tools for solving complex mathematical challenges effectively.         |
+---------------------------------------------------------------------------------------
+
+
+Here are the 12 new q-functions added in the current version (adding the previous 4 makes a total of 16):
 
-!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=
 
-Other functions and classes have
-also undergone certain
-modifications, such as adding a
-"reduce" parameter to the "qr"
-function to determine whether to
-crop the matrix.
+qbeta(a: Union[int, float, complex], b: Union[int, float, complex], q: Union[int, float, complex]) -> Union[int, float, complex]
+qcos_large(x: Union[int, float, complex], q: Union[int, float, complex]) -> Union[int, float, complex]
+qcos_small(x: Union[int, float, complex], q: Union[int, float, complex]) -> Union[int, float, complex]
+qcosh_large(x: Union[int, float, complex], q: Union[int, float, complex]) -> Union[int, float, complex]
+qcosh_small(x: Union[int, float, complex], q: Union[int, float, complex]) -> Union[int, float, complex]
+qexp_large(z: Union[int, float, complex], q: Union[int, float, complex]) -> Union[int, float, complex]
+qexp_small(z: Union[int, float, complex], q: Union[int, float, complex]) -> Union[int, float, complex]
+qpi(q: Union[int, float, complex]) -> Union[int, float, complex]
+qsin_large(x: Union[int, float, complex], q: Union[int, float, complex]) -> Union[int, float, complex]
+qsin_small(x: Union[int, float, complex], q: Union[int, float, complex]) -> Union[int, float, complex]
+qsinh_large(x: Union[int, float, complex], q: Union[int, float, complex]) -> Union[int, float, complex]
+qsinh_small(x: Union[int, float, complex], q: Union[int, float, complex]) -> Union[int, float, complex]
 
 !=!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=
 ```
@@ -286,7 +285,7 @@ PyPyNum
 │       ├── gamma_pdf(x: Any, shape: Any, scale: Any) -> Any
 │       ├── geometric_pmf(k: Any, p: Any) -> Any
 │       ├── hypergeom_pmf(k: Any, mg: Any, n: Any, nt: Any) -> Any
-│       ├── inv_gauss_pdf(x: Any, mu: Any, lambda_: Any, alpha: Any) -> Any
+│       ├── invgauss_pdf(x: Any, mu: Any, lambda_: Any, alpha: Any) -> Any
 │       ├── levy_pdf(x: Any, c: Any) -> Any
 │       ├── log_logistic_cdf(x: Any, alpha: Any, beta: Any) -> Any
 │       ├── log_logistic_pdf(x: Any, alpha: Any, beta: Any) -> Any
@@ -432,7 +431,7 @@ PyPyNum
 │       ├── cosh(x: typing.Union[int, float]) -> typing.Union[int, float]
 │       ├── cot(x: typing.Union[int, float]) -> typing.Union[int, float]
 │       ├── coth(x: typing.Union[int, float]) -> typing.Union[int, float]
-│       ├── cov(x: typing.Union[list, tuple], y: typing.Union[list, tuple], dof: int) -> typing.Union[int, float, complex]
+│       ├── cov(x: typing.Union[list, tuple], y: typing.Union[list, tuple], ddof: int) -> typing.Union[int, float, complex]
 │       ├── crt(n: typing.Union[list, tuple], a: typing.Union[list, tuple]) -> int
 │       ├── csc(x: typing.Union[int, float]) -> typing.Union[int, float]
 │       ├── csch(x: typing.Union[int, float]) -> typing.Union[int, float]
@@ -480,13 +479,13 @@ PyPyNum
 │       ├── sinh(x: typing.Union[int, float]) -> typing.Union[int, float]
 │       ├── skew(data: typing.Union[list, tuple]) -> float
 │       ├── square_mean(numbers: typing.Union[list, tuple]) -> typing.Union[int, float, complex]
-│       ├── std(numbers: typing.Union[list, tuple], dof: int) -> typing.Union[int, float, complex]
+│       ├── std(numbers: typing.Union[list, tuple], ddof: int) -> typing.Union[int, float, complex]
 │       ├── sumprod(arrays: typing.Union[list, tuple]) -> typing.Union[int, float, complex]
 │       ├── tan(x: typing.Union[int, float]) -> typing.Union[int, float]
 │       ├── tanh(x: typing.Union[int, float]) -> typing.Union[int, float]
 │       ├── totient(n: int) -> int
 │       ├── upper_gamma(s: typing.Union[int, float, complex], x: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]
-│       ├── var(numbers: typing.Union[list, tuple], dof: int) -> typing.Union[int, float, complex]
+│       ├── var(numbers: typing.Union[list, tuple], ddof: int) -> typing.Union[int, float, complex]
 │       ├── xlogy(x: typing.Union[int, float, complex], y: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]
 │       └── zeta(alpha: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]
 ├── matrices
@@ -633,10 +632,22 @@ PyPyNum
 │       ├── hyp1f1(a0: typing.Union[int, float, complex], b0: typing.Union[int, float, complex], z: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]
 │       ├── hyp2f1(a0: typing.Union[int, float, complex], a1: typing.Union[int, float, complex], b0: typing.Union[int, float, complex], z: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]
 │       ├── hyppfq(a: typing.Union[list, tuple], b: typing.Union[list, tuple], z: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]
+│       ├── qbeta(a: typing.Union[int, float, complex], b: typing.Union[int, float, complex], q: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]
 │       ├── qbinomial(n: typing.Union[int, float, complex], m: typing.Union[int, float, complex], q: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]
+│       ├── qcos_large(x: typing.Union[int, float, complex], q: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]
+│       ├── qcos_small(x: typing.Union[int, float, complex], q: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]
+│       ├── qcosh_large(x: typing.Union[int, float, complex], q: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]
+│       ├── qcosh_small(x: typing.Union[int, float, complex], q: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]
+│       ├── qexp_large(z: typing.Union[int, float, complex], q: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]
+│       ├── qexp_small(z: typing.Union[int, float, complex], q: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]
 │       ├── qfactorial(n: typing.Union[int, float, complex], q: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]
 │       ├── qgamma(n: typing.Union[int, float, complex], q: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]
-│       └── qpochhammer(a: typing.Union[int, float, complex], q: typing.Union[int, float, complex], n: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]
+│       ├── qpi(q: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]
+│       ├── qpochhammer(a: typing.Union[int, float, complex], q: typing.Union[int, float, complex], n: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]
+│       ├── qsin_large(x: typing.Union[int, float, complex], q: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]
+│       ├── qsin_small(x: typing.Union[int, float, complex], q: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]
+│       ├── qsinh_large(x: typing.Union[int, float, complex], q: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]
+│       └── qsinh_small(x: typing.Union[int, float, complex], q: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]
 ├── stattest
 │   ├── CLASS
 │   └── FUNCTION
@@ -669,8 +680,10 @@ PyPyNum
 │       ├── 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
+│       ├── findall(seq: typing.Union[list, tuple, str], pat: typing.Union[list, tuple, str]) -> list
 │       ├── frange(start: typing.Union[int, float], stop: typing.Union[int, float], step: float) -> list
 │       ├── geomspace(start: typing.Union[int, float], stop: typing.Union[int, float], number: int) -> list
+│       ├── kmp_table(pattern: typing.Union[list, tuple, str]) -> list
 │       ├── lcsubseq(x: typing.Union[list, tuple, str], y: typing.Union[list, tuple, str]) -> list
 │       ├── lcsubstr(x: typing.Union[list, tuple, str], y: typing.Union[list, tuple, str]) -> list
 │       ├── levenshtein(x: typing.Union[list, tuple, str], y: typing.Union[list, tuple, str]) -> int

pypynum/__init__.py

@@ -68,7 +68,7 @@ from .ufuncs import *
 from .utils import *
 from .vectors import *
 
-__version__ = "1.16.1"
+__version__ = "1.16.2"
 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/arrays.py

@@ -294,16 +294,22 @@ def get_shape(data):
 
 
 def is_valid_array(_array, _shape):
-    if len(_shape) != 1 and not isinstance(_array, list):
-        raise ArrayError
-    if len(_shape) == 1:
-        if not isinstance(_array, list) or len(_array) != _shape[0]:
+    def inner(a, s, al, sl):
+        if sl == 1:
+            if not isinstance(a, list) or al != s[0]:
+                raise ArrayError
+        elif al == s[0]:
+            for i in a:
+                if not isinstance(i, list):
+                    raise ArrayError
+                inner(i, s[1:], len(i), sl - 1)
+        else:
             raise ArrayError
-    elif len(_array) == _shape[0]:
-        for _ in _array:
-            is_valid_array(_, _shape[1:])
-    else:
+
+    shape_len = len(_shape)
+    if shape_len != 1 and not isinstance(_array, list):
         raise ArrayError
+    inner(_array, _shape, len(_array), shape_len)
 
 
 def array(data=None):
@@ -327,12 +333,12 @@ def asarray(data):
 
 
 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])]
+    def inner(data, length):
+        return fill_value if length == 0 else [inner(data[1:], length - 1) for _ in range(data[0])]
 
     if isinstance(fill_value, list):
         raise TypeError("The filled value cannot be a list")
-    result = inner(shape)
+    result = inner(shape, len(shape))
     return result if rtype is list else rtype(result)
 
 
@@ -374,17 +380,17 @@ def fill(shape: arr, sequence: arr = None, repeat: bool = True, pad: Any = 0, rt
     total = len(sequence)
     last = total - 1
 
-    def inner(_shape):
+    def inner(_shape, depth):
         nonlocal pointer
-        if len(_shape) == 0:
+        if depth == 0:
             if pointer == last and not repeat:
                 return pad
             pointer += 1
             return sequence[pointer % total]
         else:
-            return [inner(_shape[1:]) for _ in range(_shape[0])]
+            return [inner(_shape[1:], depth - 1) for _ in range(_shape[0])]
 
-    result = inner(shape)
+    result = inner(shape, len(shape))
     return result if rtype is list else rtype(result)
 
 
@@ -395,7 +401,9 @@ def tensorproduct(*tensors: Array) -> Array:
         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)
+        flattened_a = a.flatten()
+        flattened_b = b.flatten()
+        return Array(fill(a.shape + b.shape, [i * j for i in flattened_a for j in flattened_b], rtype=list), False)
 
     first = tensors[0]
     for second in tensors[1:]:

pypynum/chars.py

@@ -25,7 +25,16 @@ tab = [
     ["│", "╰", "╯"]
 ]
 pi = "Ππ𝜫𝝅𝝥𝝿𝞟𝞹Пп∏ϖ∐ℼㄇ兀"
-others = "¬°‰‱′″∀∂∃∅∆∇∈∉∏∐∑∝∞∟∠∣∥∧∨∩∪∫∬∭∮∯∰∴∵∷∽≈≌≒≠≡≢≤≥≪≫≮≯≰≱≲≳⊕⊙⊥⊿⌒㏑㏒"
+notsign = "¬"
+degree = "°"
+permille = "‰"
+permyriad = "‱"
+prime = "′"
+dprime = "″"
+arc = "⌒"
+ln = "㏑"
+log = "㏒"
+others = "".join(map(chr, range(0x2200, 0x2300)))
 
 
 def int2superscript(standard_str: str) -> str:

pypynum/dists.py

@@ -284,7 +284,7 @@ def hypergeom_pmf(k, mg, n, nt):
     return comb(nt, k) * comb(mg - nt, n - k) / comb(mg, n)
 
 
-def inv_gauss_pdf(x, mu, lambda_, alpha):
+def invgauss_pdf(x, mu, lambda_, alpha):
     """
     Introduction
     ==========
@@ -292,7 +292,7 @@ def inv_gauss_pdf(x, mu, lambda_, alpha):
 
     Example
     =========
-    >>> inv_gauss_pdf(1, 1, 1, 1)
+    >>> invgauss_pdf(1, 1, 1, 1)
     0.3989422804014327
     >>>
     :param x: The value at which to evaluate the PDF. It must be positive.

pypynum/maths.py

@@ -639,7 +639,7 @@ def central_moment(data: arr, order: int) -> float:
     return math.fsum(map(lambda item: (item - avg) ** order, data)) / len(data)
 
 
-def var(numbers: arr, dof: int = 0) -> num:
+def var(numbers: arr, ddof: int = 0) -> num:
     """
     Introduction
     ==========
@@ -651,10 +651,10 @@ def var(numbers: arr, dof: int = 0) -> num:
     8.25
     >>>
     :param numbers: list | tuple
-    :param dof: integer
+    :param ddof: integer
     :return:
     """
-    if dof >= len(numbers):
+    if ddof >= len(numbers):
         return float("inf")
     avg = mean(numbers)
 
@@ -662,7 +662,7 @@ def var(numbers: arr, dof: int = 0) -> num:
         d = item - avg
         return d * d
 
-    return math.fsum(map(inner, numbers)) / (len(numbers) - dof)
+    return math.fsum(map(inner, numbers)) / (len(numbers) - ddof)
 
 
 def skew(data: arr) -> float:
@@ -703,7 +703,7 @@ def kurt(data: arr, fisher: bool = True) -> float:
     return result
 
 
-def std(numbers: arr, dof: int = 0) -> num:
+def std(numbers: arr, ddof: int = 0) -> num:
     """
     Introduction
     ==========
@@ -715,13 +715,13 @@ def std(numbers: arr, dof: int = 0) -> num:
     2.8722813232690143
     >>>
     :param numbers: list | tuple
-    :param dof: integer
+    :param ddof: integer
     :return:
     """
-    return math.sqrt(var(numbers, dof=dof))
+    return math.sqrt(var(numbers, ddof=ddof))
 
 
-def cov(x: arr, y: arr, dof: int = 0) -> num:
+def cov(x: arr, y: arr, ddof: int = 0) -> num:
     """
     Introduction
     ==========
@@ -734,14 +734,14 @@ def cov(x: arr, y: arr, dof: int = 0) -> num:
     >>>
     :param x: list | tuple
     :param y: list | tuple
-    :param dof: integer
+    :param ddof: integer
     :return:
     """
-    if dof >= min(len(x), len(y)):
+    if ddof >= min(len(x), len(y)):
         return float("inf")
     mean_x = mean(x)
     mean_y = mean(y)
-    return math.fsum([(x_i - mean_x) * (y_i - mean_y) for x_i, y_i in zip(x, y)]) / (len(x) - dof)
+    return math.fsum([(x_i - mean_x) * (y_i - mean_y) for x_i, y_i in zip(x, y)]) / (len(x) - ddof)
 
 
 def corr_coeff(x: arr, y: arr) -> num:

pypynum/seqs.py

@@ -54,8 +54,9 @@ def farey(n: int) -> list:
         return [(0, 1), (1, 1)]
     else:
         f = farey(n - 1)
+        m = len(f) - 1
         result = []
-        for i in range(len(f) - 1):
+        for i in range(m):
             a1, b1 = f[i]
             a2, b2 = f[i + 1]
             result.append((a1, b1))

pypynum/special.py

@@ -1,6 +1,8 @@
 import math
 from .types import arr, num, real
 
+ConvError = ValueError("The absolute value of q must be less than 1 to ensure convergence.")
+
 
 def besselj0(x: num) -> num:
     """
@@ -336,7 +338,7 @@ def qfactorial(n: num, q: num) -> num:
     :return: The value of the q-factorial.
     """
     if abs(q) >= 1:
-        raise ValueError("The absolute value of q must be less than 1 to ensure convergence.")
+        raise ConvError
     qpoch_q = qpochhammer(q, q)
     qpoch_q_pow_n = qpochhammer(q ** (1 + n), q)
     result = qpoch_q / ((1 - q) ** n * qpoch_q_pow_n)
@@ -361,7 +363,7 @@ def qgamma(n: num, q: num) -> num:
     :return: The value of the q-gamma function.
     """
     if abs(q) >= 1:
-        raise ValueError("The absolute value of q must be less than 1 to ensure convergence.")
+        raise ConvError
     if n == 0:
         return 1 / (1 - q)
     qpoch_q = qpochhammer(q, q)
@@ -370,6 +372,34 @@ def qgamma(n: num, q: num) -> num:
     return result
 
 
+def qbeta(a: num, b: num, q: num) -> num:
+    """
+    Introduction
+    ==========
+    Calculate the q-beta function for given parameters using the q-gamma function.
+
+    The q-beta function is defined as: Β_q(a, b) = Γ_q(a) * Γ_q(b) / Γ_q(a + b)
+
+    Example
+    ==========
+    >>> qbeta(2, 3, 0.5)
+    0.3047619047619047
+    >>>
+    :param a: The first parameter of the q-beta function.
+    :param b: The second parameter of the q-beta function.
+    :param q: The q-parameter, must have an absolute value less than 1 for convergence.
+    :return: The value of the q-beta function.
+    """
+    if abs(q) >= 1:
+        raise ConvError
+    gamma_a_plus_b = qgamma(a + b, q)
+    if gamma_a_plus_b == 0:
+        return float("inf")
+    gamma_a = qgamma(a, q)
+    gamma_b = qgamma(b, q)
+    return (gamma_a * gamma_b) / gamma_a_plus_b
+
+
 def qbinomial(n: num, m: num, q: num) -> num:
     """
     Introduction
@@ -390,8 +420,252 @@ def qbinomial(n: num, m: num, q: num) -> num:
     :return: The value of the q-binomial coefficient.
     """
     if abs(q) >= 1:
-        raise ValueError("The absolute value of q must be less than 1 to ensure convergence.")
+        raise ConvError
     divisor = qpochhammer(q, q) * qpochhammer(q ** (n + 1), q)
     if not divisor:
         return float("inf")
     return qpochhammer(q ** (m + 1), q) * qpochhammer(q ** (-m + n + 1), q) / divisor
+
+
+def qexp_small(z: num, q: num) -> num:
+    """
+    Introduction
+    ==========
+    Calculate the q-exponential function for small values of z.
+
+    The q-exponential function is defined as: exp_q(z) = 1 / (z; q)_∞
+
+    Example
+    ==========
+    >>> qexp_small(2 + 1j, 0.5 + 0.1j)
+    (0.4218918210477187-1.4462561722357514j)
+    >>>
+    :param z: The argument of the q-exponential function.
+    :param q: The q-parameter, must have an absolute value less than 1 for convergence.
+    :return: The value of the q-exponential function for small z.
+    """
+    if abs(q) >= 1:
+        raise ConvError
+    qpoch_z = qpochhammer(z, q)
+    if qpoch_z == 0:
+        return float("inf")
+    return 1 / qpoch_z
+
+
+def qexp_large(z: num, q: num) -> num:
+    """
+    Introduction
+    ==========
+    Calculate the q-exponential function for large values of z.
+
+    The q-exponential function is defined as: Exp_q(z) = (-z; q)_∞
+
+    Example
+    ==========
+    >>> qexp_large(2 + 1j, 0.5 + 0.1j)
+    (0.9080956334931816+11.389341006647559j)
+    >>>
+    :param z: The argument of the q-exponential function.
+    :param q: The q-parameter, must have an absolute value less than 1 for convergence.
+    :return: The value of the q-exponential function for large z.
+    """
+    if abs(q) >= 1:
+        raise ConvError
+    return qpochhammer(-z, q)
+
+
+def qsin_small(x: num, q: num) -> num:
+    """
+    Introduction
+    ==========
+    Calculate the q-sine function for small values of x.
+
+    The q-sine function is defined as: sin_q(x) = (exp_q(i*x) - exp_q(-i*x)) / (2*i*q)
+
+    Example
+    ==========
+    >>> qsin_small(0.5, 0.5)
+    (1.404936279305213+0j)
+    >>>
+    :param x: The argument of the q-sine function.
+    :param q: The q-parameter, must have an absolute value less than 1 for convergence.
+    :return: The value of the q-sine function for small x.
+    """
+    if abs(q) >= 1:
+        raise ConvError
+    return (qexp_small(1j * x, q) - qexp_small(-1j * x, q)) / (2 * 1j * q)
+
+
+def qsin_large(x: num, q: num) -> num:
+    """
+    Introduction
+    ==========
+    Calculate the q-sine function for large values of x.
+
+    The q-sine function is defined as: Sin_q(x) = (Exp_q(i*x) - Exp_q(-i*x)) / (2*i*q)
+
+    Example
+    ==========
+    >>> qsin_large(0.5, 0.5)
+    (1.904966692271702+0j)
+    >>>
+    :param x: The argument of the q-sine function.
+    :param q: The q-parameter, must have an absolute value less than 1 for convergence.
+    :return: The value of the q-sine function for large x.
+    """
+    if abs(q) >= 1:
+        raise ConvError
+    return (qexp_large(1j * x, q) - qexp_large(-1j * x, q)) / (2 * 1j * q)
+
+
+def qsinh_small(x: num, q: num) -> num:
+    """
+    Introduction
+    ==========
+    Calculate the q-hyperbolic sine function for small values of x.
+
+    The q-hyperbolic sine function is defined as: sinh_q(x) = (exp_q(x) - exp_q(-x)) / 2
+
+    Example
+    ==========
+    >>> qsinh_small(0.5, 0.5)
+    1.521662088829978
+    >>>
+    :param x: The argument of the q-hyperbolic sine function.
+    :param q: The q-parameter, must have an absolute value less than 1 for convergence.
+    :return: The value of the q-hyperbolic sine function for small x.
+    """
+    if abs(q) >= 1:
+        raise ConvError
+    return (qexp_small(x, q) - qexp_small(-x, q)) / 2
+
+
+def qsinh_large(x: num, q: num) -> num:
+    """
+    Introduction
+    ==========
+    Calculate the q-hyperbolic sine function for large values of x.
+
+    The q-hyperbolic sine function is defined as: Sinh_q(x) = (Exp_q(x) - Exp_q(-x)) / 2
+
+    Example
+    ==========
+    >>> qsinh_large(0.5, 0.5)
+    1.0477214669723844
+    >>>
+    :param x: The argument of the q-hyperbolic sine function.
+    :param q: The q-parameter, must have an absolute value less than 1 for convergence.
+    :return: The value of the q-hyperbolic sine function for large x.
+    """
+    if abs(q) >= 1:
+        raise ConvError
+    return (qexp_large(x, q) - qexp_large(-x, q)) / 2
+
+
+def qcos_small(x: num, q: num) -> num:
+    """
+    Introduction
+    ==========
+    Calculate the q-cosine function for small values of x.
+
+    The q-cosine function is defined as: cos_q(x) = (exp_q(i*x) + exp_q(-i*x)) / 2
+
+    Example
+    ==========
+    >>> qcos_small(0.5, 0.5)
+    (0.49401494605609575+0j)
+    >>>
+    :param x: The argument of the q-cosine function.
+    :param q: The q-parameter, must have an absolute value less than 1 for convergence.
+    :return: The value of the q-cosine function for small x.
+    """
+    if abs(q) >= 1:
+        raise ConvError
+    return (qexp_small(1j * x, q) + qexp_small(-1j * x, q)) / 2
+
+
+def qcos_large(x: num, q: num) -> num:
+    """
+    Introduction
+    ==========
+    Calculate the q-cosine function for large values of x.
+
+    The q-cosine function is defined as: Cos_q(x) = (Exp_q(i*x) + Exp_q(-i*x)) / 2
+
+    Example
+    ==========
+    >>> qcos_large(0.5, 0.5)
+    (0.6698396443906053+0j)
+    >>>
+    :param x: The argument of the q-cosine function.
+    :param q: The q-parameter, must have an absolute value less than 1 for convergence.
+    :return: The value of the q-cosine function for large x.
+    """
+    if abs(q) >= 1:
+        raise ConvError
+    return (qexp_large(1j * x, q) + qexp_large(-1j * x, q)) / 2
+
+
+def qcosh_small(x: num, q: num) -> num:
+    """
+    Introduction
+    ==========
+    Calculate the q-hyperbolic cosine function for small values of x.
+
+    The q-hyperbolic cosine function is defined as: cosh_q(x) = (exp_q(x) + exp_q(-x)) / 2
+
+    Example
+    ==========
+    >>> qcosh_small(0.5, 0.5)
+    1.9410845306250857
+    >>>
+    :param x: The argument of the q-hyperbolic cosine function.
+    :param q: The q-parameter, must have an absolute value less than 1 for convergence.
+    :return: The value of the q-hyperbolic cosine function for small x.
+    """
+    if abs(q) >= 1:
+        raise ConvError
+    return (qexp_small(x, q) + qexp_small(-x, q)) / 2
+
+
+def qcosh_large(x: num, q: num) -> num:
+    """
+    Introduction
+    ==========
+    Calculate the q-hyperbolic cosine function for large values of x.
+
+    The q-hyperbolic cosine function is defined as: Cosh_q(x) = (Exp_q(x) + Exp_q(-x)) / 2
+
+    Example
+    ==========
+    >>> qcosh_large(0.5, 0.5)
+    1.3365095620589869
+    >>>
+    :param x: The argument of the q-hyperbolic cosine function.
+    :param q: The q-parameter, must have an absolute value less than 1 for convergence.
+    :return: The value of the q-hyperbolic cosine function for large x.
+    """
+    if abs(q) >= 1:
+        raise ConvError
+    return (qexp_large(x, q) + qexp_large(-x, q)) / 2
+
+
+def qpi(q: num) -> num:
+    """
+    Introduction
+    ==========
+    Calculate the q-pi function for a given q-parameter.
+
+    The q-pi function is defined as: π_q = q ^ (1 / 4)([-1 / 2]_(q ^ 2)!) ^ 2
+
+    Example
+    ==========
+    >>> qpi(0.5)
+    1.6996350531822835
+    >>>
+    :param q: The q-parameter, must have an absolute value less than 1 for convergence.
+    :return: The value of the q-pi function.
+    """
+    if abs(q) >= 1:
+        raise ValueError("The absolute value of q must be less than 1 to ensure convergence.")
+    return q ** 0.25 * qfactorial(-0.5, q * q) ** 2

pypynum/tools.py

@@ -581,6 +581,89 @@ def cos_sim(seq1: ite, seq2: ite, is_vector: bool = False) -> float:
     return dot_product / (magnitude_seq1 * magnitude_seq2)
 
 
+def kmp_table(pattern: ite) -> list:
+    """
+    Introduction
+    ==========
+    Generate the KMP (Knuth-Morris-Pratt) table for a given pattern.
+
+    The KMP table is used to efficiently find occurrences of a pattern within a sequence by avoiding unnecessary
+    comparisons after a mismatch. This table determines how many characters can be skipped after a mismatch.
+
+    Example
+    ========
+    >>> kmp_table("AGCTGATCGTACGTAAGCTAGCTA")
+    [0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 2, 3, 4, 1, 2, 3, 4, 1]
+    >>>
+    :param pattern: The pattern for which to generate the KMP table.
+    :return: A list representing the KMP table for the given pattern.
+    """
+    pattern_len = len(pattern)
+    table = [0] * pattern_len
+    pos, cnd = 1, 0
+    while pos < pattern_len:
+        if pattern[pos] == pattern[cnd]:
+            cnd += 1
+            table[pos] = cnd
+            pos += 1
+        elif cnd > 0:
+            cnd = table[cnd - 1]
+        else:
+            table[pos] = 0
+            pos += 1
+    return table
+
+
+def findall(seq: ite, pat: ite) -> list:
+    """
+    Introduction
+    ==========
+    Find all indices of the subsequence 'pat' in 'seq'.
+
+    This function is designed to handle sequences such as lists, tuples, or strings and find all indices
+    of specified subsequences. It allows overlapping matches.
+
+    Example
+    ========
+    >>> findall([2, 1, 2, 1, 2, 1, 2, 1], [1, 2, 1, 2])
+    [1, 3]
+    >>>
+    :param seq: The sequence in which to find the subsequence.
+    :param pat: The subsequence to be found.
+    :return: A list of starting indices where the subsequence is found.
+    """
+    if not isinstance(seq, (list, tuple, str)):
+        raise TypeError("Parameter 'seq' must be a list, tuple, or string, got {}".format(type(seq)))
+    if not isinstance(pat, (list, tuple, str)):
+        raise TypeError("Parameter 'pat' must be a list, tuple, or string, got {}".format(type(pat)))
+    if not pat:
+        raise ValueError("Parameter 'pat' must not be empty")
+    if isinstance(seq, str):
+        seq = tuple(seq)
+    if isinstance(pat, str):
+        pat = tuple(pat)
+    pat_len = len(pat)
+    table = kmp_table(pat)
+    indices = []
+    i, j = 0, 0
+    seq_len = len(seq)
+    while i < seq_len:
+        if j == pat_len:
+            indices.append(i - j)
+            j = table[j - 1]
+        elif seq[i] == pat[j]:
+            i += 1
+            j += 1
+        else:
+            if j != 0:
+                j = table[j - 1]
+            else:
+                i += 1
+    if j == pat_len:
+        indices.append(i - j)
+    return indices
+
+
 def replace(seq: arr, old: arr, new: arr, count: int = -1) -> arr:
     """
     Introduction
@@ -614,18 +697,7 @@ def replace(seq: arr, old: arr, new: arr, count: int = -1) -> arr:
     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
+    table = kmp_table(old)
     result = []
     i, j = 0, 0
     replaced = 0

pypynum/vectors.py

@@ -18,73 +18,82 @@ class Vector(Array):
             raise ShapeError("Vectors can only be one-dimensional in shape")
         self.len = len(data)
 
-    def __add__(self, other):
-        if self.len != other.len:
-            raise MatchError
-        return Vector([self.data[i] + other.data[i] for i in range(self.len)])
-
-    def __sub__(self, other):
-        if self.len != other.len:
-            raise MatchError
-        return Vector([self.data[i] - other.data[i] for i in range(self.len)])
-
-    def __mul__(self, other):
-        if isinstance(other, Vector):
-            if self.len != other.len:
-                raise MatchError
-            return Vector([self.data[i] * other.data[i] for i in range(self.len)])
-        else:
-            return Vector([i * other for i in self.data])
-
     def __matmul__(self, other):
         if self.len != other.len:
             raise MatchError
-        return sum([self.data[i] * other.data[i] for i in range(self.len)])
+        return sum([x * y for x, y in zip(self.data, other.data)])
 
     def __abs__(self):
         return self.norm()
 
     def __pos__(self):
-        return Vector([item for item in self.data])
+        return Vector([x for x in self.data])
 
     def __neg__(self):
-        return Vector([-item for item in self.data])
+        return Vector([-x for x in self.data])
 
     def norm(self, p=2):
         if p == 0:
-            return len([item for item in self.data if item != 0])
+            return len([x for x in self.data if x != 0])
         elif p == 1:
-            return sum([abs(item) for item in self.data])
+            return sum(map(abs, self.data))
         elif p == 2:
-            return sum([i ** 2 for i in self.data]) ** 0.5
+            return sum([x ** 2 for x in self.data]) ** 0.5
         elif p == float("inf"):
-            return max([abs(item) for item in self.data])
+            return max(map(abs, self.data))
         else:
-            return sum([i ** p for i in self.data]) ** (1 / p)
+            return sum([x ** p for x in self.data]) ** (1 / p)
 
     def normalize(self):
         norm = self.norm()
-        return Vector([i / norm for i in self.data])
+        return Vector([x / norm for x in self.data])
+
+    def cosine(self, other):
+        if self.len != other.len:
+            raise MatchError
+        dot_product = self @ other
+        norm_self = self.norm()
+        norm_other = other.norm()
+        return dot_product / (norm_self * norm_other)
 
     def angles(self, axes=None):
         from math import acos
+        identity = []
+        for i in range(self.len):
+            unit_vector = [0] * self.len
+            unit_vector[i] = 1
+            identity.append(Vector(unit_vector))
         if axes is None or axes == [] or axes == ():
-            result = []
-            for a in range(self.len):
-                axis = Vector([1 if p == a else 0 for p in range(self.len)])
-                result.append(acos(self @ axis / (self.norm() * axis.norm())))
-        elif int(abs(axes)) == axes:
-            axis = Vector([1 if p == axes else 0 for p in range(self.len)])
+            result = [acos(self @ axis / (self.norm() * axis.norm())) for axis in identity]
+        elif isinstance(axes, int) and axes >= 0:
+            axis = identity[axes]
             result = acos(self @ axis / (self.norm() * axis.norm()))
         elif isinstance(axes, (list, tuple)):
-            result = []
-            for a in axes:
-                axis = Vector([1 if p == a else 0 for p in range(self.len)])
-                result.append(acos(self @ axis / (self.norm() * axis.norm())))
+            result = [acos(self @ identity[a] / (self.norm() * identity[a].norm())) for a in axes]
         else:
-            raise TypeError("The axes parameter can only be None, natural number, list, or tuple")
+            raise TypeError("The axes parameter can only be None, non-negative integer, list, or tuple")
         return result
 
+    def chebyshev(self, other):
+        if self.len != other.len:
+            raise MatchError
+        return max([abs(x - y) for x, y in zip(self.data, other.data)])
+
+    def manhattan(self, other):
+        if self.len != other.len:
+            raise MatchError
+        return sum([abs(x - y) for x, y in zip(self.data, other.data)])
+
+    def euclidean(self, other):
+        if self.len != other.len:
+            raise MatchError
+        return sum([(x - y) ** 2 for x, y in zip(self.data, other.data)]) ** 0.5
+
+    def minkowski(self, other, p):
+        if self.len != other.len:
+            raise MatchError
+        return sum([abs(x - y) ** p for x, y in zip(self.data, other.data)]) ** (1 / p)
+
 
 def vec(data):
     return Vector(data)

pypynum/zh_cn.py

@@ -225,27 +225,27 @@ def 上伽玛(s: num, x: num) -> num:
 
 
 def 贝塞尔函数J0(x: num) -> num:
-    return bessel_j0(x)
+    return besselj0(x)
 
 
 def 贝塞尔函数J1(x: num) -> num:
-    return bessel_j1(x)
+    return besselj1(x)
 
 
 def 贝塞尔函数Jv(v: real, x: num) -> num:
-    return bessel_jv(v, x)
+    return besseljv(v, x)
 
 
 def 贝塞尔函数I0(x: num) -> num:
-    return bessel_i0(x)
+    return besseli0(x)
 
 
 def 贝塞尔函数I1(x: num) -> num:
-    return bessel_i1(x)
+    return besseli1(x)
 
 
 def 贝塞尔函数Iv(v: real, x: num) -> num:
-    return bessel_iv(v, x)
+    return besseliv(v, x)
 
 
 def 乘积和(*多个数组: List[Any]) -> float: