| Name | PyPyNum JSON |
| Version |
1.16.1
JSON |
| download |
| home_page | https://github.com/PythonSJL/PyPyNum |
| 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. |
| upload_time | 2024-10-21 05:56:55 |
| maintainer | None |
| docs_url | None |
| author | Shen Jiayi |
| requires_python | >=3.4 |
| license | Apache License Version 2.0, January 2004 http://www.apache.org/licenses/ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION 1. Definitions. "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document. "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License. "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity. "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License. "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files. "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types. "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below). "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof. "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution." "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work. 2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form. 3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed. 4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions: (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and (b) You must cause any modified files to carry prominent notices stating that You changed the files; and (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License. You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License. 5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions. 6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file. 7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License. 8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages. 9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability. END OF TERMS AND CONDITIONS APPENDIX: How to apply the Apache License to your work. To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "[]" replaced with your own identifying information. (Don't include the brackets!) The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives. Copyright [yyyy] [name of copyright owner] Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. |
| keywords |
math
数学
mathematics
数学计算
numerical
数值
computation
计算
scientific
科学
algebra
代数
calculus
微积分
statistics
统计
linear-algebra
线性代数
optimization
优化
numerical-analysis
数值分析
matrix
矩阵
vector
向量
tensor
张量
numerics
数值计算
library
库
tools
工具
utils
实用程序
algorithms
算法
software
软件
package
包
methods
方法
data-science
数据科学
machine-learning
机器学习
computational
计算的
operations
操作
functions
函数
processing
处理
programming
编程
simulation
仿真
visualization
可视化
physics
物理
|
| VCS |
 |
| bugtrack_url |
|
| requirements |
No requirements were recorded.
|
| Travis-CI |
No Travis.
|
| coveralls test coverage |
No coveralls.
|
# <font color = blue>PyPyNum</font>
<font color = gree>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.</font><font color = red>[Python>=3.4]</font>
```
________ ___ ___ ________ ___ ___ ________ ___ ___ _____ ______
|\ __ \ |\ \ / /||\ __ \ |\ \ / /||\ ___ \ |\ \|\ \ |\ _ \ _ \
\ \ \|\ \\ \ \/ / /\ \ \|\ \\ \ \/ / /\ \ \\ \ \\ \ \\\ \\ \ \\\__\ \ \
\ \ ____\\ \ / / \ \ ____\\ \ / / \ \ \\ \ \\ \ \\\ \\ \ \\|__| \ \
\ \ \___| \/ / / \ \ \___| \/ / / \ \ \\ \ \\ \ \\\ \\ \ \ \ \ \
\ \__\ __/ / / \ \__\ __/ / / \ \__\\ \__\\ \_______\\ \__\ \ \__\
\|__| |\___/ / \|__| |\___/ / \|__| \|__| \|_______| \|__| \|__|
\|___|/ \|___|/
```
[](https://pepy.tech/project/pypynum)
[](https://pepy.tech/project/pypynum)
[](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
The logo cannot be displayed on PyPI, it can be viewed in Gitee or GitHub.
### Introduction
+ Multi functional math library, similar to numpy, scipy, etc., designed specifically for PyPy interpreters and also
supports other types of Python interpreters
+ 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
### Name and Function Introduction of Submodules
| Submodule Name | Function Introduction |
|:-------------------:|:------------------------------------------------------------------:|
| `pypynum.arrays` | Provides operations and calculations for multi-dimensional arrays. |
| `pypynum.chars` | Contains a variety of special mathematical characters. |
| `pypynum.ciphers` | Implements various encryption and decryption algorithms. |
| `pypynum.consts` | Contains mathematical and physical constants. |
| `pypynum.crandom` | Generates random complex numbers. |
| `pypynum.dataproc` | Tools for data preprocessing and transformation. |
| `pypynum.dists` | Statistical distribution functions and related calculations. |
| `pypynum.equations` | Solves equations and performs symbolic operations. |
| `pypynum.fft` | Implements Fast Fourier Transforms and related functionalities. |
| `pypynum.files` | File reading and writing tools. |
| `pypynum.geoms` | Geometric shapes and calculation methods. |
| `pypynum.graphs` | Graph theory algorithms and network analysis. |
| `pypynum.groups` | Group theory calculations and structural analysis. |
| `pypynum.images` | Image processing and manipulation tools. |
| `pypynum.interp` | Interpolation methods and function approximation. |
| `pypynum.kernels` | Implementation of kernel functions and methods. |
| `pypynum.logics` | Simulates logical circuits. |
| `pypynum.maths` | Basic mathematical operations and special functions. |
| `pypynum.matrices` | Matrix operations and linear algebra calculations. |
| `pypynum.multiprec` | High-precision numerical computations. |
| `pypynum.networks` | Network models and algorithms. |
| `pypynum.numbers` | Operations on numerical types and properties. |
| `pypynum.plotting` | Data visualization tools. |
| `pypynum.polys` | Polynomial operations and calculations. |
| `pypynum.pprinters` | Advanced printing and formatting output. |
| `pypynum.quats` | Quaternion operations and transformations. |
| `pypynum.random` | Generates arrays of random numbers. |
| `pypynum.regs` | Regression analysis and model fitting. |
| `pypynum.seqs` | Computes various mathematical sequences. |
| `pypynum.special` | Provides advanced special functions for mathematical computations. |
| `pypynum.stattest` | Statistical tests and data analysis. |
| `pypynum.symbols` | Symbolic computation and expression manipulation. |
| `pypynum.tensors` | Tensor operations and calculations. |
| `pypynum.test` | Simple code testing for the library. |
| `pypynum.this` | The Zen of the library, expressing its guiding principles. |
| `pypynum.tools` | General tools and helper functions. |
| `pypynum.trees` | Tree structures and algorithm implementations. |
| `pypynum.types` | Contains various types, exceptions, and configurations. |
| `pypynum.ufuncs` | Universal functions and vectorized operations. |
| `pypynum.utils` | Utility programs and auxiliary functions. |
| `pypynum.vectors` | Vector operations and calculations. |
| `pypynum.zh_cn` | Provides Chinese language interfaces for various functionalities. |
### The Zen of PyPyNum (Preview)
```
The Zen of PyPyNum, by Shen Jiayi
In this mathematical sanctuary, we weave our algorithms with pure Python threads.
Precision outweighs approximation.
Elegance in mathematics transcends the bulky algorithms.
Clarity in logic illuminates the darkest problems.
Simplicity in form is the pinnacle of sophistication.
Flat hierarchies in our code mirror the linear nature of functions.
Sparse code, like a minimal polynomial, retains essence without redundancy.
```
```
...
Do you want to view all the content?
Enter "from pypynum import this" in your
Python interpreter and run it!
```
```
September 5, 2024
```
### Functional Changes Compared to the Previous Version
```
!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=
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
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.
!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=
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.
!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=
```
### Run Time Test
Python interpreter version
+ CPython 3.8.10
+ PyPy 3.10.12
| Matrix Time Test | NumPy+CPython (seconds) | Ranking | PyPyNum+PyPy (seconds) | Ranking | Mpmath_+_PyPy_ (seconds) | Ranking | SymPy_+_PyPy_ (seconds) | Ranking |
|------------------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------|
| Create a hundred order random number matrix | 0.000083 | 1 | 0.005374 | 2 | 0.075253 | 3 | 0.230530 | 4 |
| Create a thousand order random number matrix | 0.006740 | 1 | 0.035666 | 2 | 1.200950 | 3 | 4.370265 | 4 |
| Addition of matrices of order one hundred | 0.000029 | 1 | 0.002163 | 2 | 0.045641 | 4 | 0.035700 | 3 |
| Adding matrices of order one thousand | 0.002647 | 1 | 0.019111 | 2 | 1.746957 | 4 | 0.771542 | 3 |
| Determinant of a hundred order matrix | 0.087209 | 2 | 0.016331 | 1 | 4.354507 | 3 | 5.157206 | 4 |
| Determinant of a thousand order matrix | 0.616113 | 1 | 3.509747 | 2 | It takes a long time | 3 | It takes a long time | 4 |
| Finding the inverse of a hundred order matrix | 0.162770 | 2 | 0.015768 | 1 | 8.162948 | 3 | 21.437424 | 4 |
| Finding the inverse of a thousand order matrix | 0.598905 | 1 | 17.072552 | 2 | It takes a long time | 3 | It takes a long time | 4 |
| Array output effect | ```[[[[ -7 -67]```<br>```[-78 29]]```<br><br>```[[-86 -97]```<br>```[ 68 -3]]]```<br><br><br>```[[[ 11 42]```<br>```[ 24 -65]]```<br><br>```[[-60 72]```<br>```[ 73 2]]]]``` | / | ```[[[[ 37 83]```<br>```[ 40 2]]```<br><br>```[[ -5 -34]```<br>```[ -7 72]]]```<br><br><br>```[[[ 13 -64]```<br>```[ 6 90]]```<br><br>```[[ 68 57]```<br>```[ 78 11]]]]``` | / | ```[-80.0 -8.0 80.0 -88.0]```<br>```[-99.0 -43.0 87.0 81.0]```<br>```[ 20.0 -55.0 98.0 8.0]```<br>```[ 8.0 44.0 64.0 -35.0]```<br><br>(Only supports matrices) | / | ```⎡⎡16 -56⎤ ⎡ 8 -28⎤⎤```<br>```⎢⎢ ⎥ ⎢ ⎥⎥```<br>```⎢⎣-56 56 ⎦ ⎣-28 28 ⎦⎥```<br>```⎢ ⎥```<br>```⎢ ⎡-2 7 ⎤ ⎡-18 63 ⎤⎥```<br>```⎢ ⎢ ⎥ ⎢ ⎥⎥```<br>```⎣ ⎣7 -7⎦ ⎣63 -63⎦⎦``` | / |
### Basic Structure
```
PyPyNum
├── arrays
│ ├── CLASS
│ │ ├── Array(object)/__init__(self: Any, data: Any, check: Any) -> Any
│ │ └── BoolArray(pypynum.arrays.Array)/__init__(self: Any, data: Any, check: Any) -> Any
│ └── FUNCTION
│ ├── array(data: Any) -> Any
│ ├── asarray(data: Any) -> Any
│ ├── aslist(data: Any) -> Any
│ ├── boolarray(data: 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: 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
│ ├── int2subscript(standard_str: str) -> str
│ ├── int2superscript(standard_str: str) -> str
│ ├── subscript2int(subscript_str: str) -> str
│ └── superscript2int(superscript_str: str) -> str
├── ciphers
│ ├── CLASS
│ └── FUNCTION
│ ├── atbash(text: str) -> str
│ ├── base_64(text: str, decrypt: bool) -> str
│ ├── caesar(text: str, shift: int, decrypt: bool) -> str
│ ├── hill256(text: bytes, key: list, decrypt: bool) -> bytes
│ ├── ksa(key: bytes) -> list
│ ├── morse(text: str, decrypt: bool) -> str
│ ├── playfair(text: str, key: str, decrypt: bool) -> str
│ ├── prga(s: list) -> Any
│ ├── rc4(text: bytes, key: bytes) -> bytes
│ ├── rot13(text: str) -> str
│ ├── substitution(text: str, sub_map: dict, decrypt: bool) -> str
│ └── vigenere(text: str, key: str, decrypt: bool) -> str
├── consts
│ ├── CLASS
│ └── FUNCTION
├── crandom
│ ├── CLASS
│ └── FUNCTION
│ ├── randint_polar(left: int, right: int, mod: typing.Union[int, float], angle: typing.Union[int, float]) -> complex
│ ├── randint_rect(left: int, right: int, real: typing.Union[int, float], imag: typing.Union[int, float]) -> complex
│ ├── random_polar(mod: typing.Union[int, float], angle: typing.Union[int, float]) -> complex
│ ├── random_rect(real: typing.Union[int, float], imag: typing.Union[int, float]) -> complex
│ ├── uniform_polar(left: typing.Union[int, float], right: typing.Union[int, float], mod: typing.Union[int, float], angle: typing.Union[int, float]) -> complex
│ └── uniform_rect(left: typing.Union[int, float], right: typing.Union[int, float], real: typing.Union[int, float], imag: typing.Union[int, float]) -> complex
├── dataproc
│ ├── CLASS
│ │ └── Series(object)/__init__(self: Any, data: typing.Any, index: typing.Any) -> None
│ └── FUNCTION
├── dists
│ ├── CLASS
│ └── FUNCTION
│ ├── beta_pdf(x: Any, a: Any, b: Any) -> Any
│ ├── binom_pmf(k: Any, n: Any, p: Any) -> Any
│ ├── cauchy_cdf(x: Any, x0: Any, gamma: Any) -> Any
│ ├── cauchy_pdf(x: Any, x0: Any, gamma: Any) -> Any
│ ├── chi2_cdf(x: Any, df: Any) -> Any
│ ├── chi2_pdf(x: Any, df: Any) -> Any
│ ├── expon_cdf(x: Any, scale: Any) -> Any
│ ├── expon_pdf(x: Any, scale: Any) -> Any
│ ├── f_pdf(x: Any, dfnum: Any, dfden: Any) -> Any
│ ├── 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
│ ├── 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
│ ├── logistic_cdf(x: Any, mu: Any, s: Any) -> Any
│ ├── logistic_pdf(x: Any, mu: Any, s: Any) -> Any
│ ├── lognorm_cdf(x: Any, mu: Any, sigma: Any) -> Any
│ ├── lognorm_pdf(x: Any, s: Any, scale: Any) -> Any
│ ├── logser_pmf(k: Any, p: Any) -> Any
│ ├── multinomial_pmf(k: Any, n: Any, p: Any) -> Any
│ ├── nbinom_pmf(k: Any, n: Any, p: Any) -> Any
│ ├── nhypergeom_pmf(k: Any, m: Any, n: Any, r: Any) -> Any
│ ├── normal_cdf(x: Any, mu: Any, sigma: Any) -> Any
│ ├── normal_pdf(x: Any, mu: Any, sigma: Any) -> Any
│ ├── pareto_pdf(x: Any, k: Any, m: Any) -> Any
│ ├── poisson_pmf(k: Any, mu: Any) -> Any
│ ├── rayleigh_pdf(x: Any, sigma: Any) -> Any
│ ├── t_pdf(x: Any, df: Any) -> Any
│ ├── uniform_cdf(x: Any, loc: Any, scale: Any) -> Any
│ ├── uniform_pdf(x: Any, loc: Any, scale: Any) -> Any
│ ├── vonmises_pdf(x: Any, mu: Any, kappa: Any) -> Any
│ ├── weibull_max_pdf(x: Any, c: Any, scale: Any, loc: Any) -> Any
│ ├── weibull_min_pdf(x: Any, c: Any, scale: Any, loc: Any) -> Any
│ └── zipf_pmf(k: Any, s: Any, n: Any) -> Any
├── equations
│ ├── CLASS
│ └── FUNCTION
│ ├── lin_eq(left: list, right: list) -> list
│ └── poly_eq(coefficients: list) -> list
├── fft
│ ├── CLASS
│ │ └── FT1D(object)/__init__(self: Any, data: Any) -> Any
│ └── FUNCTION
├── files
│ ├── CLASS
│ └── FUNCTION
│ ├── read(file: str) -> list
│ └── write(file: str, cls: object) -> Any
├── geoms
│ ├── CLASS
│ │ ├── Circle(object)/__init__(self: Any, center: typing.Union[list, tuple], radius: typing.Union[int, float]) -> Any
│ │ ├── Line(object)/__init__(self: Any, a: typing.Union[list, tuple], b: typing.Union[list, tuple]) -> Any
│ │ ├── Point(object)/__init__(self: Any, p: typing.Union[list, tuple]) -> Any
│ │ ├── Polygon(object)/__init__(self: Any, p: typing.Union[list, tuple]) -> Any
│ │ ├── Quadrilateral(object)/__init__(self: Any, a: typing.Union[list, tuple], b: typing.Union[list, tuple], c: typing.Union[list, tuple], d: typing.Union[list, tuple]) -> Any
│ │ └── Triangle(object)/__init__(self: Any, a: typing.Union[list, tuple], b: typing.Union[list, tuple], c: typing.Union[list, tuple]) -> Any
│ └── FUNCTION
│ └── distance(g1: Any, g2: Any, error: typing.Union[int, float]) -> float
├── graphs
│ ├── CLASS
│ │ ├── BaseGraph(object)/__init__(self: Any) -> Any
│ │ ├── BaseWeGraph(pypynum.graphs.BaseGraph)/__init__(self: Any) -> Any
│ │ ├── DiGraph(pypynum.graphs.BaseGraph)/__init__(self: Any) -> Any
│ │ ├── UnGraph(pypynum.graphs.BaseGraph)/__init__(self: Any) -> Any
│ │ ├── WeDiGraph(pypynum.graphs.BaseWeGraph)/__init__(self: Any) -> Any
│ │ └── WeUnGraph(pypynum.graphs.BaseWeGraph)/__init__(self: Any) -> Any
│ └── FUNCTION
├── groups
│ ├── CLASS
│ │ └── Group(object)/__init__(self: Any, data: Any, operation: Any) -> Any
│ └── FUNCTION
│ └── group(data: Any) -> Any
├── images
│ ├── CLASS
│ │ └── PNG(object)/__init__(self: Any) -> None
│ └── FUNCTION
│ └── crc(data: Any, length: Any, init: Any, xor: Any) -> Any
├── interp
│ ├── CLASS
│ └── FUNCTION
│ ├── bicubic(x: Any) -> Any
│ ├── contribute(src: Any, x: Any, y: Any, channels: Any) -> Any
│ ├── interp1d(data: typing.Union[list, tuple], length: int) -> list
│ └── interp2d(src: Any, new_height: Any, new_width: Any, channels: Any, round_res: Any, min_val: Any, max_val: Any) -> Any
├── kernels
│ ├── CLASS
│ └── FUNCTION
│ ├── det2x2kernel(a: typing.Union[list, tuple]) -> float
│ ├── det3x3kernel(a: typing.Union[list, tuple]) -> float
│ ├── det4x4kernel(a: typing.Union[list, tuple]) -> float
│ ├── eigen2x2kernel(a: typing.Union[list, tuple]) -> tuple
│ ├── inv2x2kernel(a: typing.Union[list, tuple]) -> list
│ ├── inv3x3kernel(a: typing.Union[list, tuple]) -> list
│ ├── inv4x4kernel(a: typing.Union[list, tuple]) -> list
│ ├── lu2x2kernel(a: typing.Union[list, tuple]) -> tuple
│ ├── lu3x3kernel(a: typing.Union[list, tuple]) -> tuple
│ ├── lu4x4kernel(a: typing.Union[list, tuple]) -> tuple
│ ├── matexp2x2kernel(a: typing.Union[list, tuple]) -> list
│ ├── matmul2x2kernel(a: typing.Union[list, tuple], b: typing.Union[list, tuple]) -> list
│ ├── matmul3x3kernel(a: typing.Union[list, tuple], b: typing.Union[list, tuple]) -> list
│ ├── matmul4x4kernel(a: typing.Union[list, tuple], b: typing.Union[list, tuple]) -> list
│ └── matpow2x2kernel(a: typing.Union[list, tuple], n: typing.Union[int, float, complex]) -> list
├── logics
│ ├── CLASS
│ │ ├── AND(pypynum.logics.Binary)/__init__(self: Any, label: Any, pin0: Any, pin1: Any) -> Any
│ │ ├── Basic(object)/__init__(self: Any, label: Any) -> Any
│ │ ├── Binary(pypynum.logics.Basic)/__init__(self: Any, label: Any, pin0: Any, pin1: Any) -> Any
│ │ ├── COMP(pypynum.logics.Binary)/__init__(self: Any, label: Any, pin0: Any, pin1: Any) -> Any
│ │ ├── DFF(pypynum.logics.Unary)/__init__(self: Any, label: Any, pin0: Any, state: Any) -> Any
│ │ ├── FullAdder(pypynum.logics.Ternary)/__init__(self: Any, label: Any, pin0: Any, pin1: Any, pin2: Any) -> Any
│ │ ├── FullSuber(pypynum.logics.Ternary)/__init__(self: Any, label: Any, pin0: Any, pin1: Any, pin2: Any) -> Any
│ │ ├── HalfAdder(pypynum.logics.Binary)/__init__(self: Any, label: Any, pin0: Any, pin1: Any) -> Any
│ │ ├── HalfSuber(pypynum.logics.Binary)/__init__(self: Any, label: Any, pin0: Any, pin1: Any) -> Any
│ │ ├── JKFF(pypynum.logics.Binary)/__init__(self: Any, label: Any, pin0: Any, pin1: Any, state: Any) -> Any
│ │ ├── NAND(pypynum.logics.Binary)/__init__(self: Any, label: Any, pin0: Any, pin1: Any) -> Any
│ │ ├── NOR(pypynum.logics.Binary)/__init__(self: Any, label: Any, pin0: Any, pin1: Any) -> Any
│ │ ├── NOT(pypynum.logics.Unary)/__init__(self: Any, label: Any, pin0: Any) -> Any
│ │ ├── OR(pypynum.logics.Binary)/__init__(self: Any, label: Any, pin0: Any, pin1: Any) -> Any
│ │ ├── Quaternary(pypynum.logics.Basic)/__init__(self: Any, label: Any, pin0: Any, pin1: Any, pin2: Any, pin3: Any) -> Any
│ │ ├── TFF(pypynum.logics.Unary)/__init__(self: Any, label: Any, pin0: Any, state: Any) -> Any
│ │ ├── Ternary(pypynum.logics.Basic)/__init__(self: Any, label: Any, pin0: Any, pin1: Any, pin2: Any) -> Any
│ │ ├── TwoBDiver(pypynum.logics.Quaternary)/__init__(self: Any, label: Any, pin0: Any, pin1: Any, pin2: Any, pin3: Any) -> Any
│ │ ├── TwoBMuler(pypynum.logics.Quaternary)/__init__(self: Any, label: Any, pin0: Any, pin1: Any, pin2: Any, pin3: Any) -> Any
│ │ ├── Unary(pypynum.logics.Basic)/__init__(self: Any, label: Any, pin0: Any) -> Any
│ │ ├── XNOR(pypynum.logics.Binary)/__init__(self: Any, label: Any, pin0: Any, pin1: Any) -> Any
│ │ └── XOR(pypynum.logics.Binary)/__init__(self: Any, label: Any, pin0: Any, pin1: Any) -> Any
│ └── FUNCTION
│ └── connector(previous: Any, latter: Any) -> Any
├── maths
│ ├── CLASS
│ └── FUNCTION
│ ├── arrangement(n: int, r: int) -> int
│ ├── combination(n: int, r: int) -> int
│ ├── acos(x: typing.Union[int, float]) -> typing.Union[int, float]
│ ├── acosh(x: typing.Union[int, float]) -> typing.Union[int, float]
│ ├── acot(x: typing.Union[int, float]) -> typing.Union[int, float]
│ ├── acoth(x: typing.Union[int, float]) -> typing.Union[int, float]
│ ├── acsc(x: typing.Union[int, float]) -> typing.Union[int, float]
│ ├── acsch(x: typing.Union[int, float]) -> typing.Union[int, float]
│ ├── arrangement(n: int, r: int) -> int
│ ├── asec(x: typing.Union[int, float]) -> typing.Union[int, float]
│ ├── asech(x: typing.Union[int, float]) -> typing.Union[int, float]
│ ├── asin(x: typing.Union[int, float]) -> typing.Union[int, float]
│ ├── asinh(x: typing.Union[int, float]) -> typing.Union[int, float]
│ ├── atan(x: typing.Union[int, float]) -> typing.Union[int, float]
│ ├── atanh(x: typing.Union[int, float]) -> typing.Union[int, float]
│ ├── average(data: typing.Union[list, tuple], weights: typing.Union[list, tuple]) -> float
│ ├── beta(p: typing.Union[int, float], q: typing.Union[int, float]) -> typing.Union[int, float]
│ ├── central_moment(data: typing.Union[list, tuple], order: int) -> float
│ ├── coeff_det(x: typing.Union[list, tuple], y: typing.Union[list, tuple]) -> typing.Union[int, float, complex]
│ ├── combination(n: int, r: int) -> int
│ ├── corr_coeff(x: typing.Union[list, tuple], y: typing.Union[list, tuple]) -> typing.Union[int, float, complex]
│ ├── cos(x: typing.Union[int, float]) -> typing.Union[int, float]
│ ├── 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]
│ ├── 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]
│ ├── cumprod(lst: typing.Union[list, tuple]) -> list
│ ├── cumsum(lst: typing.Union[list, tuple]) -> list
│ ├── deriv(f: Any, x: float, h: float, method: str, args: Any, kwargs: Any) -> Any
│ ├── erf(x: typing.Union[int, float]) -> float
│ ├── exgcd(a: int, b: int) -> tuple
│ ├── exp(x: typing.Union[int, float]) -> typing.Union[int, float]
│ ├── factorial(n: int) -> int
│ ├── freq(data: typing.Union[list, tuple]) -> dict
│ ├── gamma(alpha: typing.Union[int, float]) -> float
│ ├── gcd(args: int) -> int
│ ├── geom_mean(numbers: typing.Union[list, tuple]) -> typing.Union[int, float, complex]
│ ├── harm_mean(numbers: typing.Union[list, tuple]) -> typing.Union[int, float, complex]
│ ├── integ(f: Any, x_start: typing.Union[int, float], x_end: typing.Union[int, float], n: int, args: Any, kwargs: Any) -> float
│ ├── iroot(y: int, n: int) -> int
│ ├── is_possibly_square(n: int) -> bool
│ ├── is_square(n: int) -> bool
│ ├── isqrt(x: int) -> int
│ ├── kurt(data: typing.Union[list, tuple], fisher: bool) -> float
│ ├── lcm(args: int) -> int
│ ├── ln(x: typing.Union[int, float]) -> typing.Union[int, float]
│ ├── lower_gamma(s: typing.Union[int, float, complex], x: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]
│ ├── mean(numbers: typing.Union[list, tuple]) -> typing.Union[int, float, complex]
│ ├── median(numbers: typing.Union[list, tuple]) -> typing.Union[int, float, complex]
│ ├── mod_order(a: int, n: int, b: int) -> int
│ ├── mode(data: typing.Union[list, tuple]) -> Any
│ ├── normalize(data: typing.Union[list, tuple], target: typing.Union[int, float, complex]) -> typing.Union[list, tuple]
│ ├── parity(x: int) -> int
│ ├── pi(i: int, n: int, f: Any) -> typing.Union[int, float, complex]
│ ├── primitive_root(a: int, single: bool) -> typing.Union[int, list]
│ ├── product(numbers: typing.Union[list, tuple]) -> typing.Union[int, float, complex]
│ ├── ptp(numbers: typing.Union[list, tuple]) -> typing.Union[int, float, complex]
│ ├── quantile(data: list, q: float, interpolation: str, ordered: bool) -> float
│ ├── raw_moment(data: typing.Union[list, tuple], order: int) -> float
│ ├── roll(seq: typing.Union[list, tuple, str], shift: int) -> typing.Union[list, tuple, str]
│ ├── root(x: typing.Union[int, float, complex], y: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]
│ ├── sec(x: typing.Union[int, float]) -> typing.Union[int, float]
│ ├── sech(x: typing.Union[int, float]) -> typing.Union[int, float]
│ ├── sigma(i: int, n: int, f: Any) -> typing.Union[int, float, complex]
│ ├── sigmoid(x: typing.Union[int, float]) -> float
│ ├── sign(x: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]
│ ├── sin(x: typing.Union[int, float]) -> typing.Union[int, float]
│ ├── 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]
│ ├── 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]
│ ├── 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
│ ├── CLASS
│ │ └── Matrix(pypynum.arrays.Array)/__init__(self: Any, data: Any, check: Any) -> Any
│ └── FUNCTION
│ ├── cholesky(matrix: pypynum.matrices.Matrix, hermitian: bool) -> pypynum.matrices.Matrix
│ ├── eigen(matrix: pypynum.matrices.Matrix) -> tuple
│ ├── hessenberg(matrix: pypynum.matrices.Matrix) -> tuple
│ ├── identity(n: int, m: int) -> pypynum.matrices.Matrix
│ ├── lu(matrix: pypynum.matrices.Matrix) -> tuple
│ ├── mat(data: Any) -> Any
│ ├── 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
│ ├── perm_mat_indices(num_rows: int, num_cols: int, row_swaps: typing.Union[list, tuple], col_swaps: typing.Union[list, tuple]) -> tuple
│ ├── qr(matrix: pypynum.matrices.Matrix, reduce: bool) -> tuple
│ ├── rank_decomp(matrix: pypynum.matrices.Matrix) -> tuple
│ ├── rotate90(matrix: pypynum.matrices.Matrix, times: int) -> pypynum.matrices.Matrix
│ ├── svd(matrix: pypynum.matrices.Matrix) -> tuple
│ ├── tril_indices(n: int, k: int, m: int) -> tuple
│ └── triu_indices(n: int, k: int, m: int) -> tuple
├── multiprec
│ ├── CLASS
│ │ └── MPComplex(object)/__init__(self: Any, real: Any, imag: Any, sigfigs: Any) -> Any
│ └── FUNCTION
│ ├── _remove_trailing_zeros(value: typing.Any) -> str
│ ├── _setprec(sigfigs: int) -> Any
│ ├── asmpc(real: typing.Union[int, float, str, decimal.Decimal, complex, pypynum.multiprec.MPComplex], imag: typing.Union[int, float, str, decimal.Decimal], sigfigs: int) -> pypynum.multiprec.MPComplex
│ ├── frac2dec(frac: fractions.Fraction, sigfigs: int) -> decimal.Decimal
│ ├── mp_acos(x: typing.Union[int, float, str, decimal.Decimal], sigfigs: int) -> decimal.Decimal
│ ├── mp_asin(x: typing.Union[int, float, str, decimal.Decimal], sigfigs: int) -> decimal.Decimal
│ ├── mp_atan(x: typing.Union[int, float, str, decimal.Decimal], sigfigs: int) -> decimal.Decimal
│ ├── mp_atan2(y: typing.Union[int, float, str, decimal.Decimal], x: typing.Union[int, float, str, decimal.Decimal], sigfigs: int) -> decimal.Decimal
│ ├── mp_catalan(sigfigs: int) -> decimal.Decimal
│ ├── mp_cos(x: typing.Union[int, float, str, decimal.Decimal], sigfigs: int) -> decimal.Decimal
│ ├── mp_cosh(x: typing.Union[int, float, str, decimal.Decimal], sigfigs: int) -> decimal.Decimal
│ ├── mp_e(sigfigs: int, method: str) -> decimal.Decimal
│ ├── mp_euler_gamma(sigfigs: int) -> decimal.Decimal
│ ├── mp_exp(x: typing.Union[int, float, str, decimal.Decimal], sigfigs: int, builtin: bool) -> decimal.Decimal
│ ├── mp_fresnel_c(x: typing.Union[int, float, str, decimal.Decimal], sigfigs: int) -> decimal.Decimal
│ ├── mp_fresnel_s(x: typing.Union[int, float, str, decimal.Decimal], sigfigs: int) -> decimal.Decimal
│ ├── mp_ln(x: typing.Union[int, float, str, decimal.Decimal], sigfigs: int, builtin: bool) -> decimal.Decimal
│ ├── mp_log(x: typing.Union[int, float, str, decimal.Decimal], base: typing.Union[int, float, str, decimal.Decimal], sigfigs: int, builtin: bool) -> decimal.Decimal
│ ├── mp_phi(sigfigs: int, method: str) -> decimal.Decimal
│ ├── mp_pi(sigfigs: int, method: str) -> decimal.Decimal
│ ├── mp_sin(x: typing.Union[int, float, str, decimal.Decimal], sigfigs: int) -> decimal.Decimal
│ └── mp_sinh(x: typing.Union[int, float, str, decimal.Decimal], sigfigs: int) -> decimal.Decimal
├── networks
│ ├── CLASS
│ │ └── NeuralNetwork(object)/__init__(self: Any, _input: Any, _hidden: Any, _output: Any) -> Any
│ └── FUNCTION
│ └── neuraln(_input: Any, _hidden: Any, _output: Any) -> Any
├── numbers
│ ├── CLASS
│ └── FUNCTION
│ ├── float2fraction(number: float, mixed: bool, error: float) -> tuple
│ ├── int2roman(integer: int, overline: bool) -> str
│ ├── int2words(integer: int) -> str
│ ├── parse_float(s: str) -> tuple
│ ├── roman2int(roman_num: str) -> int
│ ├── split_float(s: str) -> tuple
│ └── str2int(string: str) -> int
├── plotting
│ ├── CLASS
│ └── FUNCTION
│ ├── background(right: typing.Union[int, float], left: typing.Union[int, float], top: typing.Union[int, float], bottom: typing.Union[int, float], complexity: typing.Union[int, float], ratio: typing.Union[int, float], string: bool) -> typing.Union[list, str]
│ ├── binary(function: Any, right: typing.Union[int, float], left: typing.Union[int, float], top: typing.Union[int, float], bottom: typing.Union[int, float], complexity: typing.Union[int, float], ratio: typing.Union[int, float], error: Any, compare: Any, string: bool, basic: list, character: str, data: bool, coloration: Any) -> typing.Union[list, str]
│ ├── c_unary(function: Any, projection: str, right: typing.Union[int, float], left: typing.Union[int, float], top: typing.Union[int, float], bottom: typing.Union[int, float], complexity: typing.Union[int, float], ratio: typing.Union[int, float], string: bool, basic: list, character: str, data: bool, coloration: Any) -> typing.Union[list, str]
│ ├── change(data: typing.Union[list, str]) -> typing.Union[list, str]
│ ├── color(text: str, rgb: typing.Union[list, tuple]) -> str
│ └── unary(function: Any, right: typing.Union[int, float], left: typing.Union[int, float], top: typing.Union[int, float], bottom: typing.Union[int, float], complexity: typing.Union[int, float], ratio: typing.Union[int, float], string: bool, basic: list, character: str, data: bool, coloration: Any) -> typing.Union[list, str]
├── polys
│ ├── CLASS
│ │ └── Polynomial(object)/__init__(self: Any, terms: Any) -> Any
│ └── FUNCTION
│ ├── chebgauss(n: Any) -> Any
│ ├── chebpoly(n: Any, single: Any) -> Any
│ ├── from_coeffs(coeffs: Any) -> Any
│ ├── from_coords(coords: Any) -> Any
│ ├── laggauss(n: Any) -> Any
│ ├── lagpoly(n: Any, single: Any) -> Any
│ ├── leggauss(n: Any) -> Any
│ ├── legpoly(n: Any, single: Any) -> Any
│ └── poly(terms: Any) -> Any
├── pprinters
│ ├── CLASS
│ └── FUNCTION
│ └── pprint_matrix(matrix: Any, style: Any, output: Any) -> Any
├── quats
│ ├── CLASS
│ │ ├── Euler(object)/__init__(self: Any, y: typing.Union[int, float], p: typing.Union[int, float], r: typing.Union[int, float]) -> Any
│ │ └── Quaternion(object)/__init__(self: Any, w: typing.Union[int, float], x: typing.Union[int, float], y: typing.Union[int, float], z: typing.Union[int, float]) -> Any
│ └── FUNCTION
│ ├── convert(data: typing.Union[pypynum.quats.Quaternion, pypynum.matrices.Matrix, pypynum.quats.Euler], to: str) -> typing.Union[pypynum.quats.Quaternion, pypynum.matrices.Matrix, pypynum.quats.Euler]
│ ├── euler(yaw: typing.Union[int, float], pitch: typing.Union[int, float], roll: typing.Union[int, float]) -> pypynum.quats.Euler
│ └── quat(w: typing.Union[int, float], x: typing.Union[int, float], y: typing.Union[int, float], z: typing.Union[int, float]) -> pypynum.quats.Quaternion
├── random
│ ├── CLASS
│ └── FUNCTION
│ ├── __create_nested_list(dimensions: Any, func: Any) -> Any
│ ├── __validate_shape(shape: Any) -> Any
│ ├── choice(seq: typing.Union[list, tuple, str], shape: typing.Union[list, tuple]) -> Any
│ ├── gauss(mu: typing.Union[int, float], sigma: typing.Union[int, float], shape: typing.Union[list, tuple]) -> typing.Union[float, list]
│ ├── rand(shape: typing.Union[list, tuple]) -> typing.Union[float, list]
│ ├── randint(a: int, b: int, shape: typing.Union[list, tuple]) -> typing.Union[int, list]
│ └── uniform(a: typing.Union[int, float], b: typing.Union[int, float], shape: typing.Union[list, tuple]) -> typing.Union[float, list]
├── regs
│ ├── CLASS
│ └── FUNCTION
│ ├── lin_reg(x: typing.Union[list, tuple], y: typing.Union[list, tuple]) -> list
│ ├── par_reg(x: typing.Union[list, tuple], y: typing.Union[list, tuple]) -> list
│ └── poly_reg(x: typing.Union[list, tuple], y: typing.Union[list, tuple], n: int) -> list
├── seqs
│ ├── CLASS
│ └── FUNCTION
│ ├── arithmetic_sequence(a1: typing.Union[int, float], an: typing.Union[int, float], d: typing.Union[int, float], n: typing.Union[int, float], s: typing.Union[int, float]) -> dict
│ ├── bell_triangle(n: int) -> list
│ ├── bernoulli(n: int, single: bool) -> typing.Union[list, tuple]
│ ├── catalan(n: int, single: bool) -> typing.Union[int, list]
│ ├── farey(n: int) -> list
│ ├── fibonacci(n: int, single: bool) -> typing.Union[int, list]
│ ├── geometric_sequence(a1: typing.Union[int, float], an: typing.Union[int, float], r: typing.Union[int, float], n: typing.Union[int, float], s: typing.Union[int, float]) -> dict
│ ├── lucas(n: int, single: bool) -> typing.Union[int, list]
│ ├── padovan(n: int, single: bool) -> typing.Union[int, list]
│ ├── pascal_triangle(n: int) -> list
│ ├── pell(n: int, single: bool) -> typing.Union[int, list]
│ ├── pelllucas(n: int, single: bool) -> typing.Union[int, list]
│ ├── perrin(n: int, single: bool) -> typing.Union[int, list]
│ ├── recaman(n: int, single: bool) -> typing.Union[int, list]
│ ├── stirling1(n: int) -> list
│ ├── stirling2(n: int) -> list
│ ├── sylvester(n: int, single: bool) -> typing.Union[int, list]
│ ├── tetranacci(n: int, single: bool) -> typing.Union[int, list]
│ └── tribonacci(n: int, single: bool) -> typing.Union[int, list]
├── special
│ ├── CLASS
│ └── FUNCTION
│ ├── besseli0(x: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]
│ ├── besseli1(x: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]
│ ├── besseliv(v: typing.Union[int, float], x: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]
│ ├── besselj0(x: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]
│ ├── besselj1(x: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]
│ ├── besseljv(v: typing.Union[int, float], x: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]
│ ├── hyp0f1(b0: typing.Union[int, float, complex], z: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]
│ ├── 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]
│ ├── qbinomial(n: typing.Union[int, float, complex], m: 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]
├── stattest
│ ├── CLASS
│ └── FUNCTION
│ ├── chi2_cont(contingency: list, lambda_: float, calc_p: bool, corr: bool) -> tuple
│ ├── chisquare(observed: list, expected: list) -> tuple
│ ├── kurttest(data: list, two_tailed: bool) -> tuple
│ ├── mediantest(samples: Any, ties: Any, lambda_: Any, corr: Any) -> Any
│ ├── normaltest(data: list) -> tuple
│ └── skewtest(data: list, two_tailed: bool) -> tuple
├── symbols
│ ├── CLASS
│ └── FUNCTION
│ └── parse_expr(expr: str) -> list
├── tensors
│ ├── CLASS
│ │ └── 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
├── test
│ ├── CLASS
│ └── FUNCTION
├── this
│ ├── CLASS
│ └── FUNCTION
├── tools
│ ├── 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
│ ├── geomspace(start: typing.Union[int, float], stop: typing.Union[int, float], number: int) -> 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
│ ├── linspace(start: typing.Union[int, float], stop: typing.Union[int, float], number: int) -> list
│ ├── magic_square(n: int) -> list
│ ├── 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
├── trees
│ ├── CLASS
│ │ ├── BTNode(object)/__init__(self: Any, data: Any) -> Any
│ │ ├── BinaryTree(object)/__init__(self: Any, root: Any) -> Any
│ │ ├── MTNode(object)/__init__(self: Any, data: Any) -> Any
│ │ ├── MultiTree(object)/__init__(self: Any, root: Any) -> Any
│ │ ├── RBTNode(object)/__init__(self: Any, data: Any, color: Any) -> Any
│ │ └── RedBlackTree(object)/__init__(self: Any) -> Any
│ └── FUNCTION
├── types
│ ├── CLASS
│ └── FUNCTION
├── ufuncs
│ ├── CLASS
│ └── FUNCTION
│ ├── add(x: Any, y: Any) -> Any
│ ├── apply(a: Any, func: Any, rtype: Any) -> Any
│ ├── base_ufunc(arrays: Any, func: Any, args: Any, rtype: Any) -> Any
│ ├── divide(x: Any, y: Any) -> Any
│ ├── eq(x: Any, y: Any) -> Any
│ ├── floor_divide(x: Any, y: Any) -> Any
│ ├── ge(x: Any, y: Any) -> Any
│ ├── gt(x: Any, y: Any) -> Any
│ ├── le(x: Any, y: Any) -> Any
│ ├── lt(x: Any, y: Any) -> Any
│ ├── modulo(x: Any, y: Any) -> Any
│ ├── multiply(x: Any, y: Any) -> Any
│ ├── ne(x: Any, y: Any) -> Any
│ ├── power(x: Any, y: Any, m: Any) -> Any
│ ├── subtract(x: Any, y: Any) -> Any
│ └── ufunc_helper(x: Any, y: Any, func: Any) -> Any
├── utils
│ ├── CLASS
│ │ ├── InfIterator(object)/__init__(self: Any, start: typing.Union[int, float, complex], mode: str, common: typing.Union[int, float, complex]) -> Any
│ │ ├── IntervalSet(object)/__init__(self: Any, intervals: Any) -> Any
│ │ ├── LinkedList(object)/__init__(self: Any) -> Any
│ │ ├── LinkedListNode(object)/__init__(self: Any, value: Any, next_node: Any) -> Any
│ │ └── OrderedSet(object)/__init__(self: Any, sequence: Any) -> Any
│ └── FUNCTION
├── vectors
│ ├── CLASS
│ │ └── Vector(pypynum.arrays.Array)/__init__(self: Any, data: Any, check: Any) -> Any
│ └── FUNCTION
│ └── vec(data: Any) -> Any
└── zh_cn
├── CLASS
└── FUNCTION
├── Fraction转为Decimal(分数对象: fractions.Fraction, 有效位数: int) -> decimal.Decimal
├── RC4伪随机生成算法(密钥序列: list) -> Any
├── RC4初始化密钥调度算法(密钥: bytes) -> list
├── RC4密码(文本: bytes, 密钥: bytes) -> bytes
├── ROT13密码(文本: str) -> str
├── S型函数(x: typing.Union[int, float]) -> typing.Union[int, float]
├── base64密码(文本: str, 解密: bool) -> str
├── x对数y乘积(x: float, y: float) -> float
├── y次方根(被开方数: typing.Union[int, float, complex], 开方数: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]
├── 一维傅里叶变换(数据: Any) -> pypynum.fft.FT1D
├── 上伽玛(s: typing.Union[int, float, complex], x: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]
├── 上标转整数(上标字符串: str) -> str
├── 下伽玛(s: typing.Union[int, float, complex], x: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]
├── 下标转整数(下标字符串: str) -> str
├── 中位数(数据: typing.List[float]) -> float
├── 中国剩余定理(n: typing.List[int], a: typing.List[int]) -> int
├── 中心矩(数据: typing.List[float], 阶数: int) -> float
├── 乘积和(多个数组: typing.List[typing.Any]) -> float
├── 代替密码(文本: str, 替换映射: dict, 解密: bool) -> str
├── 众数(数据: typing.List[typing.Any]) -> Any
├── 伽玛函数(alpha: float) -> float
├── 余切(x: typing.Union[int, float]) -> typing.Union[int, float]
├── 余割(x: typing.Union[int, float]) -> typing.Union[int, float]
├── 余弦(x: typing.Union[int, float]) -> typing.Union[int, float]
├── 偏度(数据: typing.List[float]) -> float
├── 全一(形状: Any, 返回类型: Any) -> Any
├── 全部填充(形状: Any, 填充值: Any, 返回类型: Any) -> Any
├── 全零(形状: Any, 返回类型: Any) -> Any
├── 写入(文件: str, 对象: object) -> Any
├── 几何平均数(数据: typing.List[float]) -> float
├── 凯撒密码(文本: str, 移位: int, 解密: bool) -> str
├── 分位数(数据: list, 分位值: float, 插值方法: str, 已排序: bool) -> float
├── 判定系数(x: typing.List[float], y: typing.List[float]) -> float
├── 判断平方数(n: int) -> bool
├── 加权平均(数据: typing.List[float], 权重: typing.List[float]) -> float
├── 协方差(x: typing.List[float], y: typing.List[float], 自由度: int) -> float
├── 原根(a: int, 单个: bool) -> typing.Union[int, typing.List[int]]
├── 原点矩(数据: typing.List[float], 阶数: int) -> float
├── 双曲余切(x: typing.Union[int, float]) -> typing.Union[int, float]
├── 双曲余割(x: typing.Union[int, float]) -> typing.Union[int, float]
├── 双曲余弦(x: typing.Union[int, float]) -> typing.Union[int, float]
├── 双曲正切(x: typing.Union[int, float]) -> typing.Union[int, float]
├── 双曲正割(x: typing.Union[int, float]) -> typing.Union[int, float]
├── 双曲正弦(x: typing.Union[int, float]) -> typing.Union[int, float]
├── 反余切(x: typing.Union[int, float]) -> typing.Union[int, float]
├── 反余割(x: typing.Union[int, float]) -> typing.Union[int, float]
├── 反余弦(x: typing.Union[int, float]) -> typing.Union[int, float]
├── 反双曲余切(x: typing.Union[int, float]) -> typing.Union[int, float]
├── 反双曲余割(x: typing.Union[int, float]) -> typing.Union[int, float]
├── 反双曲余弦(x: typing.Union[int, float]) -> typing.Union[int, float]
├── 反双曲正切(x: typing.Union[int, float]) -> typing.Union[int, float]
├── 反双曲正割(x: typing.Union[int, float]) -> typing.Union[int, float]
├── 反双曲正弦(x: typing.Union[int, float]) -> typing.Union[int, float]
├── 反正切(x: typing.Union[int, float]) -> typing.Union[int, float]
├── 反正割(x: typing.Union[int, float]) -> typing.Union[int, float]
├── 反正弦(x: typing.Union[int, float]) -> typing.Union[int, float]
├── 可能是平方数(n: int) -> bool
├── 填充序列(形状: Any, 序列: Any, 重复: Any, 填充: Any, 返回类型: Any) -> Any
├── 多次方根取整(被开方数: int, 开方数: int) -> int
├── 多精度余弦(x: typing.Union[int, float], 有效位数: int) -> decimal.Decimal
├── 多精度双曲余弦(x: typing.Union[int, float], 有效位数: int) -> decimal.Decimal
├── 多精度双曲正弦(x: typing.Union[int, float], 有效位数: int) -> decimal.Decimal
├── 多精度反余弦(x: typing.Union[int, float], 有效位数: int) -> decimal.Decimal
├── 多精度反正切(x: typing.Union[int, float], 有效位数: int) -> decimal.Decimal
├── 多精度反正弦(x: typing.Union[int, float], 有效位数: int) -> decimal.Decimal
├── 多精度圆周率(有效位数: int, 方法: str) -> decimal.Decimal
├── 多精度复数(实部: typing.Union[int, float, str, decimal.Decimal], 虚部: typing.Union[int, float, str, decimal.Decimal], 有效位数: int) -> pypynum.multiprec.MPComplex
├── 多精度对数(真数: typing.Union[int, float], 底数: typing.Union[int, float], 有效位数: int, 使用内置方法: bool) -> decimal.Decimal
├── 多精度方位角(y: typing.Union[int, float], x: typing.Union[int, float], 有效位数: int) -> decimal.Decimal
├── 多精度欧拉伽马(有效位数: int) -> decimal.Decimal
├── 多精度正弦(x: typing.Union[int, float], 有效位数: int) -> decimal.Decimal
├── 多精度自然对数(真数: typing.Union[int, float], 有效位数: int, 使用内置方法: bool) -> decimal.Decimal
├── 多精度自然常数(有效位数: int, 方法: str) -> decimal.Decimal
├── 多精度自然指数(指数: typing.Union[int, float], 有效位数: int, 使用内置方法: bool) -> decimal.Decimal
├── 多精度菲涅耳余弦积分(x: typing.Union[int, float], 有效位数: int) -> decimal.Decimal
├── 多精度菲涅耳正弦积分(x: typing.Union[int, float], 有效位数: int) -> decimal.Decimal
├── 多精度黄金分割率(有效位数: int, 方法: str) -> decimal.Decimal
├── 多项式方程(系数: list) -> list
├── 字符串转整数(字符串: str) -> int
├── 导数(函数: Any, 参数: float, 步长: float, 额外参数: Any, 额外关键字参数: Any) -> float
├── 峰度(数据: typing.List[float], 费希尔: bool) -> float
├── 希尔256密码(文本: bytes, 密钥: list, 解密: bool) -> bytes
├── 平均数(数据: typing.List[float]) -> float
├── 平方平均数(数据: typing.List[float]) -> float
├── 平方根取整(被开方数: int) -> int
├── 序列滚动(序列: typing.Iterator[typing.Any], 偏移: int) -> typing.Iterator[typing.Any]
├── 归一化(数据: typing.List[float], 目标: float) -> typing.List[float]
├── 扩展欧几里得算法(a: int, b: int) -> typing.Tuple[int, int, int]
├── 拆分浮点数字符串(字符串: str) -> tuple
├── 排列数(总数: int, 选取数: int) -> int
├── 数组(数据: list, 检查: bool) -> pypynum.arrays.Array
├── 整数转上标(标准字符串: str) -> str
├── 整数转下标(标准字符串: str) -> str
├── 整数转单词(整数: int) -> str
├── 整数转罗马数(整数: int, 上划线: bool) -> str
├── 方差(数据: typing.List[float], 自由度: int) -> float
├── 普莱费尔密码(文本: str, 密钥: str, 解密: bool) -> str
├── 最大公约数(args: int) -> int
├── 最小公倍数(args: int) -> int
├── 极差(数据: typing.List[float]) -> float
├── 标准差(数据: typing.List[float], 自由度: int) -> float
├── 模运算阶(a: int, n: int, b: int) -> int
├── 欧拉函数(n: int) -> int
├── 正切(x: typing.Union[int, float]) -> typing.Union[int, float]
├── 正割(x: typing.Union[int, float]) -> typing.Union[int, float]
├── 正弦(x: typing.Union[int, float]) -> typing.Union[int, float]
├── 浮点数转分数(数值: float, 是否带分数: bool, 误差: float) -> tuple
├── 相关系数(x: typing.List[float], y: typing.List[float]) -> float
├── 积分(函数: Any, 积分开始: float, 积分结束: float, 积分点数: int, 额外参数: Any, 额外关键字参数: Any) -> float
├── 积累乘积(数据: typing.List[float]) -> float
├── 符号函数(x: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]
├── 类似形状全一(数组A: Any, 返回类型: Any) -> Any
├── 类似形状全零(数组A: Any, 返回类型: Any) -> Any
├── 类似形状填充(数组A: Any, 填充值: Any, 返回类型: Any) -> Any
├── 累乘积(序列: typing.List[float]) -> typing.List[float]
├── 累加和(序列: typing.List[float]) -> typing.List[float]
├── 线性方程组(左边: list, 右边: list) -> list
├── 组合数(总数: int, 选取数: int) -> int
├── 维吉尼亚密码(文本: str, 密钥: str, 解密: bool) -> str
├── 罗马数转整数(罗马数: str) -> int
├── 自然对数(真数: typing.Union[int, float]) -> typing.Union[int, float]
├── 自然指数(指数: typing.Union[int, float]) -> typing.Union[int, float]
├── 莫尔斯密码(文本: str, 解密: bool) -> str
├── 解析浮点数字符串(字符串: str) -> tuple
├── 误差函数(x: typing.Union[int, float]) -> typing.Union[int, float]
├── 读取(文件: str) -> list
├── 调和平均数(数据: typing.List[float]) -> float
├── 贝塔函数(p: float, q: float) -> float
├── 贝塞尔函数I0(x: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]
├── 贝塞尔函数I1(x: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]
├── 贝塞尔函数Iv(v: typing.Union[int, float], x: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]
├── 贝塞尔函数J0(x: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]
├── 贝塞尔函数J1(x: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]
├── 贝塞尔函数Jv(v: typing.Union[int, float], x: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]
├── 负一整数次幂(指数: int) -> int
├── 转为多精度复数(实部: typing.Union[int, float, str, decimal.Decimal, complex, pypynum.multiprec.MPComplex], 虚部: typing.Union[int, float, str, decimal.Decimal], 有效位数: int) -> pypynum.multiprec.MPComplex
├── 转换为列表(数据: Any) -> list
├── 转换为数组(数据: Any) -> pypynum.arrays.Array
├── 连续乘积(下界: int, 上界: int, 函数: typing.Callable) -> float
├── 连续加和(下界: int, 上界: int, 函数: typing.Callable) -> float
├── 阶乘函数(n: int) -> int
├── 阿特巴什密码(文本: str) -> str
├── 频率统计(数据: typing.List[typing.Any]) -> typing.Dict[typing.Any, int]
└── 黎曼函数(alpha: float) -> float
```
### Code Testing
```python
from pypynum import (arrays, geoms, logics, matrices, quats, symbols, tensors, vectors,
ciphers, consts, equations, maths, plotting, random, regs, tools)
...
print(arrays.array())
print(arrays.array([1, 2, 3, 4, 5, 6, 7, 8]))
print(arrays.array([[1, 2, 3, 4], [5, 6, 7, 8]]))
print(arrays.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]]))
"""
[]
[1 2 3 4 5 6 7 8]
[[1 2 3 4]
[5 6 7 8]]
[[[1 2]
[3 4]]
[[5 6]
[7 8]]]
"""
triangle = geoms.Triangle((0, 0), (2, 2), (3, 0))
print(triangle.perimeter())
print(triangle.area())
print(triangle.centroid())
"""
8.06449510224598
3.0
(1.6666666666666667, 0.6666666666666666)
"""
a, b, c = 1, 1, 1
adder0, adder1 = logics.HalfAdder("alpha", a, b), logics.HalfAdder("beta", c, None)
xor0 = logics.XOR("alpha")
ff0, ff1 = logics.DFF("alpha"), logics.DFF("beta")
xor0.set_order0(1)
xor0.set_order1(1)
logics.connector(adder0, adder1)
logics.connector(adder0, xor0)
logics.connector(adder1, xor0)
logics.connector(adder1, ff0)
logics.connector(xor0, ff1)
print("sum: {}, carry: {}".format(ff0.out(), ff1.out()))
"""
sum: [1], carry: [1]
"""
m0 = matrices.mat([[1, 2], [3, 4]])
m1 = matrices.mat([[5, 6], [7, 8]])
print(m0)
print(m1)
print(m0 + m1)
print(m0 @ m1)
print(m0.inv())
print(m1.rank())
"""
[[1 2]
[3 4]]
[[5 6]
[7 8]]
[[ 6 8]
[10 12]]
[[19 22]
[43 50]]
[[ -1.9999999999999996 0.9999999999999998]
[ 1.4999999999999998 -0.49999999999999994]]
2
"""
q0 = quats.quat(1, 2, 3, 4)
q1 = quats.quat(5, 6, 7, 8)
print(q0)
print(q1)
print(q0 + q1)
print(q0 * q1)
print(q0.inverse())
print(q1.conjugate())
"""
(1+2i+3j+4k)
(5+6i+7j+8k)
(6+8i+10j+12k)
(-60+12i+30j+24k)
(0.18257418583505536+-0.3651483716701107i+-0.5477225575051661j+-0.7302967433402214k)
(5+-6i+-7j+-8k)
"""
print(symbols.BASIC)
print(symbols.ENGLISH)
print(symbols.GREEK)
print(symbols.parse_expr("-(10+a-(3.14+b0)*(-5))**(-ζn1-2.718/mΣ99)//9"))
"""
%()*+-./0123456789
ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz
ΑΒΓΔΕΖΗΘΙΚΛΜΝΞΟΠΡΣΤΥΦΧΨΩαβγδεζηθικλμνξοπρστυφχψω
[['10', '+', 'a', '-', ['3.14', '+', 'b0'], '*', '-5'], '**', ['-ζn1', '-', '2.718', '/', 'mΣ99'], '//', '9']
"""
t0 = tensors.ten([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])
t1 = tensors.ten([[[9, 10], [11, 12]], [[13, 14], [15, 16]]])
print(t0)
print(t1)
print(t0 + t1)
print(t0 @ t1)
"""
[[[1 2]
[3 4]]
[[5 6]
[7 8]]]
[[[ 9 10]
[11 12]]
[[13 14]
[15 16]]]
[[[10 12]
[14 16]]
[[18 20]
[22 24]]]
[[[ 31 34]
[ 71 78]]
[[155 166]
[211 226]]]
"""
string = "PyPyNum"
encrypted = ciphers.caesar(string, 10)
print(string)
print(encrypted)
print(ciphers.caesar(encrypted, 10, decrypt=True))
encrypted = ciphers.vigenere(string, "ciphers")
print(string)
print(encrypted)
print(ciphers.vigenere(encrypted, "ciphers", decrypt=True))
encrypted = ciphers.morse(string)
print(string)
print(encrypted)
print(ciphers.morse(encrypted, decrypt=True))
"""
PyPyNum
ZiZiXew
PyPyNum
PyPyNum
RgEfRle
PyPyNum
PyPyNum
.--. -.-- .--. -.-- -. ..- --
PYPYNUM
"""
v0 = vectors.vec([1, 2, 3, 4])
v1 = vectors.vec([5, 6, 7, 8])
print(v0)
print(v1)
print(v0 + v1)
print(v0 @ v1)
print(v0.normalize())
print(v1.angles())
"""
[1 2 3 4]
[5 6 7 8]
[ 5 12 21 32]
70
[0.18257418583505536 0.3651483716701107 0.5477225575051661 0.7302967433402214]
[1.1820279130506308, 1.0985826410133916, 1.0114070854293842, 0.9191723423169716]
"""
print(consts.TB)
print(consts.e)
print(consts.h)
print(consts.phi)
print(consts.pi)
print(consts.tera)
"""
1099511627776
2.718281828459045
6.62607015e-34
1.618033988749895
3.141592653589793
1000000000000
"""
p = [1, -2, -3, 4]
m = [
[
[1, 2, 3],
[6, 10, 12],
[7, 16, 9]
],
[-1, -2, -3]
]
print(equations.poly_eq(p))
print(equations.lin_eq(*m))
"""
[(-1.5615528128088307-6.5209667308287455e-24j), (1.0000000000000007+3.241554513744382e-25j), (2.5615528128088294+4.456233626665941e-24j)]
[1.6666666666666665, -0.6666666666666666, -0.4444444444444444]
"""
print(maths.cot(consts.pi / 3))
print(maths.gamma(1.5))
print(maths.pi(1, 10, lambda x: x ** 2))
print(maths.product([2, 3, 5, 7, 11, 13, 17, 19, 23, 29]))
print(maths.sigma(1, 10, lambda x: x ** 2))
print(maths.var([2, 3, 5, 7, 11, 13, 17, 19, 23, 29]))
"""
0.577350269189626
0.886226925452758
13168189440000
6469693230
385
73.29
"""
plt = plotting.unary(lambda x: x ** 2, top=10, bottom=0, character="+")
print(plt)
print(plotting.binary(lambda x, y: x ** 2 + y ** 2 - 10, right=10, left=0, compare="<=", basic=plotting.change(plt)))
print(plotting.c_unary(lambda x: x ** x, right=2, left=-2, top=2, bottom=-2, complexity=20, character="-"))
"""
1.00e+01| + +
|
| + +
|
| + +
| + +
|
| + +
5.00e+00|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
| + +
| + +
| + +
| + +
| + +
| + +
| + +
| +++ +++
0.00e+00|________________________+++________________________
-5.00e+00 0.00e+00 5.00e+00
1.00e+01| + +
|
| + +
|
|......... + +
|............. +
|..............
|................ +
5.00e+00|................_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
|................ +
|................ +
|.............. + +
|............. + +
|......... + +
| + +
| + +
| +++ +++
0.00e+00|________________________+++________________________
-5.00e+00 0.00e+00 5.00e+00
2.00e+00| - - - - - -
| - - - - - - -
| - - - - - -
|- - - - - - -
| - - - - -- - - - -
| - - - - - - - - -
| - - - - -- - --- -- - -- - - - - -
| - - - -- -- - - - -- - - -
| - - - - - - - -- - --- --- - - --- -- - -
| - - - - - -- ----- -- -- --- -- -- --- -- - -
| - - - ------------ ---- - -- -- - --- - - -
| - - - - - ----- - -- ----------------------- -- ---- - -- --
| - - - - - ---- --------------------------------- - - - - - -
0.00e+00|_ _ _ _ _ _ _ _-_-_-_-_---- ------------------------------------_-- _ _ _ _ _ _ _
| - - - - ----------------------------------------- -- - - - -
| - -- - - -- - - --------------------------------- - - -
| - - ---- - - -- --------------------- ----- ---- - -- -
| - - -- --------- -- -- - ----- --- -- - - - -
| - - - - - - - ---- --- --- --- -- -- --- - - -
| - - - - - -- -- -- - - -- -- --
| - - - -- - -- -- - - -- - -
| - - - - - - - -- - - -- - -
| - - - - -- -- - - - - -
| - - - - - - - -
|- - - - - - - -
| - - - - - -
| - - - - -
-2.00e+00|___________-_________________-___________-_____________________-____________-____
-2.00e+00 0.00e+00 2.00e+00
"""
print(random.gauss(0, 1, [2, 3, 4]))
print(random.rand([2, 3, 4]))
print(random.randint(0, 9, [2, 3, 4]))
print(random.uniform(0, 9, [2, 3, 4]))
"""
[[[0.825882516672574, 1.3725886771525058, 1.0633834034457958, -0.9653681933485563], [-0.26676981942597733, -0.8111218278822722, -2.0334645819975408, -0.6920477799264579], [0.219847607640343, -0.11124595869774408, 0.3959826652933697, 0.44979678957252417]], [[-0.32870040193220884, 0.02332530718848737, -0.11463753179571698, 0.76497128138739], [0.5471632308210022, -1.208683530864806, 0.6609856809302458, -1.0172095093996394], [-0.4239944693396323, -0.9895869506909234, 0.3151444331927837, -1.0952382690567983]]]
[[[0.7391048706507907, 0.8914203442107109, 0.7810881208477741, 0.42396350784517345], [0.44782953354925625, 0.14060494681841362, 0.36645338622864543, 0.8792327342896561], [0.8328977875499322, 0.7597606669429515, 0.7309414657218207, 0.39511825984097715]], [[0.4224440661015312, 0.2817063735017259, 0.11204741761562653, 0.7932546033111754], [0.6230861699889618, 0.16789479246904482, 0.4452307316686511, 0.7298193538352331], [0.879038899493412, 0.14646565947090828, 0.6904668348145003, 0.8027750348973339]]]
[[[5, 6, 4, 0], [5, 0, 4, 1], [2, 3, 5, 4]], [[4, 2, 3, 8], [3, 0, 0, 8], [9, 9, 4, 8]]]
[[[5.350800115670108, 5.835203389972244, 8.668571640348379, 6.784139317082117], [7.838141284015925, 0.46256545431156715, 2.8571047765183932, 0.0660157726117514], [5.587670205493748, 3.567592961539832, 2.9956823476061682, 7.924798867767713]], [[1.5388683451612495, 8.64453573809756, 1.4500691204596237, 6.551614999615261], [6.95157556639829, 4.179288210881939, 6.281664642870586, 1.0867107163432608], [0.18490809809604403, 1.9708027978691627, 0.23346492301822674, 0.935059580008676]]]
"""
print(regs.lin_reg(list(range(5)), [2, 4, 6, 7, 8]))
print(regs.par_reg(list(range(5)), [2, 4, 6, 7, 8]))
print(regs.poly_reg(list(range(5)), [2, 4, 6, 7, 8], 4))
"""
[1.5, 2.4000000000000004]
[-0.21428571428571563, 2.3571428571428625, 1.971428571428569]
[0.08333333333320592, -0.666666666666571, 1.4166666666628345, 1.1666666666688208, 1.9999999999999258]
"""
print(tools.classify([1, 2.3, 4 + 5j, "string", list, True, 3.14, False, tuple, tools]))
print(tools.dedup(["Python", 6, "NumPy", int, "PyPyNum", 9, "pypynum", "NumPy", 6, True]))
print(tools.frange(0, 3, 0.4))
print(tools.linspace(0, 2.8, 8))
"""
{<class 'int'>: [1], <class 'float'>: [2.3, 3.14], <class 'complex'>: [(4+5j)], <class 'str'>: ['string'], <class 'type'>: [<class 'list'>, <class 'tuple'>], <class 'bool'>: [True, False], <class 'module'>: [<module 'pypynum.tools' from 'C:\\Users\\Administrator\\PycharmProjects\\pythonProject\\pypynum\\tools.py'>]}
['Python', 6, 'NumPy', <class 'int'>, 'PyPyNum', 9, 'pypynum', True]
[0.0, 0.4, 0.8, 1.2000000000000002, 1.6, 2.0, 2.4000000000000004, 2.8000000000000003]
[0.0, 0.39999999999999997, 0.7999999999999999, 1.2, 1.5999999999999999, 1.9999999999999998, 2.4, 2.8]
"""
# Tip:
# The test has been successfully passed and ended.
# These tests are only part of the functionality of this package.
# More features need to be explored and tried by yourself!
```
Raw data
{
"_id": null,
"home_page": "https://github.com/PythonSJL/PyPyNum",
"name": "PyPyNum",
"maintainer": null,
"docs_url": null,
"requires_python": ">=3.4",
"maintainer_email": null,
"keywords": "math, \u6570\u5b66, mathematics, \u6570\u5b66\u8ba1\u7b97, numerical, \u6570\u503c, computation, \u8ba1\u7b97, scientific, \u79d1\u5b66, algebra, \u4ee3\u6570, calculus, \u5fae\u79ef\u5206, statistics, \u7edf\u8ba1, linear-algebra, \u7ebf\u6027\u4ee3\u6570, optimization, \u4f18\u5316, numerical-analysis, \u6570\u503c\u5206\u6790, matrix, \u77e9\u9635, vector, \u5411\u91cf, tensor, \u5f20\u91cf, numerics, \u6570\u503c\u8ba1\u7b97, library, \u5e93, tools, \u5de5\u5177, utils, \u5b9e\u7528\u7a0b\u5e8f, algorithms, \u7b97\u6cd5, software, \u8f6f\u4ef6, package, \u5305, methods, \u65b9\u6cd5, data-science, \u6570\u636e\u79d1\u5b66, machine-learning, \u673a\u5668\u5b66\u4e60, computational, \u8ba1\u7b97\u7684, operations, \u64cd\u4f5c, functions, \u51fd\u6570, processing, \u5904\u7406, programming, \u7f16\u7a0b, simulation, \u4eff\u771f, visualization, \u53ef\u89c6\u5316, physics, \u7269\u7406",
"author": "Shen Jiayi",
"author_email": "2261748025@qq.com",
"download_url": "https://files.pythonhosted.org/packages/b5/45/b6c4fa1c6ea0fabe04b42135917cc11a1e55faf9edaf814b4c4c5e8cc08f/pypynum-1.16.1.tar.gz",
"platform": null,
"description": "\ufeff# <font color = blue>PyPyNum</font>\r\n\r\n<font color = gree>PyPyNum is a Python library for math & science computations, covering algebra, calculus, stats, with\r\ndata structures like matrices, vectors, tensors. It offers numerical tools, programs, and supports computational ops,\r\nfunctions, processing, simulation, & visualization in data science & ML, crucial for research, engineering, & data\r\nprocessing.</font><font color = red>[Python>=3.4]</font>\r\n\r\n```\r\n ________ ___ ___ ________ ___ ___ ________ ___ ___ _____ ______\r\n|\\ __ \\ |\\ \\ / /||\\ __ \\ |\\ \\ / /||\\ ___ \\ |\\ \\|\\ \\ |\\ _ \\ _ \\\r\n\\ \\ \\|\\ \\\\ \\ \\/ / /\\ \\ \\|\\ \\\\ \\ \\/ / /\\ \\ \\\\ \\ \\\\ \\ \\\\\\ \\\\ \\ \\\\\\__\\ \\ \\\r\n \\ \\ ____\\\\ \\ / / \\ \\ ____\\\\ \\ / / \\ \\ \\\\ \\ \\\\ \\ \\\\\\ \\\\ \\ \\\\|__| \\ \\\r\n \\ \\ \\___| \\/ / / \\ \\ \\___| \\/ / / \\ \\ \\\\ \\ \\\\ \\ \\\\\\ \\\\ \\ \\ \\ \\ \\\r\n \\ \\__\\ __/ / / \\ \\__\\ __/ / / \\ \\__\\\\ \\__\\\\ \\_______\\\\ \\__\\ \\ \\__\\\r\n \\|__| |\\___/ / \\|__| |\\___/ / \\|__| \\|__| \\|_______| \\|__| \\|__|\r\n \\|___|/ \\|___|/\r\n```\r\n\r\n[](https://pepy.tech/project/pypynum)\r\n[](https://pepy.tech/project/pypynum)\r\n[](https://pepy.tech/project/pypynum)\r\n\r\n## PyPyNum | Version -> 1.16.1 | PyPI -> https://pypi.org/project/PyPyNum/ | Gitee -> https://www.gitee.com/PythonSJL/PyPyNum | GitHub -> https://github.com/PythonSJL/PyPyNum\r\n\r\n\r\n\r\nThe logo cannot be displayed on PyPI, it can be viewed in Gitee or GitHub.\r\n\r\n### Introduction\r\n\r\n+ Multi functional math library, similar to numpy, scipy, etc., designed specifically for PyPy interpreters and also\r\n supports other types of Python interpreters\r\n+ Update versions periodically to add more practical features\r\n+ If you need to contact, please add QQ number 2261748025 (Py\ud835\ude7f\ud835\udea2\ud835\ude9d\ud835\ude91\ud835\ude98\ud835\ude97-\u6c34\u6676\u5170), or through my email 2261748025@qq.com\r\n\r\n### Name and Function Introduction of Submodules\r\n\r\n| Submodule Name | Function Introduction |\r\n|:-------------------:|:------------------------------------------------------------------:|\r\n| `pypynum.arrays` | Provides operations and calculations for multi-dimensional arrays. |\r\n| `pypynum.chars` | Contains a variety of special mathematical characters. |\r\n| `pypynum.ciphers` | Implements various encryption and decryption algorithms. |\r\n| `pypynum.consts` | Contains mathematical and physical constants. |\r\n| `pypynum.crandom` | Generates random complex numbers. |\r\n| `pypynum.dataproc` | Tools for data preprocessing and transformation. |\r\n| `pypynum.dists` | Statistical distribution functions and related calculations. |\r\n| `pypynum.equations` | Solves equations and performs symbolic operations. |\r\n| `pypynum.fft` | Implements Fast Fourier Transforms and related functionalities. |\r\n| `pypynum.files` | File reading and writing tools. |\r\n| `pypynum.geoms` | Geometric shapes and calculation methods. |\r\n| `pypynum.graphs` | Graph theory algorithms and network analysis. |\r\n| `pypynum.groups` | Group theory calculations and structural analysis. |\r\n| `pypynum.images` | Image processing and manipulation tools. |\r\n| `pypynum.interp` | Interpolation methods and function approximation. |\r\n| `pypynum.kernels` | Implementation of kernel functions and methods. |\r\n| `pypynum.logics` | Simulates logical circuits. |\r\n| `pypynum.maths` | Basic mathematical operations and special functions. |\r\n| `pypynum.matrices` | Matrix operations and linear algebra calculations. |\r\n| `pypynum.multiprec` | High-precision numerical computations. |\r\n| `pypynum.networks` | Network models and algorithms. |\r\n| `pypynum.numbers` | Operations on numerical types and properties. |\r\n| `pypynum.plotting` | Data visualization tools. |\r\n| `pypynum.polys` | Polynomial operations and calculations. |\r\n| `pypynum.pprinters` | Advanced printing and formatting output. |\r\n| `pypynum.quats` | Quaternion operations and transformations. |\r\n| `pypynum.random` | Generates arrays of random numbers. |\r\n| `pypynum.regs` | Regression analysis and model fitting. |\r\n| `pypynum.seqs` | Computes various mathematical sequences. |\r\n| `pypynum.special` | Provides advanced special functions for mathematical computations. |\r\n| `pypynum.stattest` | Statistical tests and data analysis. |\r\n| `pypynum.symbols` | Symbolic computation and expression manipulation. |\r\n| `pypynum.tensors` | Tensor operations and calculations. |\r\n| `pypynum.test` | Simple code testing for the library. |\r\n| `pypynum.this` | The Zen of the library, expressing its guiding principles. |\r\n| `pypynum.tools` | General tools and helper functions. |\r\n| `pypynum.trees` | Tree structures and algorithm implementations. |\r\n| `pypynum.types` | Contains various types, exceptions, and configurations. |\r\n| `pypynum.ufuncs` | Universal functions and vectorized operations. |\r\n| `pypynum.utils` | Utility programs and auxiliary functions. |\r\n| `pypynum.vectors` | Vector operations and calculations. |\r\n| `pypynum.zh_cn` | Provides Chinese language interfaces for various functionalities. |\r\n\r\n### The Zen of PyPyNum (Preview)\r\n\r\n```\r\n The Zen of PyPyNum, by Shen Jiayi\r\n\r\nIn this mathematical sanctuary, we weave our algorithms with pure Python threads.\r\nPrecision outweighs approximation.\r\nElegance in mathematics transcends the bulky algorithms.\r\nClarity in logic illuminates the darkest problems.\r\nSimplicity in form is the pinnacle of sophistication.\r\nFlat hierarchies in our code mirror the linear nature of functions.\r\nSparse code, like a minimal polynomial, retains essence without redundancy.\r\n```\r\n\r\n```\r\n...\r\n\r\nDo you want to view all the content?\r\n\r\nEnter \"from pypynum import this\" in your\r\n\r\nPython interpreter and run it!\r\n```\r\n\r\n```\r\n September 5, 2024\r\n```\r\n\r\n### Functional Changes Compared to the Previous Version\r\n\r\n```\r\n!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=\r\n\r\nFixed and improved the basic\r\noperation function of 'Array'.\r\n\r\n!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=\r\n\r\nWe will remove 'Tensor' in\r\nfuture versions. Because its\r\ncomputational functions have\r\nalready been implemented in\r\n'Array'. The current version\r\nwill throw 'FutureWarning' as a\r\nwarning.\r\n\r\n!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=\r\n\r\nFixed the calculation error of\r\n'mp_euler_gamma', which was\r\ncaused when modifying the\r\niteration stop condition\r\npreviously.\r\n\r\n!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=\r\n\r\n<<< Here are the newly added functions >>>\r\n\r\n\r\ncos_sim(seq1: Union[list, tuple, str], seq2: Union[list, tuple, str], is_vector: bool = False) -> float\r\n Introduction\r\n ==========\r\n Calculate the cosine similarity between two sequences.\r\n\r\n The cosine similarity is a measure of similarity between two non-zero vectors. It is defined as the cosine of the\r\n angle between them, which is computed as the dot product of the vectors divided by the product of their magnitudes.\r\n This function supports both numerical vectors and frequency distributions of sequences.\r\n\r\n Example\r\n ==========\r\n >>> cos_sim(\"hello world\", \"world hello\")\r\n 0.9999999999999998\r\n >>>\r\n :param seq1: First sequence to compare.\r\n :param seq2: Second sequence to compare.\r\n :param is_vector: A boolean indicating whether the input sequences are numerical vectors. Default is False.\r\n :return: The cosine similarity between the two sequences, ranging from -1 to 1.\r\n\r\n\r\nreplace(seq: Union[list, tuple], old: Union[list, tuple], new: Union[list, tuple], count: int = -1) -> Union[list, tuple]\r\n Introduction\r\n ==========\r\n Replace occurrences of the subsequence 'old' in 'seq' with 'new'.\r\n\r\n This function is designed to handle sequences such as lists or tuples and replace specified subsequences\r\n with new ones. It also allows limiting the number of replacements.\r\n\r\n Example\r\n ==========\r\n >>> replace([1, 2, 3, 4, 2, 3], [2, 3], [5, 6])\r\n [1, 5, 6, 4, 5, 6]\r\n >>>\r\n :param seq: The sequence in which to replace the subsequence.\r\n :param old: The subsequence to be replaced.\r\n :param new: The subsequence to replace with.\r\n :param count: The maximum number of replacements to perform. Default is -1 (unlimited).\r\n :return: The modified sequence with replacements.\r\n\r\n!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=\r\n\r\nOther functions and classes have\r\nalso undergone certain\r\nmodifications, such as adding a\r\n\"reduce\" parameter to the \"qr\"\r\nfunction to determine whether to\r\ncrop the matrix.\r\n\r\n!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=\r\n```\r\n\r\n### Run Time Test\r\n\r\nPython interpreter version\r\n\r\n+ CPython 3.8.10\r\n\r\n+ PyPy 3.10.12\r\n\r\n| Matrix Time Test | NumPy+CPython (seconds) | Ranking | PyPyNum+PyPy (seconds) | Ranking | Mpmath_+_PyPy_ (seconds) | Ranking | SymPy_+_PyPy_ (seconds) | Ranking |\r\n|------------------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------|\r\n| Create a hundred order random number matrix | 0.000083 | 1 | 0.005374 | 2 | 0.075253 | 3 | 0.230530 | 4 |\r\n| Create a thousand order random number matrix | 0.006740 | 1 | 0.035666 | 2 | 1.200950 | 3 | 4.370265 | 4 |\r\n| Addition of matrices of order one hundred | 0.000029 | 1 | 0.002163 | 2 | 0.045641 | 4 | 0.035700 | 3 |\r\n| Adding matrices of order one thousand | 0.002647 | 1 | 0.019111 | 2 | 1.746957 | 4 | 0.771542 | 3 |\r\n| Determinant of a hundred order matrix | 0.087209 | 2 | 0.016331 | 1 | 4.354507 | 3 | 5.157206 | 4 |\r\n| Determinant of a thousand order matrix | 0.616113 | 1 | 3.509747 | 2 | It takes a long time | 3 | It takes a long time | 4 |\r\n| Finding the inverse of a hundred order matrix | 0.162770 | 2 | 0.015768 | 1 | 8.162948 | 3 | 21.437424 | 4 |\r\n| Finding the inverse of a thousand order matrix | 0.598905 | 1 | 17.072552 | 2 | It takes a long time | 3 | It takes a long time | 4 |\r\n| Array output effect | ```[[[[\u2002-7\u2002-67]```<br>```[-78\u2002\u200229]]```<br><br>```[[-86\u2002-97]```<br>```[\u200268\u2002\u2002-3]]]```<br><br><br>```[[[\u200211\u2002\u200242]```<br>```[\u200224\u2002-65]]```<br><br>```[[-60\u2002\u200272]```<br>```[\u200273\u2002\u2002\u20022]]]]``` | / | ```[[[[\u200237\u2002\u200283]```<br>```[\u200240\u2002\u2002\u20022]]```<br><br>```[[\u2002-5\u2002-34]```<br>```[\u2002-7\u2002\u200272]]]```<br><br><br>```[[[\u200213\u2002-64]```<br>```[\u2002\u20026\u2002\u200290]]```<br><br>```[[\u200268\u2002\u200257]```<br>```[\u200278\u2002\u200211]]]]``` | / | ```[-80.0\u2002\u2002\u2002-8.0\u2002\u200280.0\u2002\u2002-88.0]```<br>```[-99.0\u2002\u2002-43.0\u2002\u200287.0\u2002\u2002\u200281.0]```<br>```[\u200220.0\u2002\u2002-55.0\u2002\u200298.0\u2002\u2002\u2002\u20028.0]```<br>```[\u2002\u20028.0\u2002\u2002\u200244.0\u2002\u200264.0\u2002\u2002-35.0]```<br><br>(Only supports matrices) | / | ```\u23a1\u23a116\u2002\u2002\u2002-56\u23a4\u2002\u2002\u23a1\u20028\u2002\u2002\u2002-28\u23a4\u23a4```<br>```\u23a2\u23a2\u2002\u2002\u2002\u2002\u2002\u2002\u2002\u2002\u23a5\u2002\u2002\u23a2\u2002\u2002\u2002\u2002\u2002\u2002\u2002\u2002\u23a5\u23a5```<br>```\u23a2\u23a3-56\u2002\u200256\u2002\u23a6\u2002\u2002\u23a3-28\u2002\u200228\u2002\u23a6\u23a5```<br>```\u23a2\u2002\u2002\u2002\u2002\u2002\u2002\u2002\u2002\u2002\u2002\u2002\u2002\u2002\u2002\u2002\u2002\u2002\u2002\u2002\u2002\u2002\u2002\u23a5```<br>```\u23a2\u2002\u23a1-2\u2002\u20027\u2002\u23a4\u2002\u2002\u2002\u23a1-18\u2002\u200263\u2002\u23a4\u23a5```<br>```\u23a2\u2002\u23a2\u2002\u2002\u2002\u2002\u2002\u2002\u23a5\u2002\u2002\u2002\u23a2\u2002\u2002\u2002\u2002\u2002\u2002\u2002\u2002\u23a5\u23a5```<br>```\u23a3\u2002\u23a37\u2002\u2002\u2002-7\u23a6\u2002\u2002\u2002\u23a363\u2002\u2002\u2002-63\u23a6\u23a6``` | / |\r\n\r\n### Basic Structure\r\n\r\n```\r\nPyPyNum\r\n\u251c\u2500\u2500 arrays\r\n\u2502 \u251c\u2500\u2500 CLASS\r\n\u2502 \u2502 \u251c\u2500\u2500 Array(object)/__init__(self: Any, data: Any, check: Any) -> Any\r\n\u2502 \u2502 \u2514\u2500\u2500 BoolArray(pypynum.arrays.Array)/__init__(self: Any, data: Any, check: Any) -> Any\r\n\u2502 \u2514\u2500\u2500 FUNCTION\r\n\u2502 \u251c\u2500\u2500 array(data: Any) -> Any\r\n\u2502 \u251c\u2500\u2500 asarray(data: Any) -> Any\r\n\u2502 \u251c\u2500\u2500 aslist(data: Any) -> Any\r\n\u2502 \u251c\u2500\u2500 boolarray(data: Any) -> Any\r\n\u2502 \u251c\u2500\u2500 fill(shape: typing.Union[list, tuple], sequence: typing.Union[list, tuple], repeat: bool, pad: typing.Any, rtype: typing.Callable) -> typing.Any\r\n\u2502 \u251c\u2500\u2500 full(shape: typing.Union[list, tuple], fill_value: typing.Any, rtype: typing.Callable) -> typing.Any\r\n\u2502 \u251c\u2500\u2500 full_like(a: typing.Any, fill_value: typing.Any, rtype: typing.Callable) -> typing.Any\r\n\u2502 \u251c\u2500\u2500 get_shape(data: Any) -> Any\r\n\u2502 \u251c\u2500\u2500 is_valid_array(_array: Any, _shape: Any) -> Any\r\n\u2502 \u251c\u2500\u2500 ones(shape: typing.Union[list, tuple], rtype: typing.Callable) -> typing.Any\r\n\u2502 \u251c\u2500\u2500 ones_like(a: typing.Any, rtype: typing.Callable) -> typing.Any\r\n\u2502 \u251c\u2500\u2500 tensorproduct(tensors: pypynum.arrays.Array) -> pypynum.arrays.Array\r\n\u2502 \u251c\u2500\u2500 zeros(shape: typing.Union[list, tuple], rtype: typing.Callable) -> typing.Any\r\n\u2502 \u2514\u2500\u2500 zeros_like(a: typing.Any, rtype: typing.Callable) -> typing.Any\r\n\u251c\u2500\u2500 chars\r\n\u2502 \u251c\u2500\u2500 CLASS\r\n\u2502 \u2514\u2500\u2500 FUNCTION\r\n\u2502 \u251c\u2500\u2500 int2subscript(standard_str: str) -> str\r\n\u2502 \u251c\u2500\u2500 int2superscript(standard_str: str) -> str\r\n\u2502 \u251c\u2500\u2500 subscript2int(subscript_str: str) -> str\r\n\u2502 \u2514\u2500\u2500 superscript2int(superscript_str: str) -> str\r\n\u251c\u2500\u2500 ciphers\r\n\u2502 \u251c\u2500\u2500 CLASS\r\n\u2502 \u2514\u2500\u2500 FUNCTION\r\n\u2502 \u251c\u2500\u2500 atbash(text: str) -> str\r\n\u2502 \u251c\u2500\u2500 base_64(text: str, decrypt: bool) -> str\r\n\u2502 \u251c\u2500\u2500 caesar(text: str, shift: int, decrypt: bool) -> str\r\n\u2502 \u251c\u2500\u2500 hill256(text: bytes, key: list, decrypt: bool) -> bytes\r\n\u2502 \u251c\u2500\u2500 ksa(key: bytes) -> list\r\n\u2502 \u251c\u2500\u2500 morse(text: str, decrypt: bool) -> str\r\n\u2502 \u251c\u2500\u2500 playfair(text: str, key: str, decrypt: bool) -> str\r\n\u2502 \u251c\u2500\u2500 prga(s: list) -> Any\r\n\u2502 \u251c\u2500\u2500 rc4(text: bytes, key: bytes) -> bytes\r\n\u2502 \u251c\u2500\u2500 rot13(text: str) -> str\r\n\u2502 \u251c\u2500\u2500 substitution(text: str, sub_map: dict, decrypt: bool) -> str\r\n\u2502 \u2514\u2500\u2500 vigenere(text: str, key: str, decrypt: bool) -> str\r\n\u251c\u2500\u2500 consts\r\n\u2502 \u251c\u2500\u2500 CLASS\r\n\u2502 \u2514\u2500\u2500 FUNCTION\r\n\u251c\u2500\u2500 crandom\r\n\u2502 \u251c\u2500\u2500 CLASS\r\n\u2502 \u2514\u2500\u2500 FUNCTION\r\n\u2502 \u251c\u2500\u2500 randint_polar(left: int, right: int, mod: typing.Union[int, float], angle: typing.Union[int, float]) -> complex\r\n\u2502 \u251c\u2500\u2500 randint_rect(left: int, right: int, real: typing.Union[int, float], imag: typing.Union[int, float]) -> complex\r\n\u2502 \u251c\u2500\u2500 random_polar(mod: typing.Union[int, float], angle: typing.Union[int, float]) -> complex\r\n\u2502 \u251c\u2500\u2500 random_rect(real: typing.Union[int, float], imag: typing.Union[int, float]) -> complex\r\n\u2502 \u251c\u2500\u2500 uniform_polar(left: typing.Union[int, float], right: typing.Union[int, float], mod: typing.Union[int, float], angle: typing.Union[int, float]) -> complex\r\n\u2502 \u2514\u2500\u2500 uniform_rect(left: typing.Union[int, float], right: typing.Union[int, float], real: typing.Union[int, float], imag: typing.Union[int, float]) -> complex\r\n\u251c\u2500\u2500 dataproc\r\n\u2502 \u251c\u2500\u2500 CLASS\r\n\u2502 \u2502 \u2514\u2500\u2500 Series(object)/__init__(self: Any, data: typing.Any, index: typing.Any) -> None\r\n\u2502 \u2514\u2500\u2500 FUNCTION\r\n\u251c\u2500\u2500 dists\r\n\u2502 \u251c\u2500\u2500 CLASS\r\n\u2502 \u2514\u2500\u2500 FUNCTION\r\n\u2502 \u251c\u2500\u2500 beta_pdf(x: Any, a: Any, b: Any) -> Any\r\n\u2502 \u251c\u2500\u2500 binom_pmf(k: Any, n: Any, p: Any) -> Any\r\n\u2502 \u251c\u2500\u2500 cauchy_cdf(x: Any, x0: Any, gamma: Any) -> Any\r\n\u2502 \u251c\u2500\u2500 cauchy_pdf(x: Any, x0: Any, gamma: Any) -> Any\r\n\u2502 \u251c\u2500\u2500 chi2_cdf(x: Any, df: Any) -> Any\r\n\u2502 \u251c\u2500\u2500 chi2_pdf(x: Any, df: Any) -> Any\r\n\u2502 \u251c\u2500\u2500 expon_cdf(x: Any, scale: Any) -> Any\r\n\u2502 \u251c\u2500\u2500 expon_pdf(x: Any, scale: Any) -> Any\r\n\u2502 \u251c\u2500\u2500 f_pdf(x: Any, dfnum: Any, dfden: Any) -> Any\r\n\u2502 \u251c\u2500\u2500 gamma_pdf(x: Any, shape: Any, scale: Any) -> Any\r\n\u2502 \u251c\u2500\u2500 geometric_pmf(k: Any, p: Any) -> Any\r\n\u2502 \u251c\u2500\u2500 hypergeom_pmf(k: Any, mg: Any, n: Any, nt: Any) -> Any\r\n\u2502 \u251c\u2500\u2500 inv_gauss_pdf(x: Any, mu: Any, lambda_: Any, alpha: Any) -> Any\r\n\u2502 \u251c\u2500\u2500 levy_pdf(x: Any, c: Any) -> Any\r\n\u2502 \u251c\u2500\u2500 log_logistic_cdf(x: Any, alpha: Any, beta: Any) -> Any\r\n\u2502 \u251c\u2500\u2500 log_logistic_pdf(x: Any, alpha: Any, beta: Any) -> Any\r\n\u2502 \u251c\u2500\u2500 logistic_cdf(x: Any, mu: Any, s: Any) -> Any\r\n\u2502 \u251c\u2500\u2500 logistic_pdf(x: Any, mu: Any, s: Any) -> Any\r\n\u2502 \u251c\u2500\u2500 lognorm_cdf(x: Any, mu: Any, sigma: Any) -> Any\r\n\u2502 \u251c\u2500\u2500 lognorm_pdf(x: Any, s: Any, scale: Any) -> Any\r\n\u2502 \u251c\u2500\u2500 logser_pmf(k: Any, p: Any) -> Any\r\n\u2502 \u251c\u2500\u2500 multinomial_pmf(k: Any, n: Any, p: Any) -> Any\r\n\u2502 \u251c\u2500\u2500 nbinom_pmf(k: Any, n: Any, p: Any) -> Any\r\n\u2502 \u251c\u2500\u2500 nhypergeom_pmf(k: Any, m: Any, n: Any, r: Any) -> Any\r\n\u2502 \u251c\u2500\u2500 normal_cdf(x: Any, mu: Any, sigma: Any) -> Any\r\n\u2502 \u251c\u2500\u2500 normal_pdf(x: Any, mu: Any, sigma: Any) -> Any\r\n\u2502 \u251c\u2500\u2500 pareto_pdf(x: Any, k: Any, m: Any) -> Any\r\n\u2502 \u251c\u2500\u2500 poisson_pmf(k: Any, mu: Any) -> Any\r\n\u2502 \u251c\u2500\u2500 rayleigh_pdf(x: Any, sigma: Any) -> Any\r\n\u2502 \u251c\u2500\u2500 t_pdf(x: Any, df: Any) -> Any\r\n\u2502 \u251c\u2500\u2500 uniform_cdf(x: Any, loc: Any, scale: Any) -> Any\r\n\u2502 \u251c\u2500\u2500 uniform_pdf(x: Any, loc: Any, scale: Any) -> Any\r\n\u2502 \u251c\u2500\u2500 vonmises_pdf(x: Any, mu: Any, kappa: Any) -> Any\r\n\u2502 \u251c\u2500\u2500 weibull_max_pdf(x: Any, c: Any, scale: Any, loc: Any) -> Any\r\n\u2502 \u251c\u2500\u2500 weibull_min_pdf(x: Any, c: Any, scale: Any, loc: Any) -> Any\r\n\u2502 \u2514\u2500\u2500 zipf_pmf(k: Any, s: Any, n: Any) -> Any\r\n\u251c\u2500\u2500 equations\r\n\u2502 \u251c\u2500\u2500 CLASS\r\n\u2502 \u2514\u2500\u2500 FUNCTION\r\n\u2502 \u251c\u2500\u2500 lin_eq(left: list, right: list) -> list\r\n\u2502 \u2514\u2500\u2500 poly_eq(coefficients: list) -> list\r\n\u251c\u2500\u2500 fft\r\n\u2502 \u251c\u2500\u2500 CLASS\r\n\u2502 \u2502 \u2514\u2500\u2500 FT1D(object)/__init__(self: Any, data: Any) -> Any\r\n\u2502 \u2514\u2500\u2500 FUNCTION\r\n\u251c\u2500\u2500 files\r\n\u2502 \u251c\u2500\u2500 CLASS\r\n\u2502 \u2514\u2500\u2500 FUNCTION\r\n\u2502 \u251c\u2500\u2500 read(file: str) -> list\r\n\u2502 \u2514\u2500\u2500 write(file: str, cls: object) -> Any\r\n\u251c\u2500\u2500 geoms\r\n\u2502 \u251c\u2500\u2500 CLASS\r\n\u2502 \u2502 \u251c\u2500\u2500 Circle(object)/__init__(self: Any, center: typing.Union[list, tuple], radius: typing.Union[int, float]) -> Any\r\n\u2502 \u2502 \u251c\u2500\u2500 Line(object)/__init__(self: Any, a: typing.Union[list, tuple], b: typing.Union[list, tuple]) -> Any\r\n\u2502 \u2502 \u251c\u2500\u2500 Point(object)/__init__(self: Any, p: typing.Union[list, tuple]) -> Any\r\n\u2502 \u2502 \u251c\u2500\u2500 Polygon(object)/__init__(self: Any, p: typing.Union[list, tuple]) -> Any\r\n\u2502 \u2502 \u251c\u2500\u2500 Quadrilateral(object)/__init__(self: Any, a: typing.Union[list, tuple], b: typing.Union[list, tuple], c: typing.Union[list, tuple], d: typing.Union[list, tuple]) -> Any\r\n\u2502 \u2502 \u2514\u2500\u2500 Triangle(object)/__init__(self: Any, a: typing.Union[list, tuple], b: typing.Union[list, tuple], c: typing.Union[list, tuple]) -> Any\r\n\u2502 \u2514\u2500\u2500 FUNCTION\r\n\u2502 \u2514\u2500\u2500 distance(g1: Any, g2: Any, error: typing.Union[int, float]) -> float\r\n\u251c\u2500\u2500 graphs\r\n\u2502 \u251c\u2500\u2500 CLASS\r\n\u2502 \u2502 \u251c\u2500\u2500 BaseGraph(object)/__init__(self: Any) -> Any\r\n\u2502 \u2502 \u251c\u2500\u2500 BaseWeGraph(pypynum.graphs.BaseGraph)/__init__(self: Any) -> Any\r\n\u2502 \u2502 \u251c\u2500\u2500 DiGraph(pypynum.graphs.BaseGraph)/__init__(self: Any) -> Any\r\n\u2502 \u2502 \u251c\u2500\u2500 UnGraph(pypynum.graphs.BaseGraph)/__init__(self: Any) -> Any\r\n\u2502 \u2502 \u251c\u2500\u2500 WeDiGraph(pypynum.graphs.BaseWeGraph)/__init__(self: Any) -> Any\r\n\u2502 \u2502 \u2514\u2500\u2500 WeUnGraph(pypynum.graphs.BaseWeGraph)/__init__(self: Any) -> Any\r\n\u2502 \u2514\u2500\u2500 FUNCTION\r\n\u251c\u2500\u2500 groups\r\n\u2502 \u251c\u2500\u2500 CLASS\r\n\u2502 \u2502 \u2514\u2500\u2500 Group(object)/__init__(self: Any, data: Any, operation: Any) -> Any\r\n\u2502 \u2514\u2500\u2500 FUNCTION\r\n\u2502 \u2514\u2500\u2500 group(data: Any) -> Any\r\n\u251c\u2500\u2500 images\r\n\u2502 \u251c\u2500\u2500 CLASS\r\n\u2502 \u2502 \u2514\u2500\u2500 PNG(object)/__init__(self: Any) -> None\r\n\u2502 \u2514\u2500\u2500 FUNCTION\r\n\u2502 \u2514\u2500\u2500 crc(data: Any, length: Any, init: Any, xor: Any) -> Any\r\n\u251c\u2500\u2500 interp\r\n\u2502 \u251c\u2500\u2500 CLASS\r\n\u2502 \u2514\u2500\u2500 FUNCTION\r\n\u2502 \u251c\u2500\u2500 bicubic(x: Any) -> Any\r\n\u2502 \u251c\u2500\u2500 contribute(src: Any, x: Any, y: Any, channels: Any) -> Any\r\n\u2502 \u251c\u2500\u2500 interp1d(data: typing.Union[list, tuple], length: int) -> list\r\n\u2502 \u2514\u2500\u2500 interp2d(src: Any, new_height: Any, new_width: Any, channels: Any, round_res: Any, min_val: Any, max_val: Any) -> Any\r\n\u251c\u2500\u2500 kernels\r\n\u2502 \u251c\u2500\u2500 CLASS\r\n\u2502 \u2514\u2500\u2500 FUNCTION\r\n\u2502 \u251c\u2500\u2500 det2x2kernel(a: typing.Union[list, tuple]) -> float\r\n\u2502 \u251c\u2500\u2500 det3x3kernel(a: typing.Union[list, tuple]) -> float\r\n\u2502 \u251c\u2500\u2500 det4x4kernel(a: typing.Union[list, tuple]) -> float\r\n\u2502 \u251c\u2500\u2500 eigen2x2kernel(a: typing.Union[list, tuple]) -> tuple\r\n\u2502 \u251c\u2500\u2500 inv2x2kernel(a: typing.Union[list, tuple]) -> list\r\n\u2502 \u251c\u2500\u2500 inv3x3kernel(a: typing.Union[list, tuple]) -> list\r\n\u2502 \u251c\u2500\u2500 inv4x4kernel(a: typing.Union[list, tuple]) -> list\r\n\u2502 \u251c\u2500\u2500 lu2x2kernel(a: typing.Union[list, tuple]) -> tuple\r\n\u2502 \u251c\u2500\u2500 lu3x3kernel(a: typing.Union[list, tuple]) -> tuple\r\n\u2502 \u251c\u2500\u2500 lu4x4kernel(a: typing.Union[list, tuple]) -> tuple\r\n\u2502 \u251c\u2500\u2500 matexp2x2kernel(a: typing.Union[list, tuple]) -> list\r\n\u2502 \u251c\u2500\u2500 matmul2x2kernel(a: typing.Union[list, tuple], b: typing.Union[list, tuple]) -> list\r\n\u2502 \u251c\u2500\u2500 matmul3x3kernel(a: typing.Union[list, tuple], b: typing.Union[list, tuple]) -> list\r\n\u2502 \u251c\u2500\u2500 matmul4x4kernel(a: typing.Union[list, tuple], b: typing.Union[list, tuple]) -> list\r\n\u2502 \u2514\u2500\u2500 matpow2x2kernel(a: typing.Union[list, tuple], n: typing.Union[int, float, complex]) -> list\r\n\u251c\u2500\u2500 logics\r\n\u2502 \u251c\u2500\u2500 CLASS\r\n\u2502 \u2502 \u251c\u2500\u2500 AND(pypynum.logics.Binary)/__init__(self: Any, label: Any, pin0: Any, pin1: Any) -> Any\r\n\u2502 \u2502 \u251c\u2500\u2500 Basic(object)/__init__(self: Any, label: Any) -> Any\r\n\u2502 \u2502 \u251c\u2500\u2500 Binary(pypynum.logics.Basic)/__init__(self: Any, label: Any, pin0: Any, pin1: Any) -> Any\r\n\u2502 \u2502 \u251c\u2500\u2500 COMP(pypynum.logics.Binary)/__init__(self: Any, label: Any, pin0: Any, pin1: Any) -> Any\r\n\u2502 \u2502 \u251c\u2500\u2500 DFF(pypynum.logics.Unary)/__init__(self: Any, label: Any, pin0: Any, state: Any) -> Any\r\n\u2502 \u2502 \u251c\u2500\u2500 FullAdder(pypynum.logics.Ternary)/__init__(self: Any, label: Any, pin0: Any, pin1: Any, pin2: Any) -> Any\r\n\u2502 \u2502 \u251c\u2500\u2500 FullSuber(pypynum.logics.Ternary)/__init__(self: Any, label: Any, pin0: Any, pin1: Any, pin2: Any) -> Any\r\n\u2502 \u2502 \u251c\u2500\u2500 HalfAdder(pypynum.logics.Binary)/__init__(self: Any, label: Any, pin0: Any, pin1: Any) -> Any\r\n\u2502 \u2502 \u251c\u2500\u2500 HalfSuber(pypynum.logics.Binary)/__init__(self: Any, label: Any, pin0: Any, pin1: Any) -> Any\r\n\u2502 \u2502 \u251c\u2500\u2500 JKFF(pypynum.logics.Binary)/__init__(self: Any, label: Any, pin0: Any, pin1: Any, state: Any) -> Any\r\n\u2502 \u2502 \u251c\u2500\u2500 NAND(pypynum.logics.Binary)/__init__(self: Any, label: Any, pin0: Any, pin1: Any) -> Any\r\n\u2502 \u2502 \u251c\u2500\u2500 NOR(pypynum.logics.Binary)/__init__(self: Any, label: Any, pin0: Any, pin1: Any) -> Any\r\n\u2502 \u2502 \u251c\u2500\u2500 NOT(pypynum.logics.Unary)/__init__(self: Any, label: Any, pin0: Any) -> Any\r\n\u2502 \u2502 \u251c\u2500\u2500 OR(pypynum.logics.Binary)/__init__(self: Any, label: Any, pin0: Any, pin1: Any) -> Any\r\n\u2502 \u2502 \u251c\u2500\u2500 Quaternary(pypynum.logics.Basic)/__init__(self: Any, label: Any, pin0: Any, pin1: Any, pin2: Any, pin3: Any) -> Any\r\n\u2502 \u2502 \u251c\u2500\u2500 TFF(pypynum.logics.Unary)/__init__(self: Any, label: Any, pin0: Any, state: Any) -> Any\r\n\u2502 \u2502 \u251c\u2500\u2500 Ternary(pypynum.logics.Basic)/__init__(self: Any, label: Any, pin0: Any, pin1: Any, pin2: Any) -> Any\r\n\u2502 \u2502 \u251c\u2500\u2500 TwoBDiver(pypynum.logics.Quaternary)/__init__(self: Any, label: Any, pin0: Any, pin1: Any, pin2: Any, pin3: Any) -> Any\r\n\u2502 \u2502 \u251c\u2500\u2500 TwoBMuler(pypynum.logics.Quaternary)/__init__(self: Any, label: Any, pin0: Any, pin1: Any, pin2: Any, pin3: Any) -> Any\r\n\u2502 \u2502 \u251c\u2500\u2500 Unary(pypynum.logics.Basic)/__init__(self: Any, label: Any, pin0: Any) -> Any\r\n\u2502 \u2502 \u251c\u2500\u2500 XNOR(pypynum.logics.Binary)/__init__(self: Any, label: Any, pin0: Any, pin1: Any) -> Any\r\n\u2502 \u2502 \u2514\u2500\u2500 XOR(pypynum.logics.Binary)/__init__(self: Any, label: Any, pin0: Any, pin1: Any) -> Any\r\n\u2502 \u2514\u2500\u2500 FUNCTION\r\n\u2502 \u2514\u2500\u2500 connector(previous: Any, latter: Any) -> Any\r\n\u251c\u2500\u2500 maths\r\n\u2502 \u251c\u2500\u2500 CLASS\r\n\u2502 \u2514\u2500\u2500 FUNCTION\r\n\u2502 \u251c\u2500\u2500 arrangement(n: int, r: int) -> int\r\n\u2502 \u251c\u2500\u2500 combination(n: int, r: int) -> int\r\n\u2502 \u251c\u2500\u2500 acos(x: typing.Union[int, float]) -> typing.Union[int, float]\r\n\u2502 \u251c\u2500\u2500 acosh(x: typing.Union[int, float]) -> typing.Union[int, float]\r\n\u2502 \u251c\u2500\u2500 acot(x: typing.Union[int, float]) -> typing.Union[int, float]\r\n\u2502 \u251c\u2500\u2500 acoth(x: typing.Union[int, float]) -> typing.Union[int, float]\r\n\u2502 \u251c\u2500\u2500 acsc(x: typing.Union[int, float]) -> typing.Union[int, float]\r\n\u2502 \u251c\u2500\u2500 acsch(x: typing.Union[int, float]) -> typing.Union[int, float]\r\n\u2502 \u251c\u2500\u2500 arrangement(n: int, r: int) -> int\r\n\u2502 \u251c\u2500\u2500 asec(x: typing.Union[int, float]) -> typing.Union[int, float]\r\n\u2502 \u251c\u2500\u2500 asech(x: typing.Union[int, float]) -> typing.Union[int, float]\r\n\u2502 \u251c\u2500\u2500 asin(x: typing.Union[int, float]) -> typing.Union[int, float]\r\n\u2502 \u251c\u2500\u2500 asinh(x: typing.Union[int, float]) -> typing.Union[int, float]\r\n\u2502 \u251c\u2500\u2500 atan(x: typing.Union[int, float]) -> typing.Union[int, float]\r\n\u2502 \u251c\u2500\u2500 atanh(x: typing.Union[int, float]) -> typing.Union[int, float]\r\n\u2502 \u251c\u2500\u2500 average(data: typing.Union[list, tuple], weights: typing.Union[list, tuple]) -> float\r\n\u2502 \u251c\u2500\u2500 beta(p: typing.Union[int, float], q: typing.Union[int, float]) -> typing.Union[int, float]\r\n\u2502 \u251c\u2500\u2500 central_moment(data: typing.Union[list, tuple], order: int) -> float\r\n\u2502 \u251c\u2500\u2500 coeff_det(x: typing.Union[list, tuple], y: typing.Union[list, tuple]) -> typing.Union[int, float, complex]\r\n\u2502 \u251c\u2500\u2500 combination(n: int, r: int) -> int\r\n\u2502 \u251c\u2500\u2500 corr_coeff(x: typing.Union[list, tuple], y: typing.Union[list, tuple]) -> typing.Union[int, float, complex]\r\n\u2502 \u251c\u2500\u2500 cos(x: typing.Union[int, float]) -> typing.Union[int, float]\r\n\u2502 \u251c\u2500\u2500 cosh(x: typing.Union[int, float]) -> typing.Union[int, float]\r\n\u2502 \u251c\u2500\u2500 cot(x: typing.Union[int, float]) -> typing.Union[int, float]\r\n\u2502 \u251c\u2500\u2500 coth(x: typing.Union[int, float]) -> typing.Union[int, float]\r\n\u2502 \u251c\u2500\u2500 cov(x: typing.Union[list, tuple], y: typing.Union[list, tuple], dof: int) -> typing.Union[int, float, complex]\r\n\u2502 \u251c\u2500\u2500 crt(n: typing.Union[list, tuple], a: typing.Union[list, tuple]) -> int\r\n\u2502 \u251c\u2500\u2500 csc(x: typing.Union[int, float]) -> typing.Union[int, float]\r\n\u2502 \u251c\u2500\u2500 csch(x: typing.Union[int, float]) -> typing.Union[int, float]\r\n\u2502 \u251c\u2500\u2500 cumprod(lst: typing.Union[list, tuple]) -> list\r\n\u2502 \u251c\u2500\u2500 cumsum(lst: typing.Union[list, tuple]) -> list\r\n\u2502 \u251c\u2500\u2500 deriv(f: Any, x: float, h: float, method: str, args: Any, kwargs: Any) -> Any\r\n\u2502 \u251c\u2500\u2500 erf(x: typing.Union[int, float]) -> float\r\n\u2502 \u251c\u2500\u2500 exgcd(a: int, b: int) -> tuple\r\n\u2502 \u251c\u2500\u2500 exp(x: typing.Union[int, float]) -> typing.Union[int, float]\r\n\u2502 \u251c\u2500\u2500 factorial(n: int) -> int\r\n\u2502 \u251c\u2500\u2500 freq(data: typing.Union[list, tuple]) -> dict\r\n\u2502 \u251c\u2500\u2500 gamma(alpha: typing.Union[int, float]) -> float\r\n\u2502 \u251c\u2500\u2500 gcd(args: int) -> int\r\n\u2502 \u251c\u2500\u2500 geom_mean(numbers: typing.Union[list, tuple]) -> typing.Union[int, float, complex]\r\n\u2502 \u251c\u2500\u2500 harm_mean(numbers: typing.Union[list, tuple]) -> typing.Union[int, float, complex]\r\n\u2502 \u251c\u2500\u2500 integ(f: Any, x_start: typing.Union[int, float], x_end: typing.Union[int, float], n: int, args: Any, kwargs: Any) -> float\r\n\u2502 \u251c\u2500\u2500 iroot(y: int, n: int) -> int\r\n\u2502 \u251c\u2500\u2500 is_possibly_square(n: int) -> bool\r\n\u2502 \u251c\u2500\u2500 is_square(n: int) -> bool\r\n\u2502 \u251c\u2500\u2500 isqrt(x: int) -> int\r\n\u2502 \u251c\u2500\u2500 kurt(data: typing.Union[list, tuple], fisher: bool) -> float\r\n\u2502 \u251c\u2500\u2500 lcm(args: int) -> int\r\n\u2502 \u251c\u2500\u2500 ln(x: typing.Union[int, float]) -> typing.Union[int, float]\r\n\u2502 \u251c\u2500\u2500 lower_gamma(s: typing.Union[int, float, complex], x: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]\r\n\u2502 \u251c\u2500\u2500 mean(numbers: typing.Union[list, tuple]) -> typing.Union[int, float, complex]\r\n\u2502 \u251c\u2500\u2500 median(numbers: typing.Union[list, tuple]) -> typing.Union[int, float, complex]\r\n\u2502 \u251c\u2500\u2500 mod_order(a: int, n: int, b: int) -> int\r\n\u2502 \u251c\u2500\u2500 mode(data: typing.Union[list, tuple]) -> Any\r\n\u2502 \u251c\u2500\u2500 normalize(data: typing.Union[list, tuple], target: typing.Union[int, float, complex]) -> typing.Union[list, tuple]\r\n\u2502 \u251c\u2500\u2500 parity(x: int) -> int\r\n\u2502 \u251c\u2500\u2500 pi(i: int, n: int, f: Any) -> typing.Union[int, float, complex]\r\n\u2502 \u251c\u2500\u2500 primitive_root(a: int, single: bool) -> typing.Union[int, list]\r\n\u2502 \u251c\u2500\u2500 product(numbers: typing.Union[list, tuple]) -> typing.Union[int, float, complex]\r\n\u2502 \u251c\u2500\u2500 ptp(numbers: typing.Union[list, tuple]) -> typing.Union[int, float, complex]\r\n\u2502 \u251c\u2500\u2500 quantile(data: list, q: float, interpolation: str, ordered: bool) -> float\r\n\u2502 \u251c\u2500\u2500 raw_moment(data: typing.Union[list, tuple], order: int) -> float\r\n\u2502 \u251c\u2500\u2500 roll(seq: typing.Union[list, tuple, str], shift: int) -> typing.Union[list, tuple, str]\r\n\u2502 \u251c\u2500\u2500 root(x: typing.Union[int, float, complex], y: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]\r\n\u2502 \u251c\u2500\u2500 sec(x: typing.Union[int, float]) -> typing.Union[int, float]\r\n\u2502 \u251c\u2500\u2500 sech(x: typing.Union[int, float]) -> typing.Union[int, float]\r\n\u2502 \u251c\u2500\u2500 sigma(i: int, n: int, f: Any) -> typing.Union[int, float, complex]\r\n\u2502 \u251c\u2500\u2500 sigmoid(x: typing.Union[int, float]) -> float\r\n\u2502 \u251c\u2500\u2500 sign(x: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]\r\n\u2502 \u251c\u2500\u2500 sin(x: typing.Union[int, float]) -> typing.Union[int, float]\r\n\u2502 \u251c\u2500\u2500 sinh(x: typing.Union[int, float]) -> typing.Union[int, float]\r\n\u2502 \u251c\u2500\u2500 skew(data: typing.Union[list, tuple]) -> float\r\n\u2502 \u251c\u2500\u2500 square_mean(numbers: typing.Union[list, tuple]) -> typing.Union[int, float, complex]\r\n\u2502 \u251c\u2500\u2500 std(numbers: typing.Union[list, tuple], dof: int) -> typing.Union[int, float, complex]\r\n\u2502 \u251c\u2500\u2500 sumprod(arrays: typing.Union[list, tuple]) -> typing.Union[int, float, complex]\r\n\u2502 \u251c\u2500\u2500 tan(x: typing.Union[int, float]) -> typing.Union[int, float]\r\n\u2502 \u251c\u2500\u2500 tanh(x: typing.Union[int, float]) -> typing.Union[int, float]\r\n\u2502 \u251c\u2500\u2500 totient(n: int) -> int\r\n\u2502 \u251c\u2500\u2500 upper_gamma(s: typing.Union[int, float, complex], x: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]\r\n\u2502 \u251c\u2500\u2500 var(numbers: typing.Union[list, tuple], dof: int) -> typing.Union[int, float, complex]\r\n\u2502 \u251c\u2500\u2500 xlogy(x: typing.Union[int, float, complex], y: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]\r\n\u2502 \u2514\u2500\u2500 zeta(alpha: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]\r\n\u251c\u2500\u2500 matrices\r\n\u2502 \u251c\u2500\u2500 CLASS\r\n\u2502 \u2502 \u2514\u2500\u2500 Matrix(pypynum.arrays.Array)/__init__(self: Any, data: Any, check: Any) -> Any\r\n\u2502 \u2514\u2500\u2500 FUNCTION\r\n\u2502 \u251c\u2500\u2500 cholesky(matrix: pypynum.matrices.Matrix, hermitian: bool) -> pypynum.matrices.Matrix\r\n\u2502 \u251c\u2500\u2500 eigen(matrix: pypynum.matrices.Matrix) -> tuple\r\n\u2502 \u251c\u2500\u2500 hessenberg(matrix: pypynum.matrices.Matrix) -> tuple\r\n\u2502 \u251c\u2500\u2500 identity(n: int, m: int) -> pypynum.matrices.Matrix\r\n\u2502 \u251c\u2500\u2500 lu(matrix: pypynum.matrices.Matrix) -> tuple\r\n\u2502 \u251c\u2500\u2500 mat(data: Any) -> Any\r\n\u2502 \u251c\u2500\u2500 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\r\n\u2502 \u251c\u2500\u2500 perm_mat_indices(num_rows: int, num_cols: int, row_swaps: typing.Union[list, tuple], col_swaps: typing.Union[list, tuple]) -> tuple\r\n\u2502 \u251c\u2500\u2500 qr(matrix: pypynum.matrices.Matrix, reduce: bool) -> tuple\r\n\u2502 \u251c\u2500\u2500 rank_decomp(matrix: pypynum.matrices.Matrix) -> tuple\r\n\u2502 \u251c\u2500\u2500 rotate90(matrix: pypynum.matrices.Matrix, times: int) -> pypynum.matrices.Matrix\r\n\u2502 \u251c\u2500\u2500 svd(matrix: pypynum.matrices.Matrix) -> tuple\r\n\u2502 \u251c\u2500\u2500 tril_indices(n: int, k: int, m: int) -> tuple\r\n\u2502 \u2514\u2500\u2500 triu_indices(n: int, k: int, m: int) -> tuple\r\n\u251c\u2500\u2500 multiprec\r\n\u2502 \u251c\u2500\u2500 CLASS\r\n\u2502 \u2502 \u2514\u2500\u2500 MPComplex(object)/__init__(self: Any, real: Any, imag: Any, sigfigs: Any) -> Any\r\n\u2502 \u2514\u2500\u2500 FUNCTION\r\n\u2502 \u251c\u2500\u2500 _remove_trailing_zeros(value: typing.Any) -> str\r\n\u2502 \u251c\u2500\u2500 _setprec(sigfigs: int) -> Any\r\n\u2502 \u251c\u2500\u2500 asmpc(real: typing.Union[int, float, str, decimal.Decimal, complex, pypynum.multiprec.MPComplex], imag: typing.Union[int, float, str, decimal.Decimal], sigfigs: int) -> pypynum.multiprec.MPComplex\r\n\u2502 \u251c\u2500\u2500 frac2dec(frac: fractions.Fraction, sigfigs: int) -> decimal.Decimal\r\n\u2502 \u251c\u2500\u2500 mp_acos(x: typing.Union[int, float, str, decimal.Decimal], sigfigs: int) -> decimal.Decimal\r\n\u2502 \u251c\u2500\u2500 mp_asin(x: typing.Union[int, float, str, decimal.Decimal], sigfigs: int) -> decimal.Decimal\r\n\u2502 \u251c\u2500\u2500 mp_atan(x: typing.Union[int, float, str, decimal.Decimal], sigfigs: int) -> decimal.Decimal\r\n\u2502 \u251c\u2500\u2500 mp_atan2(y: typing.Union[int, float, str, decimal.Decimal], x: typing.Union[int, float, str, decimal.Decimal], sigfigs: int) -> decimal.Decimal\r\n\u2502 \u251c\u2500\u2500 mp_catalan(sigfigs: int) -> decimal.Decimal\r\n\u2502 \u251c\u2500\u2500 mp_cos(x: typing.Union[int, float, str, decimal.Decimal], sigfigs: int) -> decimal.Decimal\r\n\u2502 \u251c\u2500\u2500 mp_cosh(x: typing.Union[int, float, str, decimal.Decimal], sigfigs: int) -> decimal.Decimal\r\n\u2502 \u251c\u2500\u2500 mp_e(sigfigs: int, method: str) -> decimal.Decimal\r\n\u2502 \u251c\u2500\u2500 mp_euler_gamma(sigfigs: int) -> decimal.Decimal\r\n\u2502 \u251c\u2500\u2500 mp_exp(x: typing.Union[int, float, str, decimal.Decimal], sigfigs: int, builtin: bool) -> decimal.Decimal\r\n\u2502 \u251c\u2500\u2500 mp_fresnel_c(x: typing.Union[int, float, str, decimal.Decimal], sigfigs: int) -> decimal.Decimal\r\n\u2502 \u251c\u2500\u2500 mp_fresnel_s(x: typing.Union[int, float, str, decimal.Decimal], sigfigs: int) -> decimal.Decimal\r\n\u2502 \u251c\u2500\u2500 mp_ln(x: typing.Union[int, float, str, decimal.Decimal], sigfigs: int, builtin: bool) -> decimal.Decimal\r\n\u2502 \u251c\u2500\u2500 mp_log(x: typing.Union[int, float, str, decimal.Decimal], base: typing.Union[int, float, str, decimal.Decimal], sigfigs: int, builtin: bool) -> decimal.Decimal\r\n\u2502 \u251c\u2500\u2500 mp_phi(sigfigs: int, method: str) -> decimal.Decimal\r\n\u2502 \u251c\u2500\u2500 mp_pi(sigfigs: int, method: str) -> decimal.Decimal\r\n\u2502 \u251c\u2500\u2500 mp_sin(x: typing.Union[int, float, str, decimal.Decimal], sigfigs: int) -> decimal.Decimal\r\n\u2502 \u2514\u2500\u2500 mp_sinh(x: typing.Union[int, float, str, decimal.Decimal], sigfigs: int) -> decimal.Decimal\r\n\u251c\u2500\u2500 networks\r\n\u2502 \u251c\u2500\u2500 CLASS\r\n\u2502 \u2502 \u2514\u2500\u2500 NeuralNetwork(object)/__init__(self: Any, _input: Any, _hidden: Any, _output: Any) -> Any\r\n\u2502 \u2514\u2500\u2500 FUNCTION\r\n\u2502 \u2514\u2500\u2500 neuraln(_input: Any, _hidden: Any, _output: Any) -> Any\r\n\u251c\u2500\u2500 numbers\r\n\u2502 \u251c\u2500\u2500 CLASS\r\n\u2502 \u2514\u2500\u2500 FUNCTION\r\n\u2502 \u251c\u2500\u2500 float2fraction(number: float, mixed: bool, error: float) -> tuple\r\n\u2502 \u251c\u2500\u2500 int2roman(integer: int, overline: bool) -> str\r\n\u2502 \u251c\u2500\u2500 int2words(integer: int) -> str\r\n\u2502 \u251c\u2500\u2500 parse_float(s: str) -> tuple\r\n\u2502 \u251c\u2500\u2500 roman2int(roman_num: str) -> int\r\n\u2502 \u251c\u2500\u2500 split_float(s: str) -> tuple\r\n\u2502 \u2514\u2500\u2500 str2int(string: str) -> int\r\n\u251c\u2500\u2500 plotting\r\n\u2502 \u251c\u2500\u2500 CLASS\r\n\u2502 \u2514\u2500\u2500 FUNCTION\r\n\u2502 \u251c\u2500\u2500 background(right: typing.Union[int, float], left: typing.Union[int, float], top: typing.Union[int, float], bottom: typing.Union[int, float], complexity: typing.Union[int, float], ratio: typing.Union[int, float], string: bool) -> typing.Union[list, str]\r\n\u2502 \u251c\u2500\u2500 binary(function: Any, right: typing.Union[int, float], left: typing.Union[int, float], top: typing.Union[int, float], bottom: typing.Union[int, float], complexity: typing.Union[int, float], ratio: typing.Union[int, float], error: Any, compare: Any, string: bool, basic: list, character: str, data: bool, coloration: Any) -> typing.Union[list, str]\r\n\u2502 \u251c\u2500\u2500 c_unary(function: Any, projection: str, right: typing.Union[int, float], left: typing.Union[int, float], top: typing.Union[int, float], bottom: typing.Union[int, float], complexity: typing.Union[int, float], ratio: typing.Union[int, float], string: bool, basic: list, character: str, data: bool, coloration: Any) -> typing.Union[list, str]\r\n\u2502 \u251c\u2500\u2500 change(data: typing.Union[list, str]) -> typing.Union[list, str]\r\n\u2502 \u251c\u2500\u2500 color(text: str, rgb: typing.Union[list, tuple]) -> str\r\n\u2502 \u2514\u2500\u2500 unary(function: Any, right: typing.Union[int, float], left: typing.Union[int, float], top: typing.Union[int, float], bottom: typing.Union[int, float], complexity: typing.Union[int, float], ratio: typing.Union[int, float], string: bool, basic: list, character: str, data: bool, coloration: Any) -> typing.Union[list, str]\r\n\u251c\u2500\u2500 polys\r\n\u2502 \u251c\u2500\u2500 CLASS\r\n\u2502 \u2502 \u2514\u2500\u2500 Polynomial(object)/__init__(self: Any, terms: Any) -> Any\r\n\u2502 \u2514\u2500\u2500 FUNCTION\r\n\u2502 \u251c\u2500\u2500 chebgauss(n: Any) -> Any\r\n\u2502 \u251c\u2500\u2500 chebpoly(n: Any, single: Any) -> Any\r\n\u2502 \u251c\u2500\u2500 from_coeffs(coeffs: Any) -> Any\r\n\u2502 \u251c\u2500\u2500 from_coords(coords: Any) -> Any\r\n\u2502 \u251c\u2500\u2500 laggauss(n: Any) -> Any\r\n\u2502 \u251c\u2500\u2500 lagpoly(n: Any, single: Any) -> Any\r\n\u2502 \u251c\u2500\u2500 leggauss(n: Any) -> Any\r\n\u2502 \u251c\u2500\u2500 legpoly(n: Any, single: Any) -> Any\r\n\u2502 \u2514\u2500\u2500 poly(terms: Any) -> Any\r\n\u251c\u2500\u2500 pprinters\r\n\u2502 \u251c\u2500\u2500 CLASS\r\n\u2502 \u2514\u2500\u2500 FUNCTION\r\n\u2502 \u2514\u2500\u2500 pprint_matrix(matrix: Any, style: Any, output: Any) -> Any\r\n\u251c\u2500\u2500 quats\r\n\u2502 \u251c\u2500\u2500 CLASS\r\n\u2502 \u2502 \u251c\u2500\u2500 Euler(object)/__init__(self: Any, y: typing.Union[int, float], p: typing.Union[int, float], r: typing.Union[int, float]) -> Any\r\n\u2502 \u2502 \u2514\u2500\u2500 Quaternion(object)/__init__(self: Any, w: typing.Union[int, float], x: typing.Union[int, float], y: typing.Union[int, float], z: typing.Union[int, float]) -> Any\r\n\u2502 \u2514\u2500\u2500 FUNCTION\r\n\u2502 \u251c\u2500\u2500 convert(data: typing.Union[pypynum.quats.Quaternion, pypynum.matrices.Matrix, pypynum.quats.Euler], to: str) -> typing.Union[pypynum.quats.Quaternion, pypynum.matrices.Matrix, pypynum.quats.Euler]\r\n\u2502 \u251c\u2500\u2500 euler(yaw: typing.Union[int, float], pitch: typing.Union[int, float], roll: typing.Union[int, float]) -> pypynum.quats.Euler\r\n\u2502 \u2514\u2500\u2500 quat(w: typing.Union[int, float], x: typing.Union[int, float], y: typing.Union[int, float], z: typing.Union[int, float]) -> pypynum.quats.Quaternion\r\n\u251c\u2500\u2500 random\r\n\u2502 \u251c\u2500\u2500 CLASS\r\n\u2502 \u2514\u2500\u2500 FUNCTION\r\n\u2502 \u251c\u2500\u2500 __create_nested_list(dimensions: Any, func: Any) -> Any\r\n\u2502 \u251c\u2500\u2500 __validate_shape(shape: Any) -> Any\r\n\u2502 \u251c\u2500\u2500 choice(seq: typing.Union[list, tuple, str], shape: typing.Union[list, tuple]) -> Any\r\n\u2502 \u251c\u2500\u2500 gauss(mu: typing.Union[int, float], sigma: typing.Union[int, float], shape: typing.Union[list, tuple]) -> typing.Union[float, list]\r\n\u2502 \u251c\u2500\u2500 rand(shape: typing.Union[list, tuple]) -> typing.Union[float, list]\r\n\u2502 \u251c\u2500\u2500 randint(a: int, b: int, shape: typing.Union[list, tuple]) -> typing.Union[int, list]\r\n\u2502 \u2514\u2500\u2500 uniform(a: typing.Union[int, float], b: typing.Union[int, float], shape: typing.Union[list, tuple]) -> typing.Union[float, list]\r\n\u251c\u2500\u2500 regs\r\n\u2502 \u251c\u2500\u2500 CLASS\r\n\u2502 \u2514\u2500\u2500 FUNCTION\r\n\u2502 \u251c\u2500\u2500 lin_reg(x: typing.Union[list, tuple], y: typing.Union[list, tuple]) -> list\r\n\u2502 \u251c\u2500\u2500 par_reg(x: typing.Union[list, tuple], y: typing.Union[list, tuple]) -> list\r\n\u2502 \u2514\u2500\u2500 poly_reg(x: typing.Union[list, tuple], y: typing.Union[list, tuple], n: int) -> list\r\n\u251c\u2500\u2500 seqs\r\n\u2502 \u251c\u2500\u2500 CLASS\r\n\u2502 \u2514\u2500\u2500 FUNCTION\r\n\u2502 \u251c\u2500\u2500 arithmetic_sequence(a1: typing.Union[int, float], an: typing.Union[int, float], d: typing.Union[int, float], n: typing.Union[int, float], s: typing.Union[int, float]) -> dict\r\n\u2502 \u251c\u2500\u2500 bell_triangle(n: int) -> list\r\n\u2502 \u251c\u2500\u2500 bernoulli(n: int, single: bool) -> typing.Union[list, tuple]\r\n\u2502 \u251c\u2500\u2500 catalan(n: int, single: bool) -> typing.Union[int, list]\r\n\u2502 \u251c\u2500\u2500 farey(n: int) -> list\r\n\u2502 \u251c\u2500\u2500 fibonacci(n: int, single: bool) -> typing.Union[int, list]\r\n\u2502 \u251c\u2500\u2500 geometric_sequence(a1: typing.Union[int, float], an: typing.Union[int, float], r: typing.Union[int, float], n: typing.Union[int, float], s: typing.Union[int, float]) -> dict\r\n\u2502 \u251c\u2500\u2500 lucas(n: int, single: bool) -> typing.Union[int, list]\r\n\u2502 \u251c\u2500\u2500 padovan(n: int, single: bool) -> typing.Union[int, list]\r\n\u2502 \u251c\u2500\u2500 pascal_triangle(n: int) -> list\r\n\u2502 \u251c\u2500\u2500 pell(n: int, single: bool) -> typing.Union[int, list]\r\n\u2502 \u251c\u2500\u2500 pelllucas(n: int, single: bool) -> typing.Union[int, list]\r\n\u2502 \u251c\u2500\u2500 perrin(n: int, single: bool) -> typing.Union[int, list]\r\n\u2502 \u251c\u2500\u2500 recaman(n: int, single: bool) -> typing.Union[int, list]\r\n\u2502 \u251c\u2500\u2500 stirling1(n: int) -> list\r\n\u2502 \u251c\u2500\u2500 stirling2(n: int) -> list\r\n\u2502 \u251c\u2500\u2500 sylvester(n: int, single: bool) -> typing.Union[int, list]\r\n\u2502 \u251c\u2500\u2500 tetranacci(n: int, single: bool) -> typing.Union[int, list]\r\n\u2502 \u2514\u2500\u2500 tribonacci(n: int, single: bool) -> typing.Union[int, list]\r\n\u251c\u2500\u2500 special\r\n\u2502 \u251c\u2500\u2500 CLASS\r\n\u2502 \u2514\u2500\u2500 FUNCTION\r\n\u2502 \u251c\u2500\u2500 besseli0(x: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]\r\n\u2502 \u251c\u2500\u2500 besseli1(x: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]\r\n\u2502 \u251c\u2500\u2500 besseliv(v: typing.Union[int, float], x: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]\r\n\u2502 \u251c\u2500\u2500 besselj0(x: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]\r\n\u2502 \u251c\u2500\u2500 besselj1(x: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]\r\n\u2502 \u251c\u2500\u2500 besseljv(v: typing.Union[int, float], x: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]\r\n\u2502 \u251c\u2500\u2500 hyp0f1(b0: typing.Union[int, float, complex], z: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]\r\n\u2502 \u251c\u2500\u2500 hyp1f1(a0: typing.Union[int, float, complex], b0: typing.Union[int, float, complex], z: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]\r\n\u2502 \u251c\u2500\u2500 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]\r\n\u2502 \u251c\u2500\u2500 hyppfq(a: typing.Union[list, tuple], b: typing.Union[list, tuple], z: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]\r\n\u2502 \u251c\u2500\u2500 qbinomial(n: typing.Union[int, float, complex], m: typing.Union[int, float, complex], q: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]\r\n\u2502 \u251c\u2500\u2500 qfactorial(n: typing.Union[int, float, complex], q: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]\r\n\u2502 \u251c\u2500\u2500 qgamma(n: typing.Union[int, float, complex], q: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]\r\n\u2502 \u2514\u2500\u2500 qpochhammer(a: typing.Union[int, float, complex], q: typing.Union[int, float, complex], n: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]\r\n\u251c\u2500\u2500 stattest\r\n\u2502 \u251c\u2500\u2500 CLASS\r\n\u2502 \u2514\u2500\u2500 FUNCTION\r\n\u2502 \u251c\u2500\u2500 chi2_cont(contingency: list, lambda_: float, calc_p: bool, corr: bool) -> tuple\r\n\u2502 \u251c\u2500\u2500 chisquare(observed: list, expected: list) -> tuple\r\n\u2502 \u251c\u2500\u2500 kurttest(data: list, two_tailed: bool) -> tuple\r\n\u2502 \u251c\u2500\u2500 mediantest(samples: Any, ties: Any, lambda_: Any, corr: Any) -> Any\r\n\u2502 \u251c\u2500\u2500 normaltest(data: list) -> tuple\r\n\u2502 \u2514\u2500\u2500 skewtest(data: list, two_tailed: bool) -> tuple\r\n\u251c\u2500\u2500 symbols\r\n\u2502 \u251c\u2500\u2500 CLASS\r\n\u2502 \u2514\u2500\u2500 FUNCTION\r\n\u2502 \u2514\u2500\u2500 parse_expr(expr: str) -> list\r\n\u251c\u2500\u2500 tensors\r\n\u2502 \u251c\u2500\u2500 CLASS\r\n\u2502 \u2502 \u2514\u2500\u2500 Tensor(pypynum.arrays.Array)/__init__(self: Any, data: Any, check: Any) -> Any\r\n\u2502 \u2514\u2500\u2500 FUNCTION\r\n\u2502 \u251c\u2500\u2500 ten(data: list) -> pypynum.tensors.Tensor\r\n\u2502 \u2514\u2500\u2500 tensor_and_number(tensor: Any, operator: Any, number: Any) -> Any\r\n\u251c\u2500\u2500 test\r\n\u2502 \u251c\u2500\u2500 CLASS\r\n\u2502 \u2514\u2500\u2500 FUNCTION\r\n\u251c\u2500\u2500 this\r\n\u2502 \u251c\u2500\u2500 CLASS\r\n\u2502 \u2514\u2500\u2500 FUNCTION\r\n\u251c\u2500\u2500 tools\r\n\u2502 \u251c\u2500\u2500 CLASS\r\n\u2502 \u2514\u2500\u2500 FUNCTION\r\n\u2502 \u251c\u2500\u2500 classify(array: typing.Union[list, tuple]) -> dict\r\n\u2502 \u251c\u2500\u2500 cos_sim(seq1: typing.Union[list, tuple, str], seq2: typing.Union[list, tuple, str], is_vector: bool) -> float\r\n\u2502 \u251c\u2500\u2500 dedup(iterable: typing.Union[list, tuple, str]) -> typing.Union[list, tuple, str]\r\n\u2502 \u251c\u2500\u2500 fast_pow(a: typing.Any, n: int, init: typing.Any, mul: typing.Callable) -> typing.Any\r\n\u2502 \u251c\u2500\u2500 frange(start: typing.Union[int, float], stop: typing.Union[int, float], step: float) -> list\r\n\u2502 \u251c\u2500\u2500 geomspace(start: typing.Union[int, float], stop: typing.Union[int, float], number: int) -> list\r\n\u2502 \u251c\u2500\u2500 lcsubseq(x: typing.Union[list, tuple, str], y: typing.Union[list, tuple, str]) -> list\r\n\u2502 \u251c\u2500\u2500 lcsubstr(x: typing.Union[list, tuple, str], y: typing.Union[list, tuple, str]) -> list\r\n\u2502 \u251c\u2500\u2500 levenshtein(x: typing.Union[list, tuple, str], y: typing.Union[list, tuple, str]) -> int\r\n\u2502 \u251c\u2500\u2500 linspace(start: typing.Union[int, float], stop: typing.Union[int, float], number: int) -> list\r\n\u2502 \u251c\u2500\u2500 magic_square(n: int) -> list\r\n\u2502 \u251c\u2500\u2500 primality(n: int, iter_num: int) -> bool\r\n\u2502 \u251c\u2500\u2500 prime_factors(integer: int, dictionary: bool, pollard_rho: bool) -> typing.Union[list, dict]\r\n\u2502 \u251c\u2500\u2500 primes(limit: int) -> list\r\n\u2502 \u251c\u2500\u2500 replace(seq: typing.Union[list, tuple], old: typing.Union[list, tuple], new: typing.Union[list, tuple], count: int) -> typing.Union[list, tuple]\r\n\u2502 \u251c\u2500\u2500 semiprimes(limit: int) -> list\r\n\u2502 \u251c\u2500\u2500 split(iterable: typing.Union[list, tuple, str], key: typing.Union[list, tuple], retain: bool) -> list\r\n\u2502 \u2514\u2500\u2500 twinprimes(limit: int) -> list\r\n\u251c\u2500\u2500 trees\r\n\u2502 \u251c\u2500\u2500 CLASS\r\n\u2502 \u2502 \u251c\u2500\u2500 BTNode(object)/__init__(self: Any, data: Any) -> Any\r\n\u2502 \u2502 \u251c\u2500\u2500 BinaryTree(object)/__init__(self: Any, root: Any) -> Any\r\n\u2502 \u2502 \u251c\u2500\u2500 MTNode(object)/__init__(self: Any, data: Any) -> Any\r\n\u2502 \u2502 \u251c\u2500\u2500 MultiTree(object)/__init__(self: Any, root: Any) -> Any\r\n\u2502 \u2502 \u251c\u2500\u2500 RBTNode(object)/__init__(self: Any, data: Any, color: Any) -> Any\r\n\u2502 \u2502 \u2514\u2500\u2500 RedBlackTree(object)/__init__(self: Any) -> Any\r\n\u2502 \u2514\u2500\u2500 FUNCTION\r\n\u251c\u2500\u2500 types\r\n\u2502 \u251c\u2500\u2500 CLASS\r\n\u2502 \u2514\u2500\u2500 FUNCTION\r\n\u251c\u2500\u2500 ufuncs\r\n\u2502 \u251c\u2500\u2500 CLASS\r\n\u2502 \u2514\u2500\u2500 FUNCTION\r\n\u2502 \u251c\u2500\u2500 add(x: Any, y: Any) -> Any\r\n\u2502 \u251c\u2500\u2500 apply(a: Any, func: Any, rtype: Any) -> Any\r\n\u2502 \u251c\u2500\u2500 base_ufunc(arrays: Any, func: Any, args: Any, rtype: Any) -> Any\r\n\u2502 \u251c\u2500\u2500 divide(x: Any, y: Any) -> Any\r\n\u2502 \u251c\u2500\u2500 eq(x: Any, y: Any) -> Any\r\n\u2502 \u251c\u2500\u2500 floor_divide(x: Any, y: Any) -> Any\r\n\u2502 \u251c\u2500\u2500 ge(x: Any, y: Any) -> Any\r\n\u2502 \u251c\u2500\u2500 gt(x: Any, y: Any) -> Any\r\n\u2502 \u251c\u2500\u2500 le(x: Any, y: Any) -> Any\r\n\u2502 \u251c\u2500\u2500 lt(x: Any, y: Any) -> Any\r\n\u2502 \u251c\u2500\u2500 modulo(x: Any, y: Any) -> Any\r\n\u2502 \u251c\u2500\u2500 multiply(x: Any, y: Any) -> Any\r\n\u2502 \u251c\u2500\u2500 ne(x: Any, y: Any) -> Any\r\n\u2502 \u251c\u2500\u2500 power(x: Any, y: Any, m: Any) -> Any\r\n\u2502 \u251c\u2500\u2500 subtract(x: Any, y: Any) -> Any\r\n\u2502 \u2514\u2500\u2500 ufunc_helper(x: Any, y: Any, func: Any) -> Any\r\n\u251c\u2500\u2500 utils\r\n\u2502 \u251c\u2500\u2500 CLASS\r\n\u2502 \u2502 \u251c\u2500\u2500 InfIterator(object)/__init__(self: Any, start: typing.Union[int, float, complex], mode: str, common: typing.Union[int, float, complex]) -> Any\r\n\u2502 \u2502 \u251c\u2500\u2500 IntervalSet(object)/__init__(self: Any, intervals: Any) -> Any\r\n\u2502 \u2502 \u251c\u2500\u2500 LinkedList(object)/__init__(self: Any) -> Any\r\n\u2502 \u2502 \u251c\u2500\u2500 LinkedListNode(object)/__init__(self: Any, value: Any, next_node: Any) -> Any\r\n\u2502 \u2502 \u2514\u2500\u2500 OrderedSet(object)/__init__(self: Any, sequence: Any) -> Any\r\n\u2502 \u2514\u2500\u2500 FUNCTION\r\n\u251c\u2500\u2500 vectors\r\n\u2502 \u251c\u2500\u2500 CLASS\r\n\u2502 \u2502 \u2514\u2500\u2500 Vector(pypynum.arrays.Array)/__init__(self: Any, data: Any, check: Any) -> Any\r\n\u2502 \u2514\u2500\u2500 FUNCTION\r\n\u2502 \u2514\u2500\u2500 vec(data: Any) -> Any\r\n\u2514\u2500\u2500 zh_cn\r\n \u251c\u2500\u2500 CLASS\r\n \u2514\u2500\u2500 FUNCTION\r\n \u251c\u2500\u2500 Fraction\u8f6c\u4e3aDecimal(\u5206\u6570\u5bf9\u8c61: fractions.Fraction, \u6709\u6548\u4f4d\u6570: int) -> decimal.Decimal\r\n \u251c\u2500\u2500 RC4\u4f2a\u968f\u673a\u751f\u6210\u7b97\u6cd5(\u5bc6\u94a5\u5e8f\u5217: list) -> Any\r\n \u251c\u2500\u2500 RC4\u521d\u59cb\u5316\u5bc6\u94a5\u8c03\u5ea6\u7b97\u6cd5(\u5bc6\u94a5: bytes) -> list\r\n \u251c\u2500\u2500 RC4\u5bc6\u7801(\u6587\u672c: bytes, \u5bc6\u94a5: bytes) -> bytes\r\n \u251c\u2500\u2500 ROT13\u5bc6\u7801(\u6587\u672c: str) -> str\r\n \u251c\u2500\u2500 S\u578b\u51fd\u6570(x: typing.Union[int, float]) -> typing.Union[int, float]\r\n \u251c\u2500\u2500 base64\u5bc6\u7801(\u6587\u672c: str, \u89e3\u5bc6: bool) -> str\r\n \u251c\u2500\u2500 x\u5bf9\u6570y\u4e58\u79ef(x: float, y: float) -> float\r\n \u251c\u2500\u2500 y\u6b21\u65b9\u6839(\u88ab\u5f00\u65b9\u6570: typing.Union[int, float, complex], \u5f00\u65b9\u6570: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]\r\n \u251c\u2500\u2500 \u4e00\u7ef4\u5085\u91cc\u53f6\u53d8\u6362(\u6570\u636e: Any) -> pypynum.fft.FT1D\r\n \u251c\u2500\u2500 \u4e0a\u4f3d\u739b(s: typing.Union[int, float, complex], x: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]\r\n \u251c\u2500\u2500 \u4e0a\u6807\u8f6c\u6574\u6570(\u4e0a\u6807\u5b57\u7b26\u4e32: str) -> str\r\n \u251c\u2500\u2500 \u4e0b\u4f3d\u739b(s: typing.Union[int, float, complex], x: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]\r\n \u251c\u2500\u2500 \u4e0b\u6807\u8f6c\u6574\u6570(\u4e0b\u6807\u5b57\u7b26\u4e32: str) -> str\r\n \u251c\u2500\u2500 \u4e2d\u4f4d\u6570(\u6570\u636e: typing.List[float]) -> float\r\n \u251c\u2500\u2500 \u4e2d\u56fd\u5269\u4f59\u5b9a\u7406(n: typing.List[int], a: typing.List[int]) -> int\r\n \u251c\u2500\u2500 \u4e2d\u5fc3\u77e9(\u6570\u636e: typing.List[float], \u9636\u6570: int) -> float\r\n \u251c\u2500\u2500 \u4e58\u79ef\u548c(\u591a\u4e2a\u6570\u7ec4: typing.List[typing.Any]) -> float\r\n \u251c\u2500\u2500 \u4ee3\u66ff\u5bc6\u7801(\u6587\u672c: str, \u66ff\u6362\u6620\u5c04: dict, \u89e3\u5bc6: bool) -> str\r\n \u251c\u2500\u2500 \u4f17\u6570(\u6570\u636e: typing.List[typing.Any]) -> Any\r\n \u251c\u2500\u2500 \u4f3d\u739b\u51fd\u6570(alpha: float) -> float\r\n \u251c\u2500\u2500 \u4f59\u5207(x: typing.Union[int, float]) -> typing.Union[int, float]\r\n \u251c\u2500\u2500 \u4f59\u5272(x: typing.Union[int, float]) -> typing.Union[int, float]\r\n \u251c\u2500\u2500 \u4f59\u5f26(x: typing.Union[int, float]) -> typing.Union[int, float]\r\n \u251c\u2500\u2500 \u504f\u5ea6(\u6570\u636e: typing.List[float]) -> float\r\n \u251c\u2500\u2500 \u5168\u4e00(\u5f62\u72b6: Any, \u8fd4\u56de\u7c7b\u578b: Any) -> Any\r\n \u251c\u2500\u2500 \u5168\u90e8\u586b\u5145(\u5f62\u72b6: Any, \u586b\u5145\u503c: Any, \u8fd4\u56de\u7c7b\u578b: Any) -> Any\r\n \u251c\u2500\u2500 \u5168\u96f6(\u5f62\u72b6: Any, \u8fd4\u56de\u7c7b\u578b: Any) -> Any\r\n \u251c\u2500\u2500 \u5199\u5165(\u6587\u4ef6: str, \u5bf9\u8c61: object) -> Any\r\n \u251c\u2500\u2500 \u51e0\u4f55\u5e73\u5747\u6570(\u6570\u636e: typing.List[float]) -> float\r\n \u251c\u2500\u2500 \u51ef\u6492\u5bc6\u7801(\u6587\u672c: str, \u79fb\u4f4d: int, \u89e3\u5bc6: bool) -> str\r\n \u251c\u2500\u2500 \u5206\u4f4d\u6570(\u6570\u636e: list, \u5206\u4f4d\u503c: float, \u63d2\u503c\u65b9\u6cd5: str, \u5df2\u6392\u5e8f: bool) -> float\r\n \u251c\u2500\u2500 \u5224\u5b9a\u7cfb\u6570(x: typing.List[float], y: typing.List[float]) -> float\r\n \u251c\u2500\u2500 \u5224\u65ad\u5e73\u65b9\u6570(n: int) -> bool\r\n \u251c\u2500\u2500 \u52a0\u6743\u5e73\u5747(\u6570\u636e: typing.List[float], \u6743\u91cd: typing.List[float]) -> float\r\n \u251c\u2500\u2500 \u534f\u65b9\u5dee(x: typing.List[float], y: typing.List[float], \u81ea\u7531\u5ea6: int) -> float\r\n \u251c\u2500\u2500 \u539f\u6839(a: int, \u5355\u4e2a: bool) -> typing.Union[int, typing.List[int]]\r\n \u251c\u2500\u2500 \u539f\u70b9\u77e9(\u6570\u636e: typing.List[float], \u9636\u6570: int) -> float\r\n \u251c\u2500\u2500 \u53cc\u66f2\u4f59\u5207(x: typing.Union[int, float]) -> typing.Union[int, float]\r\n \u251c\u2500\u2500 \u53cc\u66f2\u4f59\u5272(x: typing.Union[int, float]) -> typing.Union[int, float]\r\n \u251c\u2500\u2500 \u53cc\u66f2\u4f59\u5f26(x: typing.Union[int, float]) -> typing.Union[int, float]\r\n \u251c\u2500\u2500 \u53cc\u66f2\u6b63\u5207(x: typing.Union[int, float]) -> typing.Union[int, float]\r\n \u251c\u2500\u2500 \u53cc\u66f2\u6b63\u5272(x: typing.Union[int, float]) -> typing.Union[int, float]\r\n \u251c\u2500\u2500 \u53cc\u66f2\u6b63\u5f26(x: typing.Union[int, float]) -> typing.Union[int, float]\r\n \u251c\u2500\u2500 \u53cd\u4f59\u5207(x: typing.Union[int, float]) -> typing.Union[int, float]\r\n \u251c\u2500\u2500 \u53cd\u4f59\u5272(x: typing.Union[int, float]) -> typing.Union[int, float]\r\n \u251c\u2500\u2500 \u53cd\u4f59\u5f26(x: typing.Union[int, float]) -> typing.Union[int, float]\r\n \u251c\u2500\u2500 \u53cd\u53cc\u66f2\u4f59\u5207(x: typing.Union[int, float]) -> typing.Union[int, float]\r\n \u251c\u2500\u2500 \u53cd\u53cc\u66f2\u4f59\u5272(x: typing.Union[int, float]) -> typing.Union[int, float]\r\n \u251c\u2500\u2500 \u53cd\u53cc\u66f2\u4f59\u5f26(x: typing.Union[int, float]) -> typing.Union[int, float]\r\n \u251c\u2500\u2500 \u53cd\u53cc\u66f2\u6b63\u5207(x: typing.Union[int, float]) -> typing.Union[int, float]\r\n \u251c\u2500\u2500 \u53cd\u53cc\u66f2\u6b63\u5272(x: typing.Union[int, float]) -> typing.Union[int, float]\r\n \u251c\u2500\u2500 \u53cd\u53cc\u66f2\u6b63\u5f26(x: typing.Union[int, float]) -> typing.Union[int, float]\r\n \u251c\u2500\u2500 \u53cd\u6b63\u5207(x: typing.Union[int, float]) -> typing.Union[int, float]\r\n \u251c\u2500\u2500 \u53cd\u6b63\u5272(x: typing.Union[int, float]) -> typing.Union[int, float]\r\n \u251c\u2500\u2500 \u53cd\u6b63\u5f26(x: typing.Union[int, float]) -> typing.Union[int, float]\r\n \u251c\u2500\u2500 \u53ef\u80fd\u662f\u5e73\u65b9\u6570(n: int) -> bool\r\n \u251c\u2500\u2500 \u586b\u5145\u5e8f\u5217(\u5f62\u72b6: Any, \u5e8f\u5217: Any, \u91cd\u590d: Any, \u586b\u5145: Any, \u8fd4\u56de\u7c7b\u578b: Any) -> Any\r\n \u251c\u2500\u2500 \u591a\u6b21\u65b9\u6839\u53d6\u6574(\u88ab\u5f00\u65b9\u6570: int, \u5f00\u65b9\u6570: int) -> int\r\n \u251c\u2500\u2500 \u591a\u7cbe\u5ea6\u4f59\u5f26(x: typing.Union[int, float], \u6709\u6548\u4f4d\u6570: int) -> decimal.Decimal\r\n \u251c\u2500\u2500 \u591a\u7cbe\u5ea6\u53cc\u66f2\u4f59\u5f26(x: typing.Union[int, float], \u6709\u6548\u4f4d\u6570: int) -> decimal.Decimal\r\n \u251c\u2500\u2500 \u591a\u7cbe\u5ea6\u53cc\u66f2\u6b63\u5f26(x: typing.Union[int, float], \u6709\u6548\u4f4d\u6570: int) -> decimal.Decimal\r\n \u251c\u2500\u2500 \u591a\u7cbe\u5ea6\u53cd\u4f59\u5f26(x: typing.Union[int, float], \u6709\u6548\u4f4d\u6570: int) -> decimal.Decimal\r\n \u251c\u2500\u2500 \u591a\u7cbe\u5ea6\u53cd\u6b63\u5207(x: typing.Union[int, float], \u6709\u6548\u4f4d\u6570: int) -> decimal.Decimal\r\n \u251c\u2500\u2500 \u591a\u7cbe\u5ea6\u53cd\u6b63\u5f26(x: typing.Union[int, float], \u6709\u6548\u4f4d\u6570: int) -> decimal.Decimal\r\n \u251c\u2500\u2500 \u591a\u7cbe\u5ea6\u5706\u5468\u7387(\u6709\u6548\u4f4d\u6570: int, \u65b9\u6cd5: str) -> decimal.Decimal\r\n \u251c\u2500\u2500 \u591a\u7cbe\u5ea6\u590d\u6570(\u5b9e\u90e8: typing.Union[int, float, str, decimal.Decimal], \u865a\u90e8: typing.Union[int, float, str, decimal.Decimal], \u6709\u6548\u4f4d\u6570: int) -> pypynum.multiprec.MPComplex\r\n \u251c\u2500\u2500 \u591a\u7cbe\u5ea6\u5bf9\u6570(\u771f\u6570: typing.Union[int, float], \u5e95\u6570: typing.Union[int, float], \u6709\u6548\u4f4d\u6570: int, \u4f7f\u7528\u5185\u7f6e\u65b9\u6cd5: bool) -> decimal.Decimal\r\n \u251c\u2500\u2500 \u591a\u7cbe\u5ea6\u65b9\u4f4d\u89d2(y: typing.Union[int, float], x: typing.Union[int, float], \u6709\u6548\u4f4d\u6570: int) -> decimal.Decimal\r\n \u251c\u2500\u2500 \u591a\u7cbe\u5ea6\u6b27\u62c9\u4f3d\u9a6c(\u6709\u6548\u4f4d\u6570: int) -> decimal.Decimal\r\n \u251c\u2500\u2500 \u591a\u7cbe\u5ea6\u6b63\u5f26(x: typing.Union[int, float], \u6709\u6548\u4f4d\u6570: int) -> decimal.Decimal\r\n \u251c\u2500\u2500 \u591a\u7cbe\u5ea6\u81ea\u7136\u5bf9\u6570(\u771f\u6570: typing.Union[int, float], \u6709\u6548\u4f4d\u6570: int, \u4f7f\u7528\u5185\u7f6e\u65b9\u6cd5: bool) -> decimal.Decimal\r\n \u251c\u2500\u2500 \u591a\u7cbe\u5ea6\u81ea\u7136\u5e38\u6570(\u6709\u6548\u4f4d\u6570: int, \u65b9\u6cd5: str) -> decimal.Decimal\r\n \u251c\u2500\u2500 \u591a\u7cbe\u5ea6\u81ea\u7136\u6307\u6570(\u6307\u6570: typing.Union[int, float], \u6709\u6548\u4f4d\u6570: int, \u4f7f\u7528\u5185\u7f6e\u65b9\u6cd5: bool) -> decimal.Decimal\r\n \u251c\u2500\u2500 \u591a\u7cbe\u5ea6\u83f2\u6d85\u8033\u4f59\u5f26\u79ef\u5206(x: typing.Union[int, float], \u6709\u6548\u4f4d\u6570: int) -> decimal.Decimal\r\n \u251c\u2500\u2500 \u591a\u7cbe\u5ea6\u83f2\u6d85\u8033\u6b63\u5f26\u79ef\u5206(x: typing.Union[int, float], \u6709\u6548\u4f4d\u6570: int) -> decimal.Decimal\r\n \u251c\u2500\u2500 \u591a\u7cbe\u5ea6\u9ec4\u91d1\u5206\u5272\u7387(\u6709\u6548\u4f4d\u6570: int, \u65b9\u6cd5: str) -> decimal.Decimal\r\n \u251c\u2500\u2500 \u591a\u9879\u5f0f\u65b9\u7a0b(\u7cfb\u6570: list) -> list\r\n \u251c\u2500\u2500 \u5b57\u7b26\u4e32\u8f6c\u6574\u6570(\u5b57\u7b26\u4e32: str) -> int\r\n \u251c\u2500\u2500 \u5bfc\u6570(\u51fd\u6570: Any, \u53c2\u6570: float, \u6b65\u957f: float, \u989d\u5916\u53c2\u6570: Any, \u989d\u5916\u5173\u952e\u5b57\u53c2\u6570: Any) -> float\r\n \u251c\u2500\u2500 \u5cf0\u5ea6(\u6570\u636e: typing.List[float], \u8d39\u5e0c\u5c14: bool) -> float\r\n \u251c\u2500\u2500 \u5e0c\u5c14256\u5bc6\u7801(\u6587\u672c: bytes, \u5bc6\u94a5: list, \u89e3\u5bc6: bool) -> bytes\r\n \u251c\u2500\u2500 \u5e73\u5747\u6570(\u6570\u636e: typing.List[float]) -> float\r\n \u251c\u2500\u2500 \u5e73\u65b9\u5e73\u5747\u6570(\u6570\u636e: typing.List[float]) -> float\r\n \u251c\u2500\u2500 \u5e73\u65b9\u6839\u53d6\u6574(\u88ab\u5f00\u65b9\u6570: int) -> int\r\n \u251c\u2500\u2500 \u5e8f\u5217\u6eda\u52a8(\u5e8f\u5217: typing.Iterator[typing.Any], \u504f\u79fb: int) -> typing.Iterator[typing.Any]\r\n \u251c\u2500\u2500 \u5f52\u4e00\u5316(\u6570\u636e: typing.List[float], \u76ee\u6807: float) -> typing.List[float]\r\n \u251c\u2500\u2500 \u6269\u5c55\u6b27\u51e0\u91cc\u5f97\u7b97\u6cd5(a: int, b: int) -> typing.Tuple[int, int, int]\r\n \u251c\u2500\u2500 \u62c6\u5206\u6d6e\u70b9\u6570\u5b57\u7b26\u4e32(\u5b57\u7b26\u4e32: str) -> tuple\r\n \u251c\u2500\u2500 \u6392\u5217\u6570(\u603b\u6570: int, \u9009\u53d6\u6570: int) -> int\r\n \u251c\u2500\u2500 \u6570\u7ec4(\u6570\u636e: list, \u68c0\u67e5: bool) -> pypynum.arrays.Array\r\n \u251c\u2500\u2500 \u6574\u6570\u8f6c\u4e0a\u6807(\u6807\u51c6\u5b57\u7b26\u4e32: str) -> str\r\n \u251c\u2500\u2500 \u6574\u6570\u8f6c\u4e0b\u6807(\u6807\u51c6\u5b57\u7b26\u4e32: str) -> str\r\n \u251c\u2500\u2500 \u6574\u6570\u8f6c\u5355\u8bcd(\u6574\u6570: int) -> str\r\n \u251c\u2500\u2500 \u6574\u6570\u8f6c\u7f57\u9a6c\u6570(\u6574\u6570: int, \u4e0a\u5212\u7ebf: bool) -> str\r\n \u251c\u2500\u2500 \u65b9\u5dee(\u6570\u636e: typing.List[float], \u81ea\u7531\u5ea6: int) -> float\r\n \u251c\u2500\u2500 \u666e\u83b1\u8d39\u5c14\u5bc6\u7801(\u6587\u672c: str, \u5bc6\u94a5: str, \u89e3\u5bc6: bool) -> str\r\n \u251c\u2500\u2500 \u6700\u5927\u516c\u7ea6\u6570(args: int) -> int\r\n \u251c\u2500\u2500 \u6700\u5c0f\u516c\u500d\u6570(args: int) -> int\r\n \u251c\u2500\u2500 \u6781\u5dee(\u6570\u636e: typing.List[float]) -> float\r\n \u251c\u2500\u2500 \u6807\u51c6\u5dee(\u6570\u636e: typing.List[float], \u81ea\u7531\u5ea6: int) -> float\r\n \u251c\u2500\u2500 \u6a21\u8fd0\u7b97\u9636(a: int, n: int, b: int) -> int\r\n \u251c\u2500\u2500 \u6b27\u62c9\u51fd\u6570(n: int) -> int\r\n \u251c\u2500\u2500 \u6b63\u5207(x: typing.Union[int, float]) -> typing.Union[int, float]\r\n \u251c\u2500\u2500 \u6b63\u5272(x: typing.Union[int, float]) -> typing.Union[int, float]\r\n \u251c\u2500\u2500 \u6b63\u5f26(x: typing.Union[int, float]) -> typing.Union[int, float]\r\n \u251c\u2500\u2500 \u6d6e\u70b9\u6570\u8f6c\u5206\u6570(\u6570\u503c: float, \u662f\u5426\u5e26\u5206\u6570: bool, \u8bef\u5dee: float) -> tuple\r\n \u251c\u2500\u2500 \u76f8\u5173\u7cfb\u6570(x: typing.List[float], y: typing.List[float]) -> float\r\n \u251c\u2500\u2500 \u79ef\u5206(\u51fd\u6570: Any, \u79ef\u5206\u5f00\u59cb: float, \u79ef\u5206\u7ed3\u675f: float, \u79ef\u5206\u70b9\u6570: int, \u989d\u5916\u53c2\u6570: Any, \u989d\u5916\u5173\u952e\u5b57\u53c2\u6570: Any) -> float\r\n \u251c\u2500\u2500 \u79ef\u7d2f\u4e58\u79ef(\u6570\u636e: typing.List[float]) -> float\r\n \u251c\u2500\u2500 \u7b26\u53f7\u51fd\u6570(x: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]\r\n \u251c\u2500\u2500 \u7c7b\u4f3c\u5f62\u72b6\u5168\u4e00(\u6570\u7ec4A: Any, \u8fd4\u56de\u7c7b\u578b: Any) -> Any\r\n \u251c\u2500\u2500 \u7c7b\u4f3c\u5f62\u72b6\u5168\u96f6(\u6570\u7ec4A: Any, \u8fd4\u56de\u7c7b\u578b: Any) -> Any\r\n \u251c\u2500\u2500 \u7c7b\u4f3c\u5f62\u72b6\u586b\u5145(\u6570\u7ec4A: Any, \u586b\u5145\u503c: Any, \u8fd4\u56de\u7c7b\u578b: Any) -> Any\r\n \u251c\u2500\u2500 \u7d2f\u4e58\u79ef(\u5e8f\u5217: typing.List[float]) -> typing.List[float]\r\n \u251c\u2500\u2500 \u7d2f\u52a0\u548c(\u5e8f\u5217: typing.List[float]) -> typing.List[float]\r\n \u251c\u2500\u2500 \u7ebf\u6027\u65b9\u7a0b\u7ec4(\u5de6\u8fb9: list, \u53f3\u8fb9: list) -> list\r\n \u251c\u2500\u2500 \u7ec4\u5408\u6570(\u603b\u6570: int, \u9009\u53d6\u6570: int) -> int\r\n \u251c\u2500\u2500 \u7ef4\u5409\u5c3c\u4e9a\u5bc6\u7801(\u6587\u672c: str, \u5bc6\u94a5: str, \u89e3\u5bc6: bool) -> str\r\n \u251c\u2500\u2500 \u7f57\u9a6c\u6570\u8f6c\u6574\u6570(\u7f57\u9a6c\u6570: str) -> int\r\n \u251c\u2500\u2500 \u81ea\u7136\u5bf9\u6570(\u771f\u6570: typing.Union[int, float]) -> typing.Union[int, float]\r\n \u251c\u2500\u2500 \u81ea\u7136\u6307\u6570(\u6307\u6570: typing.Union[int, float]) -> typing.Union[int, float]\r\n \u251c\u2500\u2500 \u83ab\u5c14\u65af\u5bc6\u7801(\u6587\u672c: str, \u89e3\u5bc6: bool) -> str\r\n \u251c\u2500\u2500 \u89e3\u6790\u6d6e\u70b9\u6570\u5b57\u7b26\u4e32(\u5b57\u7b26\u4e32: str) -> tuple\r\n \u251c\u2500\u2500 \u8bef\u5dee\u51fd\u6570(x: typing.Union[int, float]) -> typing.Union[int, float]\r\n \u251c\u2500\u2500 \u8bfb\u53d6(\u6587\u4ef6: str) -> list\r\n \u251c\u2500\u2500 \u8c03\u548c\u5e73\u5747\u6570(\u6570\u636e: typing.List[float]) -> float\r\n \u251c\u2500\u2500 \u8d1d\u5854\u51fd\u6570(p: float, q: float) -> float\r\n \u251c\u2500\u2500 \u8d1d\u585e\u5c14\u51fd\u6570I0(x: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]\r\n \u251c\u2500\u2500 \u8d1d\u585e\u5c14\u51fd\u6570I1(x: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]\r\n \u251c\u2500\u2500 \u8d1d\u585e\u5c14\u51fd\u6570Iv(v: typing.Union[int, float], x: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]\r\n \u251c\u2500\u2500 \u8d1d\u585e\u5c14\u51fd\u6570J0(x: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]\r\n \u251c\u2500\u2500 \u8d1d\u585e\u5c14\u51fd\u6570J1(x: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]\r\n \u251c\u2500\u2500 \u8d1d\u585e\u5c14\u51fd\u6570Jv(v: typing.Union[int, float], x: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]\r\n \u251c\u2500\u2500 \u8d1f\u4e00\u6574\u6570\u6b21\u5e42(\u6307\u6570: int) -> int\r\n \u251c\u2500\u2500 \u8f6c\u4e3a\u591a\u7cbe\u5ea6\u590d\u6570(\u5b9e\u90e8: typing.Union[int, float, str, decimal.Decimal, complex, pypynum.multiprec.MPComplex], \u865a\u90e8: typing.Union[int, float, str, decimal.Decimal], \u6709\u6548\u4f4d\u6570: int) -> pypynum.multiprec.MPComplex\r\n \u251c\u2500\u2500 \u8f6c\u6362\u4e3a\u5217\u8868(\u6570\u636e: Any) -> list\r\n \u251c\u2500\u2500 \u8f6c\u6362\u4e3a\u6570\u7ec4(\u6570\u636e: Any) -> pypynum.arrays.Array\r\n \u251c\u2500\u2500 \u8fde\u7eed\u4e58\u79ef(\u4e0b\u754c: int, \u4e0a\u754c: int, \u51fd\u6570: typing.Callable) -> float\r\n \u251c\u2500\u2500 \u8fde\u7eed\u52a0\u548c(\u4e0b\u754c: int, \u4e0a\u754c: int, \u51fd\u6570: typing.Callable) -> float\r\n \u251c\u2500\u2500 \u9636\u4e58\u51fd\u6570(n: int) -> int\r\n \u251c\u2500\u2500 \u963f\u7279\u5df4\u4ec0\u5bc6\u7801(\u6587\u672c: str) -> str\r\n \u251c\u2500\u2500 \u9891\u7387\u7edf\u8ba1(\u6570\u636e: typing.List[typing.Any]) -> typing.Dict[typing.Any, int]\r\n \u2514\u2500\u2500 \u9ece\u66fc\u51fd\u6570(alpha: float) -> float\r\n```\r\n\r\n### Code Testing\r\n\r\n```python\r\nfrom pypynum import (arrays, geoms, logics, matrices, quats, symbols, tensors, vectors,\r\n ciphers, consts, equations, maths, plotting, random, regs, tools)\r\n\r\n...\r\n\r\nprint(arrays.array())\r\nprint(arrays.array([1, 2, 3, 4, 5, 6, 7, 8]))\r\nprint(arrays.array([[1, 2, 3, 4], [5, 6, 7, 8]]))\r\nprint(arrays.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]]))\r\n\r\n\"\"\"\r\n[]\r\n[1 2 3 4 5 6 7 8]\r\n[[1 2 3 4]\r\n [5 6 7 8]]\r\n[[[1 2]\r\n [3 4]]\r\n\r\n [[5 6]\r\n [7 8]]]\r\n\"\"\"\r\n\r\ntriangle = geoms.Triangle((0, 0), (2, 2), (3, 0))\r\nprint(triangle.perimeter())\r\nprint(triangle.area())\r\nprint(triangle.centroid())\r\n\r\n\"\"\"\r\n8.06449510224598\r\n3.0\r\n(1.6666666666666667, 0.6666666666666666)\r\n\"\"\"\r\n\r\na, b, c = 1, 1, 1\r\nadder0, adder1 = logics.HalfAdder(\"alpha\", a, b), logics.HalfAdder(\"beta\", c, None)\r\nxor0 = logics.XOR(\"alpha\")\r\nff0, ff1 = logics.DFF(\"alpha\"), logics.DFF(\"beta\")\r\nxor0.set_order0(1)\r\nxor0.set_order1(1)\r\nlogics.connector(adder0, adder1)\r\nlogics.connector(adder0, xor0)\r\nlogics.connector(adder1, xor0)\r\nlogics.connector(adder1, ff0)\r\nlogics.connector(xor0, ff1)\r\nprint(\"sum: {}, carry: {}\".format(ff0.out(), ff1.out()))\r\n\r\n\"\"\"\r\nsum: [1], carry: [1]\r\n\"\"\"\r\n\r\nm0 = matrices.mat([[1, 2], [3, 4]])\r\nm1 = matrices.mat([[5, 6], [7, 8]])\r\nprint(m0)\r\nprint(m1)\r\nprint(m0 + m1)\r\nprint(m0 @ m1)\r\nprint(m0.inv())\r\nprint(m1.rank())\r\n\r\n\"\"\"\r\n[[1 2]\r\n [3 4]]\r\n[[5 6]\r\n [7 8]]\r\n[[ 6 8]\r\n [10 12]]\r\n[[19 22]\r\n [43 50]]\r\n[[ -1.9999999999999996 0.9999999999999998]\r\n [ 1.4999999999999998 -0.49999999999999994]]\r\n2\r\n\"\"\"\r\n\r\nq0 = quats.quat(1, 2, 3, 4)\r\nq1 = quats.quat(5, 6, 7, 8)\r\nprint(q0)\r\nprint(q1)\r\nprint(q0 + q1)\r\nprint(q0 * q1)\r\nprint(q0.inverse())\r\nprint(q1.conjugate())\r\n\r\n\"\"\"\r\n(1+2i+3j+4k)\r\n(5+6i+7j+8k)\r\n(6+8i+10j+12k)\r\n(-60+12i+30j+24k)\r\n(0.18257418583505536+-0.3651483716701107i+-0.5477225575051661j+-0.7302967433402214k)\r\n(5+-6i+-7j+-8k)\r\n\"\"\"\r\n\r\nprint(symbols.BASIC)\r\nprint(symbols.ENGLISH)\r\nprint(symbols.GREEK)\r\nprint(symbols.parse_expr(\"-(10+a-(3.14+b0)*(-5))**(-\u03b6n1-2.718/m\u03a399)//9\"))\r\n\r\n\"\"\"\r\n%()*+-./0123456789\r\nABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz\r\n\u0391\u0392\u0393\u0394\u0395\u0396\u0397\u0398\u0399\u039a\u039b\u039c\u039d\u039e\u039f\u03a0\u03a1\u03a3\u03a4\u03a5\u03a6\u03a7\u03a8\u03a9\u03b1\u03b2\u03b3\u03b4\u03b5\u03b6\u03b7\u03b8\u03b9\u03ba\u03bb\u03bc\u03bd\u03be\u03bf\u03c0\u03c1\u03c3\u03c4\u03c5\u03c6\u03c7\u03c8\u03c9\r\n[['10', '+', 'a', '-', ['3.14', '+', 'b0'], '*', '-5'], '**', ['-\u03b6n1', '-', '2.718', '/', 'm\u03a399'], '//', '9']\r\n\"\"\"\r\n\r\nt0 = tensors.ten([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])\r\nt1 = tensors.ten([[[9, 10], [11, 12]], [[13, 14], [15, 16]]])\r\nprint(t0)\r\nprint(t1)\r\nprint(t0 + t1)\r\nprint(t0 @ t1)\r\n\r\n\"\"\"\r\n[[[1 2]\r\n [3 4]]\r\n\r\n [[5 6]\r\n [7 8]]]\r\n[[[ 9 10]\r\n [11 12]]\r\n\r\n [[13 14]\r\n [15 16]]]\r\n[[[10 12]\r\n [14 16]]\r\n\r\n [[18 20]\r\n [22 24]]]\r\n[[[ 31 34]\r\n [ 71 78]]\r\n\r\n [[155 166]\r\n [211 226]]]\r\n\"\"\"\r\n\r\nstring = \"PyPyNum\"\r\nencrypted = ciphers.caesar(string, 10)\r\nprint(string)\r\nprint(encrypted)\r\nprint(ciphers.caesar(encrypted, 10, decrypt=True))\r\nencrypted = ciphers.vigenere(string, \"ciphers\")\r\nprint(string)\r\nprint(encrypted)\r\nprint(ciphers.vigenere(encrypted, \"ciphers\", decrypt=True))\r\nencrypted = ciphers.morse(string)\r\nprint(string)\r\nprint(encrypted)\r\nprint(ciphers.morse(encrypted, decrypt=True))\r\n\r\n\"\"\"\r\nPyPyNum\r\nZiZiXew\r\nPyPyNum\r\nPyPyNum\r\nRgEfRle\r\nPyPyNum\r\nPyPyNum\r\n.--. -.-- .--. -.-- -. ..- --\r\nPYPYNUM\r\n\"\"\"\r\n\r\nv0 = vectors.vec([1, 2, 3, 4])\r\nv1 = vectors.vec([5, 6, 7, 8])\r\nprint(v0)\r\nprint(v1)\r\nprint(v0 + v1)\r\nprint(v0 @ v1)\r\nprint(v0.normalize())\r\nprint(v1.angles())\r\n\r\n\"\"\"\r\n[1 2 3 4]\r\n[5 6 7 8]\r\n[ 5 12 21 32]\r\n70\r\n[0.18257418583505536 0.3651483716701107 0.5477225575051661 0.7302967433402214]\r\n[1.1820279130506308, 1.0985826410133916, 1.0114070854293842, 0.9191723423169716]\r\n\"\"\"\r\n\r\nprint(consts.TB)\r\nprint(consts.e)\r\nprint(consts.h)\r\nprint(consts.phi)\r\nprint(consts.pi)\r\nprint(consts.tera)\r\n\r\n\"\"\"\r\n1099511627776\r\n2.718281828459045\r\n6.62607015e-34\r\n1.618033988749895\r\n3.141592653589793\r\n1000000000000\r\n\"\"\"\r\n\r\np = [1, -2, -3, 4]\r\nm = [\r\n [\r\n [1, 2, 3],\r\n [6, 10, 12],\r\n [7, 16, 9]\r\n ],\r\n [-1, -2, -3]\r\n]\r\nprint(equations.poly_eq(p))\r\nprint(equations.lin_eq(*m))\r\n\r\n\"\"\"\r\n[(-1.5615528128088307-6.5209667308287455e-24j), (1.0000000000000007+3.241554513744382e-25j), (2.5615528128088294+4.456233626665941e-24j)]\r\n[1.6666666666666665, -0.6666666666666666, -0.4444444444444444]\r\n\"\"\"\r\n\r\nprint(maths.cot(consts.pi / 3))\r\nprint(maths.gamma(1.5))\r\nprint(maths.pi(1, 10, lambda x: x ** 2))\r\nprint(maths.product([2, 3, 5, 7, 11, 13, 17, 19, 23, 29]))\r\nprint(maths.sigma(1, 10, lambda x: x ** 2))\r\nprint(maths.var([2, 3, 5, 7, 11, 13, 17, 19, 23, 29]))\r\n\r\n\"\"\"\r\n0.577350269189626\r\n0.886226925452758\r\n13168189440000\r\n6469693230\r\n385\r\n73.29\r\n\"\"\"\r\n\r\nplt = plotting.unary(lambda x: x ** 2, top=10, bottom=0, character=\"+\")\r\nprint(plt)\r\nprint(plotting.binary(lambda x, y: x ** 2 + y ** 2 - 10, right=10, left=0, compare=\"<=\", basic=plotting.change(plt)))\r\nprint(plotting.c_unary(lambda x: x ** x, right=2, left=-2, top=2, bottom=-2, complexity=20, character=\"-\"))\r\n\r\n\"\"\"\r\n 1.00e+01| + + \r\n | \r\n | + + \r\n | \r\n | + + \r\n | + + \r\n | \r\n | + + \r\n 5.00e+00|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _\r\n | + + \r\n | + + \r\n | + + \r\n | + + \r\n | + + \r\n | + + \r\n | + + \r\n | +++ +++ \r\n 0.00e+00|________________________+++________________________\r\n -5.00e+00 0.00e+00 5.00e+00\r\n 1.00e+01| + + \r\n | \r\n | + + \r\n | \r\n |......... + + \r\n |............. + \r\n |.............. \r\n |................ + \r\n 5.00e+00|................_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _\r\n |................ + \r\n |................ + \r\n |.............. + + \r\n |............. + + \r\n |......... + + \r\n | + + \r\n | + + \r\n | +++ +++ \r\n 0.00e+00|________________________+++________________________\r\n -5.00e+00 0.00e+00 5.00e+00\r\n 2.00e+00| - - - - - - \r\n | - - - - - - - \r\n | - - - - - - \r\n |- - - - - - - \r\n | - - - - -- - - - - \r\n | - - - - - - - - -\r\n | - - - - -- - --- -- - -- - - - - - \r\n | - - - -- -- - - - -- - - - \r\n | - - - - - - - -- - --- --- - - --- -- - - \r\n | - - - - - -- ----- -- -- --- -- -- --- -- - -\r\n | - - - ------------ ---- - -- -- - --- - - - \r\n | - - - - - ----- - -- ----------------------- -- ---- - -- -- \r\n | - - - - - ---- --------------------------------- - - - - - - \r\n 0.00e+00|_ _ _ _ _ _ _ _-_-_-_-_---- ------------------------------------_-- _ _ _ _ _ _ _\r\n | - - - - ----------------------------------------- -- - - - - \r\n | - -- - - -- - - --------------------------------- - - - \r\n | - - ---- - - -- --------------------- ----- ---- - -- - \r\n | - - -- --------- -- -- - ----- --- -- - - - - \r\n | - - - - - - - ---- --- --- --- -- -- --- - - -\r\n | - - - - - -- -- -- - - -- -- -- \r\n | - - - -- - -- -- - - -- - - \r\n | - - - - - - - -- - - -- - - \r\n | - - - - -- -- - - - - -\r\n | - - - - - - - - \r\n |- - - - - - - - \r\n | - - - - - - \r\n | - - - - - \r\n -2.00e+00|___________-_________________-___________-_____________________-____________-____\r\n -2.00e+00 0.00e+00 2.00e+00\r\n\"\"\"\r\n\r\nprint(random.gauss(0, 1, [2, 3, 4]))\r\nprint(random.rand([2, 3, 4]))\r\nprint(random.randint(0, 9, [2, 3, 4]))\r\nprint(random.uniform(0, 9, [2, 3, 4]))\r\n\r\n\"\"\"\r\n[[[0.825882516672574, 1.3725886771525058, 1.0633834034457958, -0.9653681933485563], [-0.26676981942597733, -0.8111218278822722, -2.0334645819975408, -0.6920477799264579], [0.219847607640343, -0.11124595869774408, 0.3959826652933697, 0.44979678957252417]], [[-0.32870040193220884, 0.02332530718848737, -0.11463753179571698, 0.76497128138739], [0.5471632308210022, -1.208683530864806, 0.6609856809302458, -1.0172095093996394], [-0.4239944693396323, -0.9895869506909234, 0.3151444331927837, -1.0952382690567983]]]\r\n[[[0.7391048706507907, 0.8914203442107109, 0.7810881208477741, 0.42396350784517345], [0.44782953354925625, 0.14060494681841362, 0.36645338622864543, 0.8792327342896561], [0.8328977875499322, 0.7597606669429515, 0.7309414657218207, 0.39511825984097715]], [[0.4224440661015312, 0.2817063735017259, 0.11204741761562653, 0.7932546033111754], [0.6230861699889618, 0.16789479246904482, 0.4452307316686511, 0.7298193538352331], [0.879038899493412, 0.14646565947090828, 0.6904668348145003, 0.8027750348973339]]]\r\n[[[5, 6, 4, 0], [5, 0, 4, 1], [2, 3, 5, 4]], [[4, 2, 3, 8], [3, 0, 0, 8], [9, 9, 4, 8]]]\r\n[[[5.350800115670108, 5.835203389972244, 8.668571640348379, 6.784139317082117], [7.838141284015925, 0.46256545431156715, 2.8571047765183932, 0.0660157726117514], [5.587670205493748, 3.567592961539832, 2.9956823476061682, 7.924798867767713]], [[1.5388683451612495, 8.64453573809756, 1.4500691204596237, 6.551614999615261], [6.95157556639829, 4.179288210881939, 6.281664642870586, 1.0867107163432608], [0.18490809809604403, 1.9708027978691627, 0.23346492301822674, 0.935059580008676]]]\r\n\"\"\"\r\n\r\nprint(regs.lin_reg(list(range(5)), [2, 4, 6, 7, 8]))\r\nprint(regs.par_reg(list(range(5)), [2, 4, 6, 7, 8]))\r\nprint(regs.poly_reg(list(range(5)), [2, 4, 6, 7, 8], 4))\r\n\r\n\"\"\"\r\n[1.5, 2.4000000000000004]\r\n[-0.21428571428571563, 2.3571428571428625, 1.971428571428569]\r\n[0.08333333333320592, -0.666666666666571, 1.4166666666628345, 1.1666666666688208, 1.9999999999999258]\r\n\"\"\"\r\n\r\nprint(tools.classify([1, 2.3, 4 + 5j, \"string\", list, True, 3.14, False, tuple, tools]))\r\nprint(tools.dedup([\"Python\", 6, \"NumPy\", int, \"PyPyNum\", 9, \"pypynum\", \"NumPy\", 6, True]))\r\nprint(tools.frange(0, 3, 0.4))\r\nprint(tools.linspace(0, 2.8, 8))\r\n\r\n\"\"\"\r\n{<class 'int'>: [1], <class 'float'>: [2.3, 3.14], <class 'complex'>: [(4+5j)], <class 'str'>: ['string'], <class 'type'>: [<class 'list'>, <class 'tuple'>], <class 'bool'>: [True, False], <class 'module'>: [<module 'pypynum.tools' from 'C:\\\\Users\\\\Administrator\\\\PycharmProjects\\\\pythonProject\\\\pypynum\\\\tools.py'>]}\r\n['Python', 6, 'NumPy', <class 'int'>, 'PyPyNum', 9, 'pypynum', True]\r\n[0.0, 0.4, 0.8, 1.2000000000000002, 1.6, 2.0, 2.4000000000000004, 2.8000000000000003]\r\n[0.0, 0.39999999999999997, 0.7999999999999999, 1.2, 1.5999999999999999, 1.9999999999999998, 2.4, 2.8]\r\n\"\"\"\r\n\r\n# Tip:\r\n# The test has been successfully passed and ended.\r\n# These tests are only part of the functionality of this package.\r\n# More features need to be explored and tried by yourself!\r\n```\r\n",
"bugtrack_url": null,
"license": " Apache License Version 2.0, January 2004 http://www.apache.org/licenses/ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION 1. Definitions. \"License\" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document. \"Licensor\" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License. \"Legal Entity\" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, \"control\" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity. \"You\" (or \"Your\") shall mean an individual or Legal Entity exercising permissions granted by this License. \"Source\" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files. \"Object\" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types. \"Work\" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below). \"Derivative Works\" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof. \"Contribution\" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, \"submitted\" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as \"Not a Contribution.\" \"Contributor\" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work. 2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form. 3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed. 4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions: (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and (b) You must cause any modified files to carry prominent notices stating that You changed the files; and (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and (d) If the Work includes a \"NOTICE\" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License. You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License. 5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions. 6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file. 7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License. 8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages. 9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability. END OF TERMS AND CONDITIONS APPENDIX: How to apply the Apache License to your work. To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets \"[]\" replaced with your own identifying information. (Don't include the brackets!) The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same \"printed page\" as the copyright notice for easier identification within third-party archives. Copyright [yyyy] [name of copyright owner] Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. ",
"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.",
"version": "1.16.1",
"project_urls": {
"Homepage": "https://github.com/PythonSJL/PyPyNum"
},
"split_keywords": [
"math",
" \u6570\u5b66",
" mathematics",
" \u6570\u5b66\u8ba1\u7b97",
" numerical",
" \u6570\u503c",
" computation",
" \u8ba1\u7b97",
" scientific",
" \u79d1\u5b66",
" algebra",
" \u4ee3\u6570",
" calculus",
" \u5fae\u79ef\u5206",
" statistics",
" \u7edf\u8ba1",
" linear-algebra",
" \u7ebf\u6027\u4ee3\u6570",
" optimization",
" \u4f18\u5316",
" numerical-analysis",
" \u6570\u503c\u5206\u6790",
" matrix",
" \u77e9\u9635",
" vector",
" \u5411\u91cf",
" tensor",
" \u5f20\u91cf",
" numerics",
" \u6570\u503c\u8ba1\u7b97",
" library",
" \u5e93",
" tools",
" \u5de5\u5177",
" utils",
" \u5b9e\u7528\u7a0b\u5e8f",
" algorithms",
" \u7b97\u6cd5",
" software",
" \u8f6f\u4ef6",
" package",
" \u5305",
" methods",
" \u65b9\u6cd5",
" data-science",
" \u6570\u636e\u79d1\u5b66",
" machine-learning",
" \u673a\u5668\u5b66\u4e60",
" computational",
" \u8ba1\u7b97\u7684",
" operations",
" \u64cd\u4f5c",
" functions",
" \u51fd\u6570",
" processing",
" \u5904\u7406",
" programming",
" \u7f16\u7a0b",
" simulation",
" \u4eff\u771f",
" visualization",
" \u53ef\u89c6\u5316",
" physics",
" \u7269\u7406"
],
"urls": [
{
"comment_text": "",
"digests": {
"blake2b_256": "5959bffe5194b538b8b4a5609693441bf91f390f2287a0620462429c09130bf0",
"md5": "3c94d151a68608d8d7e221c0cda5c2b4",
"sha256": "6a825c6c268644373e09cf9d5ad8230cbe5a890b4dc0445e878b762f651ebee4"
},
"downloads": -1,
"filename": "PyPyNum-1.16.1-py3-none-any.whl",
"has_sig": false,
"md5_digest": "3c94d151a68608d8d7e221c0cda5c2b4",
"packagetype": "bdist_wheel",
"python_version": "py3",
"requires_python": ">=3.4",
"size": 150543,
"upload_time": "2024-10-21T05:56:53",
"upload_time_iso_8601": "2024-10-21T05:56:53.715750Z",
"url": "https://files.pythonhosted.org/packages/59/59/bffe5194b538b8b4a5609693441bf91f390f2287a0620462429c09130bf0/PyPyNum-1.16.1-py3-none-any.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "b545b6c4fa1c6ea0fabe04b42135917cc11a1e55faf9edaf814b4c4c5e8cc08f",
"md5": "b1c83025d94a9ad830a92aebc0bb6ffe",
"sha256": "b475650ff125adf86a3b06cb4440ac65e5346d3a224c1006dcaabba48b6c5150"
},
"downloads": -1,
"filename": "pypynum-1.16.1.tar.gz",
"has_sig": false,
"md5_digest": "b1c83025d94a9ad830a92aebc0bb6ffe",
"packagetype": "sdist",
"python_version": "source",
"requires_python": ">=3.4",
"size": 166295,
"upload_time": "2024-10-21T05:56:55",
"upload_time_iso_8601": "2024-10-21T05:56:55.795210Z",
"url": "https://files.pythonhosted.org/packages/b5/45/b6c4fa1c6ea0fabe04b42135917cc11a1e55faf9edaf814b4c4c5e8cc08f/pypynum-1.16.1.tar.gz",
"yanked": false,
"yanked_reason": null
}
],
"upload_time": "2024-10-21 05:56:55",
"github": true,
"gitlab": false,
"bitbucket": false,
"codeberg": false,
"github_user": "PythonSJL",
"github_project": "PyPyNum",
"travis_ci": false,
"coveralls": false,
"github_actions": false,
"lcname": "pypynum"
}
