PyPyNum 1.17.2__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.2 | 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,51 +151,64 @@ Python interpreter and run it!
 ```
 !=!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=
 
-Fixed some known issues.
+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`).
 
-The pypynum.utils module has recently introduced a new class
-called RadixInt. This class is designed to facilitate the
-representation and manipulation of integers in various bases,
-ranging from base 2 to base 36.
-
-The RadixInt class within the pypynum.utils module provides a
-robust way to work with integers in custom bases. It allows
-users to initialize instances with either a decimal number or a
-string representation of a number in the desired base. The class
-supports conversion between different bases, as well as basic
-arithmetic operations that can be performed on integers
-represented in various bases.
-
-
-<<< The following are some usage examples >>>
-
-
-from pypynum import RadixInt
-
-# Base-2 and base-10 numbers
-binary_num = RadixInt("1010", 2)
-decimal_num = RadixInt(10, 10)
-print(binary_num)  # Output: (1010)_{2}
-print(decimal_num)  # Output: (10)_{10}
-binary_to_octal = RadixInt("1010", 2).to_base(8)
-print(binary_to_octal)  # Output: (12)_{8}
-# Addition
-result_add = binary_num + decimal_num
-print(result_add)  # Output: (20)_{10}
-# Base-8 and base-10 numbers
-octal_num = RadixInt("123", 8)
-decimal_num = RadixInt(5, 10)
-# Subtraction
-result_sub = octal_num - decimal_num
-print(result_sub)  # Output: (78)_{10}
-# Base-16 and base-2 numbers
-hex_num = RadixInt("1A", 16)
-binary_num = RadixInt("11", 2)
-# Multiplication
-result_mul = hex_num * binary_num
-print(result_mul)  # Output: (78)_{10}
+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`
 
 !=!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=!=
 ```
@@ -254,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
@@ -357,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
@@ -372,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
@@ -399,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
@@ -461,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]
@@ -504,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
@@ -517,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
@@ -571,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
@@ -580,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
@@ -632,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]
@@ -646,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]
@@ -677,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
@@ -738,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
@@ -756,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
@@ -854,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 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.
 
 Copyright
 ==========
@@ -68,7 +68,7 @@ from .ufuncs import *
 from .utils import *
 from .vectors import *
 
-__version__ = "1.17.2"
+__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())