PyPI - PyPyNum - Versions diffs - 1.8.1__py3-none-any.whl → 1.9.0__py3-none-any.whl - Mend

PyPyNum 1.8.1py3-none-any.whl → 1.9.0py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (19) hide show

{PyPyNum-1.8.1.dist-info → PyPyNum-1.9.0.dist-info}/METADATA +589 -492
{PyPyNum-1.8.1.dist-info → PyPyNum-1.9.0.dist-info}/RECORD +19 -19
pypynum/Array.py +5 -4
pypynum/Quaternion.py +1 -1
pypynum/README.md +585 -488
pypynum/Symbolics.py +11 -13
pypynum/Vector.py +2 -2
pypynum/__init__.py +4 -4
pypynum/cipher.py +202 -22
pypynum/constants.py +26 -2
pypynum/errors.py +4 -0
pypynum/maths.py +29 -21
pypynum/probability.py +38 -0
pypynum/test.py +156 -107
pypynum/this.py +2 -1
pypynum/tools.py +5 -5
pypynum/utils.py +154 -11
{PyPyNum-1.8.1.dist-info → PyPyNum-1.9.0.dist-info}/WHEEL +0 -0
{PyPyNum-1.8.1.dist-info → PyPyNum-1.9.0.dist-info}/top_level.txt +0 -0

{PyPyNum-1.8.1.dist-info → PyPyNum-1.9.0.dist-info}/METADATA RENAMED Viewed

@@ -1,8 +1,8 @@
 Metadata-Version: 2.1
 Name: PyPyNum
-Version: 1.8.1
-Summary: A multifunctional mathematical calculation package written in pure Python programming language [Python>=3.5]
-Home-page: https://www.gitee.com/PythonSJL/PyPyNum
+Version: 1.9.0
+Summary: A multifunctional mathematical calculation package written in pure Python programming language [Python>=3.4]
+Home-page: https://github.com/PythonSJL/PyPyNum
 Author: Shen Jiayi
 Author-email: 2261748025@qq.com
 License:
@@ -669,13 +669,13 @@ License:
         <http://www.gnu.org/licenses/>.
 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,物理
-Requires-Python: >=3.5
+Requires-Python: >=3.4
 Description-Content-Type: text/markdown
 # <font color = blue>PyPyNum</font>
 <font color = gree>A multifunctional mathematical calculation package written in pure Python programming language
-</font><font color = red>[Python>=3.5]</font>
+</font><font color = red>[Python>=3.4]</font>
 ```
  ________   ___    ___  ________   ___    ___  ________    ___  ___   _____ ______
@@ -692,24 +692,64 @@ Description-Content-Type: text/markdown
 [![Downloads](https://static.pepy.tech/badge/pypynum/month)](https://pepy.tech/project/pypynum)
 [![Downloads](https://static.pepy.tech/badge/pypynum/week)](https://pepy.tech/project/pypynum)
-## Version -> 1.8.1 | PyPI -> https://pypi.org/project/PyPyNum/ | Gitee -> https://www.gitee.com/PythonSJL/PyPyNum
+## Version -> 1.9.0 | PyPI -> https://pypi.org/project/PyPyNum/ | Gitee -> https://www.gitee.com/PythonSJL/PyPyNum | GitHub -> https://github.com/PythonSJL/PyPyNum
 ![LOGO](PyPyNum.png)
-PyPI上无法显示logo，可以在Gitee中查看。
+PyPI上无法显示logo，可以在Gitee或者GitHub中查看。
-The logo cannot be displayed on PyPI, it can be viewed in Gitee.
+The logo cannot be displayed on PyPI, it can be viewed in Gitee or GitHub.
 ### 介绍
 #### Introduction
-+ DIY数学库，类似于numpy、scipy等，专为PyPy解释器制作
-+ DIY math library, similar to numpy, scipy, etc., specifically designed for PyPy interpreters
++ 多功能数学库，类似于numpy、scipy等，专为PyPy解释器制作，亦支持其他类型的Python解释器
++ 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
-+ 如需联系，QQ 2261748025 （Py𝙿𝚢𝚝𝚑𝚘𝚗-水晶兰）
-+ If you need to contact, QQ 2261748025 (Py𝙿𝚢𝚝𝚑𝚘𝚗-水晶兰)
++ 如需联系，请添加QQ号2261748025 （Py𝙿𝚢𝚝𝚑𝚘𝚗-水晶兰）
++ If you need to contact, please add QQ number 2261748025 (Py𝙿𝚢𝚝𝚑𝚘𝚗-水晶兰)
+### 子模块的名称与功能简介
+#### Name and Function Introduction of Submodules
+| 子模块名称 Submodule Name  | 功能简介 Function Introduction                 |
+|-----------------------|--------------------------------------------|
+| `pypynum.Array`       | 多维数组 Multidimensional array                |
+| `pypynum.chars`       | 特殊数学符号 Special mathematical symbols        |
+| `pypynum.cipher`      | 加密解密算法 Encryption and decryption algorithm |
+| `pypynum.constants`   | 数学常数集合 Set of mathematical constants       |
+| `pypynum.equations`   | 方程求解 Solving equations                     |
+| `pypynum.errors`      | 异常对象 Exception object                      |
+| `pypynum.file`        | 文件读写 File read and write                   |
+| `pypynum.FourierT`    | 傅里叶变换 Fourier transform                    |
+| `pypynum.Geometry`    | 几何形状 Geometric shape                       |
+| `pypynum.Graph`       | 图论算法 Graph Theory Algorithm                |
+| `pypynum.Group`       | 群论算法 Group Theory Algorithm                |
+| `pypynum.Logic`       | 逻辑电路设计 Logic circuit design                |
+| `pypynum.maths`       | 通用数学函数 General mathematical functions      |
+| `pypynum.Matrix`      | 矩阵运算 Matrix operation                      |
+| `pypynum.NeuralN`     | 神经网络训练 Neural network training             |
+| `pypynum.numbers`     | 数字处理 Number processing                     |
+| `pypynum.plotting`    | 数据可视化 Data visualization                   |
+| `pypynum.polynomial`  | 多项式运算 Polynomial operation                 |
+| `pypynum.probability` | 概率统计 Probability statistics                |
+| `pypynum.Quaternion`  | 四元数运算 Quaternion operation                 |
+| `pypynum.random`      | 随机数生成 Random number generation             |
+| `pypynum.regression`  | 回归分析 Regression analysis                   |
+| `pypynum.sequence`    | 数列计算 Sequence calculation                  |
+| `pypynum.Symbolics`   | 符号计算 Symbol calculation                    |
+| `pypynum.Tensor`      | 张量运算 Tensor operation                      |
+| `pypynum.test`        | 简易测试 Easy test                             |
+| `pypynum.this`        | 项目之禅 Zen of Projects                       |
+| `pypynum.tools`       | 辅助函数 Auxiliary functions                   |
+| `pypynum.Tree`        | 树形数据结构 Tree data structure                 |
+| `pypynum.types`       | 特殊类型 Special types                         |
+| `pypynum.utils`       | 实用工具 Utility                               |
+| `pypynum.Vector`      | 向量运算 Vector operation                      |
 ### PyPyNum的Zen（预览）
@@ -726,11 +766,19 @@ Straightforwardness is preferred over convolution.
 Sophisticated is better than overcomplicated.
 Flat structure beats nested hierarchies.
 Sparse code wins over bloated ones.
+```
+```
+...
+Do you want to view all the content?
-... (Do you want to view all the content?
 Enter "from pypynum import this" in your
-Python interpreter and run it!)
+Python interpreter and run it!
+```
+```
                                         February 27, 2024
 ```
@@ -741,26 +789,61 @@ Python interpreter and run it!)
 ```
 !=!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=
-eig函数修复了计算错误并改名为eigen
+新增的代码行数约三百行。
+The number of new code lines is
+about 300.
+!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=
+以下函数进行了改名，使用时请注意。
+The following functions have
+been renamed, please be careful
+when using them.
-The eig function fixed
-calculation errors and changed
-its name to eigen
+interpreter -> parse_expr
+deduplicate -> dedup
+interpolation -> interp
 !=!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=
-<<<以下结构中的省略号表示原有的部分>>>
+“chi2_cont”是卡方检验函数，支持输入一
+个列联表，返回(chi2，p，dof，
+expected)，当自由度为1时可以设置是否
+经过Yates校正。
-<<<The ellipsis in the following structure represents the original part>>>
+"chi2_cont" is a chi-square
+test function that supports
+entering a contingency table and
+returning (chi2, p, dof,
+expected). When the degree of
+freedom is 1, you can set
+whether to perform Yates
+correction.
+!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=
 PyPyNum
-    ★ Matrix [Matrix calculation]
-        FUNCTIONS
-            ...
-            rotate90(matrix: pypynum.Matrix.Matrix, times: int) -> pypynum.Matrix.Matrix
-            hessenberg(matrix: pypynum.Matrix.Matrix) -> tuple
-            eigen(matrix: pypynum.Matrix.Matrix) -> tuple
-            ...
+├── cipher
+│   └── FUNCTION
+│       ├── atbash(text: str) -> str
+│       ├── base_64(text: str, decrypt: bool) -> str
+│       ├── caesar(text: str, shift: int, decrypt: bool) -> str
+│       ├── morse(text: str, decrypt: bool) -> str
+│       ├── playfair(text: str, key: str, decrypt: bool) -> str
+│       ├── rot13(text: str) -> str
+│       ├── substitution(text: str, sub_map: dict, decrypt: bool) -> str
+│       └── vigenere(text: str, key: str, decrypt: bool) -> str
+├── probability
+│   └── FUNCTION
+│       ├── chi2_cont(contingency: list, calc_p: bool, corr: bool) -> tuple
+│       ├── chi2_pdf(x: typing.Union[int, float], k: typing.Union[int, float]) -> float
+└── utils
+    ├── CLASS
+    │   ├── LinkedList(object)/__init__(self: Any) -> Any
+    │   ├── LinkedListNode(object)/__init__(self: Any, value: Any, next_node: Any) -> Any
 ```
 ### 运行用时测试
@@ -785,374 +868,343 @@ PyPyNum
 ```
 PyPyNum
-    ★ __init__
-        [Import some features from other modules in this package]
-    ★ errors [Special errors]
-        CLASSES
-            LogicError
-            RandomError
-            ShapeError
-    ★ file [Reading and saving instance data]
-        FUNCTIONS
-            read(file: str) -> list
-            write(file: str, *cls: object)
-    ★ test
-        [A code test file]
-    ★ this
-        [The Zen of PyPyNum]
-    ★ types [Special types]
-        DATA
-            arr = typing.Union[list, tuple]
-            ite = typing.Union[list, tuple, str]
-            num = typing.Union[int, float, complex]
-            real = typing.Union[int, float]
-    ★ Array [N-dimensional array]
-        CLASSES
-            Array
-        FUNCTIONS
-            array(data=None)
-            fill(shape, sequence=None)
-            function(_array, _function, args=None)
-            get_shape(data)
-            is_valid_array(_array, _shape)
-            zeros(shape)
-            zeros_like(_nested_list)
-    ★ FourierT [Fourier transform and inverse Fourier transform]
-        CLASSES
-            FT1D
-    ★ Geometry [Planar geometry]
-        CLASSES
-            Circle
-            Line
-            Point
-            Polygon
-            Quadrilateral
-            Triangle
-        FUNCTIONS
-            distance(g1, g2, error: int | float = 0) -> float
-    ★ Graph [Graph theory]
-        CLASSES
-            BaseGraph
-                BaseWeGraph
-                    WeDiGraph
-                    WeUnGraph
-                DiGraph
-                UnGraph
-    ★ Group [Group theory]
-        CLASSES
-            Group
-        FUNCTIONS
-            add(x, y)
-            divide(x, y)
-            group(data)
-            multiply(x, y)
-            subtract(x, y)
-    ★ Logic [Logic circuit simulation]
-        CLASSES
-            Basic
-                Binary
-                    AND
-                    COMP
-                    HalfAdder
-                    HalfSuber
-                    JKFF
-                    NAND
-                    NOR
-                    OR
-                    XNOR
-                    XOR
-                Quaternary
-                    TwoBDiver
-                    TwoBMuler
-                Ternary
-                    FullAdder
-                    FullSuber
-                Unary
-                    DFF
-                    NOT
-                    TFF
-    ★ Matrix [Matrix calculation]
-        CLASSES
-            Matrix
-        FUNCTIONS
-            eigen(matrix: pypynum.Matrix.Matrix) -> tuple
-            hessenberg(matrix: pypynum.Matrix.Matrix) -> tuple
-            identity(n: int) -> pypynum.Matrix.Matrix
-            lu(matrix: pypynum.Matrix.Matrix) -> tuple
-            mat(data)
-            qr(matrix: pypynum.Matrix.Matrix) -> tuple
-            rotate90(matrix: pypynum.Matrix.Matrix, times: int) -> pypynum.Matrix.Matrix
-            same(rows, cols, value=0)
-            svd(matrix: pypynum.Matrix.Matrix) -> tuple
-            tril_indices(n: int, k: int = 0, m: int = None) -> tuple
-            zeros(_dimensions)
-            zeros_like(_nested_list)
-    ★ NeuralN [A simple neural network model]
-        CLASSES
-            NeuralNetwork
-        FUNCTIONS
-            neuraln(_input, _hidden, _output)
-    ★ Quaternion [Quaternion calculation]
-        CLASSES
-            Euler
-            Quaternion
-        FUNCTIONS
-            change(data: Union[pypynum.Quaternion.Quaternion, pypynum.Matrix.Matrix, pypynum.Quaternion.Euler], to: str) -> Union[pypynum.Quaternion.Quaternion, pypynum.Matrix.Matrix, pypynum.Quaternion.Euler]
-            euler(yaw: Union[int, float] = 0, pitch: Union[int, float] = 0, roll: Union[int, float] = 0) -> pypynum.Quaternion.Euler
-            quat(w: Union[int, float] = 0, x: Union[int, float] = 0, y: Union[int, float] = 0, z: Union[int, float] = 0) -> pypynum.Quaternion.Quaternion
-    ★ Symbolics [Symbol calculation]
-        FUNCTIONS
-            interpreter(expr: str) -> list
-        DATA
-            basic = "%()*+-./0123456789"
-            english = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
-            greek = "ΑΒΓΔΕΖΗΘΙΚΛΜΝΞΟΠΡΣΤΥΦΧΨΩαβγδεζηθικλμνξοπρστυφχψω"
-            operators = ["**", "*", "//", "/", "%", "+", "-"]
-            valid = "%()*+-./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcd...zΑΒΓΔΕΖΗΘΙ...
-    ★ Tensor [Tensor calculation]
-        CLASSES
-            Tensor
-        FUNCTIONS
-            ten(data)
-            tensor_and_number(tensor, operator, number)
-            tolist(_nested_list)
-            zeros(_dimensions)
-            zeros_like(_nested_list)
-    ★ Tree [Various trees]
-        CLASSES
-            MultiTree
-            MultiTreeNode
-    ★ Vector [Vector calculation]
-        CLASSES
-            Vector
-        FUNCTIONS
-            same(length, value=0)
-            vec(data)
-            zeros(_dimensions)
-            zeros_like(_nested_list)
-    ★ chars [Special mathematical symbols]
-        DATA
-            arrow = [["↖", "↑", "↗"], ["←", "⇌", "→"], ["↙", "↓", "↘"], ["↔", "⇋",...
-            div = "÷"
-            mul = "×"
-            others = "¬°‰‱′″∀∂∃∅∆∇∈∉∏∐∑∝∞∟∠∣∥∧∨∩∪∫∬∭∮∯∰∴∵∷∽≈≌≒≠≡≢≤≥≪≫≮≯≰≱≲≳⊕⊙⊥⊿⌒㏑㏒...
-            overline = "̄"
-            pi = "Ππ𝜫𝝅𝝥𝝿𝞟𝞹Пп∏ϖ∐ℼㄇ兀"
-            sgn = "±"
-            strikethrough = "̶"
-            subscript = "₀₁₂₃₄₅₆₇₈₉₊₋₌₍₎ₐₑₕᵢⱼₖₗₘₙₒₚᵣₛₜᵤᵥₓ"
-            superscript = "⁰¹²³⁴⁵⁶⁷⁸⁹⁺⁻⁼⁽⁾ᴬᴮᴰᴱᴳᴴᴵᴶᴷᴸᴹᴺᴼᴾᴿᵀᵁⱽᵂᵃᵇᶜᵈᵉᶠᵍʰⁱʲᵏˡᵐⁿᵒᵖʳˢᵗᵘᵛ...
-            tab = [["┌", "┬", "┐"], ["├", "┼", "┤"], ["└", "┴", "┘"], ["─", "╭", "...
-            underline = "_"
-    ★ cipher [String encryption and decryption algorithms]
-        FUNCTIONS
-            dna(string: str, decrypt: bool = False) -> str
-    ★ constants [Constants in mathematics and science]
-        DATA
-            AMU = 1.6605402e-27
-            EB = 1152921504606846976
-            G = 6.6743e-11
-            GB = 1073741824
-            KB = 1024
-            MB = 1048576
-            NA = 6.02214076e+23
-            PB = 1125899906842624
-            TB = 1099511627776
-            YB = 1208925819614629174706176
-            ZB = 1180591620717411303424
-            atto = 1e-18
-            c = 299792458
-            centi = 0.01
-            deci = 0.1
-            deka = 10
-            e = 2.718281828459045
-            exa = 1000000000000000000
-            femto = 1e-15
-            gamma = 0.5772156649015329
-            giga = 1000000000
-            h = 6.62607015e-34
-            hecto = 100
-            inf = inf
-            kilo = 1000
-            mega = 1000000
-            micro = 1e-06
-            milli = 0.001
-            nan = nan
-            nano = 1e-09
-            peta = 1000000000000000
-            phi = 1.618033988749895
-            pi = 3.141592653589793
-            pico = 1e-12
-            qe = 1.60217733e-19
-            tera = 1000000000000
-            yocto = 1e-24
-            yotta = 1000000000000000000000000
-            zepto = 1e-21
-            zetta = 1000000000000000000000
-    ★ equations [Solving specific forms of equations]
-        FUNCTIONS
-            linear_equation(left: list, right: list) -> list
-            polynomial_equation(coefficients: list) -> list
-    ★ maths [Mathematical functions]
-        FUNCTIONS
-            root(x: num, y: num) -> num
-            exp(x: real) -> real
-            ln(x: real) -> real
-            gcd(*args: int) -> int
-            lcm(*args: int) -> int
-            sin(x: real) -> real
-            cos(x: real) -> real
-            tan(x: real) -> real
-            csc(x: real) -> real
-            sec(x: real) -> real
-            cot(x: real) -> real
-            asin(x: real) -> real
-            acos(x: real) -> real
-            atan(x: real) -> real
-            acsc(x: real) -> real
-            asec(x: real) -> real
-            acot(x: real) -> real
-            sinh(x: real) -> real
-            cosh(x: real) -> real
-            tanh(x: real) -> real
-            csch(x: real) -> real
-            sech(x: real) -> real
-            coth(x: real) -> real
-            asinh(x: real) -> real
-            acosh(x: real) -> real
-            atanh(x: real) -> real
-            acsch(x: real) -> real
-            asech(x: real) -> real
-            acoth(x: real) -> real
-            ptp(numbers: arr) -> num
-            median(numbers: arr) -> num
-            freq(data: arr) -> dict
-            mode(data: arr)
-            mean(numbers: arr) -> num
-            geom_mean(numbers: arr) -> num
-            square_mean(numbers: arr) -> num
-            harm_mean(numbers: arr) -> num
-            raw_moment(data: arr, order: int) -> float
-            central_moment(data: arr, order: int) -> float
-            var(numbers: arr, ddof: int = 0) -> num
-            skew(data: arr) -> float
-            kurt(data: arr) -> float
-            std(numbers: arr, ddof: int = 0) -> num
-            cov(x: arr, y: arr, ddof: int = 0) -> num
-            corr_coeff(x: arr, y: arr) -> num
-            coeff_det(x: arr, y: arr) -> num
-            product(numbers: arr) -> num
-            sigma(i: int, n: int, f) -> num
-            pi(i: int, n: int, f) -> num
-            derivative(f, x: real, h: real = 1e-7) -> float
-            definite_integral(f, x_start: real, x_end: real, n: int = 10000000) -> float
-            beta(p: real, q: real) -> real
-            gamma(alpha: real) -> float
-            factorial(n: int) -> int
-            arrangement(n: int, r: int) -> int
-            combination(n: int, r: int) -> int
-            zeta(alpha: real) -> float
-            gaussian(x: real, _mu: real = 0, _sigma: real = 1) -> float
-            poisson(x: int, _lambda: real) -> float
-            erf(x: real) -> float
-            sigmoid(x: real) -> float
-            sign(x: real) -> int
-            parity(x: int) -> int
-            cumsum(lst: arr) -> list
-            cumprod(lst: arr) -> list
-            iroot(y: int, n: int) -> int
-            totient(n: int) -> int
-            mod_order(a: int, n: int, b: int) -> int
-            primitive_root(a: int, single: bool = False) -> Union[int, list]
-            normalize(data: arr, target: num = 1) -> arr
-            average(data, weights, expected=False)
-            exgcd(a: int, b: int) -> tuple
-            crt(n: arr, a: arr) -> int
-            isqrt(x: int) -> int
-            is_possibly_square(n: int) -> bool
-            is_square(n: int) -> bool
-    ★ numbers [Conversion of various numbers]
-        FUNCTIONS
-            float2fraction(number: float, mixed: bool = False, error: float = 1e-15) -> tuple
-            int2roman(integer: int, overline: bool = True) -> str
-            roman2int(roman_num: str) -> int
-            str2int(string: str) -> int
-        DATA
-            roman_symbols = ["M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I"]
-            roman_values = [1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1]
-    ★ plotting [Draw a graph of equations using characters]
-        FUNCTIONS
-            color(text: str, rgb: arr) -> str
-            change(data: thing) -> thing
-            background(right: real = 5, left: real = -5, top: real = 5, bottom: real = -5...
-            unary(function, right: real = 5, left: real = -5, top: real = 5, bottom: real = -5, complexity: real = 5...
-            binary(function, right: real = 5, left: real = -5, top: real = 5, bottom: real = -5, complexity: real = 5...
-            c_unary(function, start: real, end: real, interval: real = 5, projection: str = "ri", right: real = 5...
-    ★ polynomial [Polynomial object]
-        CLASSES
-            Polynomial
-        FUNCTIONS
-            poly(terms=None)
-    ★ probability [Probability function]
-        FUNCTIONS
-            binomial(sample_size: int, successes: int, success_probability: Union[int, float]) -> float
-            hypergeometric(total_items: int, success_items: int, sample_size: int, successes_in_sample: int) -> float
-    ★ random [Generate random numbers or random arrays]
-        FUNCTIONS
-            choice(seq: Union[list, tuple, str], shape: Union[list, tuple] = None)
-            gauss(mu: Union[int, float] = 0, sigma: Union[int, float] = 1, shape: Union[list, tuple] = None) -> Union[float, list]
-            gauss_error(original: Union[list, tuple], mu: Union[int, float] = 0, sigma: Union[int, float] = 1) -> list
-            rand(shape: Union[list, tuple] = None) -> Union[float, list]
-            randint(a: int, b: int, shape: Union[list, tuple] = None) -> Union[int, list]
-            uniform(a: Union[int, float], b: Union[int, float], shape: Union[list, tuple] = None) -> Union[float, list]
-    ★ regression [Formula based polynomial regression]
-        FUNCTIONS
-            linear_regression(x: Union[list, tuple], y: Union[list, tuple]) -> list
-            parabolic_regression(x: Union[list, tuple], y: Union[list, tuple]) -> list
-            polynomial_regression(x: Union[list, tuple], y: Union[list, tuple], n: int = None) -> list
-    ★ sequence [Various sequences]
-        FUNCTIONS
-            farey(n: int) -> list
-            fibonacci(n: int, single: bool = True) -> Union[int, list]
-            catalan(n: int, single: bool = True) -> Union[int, list]
-            bernoulli(n: int, single: bool = True) -> list
-            recaman(n: int, single: bool = True) -> Union[int, list]
-            arithmetic_sequence(*, a1: real = None, an: real = None, d: real = None, n: real = None, s: real = None) -> dict
-            geometric_sequence(*, a1: real = None, an: real = None, r: real = None, n: real = None, s: real = None) -> dict
-    ★ tools [Other useful tools]
-        FUNCTIONS
-            frange(start: real, stop: real, step: float = 1.0) -> list
-            linspace(start: real, stop: real, number: int) -> list
-            geomspace(start: real, stop: real, number: int) -> list
-            deduplicate(iterable: ite) -> ite
-            classify(array: arr) -> dict
-            split(iterable: ite, key: arr, retain: bool = False) -> list
-            interpolation(data: arr, length: int) -> list
-            primality(n: int, iter_num: int = 10) -> bool
-            generate_primes(limit: int) -> list
-            prime_factors(integer: int, dictionary: bool = False, pollard_rho: bool = True) -> Union[list, dict]
-            magic_square(n)
-    ★ utils [Other useful tools]
-        CLASSES
-            InfIterator
-            OrderedSet
+├── Array
+│   ├── CLASS
+│   │   └── Array(object)/__init__(self: Any, data: Any, check: Any) -> Any
+│   └── FUNCTION
+│       ├── array(data: Any) -> Any
+│       ├── fill(shape: Any, sequence: Any, repeat: Any) -> Any
+│       ├── function(_array: Any, _function: Any, args: Any) -> Any
+│       ├── get_shape(data: Any) -> Any
+│       ├── is_valid_array(_array: Any, _shape: Any) -> Any
+│       ├── zeros(shape: Any) -> Any
+│       └── zeros_like(_nested_list: Any) -> Any
+├── FourierT
+│   ├── CLASS
+│   │   └── FT1D(object)/__init__(self: Any, data: Any) -> Any
+│   └── FUNCTION
+├── Geometry
+│   ├── 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
+├── Graph
+│   ├── CLASS
+│   │   ├── BaseGraph(object)/__init__(self: Any) -> Any
+│   │   ├── BaseWeGraph(pypynum.Graph.BaseGraph)/__init__(self: Any) -> Any
+│   │   ├── DiGraph(pypynum.Graph.BaseGraph)/__init__(self: Any) -> Any
+│   │   ├── UnGraph(pypynum.Graph.BaseGraph)/__init__(self: Any) -> Any
+│   │   ├── WeDiGraph(pypynum.Graph.BaseWeGraph)/__init__(self: Any) -> Any
+│   │   └── WeUnGraph(pypynum.Graph.BaseWeGraph)/__init__(self: Any) -> Any
+│   └── FUNCTION
+├── Group
+│   ├── CLASS
+│   │   └── Group(object)/__init__(self: Any, data: Any) -> Any
+│   └── FUNCTION
+│       ├── add(x: Any, y: Any) -> Any
+│       ├── divide(x: Any, y: Any) -> Any
+│       ├── group(data: Any) -> Any
+│       ├── multiply(x: Any, y: Any) -> Any
+│       └── subtract(x: Any, y: Any) -> Any
+├── Logic
+│   ├── CLASS
+│   │   ├── AND(pypynum.Logic.Binary)/__init__(self: Any, label: Any, pin0: Any, pin1: Any) -> Any
+│   │   ├── Basic(object)/__init__(self: Any, label: Any) -> Any
+│   │   ├── Binary(pypynum.Logic.Basic)/__init__(self: Any, label: Any, pin0: Any, pin1: Any) -> Any
+│   │   ├── COMP(pypynum.Logic.Binary)/__init__(self: Any, label: Any, pin0: Any, pin1: Any) -> Any
+│   │   ├── DFF(pypynum.Logic.Unary)/__init__(self: Any, label: Any, pin0: Any, state: Any) -> Any
+│   │   ├── FullAdder(pypynum.Logic.Ternary)/__init__(self: Any, label: Any, pin0: Any, pin1: Any, pin2: Any) -> Any
+│   │   ├── FullSuber(pypynum.Logic.Ternary)/__init__(self: Any, label: Any, pin0: Any, pin1: Any, pin2: Any) -> Any
+│   │   ├── HalfAdder(pypynum.Logic.Binary)/__init__(self: Any, label: Any, pin0: Any, pin1: Any) -> Any
+│   │   ├── HalfSuber(pypynum.Logic.Binary)/__init__(self: Any, label: Any, pin0: Any, pin1: Any) -> Any
+│   │   ├── JKFF(pypynum.Logic.Binary)/__init__(self: Any, label: Any, pin0: Any, pin1: Any, state: Any) -> Any
+│   │   ├── NAND(pypynum.Logic.Binary)/__init__(self: Any, label: Any, pin0: Any, pin1: Any) -> Any
+│   │   ├── NOR(pypynum.Logic.Binary)/__init__(self: Any, label: Any, pin0: Any, pin1: Any) -> Any
+│   │   ├── NOT(pypynum.Logic.Unary)/__init__(self: Any, label: Any, pin0: Any) -> Any
+│   │   ├── OR(pypynum.Logic.Binary)/__init__(self: Any, label: Any, pin0: Any, pin1: Any) -> Any
+│   │   ├── Quaternary(pypynum.Logic.Basic)/__init__(self: Any, label: Any, pin0: Any, pin1: Any, pin2: Any, pin3: Any) -> Any
+│   │   ├── TFF(pypynum.Logic.Unary)/__init__(self: Any, label: Any, pin0: Any, state: Any) -> Any
+│   │   ├── Ternary(pypynum.Logic.Basic)/__init__(self: Any, label: Any, pin0: Any, pin1: Any, pin2: Any) -> Any
+│   │   ├── TwoBDiver(pypynum.Logic.Quaternary)/__init__(self: Any, label: Any, pin0: Any, pin1: Any, pin2: Any, pin3: Any) -> Any
+│   │   ├── TwoBMuler(pypynum.Logic.Quaternary)/__init__(self: Any, label: Any, pin0: Any, pin1: Any, pin2: Any, pin3: Any) -> Any
+│   │   ├── Unary(pypynum.Logic.Basic)/__init__(self: Any, label: Any, pin0: Any) -> Any
+│   │   ├── XNOR(pypynum.Logic.Binary)/__init__(self: Any, label: Any, pin0: Any, pin1: Any) -> Any
+│   │   └── XOR(pypynum.Logic.Binary)/__init__(self: Any, label: Any, pin0: Any, pin1: Any) -> Any
+│   └── FUNCTION
+│       └── connector(previous: Any, latter: Any) -> Any
+├── Matrix
+│   ├── CLASS
+│   │   └── Matrix(pypynum.Array.Array)/__init__(self: Any, data: Any, check: Any) -> Any
+│   └── FUNCTION
+│       ├── eigen(matrix: pypynum.Matrix.Matrix) -> tuple
+│       ├── hessenberg(matrix: pypynum.Matrix.Matrix) -> tuple
+│       ├── identity(n: int) -> pypynum.Matrix.Matrix
+│       ├── lu(matrix: pypynum.Matrix.Matrix) -> tuple
+│       ├── mat(data: Any) -> Any
+│       ├── qr(matrix: pypynum.Matrix.Matrix) -> tuple
+│       ├── rotate90(matrix: pypynum.Matrix.Matrix, times: int) -> pypynum.Matrix.Matrix
+│       ├── same(rows: Any, cols: Any, value: Any) -> Any
+│       ├── svd(matrix: pypynum.Matrix.Matrix) -> tuple
+│       ├── tril_indices(n: int, k: int, m: int) -> tuple
+│       ├── zeros(_dimensions: Any) -> Any
+│       └── zeros_like(_nested_list: Any) -> Any
+├── NeuralN
+│   ├── CLASS
+│   │   └── NeuralNetwork(object)/__init__(self: Any, _input: Any, _hidden: Any, _output: Any) -> Any
+│   └── FUNCTION
+│       └── neuraln(_input: Any, _hidden: Any, _output: Any) -> Any
+├── Quaternion
+│   ├── 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
+│       ├── change(data: typing.Union[pypynum.Quaternion.Quaternion, pypynum.Matrix.Matrix, pypynum.Quaternion.Euler], to: str) -> typing.Union[pypynum.Quaternion.Quaternion, pypynum.Matrix.Matrix, pypynum.Quaternion.Euler]
+│       ├── euler(yaw: typing.Union[int, float], pitch: typing.Union[int, float], roll: typing.Union[int, float]) -> pypynum.Quaternion.Euler
+│       └── quat(w: typing.Union[int, float], x: typing.Union[int, float], y: typing.Union[int, float], z: typing.Union[int, float]) -> pypynum.Quaternion.Quaternion
+├── Symbolics
+│   ├── CLASS
+│   └── FUNCTION
+│       └── parse_expr(expr: str) -> list
+├── Tensor
+│   ├── CLASS
+│   │   └── Tensor(pypynum.Array.Array)/__init__(self: Any, data: Any, check: Any) -> Any
+│   └── FUNCTION
+│       ├── ten(data: list) -> pypynum.Tensor.Tensor
+│       ├── tensor_and_number(tensor: Any, operator: Any, number: Any) -> Any
+│       ├── tensorproduct(tensors: pypynum.Tensor.Tensor) -> pypynum.Tensor.Tensor
+│       ├── zeros(_dimensions: Any) -> Any
+│       └── zeros_like(_nested_list: Any) -> Any
+├── Tree
+│   ├── CLASS
+│   │   ├── MultiTree(object)/__init__(self: Any, root: Any) -> Any
+│   │   └── MultiTreeNode(object)/__init__(self: Any, data: Any) -> Any
+│   └── FUNCTION
+├── Vector
+│   ├── CLASS
+│   │   └── Vector(pypynum.Array.Array)/__init__(self: Any, data: Any, check: Any) -> Any
+│   └── FUNCTION
+│       ├── same(length: Any, value: Any) -> Any
+│       ├── vec(data: Any) -> Any
+│       ├── zeros(_dimensions: Any) -> Any
+│       └── zeros_like(_nested_list: Any) -> Any
+├── chars
+│   ├── CLASS
+│   └── FUNCTION
+├── cipher
+│   ├── CLASS
+│   └── FUNCTION
+│       ├── atbash(text: str) -> str
+│       ├── base_64(text: str, decrypt: bool) -> str
+│       ├── caesar(text: str, shift: int, decrypt: bool) -> str
+│       ├── morse(text: str, decrypt: bool) -> str
+│       ├── playfair(text: str, key: str, decrypt: bool) -> str
+│       ├── rot13(text: str) -> str
+│       ├── substitution(text: str, sub_map: dict, decrypt: bool) -> str
+│       └── vigenere(text: str, key: str, decrypt: bool) -> str
+├── constants
+│   ├── CLASS
+│   └── FUNCTION
+├── equations
+│   ├── CLASS
+│   └── FUNCTION
+│       ├── linear_equation(left: list, right: list) -> list
+│       └── polynomial_equation(coefficients: list) -> list
+├── errors
+│   ├── CLASS
+│   └── FUNCTION
+├── file
+│   ├── CLASS
+│   └── FUNCTION
+│       ├── read(file: str) -> list
+│       └── write(file: str, cls: object) -> 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: Any, weights: Any, expected: Any) -> Any
+│       ├── 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
+│       ├── definite_integral(f: Any, x_start: typing.Union[int, float], x_end: typing.Union[int, float], n: int, args: Any, kwargs: Any) -> float
+│       ├── derivative(f: Any, x: typing.Union[int, float], h: typing.Union[int, float], args: Any, kwargs: Any) -> float
+│       ├── 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
+│       ├── gaussian(x: typing.Union[int, float], _mu: typing.Union[int, float], _sigma: 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]
+│       ├── 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]) -> float
+│       ├── lcm(args: int) -> int
+│       ├── ln(x: typing.Union[int, float]) -> typing.Union[int, float]
+│       ├── 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]
+│       ├── poisson(x: int, _lambda: typing.Union[int, float]) -> float
+│       ├── 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]
+│       ├── raw_moment(data: typing.Union[list, tuple], order: int) -> float
+│       ├── 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]) -> int
+│       ├── 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]
+│       ├── tan(x: typing.Union[int, float]) -> typing.Union[int, float]
+│       ├── tanh(x: typing.Union[int, float]) -> typing.Union[int, float]
+│       ├── totient(n: int) -> int
+│       ├── var(numbers: typing.Union[list, tuple], dof: int) -> typing.Union[int, float, complex]
+│       └── zeta(alpha: typing.Union[int, float]) -> float
+├── numbers
+│   ├── CLASS
+│   └── FUNCTION
+│       ├── float2fraction(number: float, mixed: bool, error: float) -> tuple
+│       ├── int2roman(integer: int, overline: bool) -> str
+│       ├── roman2int(roman_num: str) -> int
+│       └── 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, start: typing.Union[int, float], end: typing.Union[int, float], interval: typing.Union[int, float], 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]
+├── polynomial
+│   ├── CLASS
+│   │   └── Polynomial(object)/__init__(self: Any, terms: Any) -> Any
+│   └── FUNCTION
+│       └── poly(terms: Any) -> Any
+├── probability
+│   ├── CLASS
+│   └── FUNCTION
+│       ├── binomial(sample_size: int, successes: int, success_probability: typing.Union[int, float]) -> float
+│       ├── chi2_cont(contingency: list, calc_p: bool, corr: bool) -> tuple
+│       ├── chi2_pdf(x: typing.Union[int, float], k: typing.Union[int, float]) -> float
+│       └── hypergeometric(total_items: int, success_items: int, sample_size: int, successes_in_sample: int) -> float
+├── random
+│   ├── CLASS
+│   └── FUNCTION
+│       ├── 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]
+│       ├── gauss_error(original: typing.Union[list, tuple], mu: typing.Union[int, float], sigma: typing.Union[int, 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]
+├── regression
+│   ├── CLASS
+│   └── FUNCTION
+│       ├── linear_regression(x: typing.Union[list, tuple], y: typing.Union[list, tuple]) -> list
+│       ├── parabolic_regression(x: typing.Union[list, tuple], y: typing.Union[list, tuple]) -> list
+│       └── polynomial_regression(x: typing.Union[list, tuple], y: typing.Union[list, tuple], n: int) -> list
+├── sequence
+│   ├── 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
+│       ├── bernoulli(n: int, single: bool) -> list
+│       ├── 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
+│       └── recaman(n: int, single: bool) -> typing.Union[int, list]
+├── test
+│   ├── CLASS
+│   └── FUNCTION
+├── this
+│   ├── CLASS
+│   └── FUNCTION
+├── tools
+│   ├── CLASS
+│   └── FUNCTION
+│       ├── classify(array: typing.Union[list, tuple]) -> dict
+│       ├── dedup(iterable: typing.Union[list, tuple, str]) -> typing.Union[list, tuple, str]
+│       ├── frange(start: typing.Union[int, float], stop: typing.Union[int, float], step: float) -> list
+│       ├── generate_primes(limit: int) -> list
+│       ├── generate_semiprimes(limit: int) -> list
+│       ├── geomspace(start: typing.Union[int, float], stop: typing.Union[int, float], number: int) -> list
+│       ├── interp(data: typing.Union[list, tuple], length: int) -> list
+│       ├── linspace(start: typing.Union[int, float], stop: typing.Union[int, float], number: int) -> list
+│       ├── magic_square(n: Any) -> Any
+│       ├── primality(n: int, iter_num: int) -> bool
+│       ├── prime_factors(integer: int, dictionary: bool, pollard_rho: bool) -> typing.Union[list, dict]
+│       └── split(iterable: typing.Union[list, tuple, str], key: typing.Union[list, tuple], retain: bool) -> list
+├── types
+│   ├── CLASS
+│   └── FUNCTION
+└── utils
+    ├── CLASS
+    │   ├── InfIterator(object)/__init__(self: Any, start: typing.Union[int, float, complex], mode: str, common: typing.Union[int, float, complex]) -> 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
 ```
 ### 代码测试
 #### Code testing
-```
->>> from pypynum import (Array, Geometry, Logic, Matrix, Quaternion, Symbolics, Tensor, Vector,
-                         cipher, constants, equations, maths, plotting, random, regression, tools)
+```python
+from pypynum import (Array, Geometry, Logic, Matrix, Quaternion, Symbolics, Tensor, Vector,
+                     cipher, constants, equations, maths, plotting, random, regression, tools)
 ...
->>> print(Array.array())
->>> print(Array.array([1, 2, 3, 4, 5, 6, 7, 8]))
->>> print(Array.array([[1, 2, 3, 4], [5, 6, 7, 8]]))
->>> print(Array.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]]))
+print(Array.array())
+print(Array.array([1, 2, 3, 4, 5, 6, 7, 8]))
+print(Array.array([[1, 2, 3, 4], [5, 6, 7, 8]]))
+print(Array.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]]))
+"""
 []
 [1 2 3 4 5 6 7 8]
 [[1 2 3 4]
@@ -1162,40 +1214,46 @@ PyPyNum
  [[5 6]
   [7 8]]]
+"""
->>> triangle = Geometry.Triangle((0, 0), (2, 2), (3, 0))
->>> print(triangle.perimeter())
->>> print(triangle.area())
->>> print(triangle.centroid())
+triangle = Geometry.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 = Logic.HalfAdder("alpha", a, b), Logic.HalfAdder("beta", c, None)
->>> xor0 = Logic.XOR("alpha")
->>> ff0, ff1 = Logic.DFF("alpha"), Logic.DFF("beta")
->>> xor0.set_order0(1)
->>> xor0.set_order1(1)
->>> Logic.connector(adder0, adder1)
->>> Logic.connector(adder0, xor0)
->>> Logic.connector(adder1, xor0)
->>> Logic.connector(adder1, ff0)
->>> Logic.connector(xor0, ff1)
->>> print("sum: {}, carry: {}".format(ff0.out(), ff1.out()))
+"""
+a, b, c = 1, 1, 1
+adder0, adder1 = Logic.HalfAdder("alpha", a, b), Logic.HalfAdder("beta", c, None)
+xor0 = Logic.XOR("alpha")
+ff0, ff1 = Logic.DFF("alpha"), Logic.DFF("beta")
+xor0.set_order0(1)
+xor0.set_order1(1)
+Logic.connector(adder0, adder1)
+Logic.connector(adder0, xor0)
+Logic.connector(adder1, xor0)
+Logic.connector(adder1, ff0)
+Logic.connector(xor0, ff1)
+print("sum: {}, carry: {}".format(ff0.out(), ff1.out()))
+"""
 sum: [1], carry: [1]
->>> m0 = Matrix.mat([[1, 2], [3, 4]])
->>> m1 = Matrix.mat([[5, 6], [7, 8]])
->>> print(m0)
->>> print(m1)
->>> print(m0 + m1)
->>> print(m0 @ m1)
->>> print(m0.inv())
->>> print(m1.rank())
+"""
+m0 = Matrix.mat([[1, 2], [3, 4]])
+m1 = Matrix.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]
@@ -1207,40 +1265,46 @@ sum: [1], carry: [1]
 [[-2.0  1.0]
  [ 1.5 -0.5]]
 2
->>> q0 = Quaternion.quat(1, 2, 3, 4)
->>> q1 = Quaternion.quat(5, 6, 7, 8)
->>> print(q0)
->>> print(q1)
->>> print(q0 + q1)
->>> print(q0 * q1)
->>> print(q0.inverse())
->>> print(q1.conjugate())
+"""
+q0 = Quaternion.quat(1, 2, 3, 4)
+q1 = Quaternion.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(Symbolics.basic)
->>> print(Symbolics.english)
->>> print(Symbolics.greek)
->>> print(Symbolics.interpreter("-(10+a-(3.14+b0)*(-5))**(-ζn1-2.718/mΣ99)//9"))
+print(Symbolics.BASIC)
+print(Symbolics.ENGLISH)
+print(Symbolics.GREEK)
+print(Symbolics.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 = Tensor.ten([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])
->>> t1 = Tensor.ten([[[9, 10], [11, 12]], [[13, 14], [15, 16]]])
->>> print(t0)
->>> print(t1)
->>> print(t0 + t1)
->>> print(t0 @ t1)
+t0 = Tensor.ten([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])
+t1 = Tensor.ten([[[9, 10], [11, 12]], [[13, 14], [15, 16]]])
+print(t0)
+print(t1)
+print(t0 + t1)
+print(t0 @ t1)
+"""
 [[[1 2]
   [3 4]]
@@ -1261,16 +1325,33 @@ ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz
  [[155 166]
   [211 226]]]
->>> string = "PyPyNum"
->>> encrypted = cipher.dna(string)
->>> print(string)
->>> print(encrypted)
->>> print(cipher.dna(encrypted, decrypt=True))
+"""
+string = "PyPyNum"
+encrypted = cipher.caesar(string, 10)
+print(string)
+print(encrypted)
+print(cipher.caesar(encrypted, 10, decrypt=True))
+encrypted = cipher.vigenere(string, "cipher")
+print(string)
+print(encrypted)
+print(cipher.vigenere(encrypted, "cipher", decrypt=True))
+encrypted = cipher.morse(string)
+print(string)
+print(encrypted)
+print(cipher.morse(encrypted, decrypt=True))
+"""
+PyPyNum
+ZiZiXew
+PyPyNum
 PyPyNum
-CCCTAGACCCTCGTCCCGCTAAACCCTG
+RgEfRlo
 PyPyNum
+PyPyNum
+.--. -.-- .--. -.-- -. ..- --
+PYPYNUM
+"""
 v0 = Vector.vec([1, 2, 3, 4])
 v1 = Vector.vec([5, 6, 7, 8])
@@ -1281,29 +1362,33 @@ 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(constants.TB)
->>> print(constants.e)
->>> print(constants.h)
->>> print(constants.phi)
->>> print(constants.pi)
->>> print(constants.tera)
+print(constants.TB)
+print(constants.e)
+print(constants.h)
+print(constants.phi)
+print(constants.pi)
+print(constants.tera)
+"""
 1099511627776
 2.718281828459045
 6.62607015e-34
 1.618033988749895
 3.141592653589793
 1000000000000
+"""
->>> p = [1, -2, -3, 4]
->>> m = [
+p = [1, -2, -3, 4]
+m = [
     [
         [1, 2, 3],
         [6, 10, 12],
@@ -1311,33 +1396,38 @@ print(v1.angles())
     ],
     [-1, -2, -3]
 ]
->>> print(equations.polynomial_equation(p))
->>> print(equations.linear_equation(*m))
+print(equations.polynomial_equation(p))
+print(equations.linear_equation(*m))
+"""
 [[(-1.5615528128088307-6.5209667308287455e-24j)                                             0                                             0]
  [                                            0   (2.5615528128088294+4.456233626665941e-24j)                                             0]
  [                                            0                                             0   (1.0000000000000007+3.241554513744382e-25j)]]
 [ 1.6666666666666667 -0.6666666666666666 -0.4444444444444444]
+"""
->>> print(maths.cot(constants.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]))
+print(maths.cot(constants.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, start=-10, end=10, interval=100, right=2, left=-2, top=2, bottom=-2, complexity=20, character="-"))
+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, start=-10, end=10, interval=100, right=2, left=-2, top=2, bottom=-2, complexity=20, character="-"))
+"""
   1.00e+01|         +                               +
           |
           |          +                             +
@@ -1405,48 +1495,55 @@ print(v1.angles())
           |
  -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]))
+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]))
-[[[1.524086835643172, -0.20868457467847845, 0.5240261503975477, -0.6439838767682032], [-1.091904210196648, -0.20567633973733265, 1.374424576574523, 0.6563097903476932], [0.2171635934136032, 1.0821030876490199, -0.8410496800310051, -0.8321549344577578]], [[0.5306996954571072, -0.4441704154154241, 1.0481960055260355, 0.39805451821848287], [-0.4006858882593715, -0.06238294764009237, -1.1536673264483728, -0.8063185246185602], [0.3029117113345387, -0.32570360518676644, 0.6608320231980702, 1.7415150171137153]]]
-[[[0.3736243541521843, 0.8599079983285199, 0.4260061864869946, 0.8441437619796597], [0.8955986631978392, 0.7570336992646656, 0.6706841989644684, 0.328634366074538], [0.4371430562585502, 0.9576395263025738, 0.2380278778546957, 0.806813631306664]], [[0.18549375381453237, 0.5749941389233029, 0.7009767023241946, 0.30017399397762223], [0.6661914823434657, 0.7802291606608635, 0.6847755352217044, 0.2661053533652564], [0.07937643994416943, 0.5452043474222034, 0.8026792060861194, 0.07776400257578953]]]
-[[[9, 0, 9, 0], [2, 6, 3, 4], [5, 8, 4, 7]], [[7, 7, 6, 3], [5, 5, 5, 8], [3, 4, 6, 6]]]
-[[[5.049093842782947, 1.3880585421884204, 8.533634113864629, 3.550264239771317], [3.3311351975225176, 5.131771033264564, 0.9570872044431911, 5.165536082759862], [1.2035779060925538, 8.292998518472567, 8.014641974770818, 6.251632912237915]], [[6.411677800595937, 5.365937405245105, 8.70943859614565, 4.348757668525482], [7.827612569569748, 1.3718742546020972, 0.5252489627763138, 2.065015517785291], [4.620664668451086, 2.604569735623819, 5.548107842615733, 7.60342292447815]]]
+"""
+[[[1.5224810365398622, -0.3957309179046998, 0.22865800022960608, 0.69458992002954], [1.2796914880445907, -0.9963205507196862, -1.035672172661647, 0.6685698624811087], [0.7966036403993993, 1.4728609716690575, 1.4271945372122727, 1.1346636992788732]], [[-1.5167315121066547, 0.5337355746221562, -0.3856209788535444, 0.9933311189027801], [-0.3000451683620412, 1.985371100287406, 1.0044445415210081, -0.160547602340231], [-1.4024800661532726, -0.2943388293424122, 0.39426575084974064, -0.1788920335787877]]]
+[[[0.5832734051570118, 0.12709072960713108, 0.8460371711928255, 0.7732502834495745], [0.1337174418330055, 0.20214133151753821, 0.11501155244785399, 0.945090241309287], [0.784115524194132, 0.5008953798117651, 0.3514598489060844, 0.2730882163660271]], [[0.8536525608965406, 0.03101021951426164, 0.8904423549934418, 0.30844019778976395], [0.6686071112680847, 0.8622569244011669, 0.5624751157425253, 0.25138337174684133], [0.28360470724085995, 0.31597491199666694, 0.8115190344839784, 0.2685895801115009]]]
+[[[7, 1, 2, 5], [0, 7, 9, 9], [3, 0, 5, 6]], [[2, 2, 4, 3], [9, 7, 2, 0], [2, 5, 6, 6]]]
+[[[3.2674331705558304, 8.794845124593792, 8.48281482952606, 4.071439810303413], [3.525937325174985, 8.353244015747865, 5.167113956700689, 8.200558536323298], [0.5729366698493622, 4.49113422389227, 7.736245315815029, 1.9082811620380302]], [[4.889120931109369, 1.6037956737307013, 7.983047897048623, 1.3817112552960102], [5.866208284533167, 0.5963242816793028, 6.17792540726971, 8.415093555918986], [0.2560629015262261, 1.9094767046602064, 5.647362624435581, 4.042400239970636]]]
+"""
->>> print(regression.linear_regression(list(range(5)), [2, 4, 6, 7, 8]))
->>> print(regression.parabolic_regression(list(range(5)), [2, 4, 6, 7, 8]))
->>> print(regression.polynomial_regression(list(range(5)), [2, 4, 6, 7, 8], 4))
+print(regression.linear_regression(list(range(5)), [2, 4, 6, 7, 8]))
+print(regression.parabolic_regression(list(range(5)), [2, 4, 6, 7, 8]))
+print(regression.polynomial_regression(list(range(5)), [2, 4, 6, 7, 8], 4))
+"""
 [1.5, 2.4000000000000004]
 [-0.21428571428571183, 2.3571428571428474, 1.9714285714285764]
 [0.08333333334800574, -0.6666666668092494, 1.4166666678382942, 1.1666666648311956, 2.0000000002900613]
+"""
->>> print(tools.classify([1, 2.3, 4 + 5j, "string", list, True, 3.14, False, tuple, tools]))
->>> print(tools.deduplicate(["Python", 6, "NumPy", int, "PyPyNum", 9, "pypynum", "NumPy", 6, True]))
->>> print(tools.frange(0, 3, 0.4))
->>> print(tools.linspace(0, 2.8, 8))
+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 'F:\\PyPyproject\\PyPyproject1\\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!
+"""
+# 提示：
+#
+# 测试已成功通过并结束。
+#
+# 这些测试只是这个包功能的一部分。
+#
+# 更多的功能需要自己探索和尝试！
+#
+# 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!
 ```

PyPyNum 1.8.1__py3-none-any.whl → 1.9.0__py3-none-any.whl

PyPyNum 1.8.1py3-none-any.whl → 1.9.0py3-none-any.whl