PyPyNum 1.17.1__py3-none-any.whl → 1.18.0__py3-none-any.whl

pypynum/README.md

@@ -1,8 +1,8 @@
 # PyPyNum
 
-PyPyNum is a multifunctional Python math lib. It includes modules for math, data analysis, array ops, crypto, physics,
-randomness, data prep, stats, solving eqns, image processing, interp, matrix calc, and high-precision math. Designed for
-scientific computing, data science, and machine learning, PyPyNum provides efficient and versatile tools.
+PyPyNum is a versatile Python math lib. It features modules for math, data analysis, arrays, crypto, physics, RNG, data
+proc, stats, eq solving, image proc, interp, matrix calc, and high-prec math. Designed for scientific computing, data
+science, and ML, it offers efficient, general-purpose tools.
 
 ```
  ________   ___    ___  ________   ___    ___  ________    ___  ___   _____ ______
@@ -19,7 +19,7 @@ scientific computing, data science, and machine learning, PyPyNum provides effic
 [![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.17.1 | PyPI -> https://pypi.org/project/PyPyNum/ | Gitee -> https://www.gitee.com/PythonSJL/PyPyNum | GitHub -> https://github.com/PythonSJL/PyPyNum
+## PyPyNum | Version -> 1.18.0 | PyPI -> https://pypi.org/project/PyPyNum/ | Gitee -> https://www.gitee.com/PythonSJL/PyPyNum | GitHub -> https://github.com/PythonSJL/PyPyNum
 
 ![LOGO](PyPyNum.png)
 
@@ -30,7 +30,7 @@ The logo cannot be displayed on PyPI, it can be viewed in Gitee or GitHub.
 + 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
++ If you need to contact, please add QQ number 2261748025 (一只水晶兰), or through my email 2261748025@qq.com
 
 ```
 +++++++++++++++++++++++++++++++++++++++++
@@ -151,71 +151,64 @@ Python interpreter and run it!
 ```
 !=!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=
 
-The `pypynum.images` module
-now encompasses three classes,
-expanding its image processing functionality.
-The original `PNG` class
-has been transformed to be based on
-the `BaseImage` class.
-This update includes a specific fix
-for the `read` method in `PNG`,
-addressing issues with reading
-large images.
-1. `BaseImage`: A foundational class
-for image processing, offering
-basic methods like image creation,
-pixel access, and metadata retrieval.
-2. `BMP`: A subclass of `BaseImage`,
-tailored for BMP image handling,
-providing specialized BMP functionalities.
-3. `PNG`: The `PNG` class, now built on
-`BaseImage`, with an improved `read`
-method that solves the problem of
-reading large PNG files.
-This fix to the `read` method in `PNG`
-ensures efficient processing of large images,
-maintaining image quality and integrity.
-The module's enhanced capabilities
-make it more robust and user-friendly
-for handling substantial PNG files.
-
-
-<<< The following are some usage examples >>>
-
-
-# Import BMP and PNG classes
-from pypynum import BMP, PNG
-
-# Instantiate BMP class
-bmp_image = BMP()
-# Instantiate a BMP image with specified dimensions and color
-bmp_image.new(width=100, height=100, color=(255, 0, 0), color_mode="RGB", bit_depth=8)
-# Set pixel color at (50, 50) to blue
-bmp_image[50, 50] = (0, 0, 255)
-# Save the BMP image
-bmp_image.write("output_bmp.bmp")
-# Instantiate PNG class
-png_image = PNG()
-# Instantiate a PNG image with specified dimensions and color
-png_image.new(width=100, height=100, color=(0, 255, 0), color_mode="RGB", bit_depth=8)
-# Set pixel color at (50, 50) to yellow
-png_image[50, 50] = (255, 255, 0)
-# Save the PNG image
-png_image.write("output_png.png")
-# Create BMP reader to read the BMP image
-bmp_reader = BMP()
-# Read the BMP image from the file
-bmp_reader.read("output_bmp.bmp")
-# Print the BMP image and pixel at (50, 50)
-print("BMP Image:", bmp_reader)
-print("BMP Pixel at (50, 50):", bmp_reader[50, 50])
-# Create PNG reader to read the PNG image
-png_reader = PNG()
-# Read the PNG image from the file
-png_reader.read("output_png.png")
-# Print the PNG image and pixel at (50, 50)
-print("PNG Image:", png_reader)
-print("PNG Pixel at (50, 50):", png_reader[50, 50])
+PyPyNum version 1.18.0 has undergone the following functional changes compared to version 1.17.2:
+
+1. `arrays` Module
+   a. Fixed reflection operation errors in the `Array` class.
+
+2. `ciphers` Module
+   a. The `base_64` function's input parameter and return type have been changed from `str` to `bytes`.
+
+3. `groups` Module
+   a. The `Group` class has been refactored and new available methods have been added.
+   b. The `group` function now accepts an additional `operation` parameter.
+
+4. `images` Module
+   a. Added a new class `JPEG` for JPEG image handling.
+   b. Added JPEG processing functions: `jpeg_adjust_qtable`, `jpeg_category`, `jpeg_channel_encoding`,
+      `jpeg_chroma_dc_huff`, `jpeg_dct8x8`, `jpeg_decode_pixels`, `jpeg_encode_pixels`, `jpeg_luma_dc_huff`,
+      `jpeg_rle_decoding`, `jpeg_rle_encoding`, `jpeg_split_pixels`, and `jpeg_zigzag`.
+   c. Added color space conversion functions `rgb2ycbcr` and `ycbcr2rgb` (which are JPEG-related functions).
+   d. Added `entropy` function (which is a PNG function).
+   e. Added PNG filter functions `png_apply_filter` and `png_reverse_filter`, allowing the `apply_filter` parameter
+      to be specified during writing to compress the generated file size.
+
+5. `kernels` Module
+   a. Added `matmul8x8kernel` function for 8x8 matrix multiplication kernel operations.
+
+6. `maths` Module
+   a. Added `dsigmoid` function.
+   b. Updated `sumprod` function with a new `floating` parameter.
+
+7. `matrices` Module
+   a. Added `dctmtx` function to generate a discrete cosine transform matrix.
+
+8. `numbers` Module
+   a. Added `round_sigfig` function.
+   b. Added `words2int` function to convert English words to integers.
+
+9. `plotting` Module
+   a. Renamed the `color` function to `colortext`.
+
+10. `seqs` Module
+    a. Updated `stirling1` function with a new `sign` parameter.
+
+11. `special` Module
+    a. Added `ellipe` and `ellipk` functions for complete elliptic integrals.
+
+12. `symbols` Module
+    a. Added `Expr` class.
+    b. Added `build_expr_tree`, `infix2postfix`, and `tokenize` functions.
+    c. The `parse_expr` function now returns an `Expr` object (previously returned a `list`).
+
+13. `ufuncs` Module
+    a. Renamed comparison functions to follow more explicit naming conventions:
+       i. `eq` renamed to `equal`
+       ii. `ge` renamed to `greater_equal`
+       iii. `gt` renamed to `greater_than`
+       iv. `le` renamed to `less_equal`
+       v. `lt` renamed to `less_than`
+       vi. `ne` renamed to `not_equal`
 
 !=!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=
 ```
@@ -274,7 +267,7 @@ PyPyNum
 │   ├── CLASS
 │   └── FUNCTION
 │       ├── atbash(text: str) -> str
-│       ├── base_64(text: str, decrypt: bool) -> str
+│       ├── base_64(text: bytes, decrypt: bool) -> bytes
 │       ├── caesar(text: str, shift: int, decrypt: bool) -> str
 │       ├── hill256(text: bytes, key: list, decrypt: bool) -> bytes
 │       ├── ksa(key: bytes) -> list
@@ -377,7 +370,7 @@ PyPyNum
 │   ├── CLASS
 │   │   └── Group(object)/__init__(self: Any, data: Any, operation: Any) -> Any
 │   └── FUNCTION
-│       └── group(data: Any) -> Any
+│       └── group(data: Any, operation: Any) -> Any
 ├── hypcmpnms
 │   ├── CLASS
 │   │   ├── Euler(object)/__init__(self: Any, y: typing.Union[int, float], p: typing.Union[int, float], r: typing.Union[int, float]) -> Any
@@ -392,9 +385,26 @@ PyPyNum
 │   ├── CLASS
 │   │   ├── BMP(pypynum.images.BaseImage)/__init__(self: Any) -> None
 │   │   ├── BaseImage(object)/__init__(self: Any) -> None
+│   │   ├── JPEG(pypynum.images.BaseImage)/__init__(self: Any) -> None
 │   │   └── PNG(pypynum.images.BaseImage)/__init__(self: Any) -> None
 │   └── FUNCTION
-│       └── crc(data: Any, length: Any, init: Any, xor: Any) -> Any
+│       ├── entropy(data: typing.Any) -> float
+│       ├── jpeg_adjust_qtable(qtable: typing.Union[list, tuple], quality: int) -> list
+│       ├── jpeg_category(data: typing.Any, reverse: bool) -> typing.Any
+│       ├── jpeg_channel_encoding(matrix: list, quality: int, mode: int) -> tuple
+│       ├── jpeg_chroma_dc_huff(data: typing.Any, reverse: bool) -> typing.Any
+│       ├── jpeg_dct8x8(block: typing.Union[list, tuple], reverse: bool) -> list
+│       ├── jpeg_decode_pixels(scan_data: bytes, lqtable: list, cqtable: list, width: int, height: int) -> list
+│       ├── jpeg_encode_pixels(pixels: typing.Union[list, tuple], quality: int) -> tuple
+│       ├── jpeg_luma_dc_huff(data: typing.Any, reverse: bool) -> typing.Any
+│       ├── jpeg_rle_decoding(sequence: typing.Union[list, tuple]) -> list
+│       ├── jpeg_rle_encoding(sequence: typing.Union[list, tuple]) -> list
+│       ├── jpeg_split_pixels(matrix: list) -> list
+│       ├── jpeg_zigzag(data: typing.Union[list, tuple], reverse: bool) -> list
+│       ├── png_apply_filter(pixels: list, above_pixels: list, filter_type: int) -> list
+│       ├── png_reverse_filter(pixels: list, above_pixels: list, filter_type: int) -> list
+│       ├── rgb2ycbcr(weights: typing.Union[list, tuple]) -> tuple
+│       └── ycbcr2rgb(weights: typing.Union[list, tuple]) -> tuple
 ├── interp
 │   ├── CLASS
 │   └── FUNCTION
@@ -419,6 +429,7 @@ PyPyNum
 │       ├── 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
+│       ├── matmul8x8kernel(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
@@ -481,6 +492,7 @@ PyPyNum
 │       ├── 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
+│       ├── dsigmoid(x: typing.Union[int, float]) -> float
 │       ├── erf(x: typing.Union[int, float]) -> float
 │       ├── exgcd(a: int, b: int) -> tuple
 │       ├── exp(x: typing.Union[int, float]) -> typing.Union[int, float]
@@ -524,7 +536,7 @@ PyPyNum
 │       ├── 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], ddof: int) -> typing.Union[int, float, complex]
-│       ├── sumprod(arrays: typing.Union[list, tuple]) -> typing.Union[int, float, complex]
+│       ├── sumprod(arrays: typing.Union[list, tuple], floating: bool) -> 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
@@ -537,13 +549,14 @@ PyPyNum
 │   │   └── Matrix(pypynum.arrays.Array)/__init__(self: Any, data: Any, check: Any) -> Any
 │   └── FUNCTION
 │       ├── cholesky(matrix: pypynum.matrices.Matrix, hermitian: bool) -> pypynum.matrices.Matrix
+│       ├── dctmtx(n: int) -> pypynum.matrices.Matrix
 │       ├── diag(v: typing.Any, k: int, n: int, m: int) -> typing.Any
 │       ├── diag_indices(n: int, k: int, m: int) -> tuple
 │       ├── 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
+│       ├── mat(data: typing.Any) -> pypynum.matrices.Matrix
 │       ├── 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
@@ -591,8 +604,9 @@ PyPyNum
 │       ├── int2words(integer: int) -> str
 │       ├── parse_float(s: str) -> tuple
 │       ├── roman2int(roman_num: str) -> int
-│       ├── split_float(s: str) -> tuple
-│       └── str2int(string: str) -> int
+│       ├── round_sigfig(number: str, n: int, scientific: bool) -> str
+│       ├── str2int(string: str) -> int
+│       └── words2int(words: str) -> int
 ├── plotting
 │   ├── CLASS
 │   └── FUNCTION
@@ -600,7 +614,7 @@ PyPyNum
 │       ├── 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
+│       ├── colortext(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
@@ -652,7 +666,7 @@ PyPyNum
 │       ├── 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
+│       ├── stirling1(n: int, sign: bool) -> list
 │       ├── stirling2(n: int) -> list
 │       ├── sylvester(n: int, single: bool) -> typing.Union[int, list]
 │       ├── tetranacci(n: int, single: bool) -> typing.Union[int, list]
@@ -666,6 +680,8 @@ PyPyNum
 │       ├── 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]
+│       ├── ellipe(m: typing.Union[int, float, complex]) -> typing.Union[int, float, complex]
+│       ├── ellipk(m: 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]
@@ -697,8 +713,12 @@ PyPyNum
 │       └── skewtest(data: list, two_tailed: bool) -> tuple
 ├── symbols
 │   ├── CLASS
+│   │   └── Expr(object)/__init__(self: Any, tree: typing.Union[str, pypynum.trees.BinaryTree]) -> Any
 │   └── FUNCTION
-│       └── parse_expr(expr: str) -> list
+│       ├── build_expr_tree(postfix_expr: list) -> pypynum.trees.BinaryTree
+│       ├── infix2postfix(infix_expr: list) -> list
+│       ├── parse_expr(expr: str) -> pypynum.symbols.Expr
+│       └── tokenize(expr: str) -> list
 ├── tensors
 │   ├── CLASS
 │   │   └── Tensor(pypynum.arrays.Array)/__init__(self: Any, data: Any, check: Any) -> Any
@@ -758,15 +778,15 @@ PyPyNum
 │       ├── 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
+│       ├── equal(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
+│       ├── greater_equal(x: Any, y: Any) -> Any
+│       ├── greater_than(x: Any, y: Any) -> Any
+│       ├── less_equal(x: Any, y: Any) -> Any
+│       ├── less_than(x: Any, y: Any) -> Any
 │       ├── modulo(x: Any, y: Any) -> Any
 │       ├── multiply(x: Any, y: Any) -> Any
-│       ├── ne(x: Any, y: Any) -> Any
+│       ├── not_equal(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
@@ -776,7 +796,8 @@ PyPyNum
 │   │   ├── 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
+│   │   ├── OrderedSet(object)/__init__(self: Any, sequence: Any) -> Any
+│   │   └── RadixInt(object)/__init__(self: Any, number: Any, base: Any) -> Any
 │   └── FUNCTION
 ├── vectors
 │   ├── CLASS
@@ -874,7 +895,6 @@ PyPyNum
         ├── 序列滚动(序列: 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

pypynum/__init__.py

@@ -11,9 +11,9 @@ r"""
 PyPyNum
 ==========
 
-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.
+PyPyNum is a versatile Python math lib. It features modules for math, data analysis, arrays, crypto, physics, RNG,
+data proc, stats, eq solving, image proc, interp, matrix calc, and high-prec math. Designed for scientific computing,
+data science, and ML, it offers efficient, general-purpose tools.
 
 Copyright
 ==========
@@ -68,7 +68,7 @@ from .ufuncs import *
 from .utils import *
 from .vectors import *
 
-__version__ = "1.17.1"
+__version__ = "1.18.0"
 print("PyPyNum", "Version -> " + __version__, "PyPI -> https://pypi.org/project/PyPyNum/",
       "Gitee -> https://www.gitee.com/PythonSJL/PyPyNum", "GitHub -> https://github.com/PythonSJL/PyPyNum", sep=" | ")
 for key, value in tuple(globals().items()):

pypynum/arrays.py

@@ -173,12 +173,37 @@ class Array:
             raise ValueError("Exponential and modulus must both be arrays or numbers")
 
     __radd__ = __add__
-    __rsub__ = __sub__
     __rmul__ = __mul__
-    __rtruediv__ = __truediv__
-    __rfloordiv__ = __floordiv__
-    __rmod__ = __mod__
-    __rpow__ = __pow__
+
+    def __rsub__(self, other):
+        if isinstance(other, (int, float, complex)):
+            return fill(self.shape, [other - t for t in self.flatten()], rtype=type(self))
+        else:
+            raise ValueError("Another must be an array or number")
+
+    def __rtruediv__(self, other):
+        if isinstance(other, (int, float, complex)):
+            return fill(self.shape, [other / t for t in self.flatten()], rtype=type(self))
+        else:
+            raise ValueError("Another must be an array or number")
+
+    def __rfloordiv__(self, other):
+        if isinstance(other, (int, float, complex)):
+            return fill(self.shape, [other // t for t in self.flatten()], rtype=type(self))
+        else:
+            raise ValueError("Another must be an array or number")
+
+    def __rmod__(self, other):
+        if isinstance(other, (int, float, complex)):
+            return fill(self.shape, [other % t for t in self.flatten()], rtype=type(self))
+        else:
+            raise ValueError("Another must be an array or number")
+
+    def __rpow__(self, other):
+        if isinstance(other, (int, float, complex)):
+            return fill(self.shape, [other ** t for t in self.flatten()], rtype=type(self))
+        else:
+            raise ValueError("Exponential must be an array or number")
 
     def __gt__(self, other):
         return self.comparison(other, lambda x, y: x > y)
@@ -200,12 +225,12 @@ class Array:
 
     def comparison(self, other, func):
         from .ufuncs import apply, base_ufunc
-        if isinstance(other, (int, float, complex)):
-            return apply(self, lambda x: func(x, other), BoolArray)
-        elif isinstance(other, Array):
+        if isinstance(other, Array):
             if self.shape != other.shape:
                 raise ValueError("Shapes must be equal for element-wise comparison")
             return base_ufunc(self, other, func=func, rtype=BoolArray)
+        elif isinstance(other, (int, float, complex)):
+            return apply(self, lambda x: func(x, other), BoolArray)
         else:
             raise TypeError("Unsupported operand type(s) for comparison: '{}' and '{}'".format(type(self), type(other)))
 
@@ -376,7 +401,7 @@ def fill(shape: arr, sequence: ite = None, repeat: bool = True, pad: Any = 0, rt
     for item in shape:
         length *= item
     if sequence is None:
-        sequence = list(range(length))
+        sequence = tuple(range(length))
     total = len(sequence)
     last = total - 1
 

pypynum/ciphers.py

@@ -15,13 +15,13 @@ __MORSE_CODE = {
 __MORSE_CODE_REVERSE = {v: k for k, v in __MORSE_CODE.items()}
 
 
-def base_64(text: str, decrypt: bool = False) -> str:
-    base64_chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
+def base_64(text: bytes, decrypt: bool = False) -> bytes:
+    base64_chars = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
     base64_index = {c: i for i, c in enumerate(base64_chars)}
-    base64_padding = "="
+    base64_padding = b"="
 
     def base64_encode(data):
-        encoded = ""
+        encoded = bytearray()
         remainder = len(data) % 3
         padding_len = 3 - remainder if remainder else 0
         for i in range(0, len(data) - remainder, 3):
@@ -29,18 +29,18 @@ def base_64(text: str, decrypt: bool = False) -> str:
             int_value = (chunk[0] << 16) + (chunk[1] << 8) + chunk[2]
             for j in range(4):
                 bits = (int_value >> (6 * (3 - j))) & 0x3F
-                encoded += base64_chars[bits]
+                encoded.append(base64_chars[bits])
         if padding_len:
             chunk = data[-remainder:]
             binary = "".join([format(i, "08b") for i in chunk]) + "0" * (6 - len(chunk) * 8 % 6)
-            encoded += "".join([base64_chars[int(binary[j:j + 6], 2)] for j in range(
-                0, len(binary), 6)]) + base64_padding * (padding_len % 3)
-        return encoded
+            encoded.extend([base64_chars[int(binary[j:j + 6], 2)] for j in range(0, len(binary), 6)])
+            encoded.extend(base64_padding * (padding_len % 3))
+        return bytes(encoded)
 
     def base64_decode(encoded):
-        encoded = encoded.replace("\n", "").replace(" ", "")
+        encoded = encoded.replace(b"\n", b"").replace(b" ", b"")
         decoded = b""
-        if not all([c in base64_chars or c == base64_padding for c in encoded]):
+        if not all([c in base64_chars or c == 61 for c in encoded]):
             raise ContentError
         position = encoded.find(base64_padding)
         padding_len = len(encoded) - position if position != -1 else 0
@@ -67,11 +67,9 @@ def base_64(text: str, decrypt: bool = False) -> str:
         return decoded
 
     if decrypt:
-        decoded_bytes = base64_decode(text).decode("UTF-8")
-        return decoded_bytes
+        return base64_decode(text)
     else:
-        encoded_bytes = base64_encode(text.encode("UTF-8"))
-        return encoded_bytes
+        return base64_encode(text)
 
 
 def atbash(text: str) -> str:
@@ -206,7 +204,6 @@ def playfair(text: str, key: str, decrypt: bool = False) -> str:
 def hill256(text: bytes, key: list, decrypt: bool = False) -> bytes:
     from .arrays import fill
     from .matrices import mat
-
     def decrypt_key(k):
         try:
             det = round(k.det())

pypynum/dists.py

@@ -57,7 +57,7 @@ def cauchy_pdf(x, x0, gamma):
     Cauchy probability density function
 
     Example
-    =========
+    ==========
     >>> cauchy_pdf(0, 0, 1)
     0.3183098861837907
     >>>
@@ -74,10 +74,12 @@ def cauchy_pdf(x, x0, gamma):
 
 def cauchy_cdf(x, x0, gamma):
     """
+    Introduction
+    ==========
     Cauchy cumulative distribution function
 
     Example
-    =========
+    ==========
     >>> cauchy_cdf(0, 0, 1)
     0.5
     >>>
@@ -133,8 +135,8 @@ def chi2_cdf(x, df=1):
     :return: The probability density at x for the Chi-squared distribution with df degrees of freedom.
     """
     from math import gamma
-    from .maths import lower_gamma
-    return lower_gamma(df / 2, x / 2) / gamma(df / 2)
+    from .maths import lowergamma
+    return lowergamma(df / 2, x / 2) / gamma(df / 2)
 
 
 def expon_pdf(x, scale=1.0):
@@ -291,7 +293,7 @@ def invgauss_pdf(x, mu, lambda_, alpha):
     Inverse Gaussian (inverse normal) probability density function
 
     Example
-    =========
+    ==========
     >>> invgauss_pdf(1, 1, 1, 1)
     0.3989422804014327
     >>>
@@ -317,7 +319,7 @@ def levy_pdf(x, c):
     Lévy probability density function
 
     Example
-    =========
+    ==========
     >>> levy_pdf(1, 1)
     0.24197072451914337
     >>>
@@ -339,7 +341,7 @@ def log_logistic_pdf(x, alpha, beta):
     Log-logistic probability density function
 
     Example
-    =========
+    ==========
     >>> log_logistic_pdf(1, 1, 1)
     0.25
     >>>
@@ -363,7 +365,7 @@ def log_logistic_cdf(x, alpha, beta):
     Log-logistic cumulative distribution function
 
     Example
-    =========
+    ==========
     >>> log_logistic_cdf(1, 1, 1)
     0.5906161091496412
     >>>
@@ -387,7 +389,7 @@ def logistic_pdf(x, mu=0, s=1):
     Logistic probability density function
 
     Example
-    =========
+    ==========
     >>> logistic_pdf(0, 0, 1)
     0.25
     >>>
@@ -409,7 +411,7 @@ def logistic_cdf(x, mu=0, s=1):
     Logistic cumulative distribution function
 
     Example
-    =========
+    ==========
     >>> logistic_cdf(0, 0, 1)
     0.5
     >>>
@@ -502,7 +504,7 @@ def multinomial_pmf(k, n, p):
     Multinomial probability mass function
 
     Example
-    =========
+    ==========
     >>> multinomial_pmf([2, 1, 0], 3, [0.5, 0.4, 0.1])
     0.30000000000000004
     >>>
@@ -636,7 +638,7 @@ def pareto_pdf(x, k, m):
     Pareto probability density function
 
     Example
-    =========
+    ==========
     >>> pareto_pdf(10, 2, 5)
     0.00040000000000000013
     >>>
@@ -679,7 +681,7 @@ def rayleigh_pdf(x, sigma):
     Rayleigh probability density function
 
     Example
-    =========
+    ==========
     >>> rayleigh_pdf(1, 1)
     0.6065306597126334
     >>>
@@ -840,7 +842,7 @@ def zipf_pmf(k, s, n):
     Zipf probability mass function
 
     Example
-    =========
+    ==========
     >>> zipf_pmf(1, 1, 10)
     0.34141715214740553
     >>>