hhltools 1.2.7__py2.py3-none-any.whl

HHLtools/ADT.py

@@ -0,0 +1,279 @@
+from collections.abc import Iterable
+from HHLtools.Herror import *
+class Queue:
+    def __init__(self,size:int = -1):
+        """
+        :param size: the fixed size of the queue, if not set, infinite length
+        """
+        if size > 0:
+            self.__size = size
+            self.__queue = [None] * size
+            self.__head = 0
+            self.__tail = 0
+            self.__count = 0
+        else:
+            self.__size = -1
+            self.__queue = []
+
+    def __repr__(self):
+        if self.__size != -1:
+            return f'Queue({str(self.__queue)}, ' \
+               f'headPointer = {self.__head if self.__size != -1 else len(self.__queue) - 1}, ' \
+               f'tailPointer = {self.__tail if self.__size != -1 else 0}, Fixedlength = True)'
+        else:
+            return f'Queue({str(self.__queue)})'
+
+    def __len__(self):
+        return self.__count if self.__size != -1 else len(self.__queue)
+
+    def __iter__(self):
+        return iter(self.getlist())
+
+    def __contains__(self, item):
+        return item in self.getlist()
+
+    def __getitem__(self, item):
+        return self.getlist()[int(item)]
+
+    def __eq__(self, other):
+        return self.getlist() == other.getlist()
+
+    def getlist(self):
+        contents = []
+        if self.__size == -1:
+            contents = self.__queue[:]
+        else:
+            head = self.__head
+            while 1:
+                contents.append(self.__queue[head])
+                head += 1
+                head = head % self.__size
+                if head == self.__tail:
+                    break
+        return contents
+
+    def show(self):
+        contents = self.__queue
+        maxlen = 0
+        for c in contents:
+            if len(str(c)) > maxlen:
+                maxlen = len(str(c))
+        print('='*(15+maxlen+15))
+        for c in range(len(contents)):
+            front = ' '*15
+            end = ' '
+            if c == self.__head:
+                front = 'headPointer    '
+            if c == self.__tail:
+                end = (maxlen+4)*' ' +'tailPointer'
+            print(front+str(contents[c])+' '*(maxlen-len(str(contents[c])))+end)
+        print('=' * (15 + maxlen + 15))
+
+    def push(self, content):
+        # if type(content) not in (int, str, float):
+        #     error(TypeError, f"push() argument must be an integer, a string, or a real number, not {str(type(content))[7:-1]}")
+        if self.__size > 0:
+            if self.__count == self.__size:
+                error(IndexOutOfBoundError, 'the queue is full, try pop()')
+                return
+            self.__queue[self.__tail] = content
+            self.__tail = (self.__tail+1)%self.__size
+            self.__count += 1
+        else:
+            self.__queue.append(content)
+
+    def pop(self):
+        if self.__size > 0:
+            if self.__count == 0:
+                return None
+            tmp = self.__head
+            self.__head = (self.__head + 1)%self.__size
+            self.__count -= 1
+            return self.__queue[tmp]
+        else:
+            try:
+                res = self.__queue[0]
+                del self.__queue[0]
+                return res
+            except IndexError:
+                return None
+
+
+class Stack:
+    def __init__(self,size:int=-1):
+        """
+
+        :param size: the fixed size of the stack, if not set, infinite length
+        """
+        self.a = 0
+        if size > 0:
+            self.__stack = [None]*size
+            self.__size = size
+        else:
+            self.__stack = []
+            self.__size = -1
+        self.__top = -1
+
+    def __repr__(self):
+        if self.__size != -1:
+            return f'Stack({str(self.__stack)}, topPointer = {self.__top})'
+        else:
+            return f'Stack({str(self.__stack)})'
+
+    def __len__(self):
+        return self.__top if self.__size != -1 else len(self.__stack)
+
+    def __iter__(self):
+        return iter(self.getlist())
+
+    def __contains__(self, item):
+        return item in self.getlist()
+
+    def __getitem__(self, item):
+        return self.getlist()[int(item)]
+
+    def __eq__(self, other):
+        return self.getlist() == other.getlist()
+
+    def getlist(self):
+        contents = []
+        if self.__size == -1:
+            contents = self.__stack[:]
+        else:
+            for i in range(0, self.__top):
+                contents.append(self.__stack[i])
+        return contents
+
+    def push(self, content):
+        # if type(content) not in (int, str, float):
+        #     error(TypeError, f"push() argument must be an integer, a string, or a real number, not {str(type(content))[7:-1]}")
+        if self.__size > 0:
+            if self.__top < self.__size - 1:
+                self.__top += 1
+                self.__stack[self.__top] = content
+            else:
+                error(IndexOutOfBoundError, 'the stack is full, try pop()')
+        else:
+            self.__stack.insert(0,content)
+
+    def pop(self):
+        if self.__size > 0:
+            if self.__top > -1:
+                self.__top -= 1
+                return self.__stack[self.__top + 1]
+            else:
+                return None
+        else:
+            try:
+                res = self.__stack[0]
+                del self.__stack[0]
+                return res
+            except IndexError:
+                return None
+
+
+
+class LinkedListNode:
+    def __init__(self, val):
+        # if type(val) not in (int, str, float):
+        #     error(TypeError, f"an element in linked list must be an integer, a string, or a real number, not {str(type(val))[7:-1]}")
+        self.val = val
+        self.next = None
+
+    def __repr__(self):
+        content = []
+        temp = self
+        while temp.next is not None:
+            content.append(temp.val)
+            temp = temp.next
+        content.append(temp.val)
+        return f'LinkedList({content})'
+
+    def __iter__(self):
+        return iter(self.getlist())
+
+    def __contains__(self, item):
+        return item in self.getlist()
+
+    def __getitem__(self, item):
+        return self.getlist()[int(item)]
+
+    def __eq__(self, other):
+        return self.getlist() == other.getlist()
+
+    def __add__(self, other):
+        if type(other) != LinkedListNode:
+            error(TypeError, f"unsupported operand type(s) for +: 'LinkedListNode' and {str(type(other))[7:-1]}")
+        temp = self
+        while temp.next is not None:
+            temp = temp.next
+        temp.next = other
+        return self
+
+    def getlist(self):
+        content = []
+        temp = self
+        while temp is not None:
+            content.append(temp.val)
+            temp = temp.next
+        return content
+
+def create_linkedlist_from_list(lst:list):
+    if not isinstance(lst, Iterable):
+        error(TypeError, f"'{type(lst)}' object is not iterable")
+    if len(lst) == 0:
+        return LinkedListNode(None)
+    node = LinkedListNode(lst[0])
+    temp = node
+    for i in lst[1:]:
+        temp.next = LinkedListNode(i)
+        temp = temp.next
+    return node
+
+def create_stack_from_list(lst:list, Fixedlength:bool = True):
+    if not isinstance(lst, Iterable):
+        error(TypeError, f"'{type(lst)}' object is not iterable")
+
+    if Fixedlength:
+        stack = Stack(len(lst))
+    else:
+        stack = Stack()
+    for i in lst:
+        stack.push(i)
+    return stack
+
+def create_queue_from_list(lst:list, Fixedlength:bool = True):
+    if not isinstance(lst, Iterable):
+        error(TypeError, f"'{type(lst)}' object is not iterable")
+
+    if Fixedlength:
+        queue = Queue(len(lst))
+    else:
+        queue = Queue()
+    for i in lst:
+        queue.push(i)
+    return queue
+
+
+
+def BinarySearch(iterable, target):
+    if not isinstance(iterable, Iterable):
+        error(TypeError, f"'{type(iterable)}' object is not iterable")
+    found = False
+    highIndex = len(iterable)-1
+    lowIndex = 0
+    while not found and lowIndex <= highIndex:
+        mid = (highIndex + lowIndex) // 2
+        if iterable[mid] == target:
+            found = True
+            print(mid)
+        elif iterable[mid] > target:
+            highIndex = mid - 1
+        else:
+            lowIndex = mid + 1
+
+    if not found:
+        print("not found")
+
+
+

HHLtools/Herror.py

@@ -0,0 +1,23 @@
+import sys, types, traceback
+
+
+def error(err, info):
+    try:
+        raise err(info)
+    except:
+        ei = sys.exc_info()
+        back_frame = ei[2].tb_frame.f_back
+        back_tb = types.TracebackType(tb_next=None,
+                                      tb_frame=back_frame,
+                                      tb_lasti=back_frame.f_lasti,
+                                      tb_lineno=back_frame.f_lineno)
+        traceback.print_exception(ei[0], ei[1], tb=back_tb)
+        sys.exit(1)
+
+
+class DimensionError(Exception):
+    pass
+
+
+class IndexOutOfBoundError(Exception):
+    pass

HHLtools/Hmath.py

@@ -0,0 +1,132 @@
+from HHLtools.Herror import *
+
+class Function:
+    def __init__(self, expression: str, variable: str):
+        if type(expression) != str:
+            error(TypeError, f"the expression must be a string, not '{str(type(expression))[7:-1]}'")
+        if type(variable) != str:
+            error(TypeError, f"the variable must be a string, not '{str(type(variable))[7:-1]}'")
+        self.__expression = expression
+        self.__var = variable
+
+    def evaluate(self, value: int | float):
+        if type(value) not in (int, float):
+            error(TypeError, f"the value must be an integer, or a real number, not '{str(type(value))[7:-1]}'")
+        expression = self.__expression.replace(self.__var, str(value))
+        return eval(expression)
+
+    def gradient(self, accuracy: float, value: int | float):
+        if type(value) not in (int, float):
+            error(TypeError, f"the value must be an integer, or a real number, not '{str(type(value))[7:-1]}'")
+        if type(accuracy) != float:
+            error(TypeError, f"the acuuracy must be a real number, not '{str(type(value))[7:-1]}'")
+        x1 = value
+        x2 = value + 10 ** -accuracy
+        y1 = self.evaluate(x1)
+        y2 = self.evaluate(x2)
+        res = (y2 - y1) / (x2 - x1)
+        return round(res, 1) if res - int(res) > 0.999 or res - int(res) < 0.001 else round(res, 3)
+
+
+
+class Vector:
+    def __init__(self, dimensions:list):
+        """
+        only support two-dimensional and three-dimensional vectors
+        :param dimensions: the components of the vector in i, j(, k) directions
+        """
+        if len(dimensions) != 2 and len(dimensions) != 3:
+            error(DimensionError, f'expected 2 or 3 dimensions, got {len(dimensions)}')
+        self.dimensions = dimensions
+
+    def __repr__(self):
+        return f'Vector({self.dimensions})'
+
+    def __len__(self):
+        return len(self.dimensions)
+
+    def __eq__(self, other):
+        return self.dimensions == other.dimensions
+
+    def __add__(self, other):
+        if type(other) != Vector:
+            error(TypeError, f"unsupported operand type(s) for +: 'Vector' and {str(type(other))[7:-1]}")
+        if len(self) != len(other):
+            error(DimensionError, f'unsupported operand dimension(s) for +: Vectors of different dimensions')
+        res = [self.dimensions[i] + other.dimensions[i] for i in range(len(self))]
+        return Vector(res)
+
+    def __sub__(self, other):
+        if type(other) != Vector:
+            error(TypeError, f"unsupported operand type(s) for -: 'Vector' and {str(type(other))[7:-1]}")
+        if len(self) != len(other):
+            error(DimensionError, f"unsupported operand dimension(s) for -: Vectors of different dimensions")
+        res = [self.dimensions[i] - other.dimensions[i] for i in range(len(self))]
+        return Vector(res)
+
+    def __mul__(self, other):
+        if type(other) == int:
+            return Vector([other * i for i in self.dimensions])
+        elif type(other) == Vector:
+            if len(self) != len(other):
+                error(DimensionError, f"unsupported operand dimension(s) for *: Vectors of different dimensions")
+            return sum([self.dimensions[i] * other.dimensions[i] for i in range(len(self))])
+        else:
+            error(TypeError, f"unsupported operand type(s) for *: 'Vector' and {str(type(other))[7:-1]}")
+
+    def __rmul__(self, other):
+        if type(other) == int:
+            return Vector([other * i for i in self.dimensions])
+        elif type(other) == Vector:
+            if len(self) != len(other):
+                error(DimensionError, f"unsupported operand dimension(s) for *: Vectors of different dimensions")
+            return sum([self.dimensions[i] * other.dimensions[i] for i in range(len(self))])
+        else:
+            error(TypeError, f"unsupported operand type(s) for *: {str(type(other))[7:-1]} and 'Vector'")
+
+    def __abs__(self):
+        return sum([i**2 for i in self.dimensions])**(1/2)
+
+    def __matmul__(self, other):
+        if type(other) != Vector:
+            error(TypeError, f"unsupported operand type(s) for @: 'Vector' and {str(type(other))[7:-1]}")
+        if len(self.dimensions) != 3 or len(other.dimensions) != 3:
+            error(DimensionError, f"unsupported operand dimension(s) for @: Not 3 dimension Vector(s)")
+        x = self.dimensions[1] * other.dimensions[2] - self.dimensions[2] * other.dimensions[1]
+        y = self.dimensions[2] * other.dimensions[0] - self.dimensions[0] * other.dimensions[2]
+        z = self.dimensions[0] * other.dimensions[1] - self.dimensions[1] * other.dimensions[0]
+        return Vector([x,y,z])
+
+class Line:
+    _chars = []
+    def __init__(self, position:Vector, direction:Vector, scalar:str):
+        if len(position) != 3:
+            error(DimensionError, f'expected 3 dimensions, got {len(position)}')
+        if len(direction) != 3:
+            error(DimensionError, f'expected 3 dimensions, got {len(direction)}')
+        chars = self.__class__._chars
+        if scalar in chars:
+            error(NameError, f"duplicated scalar symbol {scalar}")
+        chars.append(scalar)
+        self.position = position
+        self.direction = direction
+        self.scalar = scalar
+
+    def __repr__(self):
+        pos = self.position.dimensions
+        di = self.direction.dimensions
+        return f'({pos[0] if pos[0] != 1 else ""}i+' \
+               f'{pos[1] if pos[1] != 1 else ""}j+' \
+               f'{pos[2] if pos[2] != 1 else ""}k) + ' \
+               f'{self.scalar}' \
+               f'({di[0] if di[0] != 1 else ""}i+' \
+               f'{di[1] if di[1] != 1 else ""}j+' \
+               f'{di[2] if di[2] != 1 else ""}k)'
+
+
+p = Vector([1,2,3])
+d = Vector([1,2,3])
+l1 = Line(p, d, 'r')
+
+print(l1)
+

HHLtools/__init__.py

@@ -0,0 +1,18 @@
+"""
+HHLtools
+
+DESCRIPTION
+===================================================
+Noting here, but you can import my sub-packages
+
+ADT: support some abstract data types
+CN: support some Chinese keywords
+Herror: some of my custom errors
+Hmath: some math functions
+prints: support print with different styles
+===================================================
+"""
+
+
+
+

HHLtools/lang.py

@@ -0,0 +1,34 @@
+真 = True
+假 = False
+输出 = print
+输入 = input
+范围 = range
+整型 = int
+浮点型 = float
+字符串 = str
+长度 = len
+解析 = eval
+最大值 = max
+最小值 = min
+打开 = open
+绝对值 = abs
+字符 = chr
+执行 = exec
+是否属于 = isinstance
+编号 = ord
+保留小数 = round
+求和 = sum
+
+
+
+class IO:
+    def __init__(self):
+        pass
+    def __lshift__(self, other):
+        print(other)
+
+cout = IO()
+
+
+
+

HHLtools/prints.py

@@ -0,0 +1,43 @@
+from HHLtools.Herror import *
+
+
+class FontStyle:
+    DEFAULT = 0
+    BOLD = 1
+    UNDERLINE = 4
+    BLINK = 5
+    REVERSE = 7
+
+
+class FontColor:
+    BLACK = 30
+    RED = 31
+    GREEN = 32
+    YELLOW = 33
+    BLUE = 34
+    PURPLE = 35
+    CYAN = 36
+    WHITE = 37
+
+
+class BackgroundColor:
+    DEFAULT = 0
+    BLACK = 40
+    RED = 41
+    GREEN = 42
+    YELLOW = 43
+    BLUE = 44
+    PURPLE = 45
+    CYAN = 46
+    WHITE = 47
+
+
+def prints(content, fontStyle=None, fontColor=None, backgroundColor=None):
+    codes = []
+    if fontStyle is not None and fontStyle != 0:
+        codes.append(str(fontStyle))
+    if fontColor is not None:
+        codes.append(str(fontColor))
+    if backgroundColor is not None:
+        codes.append(str(backgroundColor))
+    print(f"\033[{';'.join(codes)}m{content}\033[0m")

hhltools-1.2.7.dist-info/METADATA

@@ -0,0 +1,68 @@
+Metadata-Version: 2.1
+Name: hhltools
+Version: 1.2.7
+Summary: A tool for CAIE 9618 learner, and some math function
+Author: hhaolin
+Author-email: 2813579566@qq.com
+License: MIT
+Keywords: HHLtools
+Platform: all
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Natural Language :: Chinese (Simplified)
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.5
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Libraries
+
+HHLTools
+--------------------------
+2022/8/7:
+    | 1.0.0 The FIRST version!
+    | 1.0.1 fix bugs
+    | 1.0.2 add fibonacci
+    | 1.0.3 fix bugs
+
+2022/9/17:
+    | 1.0.4 add stack and queue
+
+2022/9/28
+    | 1.0.5 fix bugs
+
+2022/10/2
+    | 1.0.6 add Hmath
+
+2022/10/28
+    | 1.0.7 add prints,python 3.11 available
+
+2022/11/4
+    | 1.0.8 Chinese extension
+    | 1.0.8.1 fix bugs
+
+2023/4/21
+    | 1.1.0 add linked list, and some useful modifications to previous function
+
+2023/4/22
+    | 1.2.0 fix bugs, modify the error display, add Vector (only 2 or 3 dimensions)
+    | 1.2.1 fix bugs, remove fibonacci
+
+2023/12/20
+    | 1.2.2 fix bugs
+    | 1.2.3 fix bugs
+    | 1.2.4 fix bugs
+
+2026/2/12
+    | 1.2.6 fix prints bugs
+
+2026/9/3
+    | 1.2.7 fix bugs
+
+

hhltools-1.2.7.dist-info/RECORD

@@ -0,0 +1,11 @@
+HHLtools/ADT.py,sha256=SJLqUdqFf7r3C_qyue_RaM4BNhbd2vUyNxXBeTMP6H8,8172
+HHLtools/Herror.py,sha256=XRCgJorxrf9GnX_YpBlUj2VAMqQzvtjlKp2R5w7Sahk,590
+HHLtools/Hmath.py,sha256=dnBSXLRUu42pzvwkuTSfz81QVjvUbmkzXIlV6L9ZT40,5755
+HHLtools/RPN.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+HHLtools/__init__.py,sha256=UeFqPVt9a9xE5ODubTwIPnEJQGKkr1gwtpMokoN0Fe8,381
+HHLtools/lang.py,sha256=naTpcOymuBqTrV5P8sMAJkUB5uQqev_qsJ_uEMZt9CY,425
+HHLtools/prints.py,sha256=GaxZYuIDf83iS4IGd_2j1OdW5wEFa7mGcZUU5gmxF6g,799
+hhltools-1.2.7.dist-info/METADATA,sha256=9VTXFIWNZ6uKa373NqF2H1IWXKdSRKmqEwL6o--qt-4,1708
+hhltools-1.2.7.dist-info/WHEEL,sha256=z9j0xAa_JmUKMpmz72K0ZGALSM_n-wQVmGbleXx2VHg,110
+hhltools-1.2.7.dist-info/top_level.txt,sha256=iWPR0VidexazFhZwXCYAmN4VW8BPH7H6s7y1PC-UvXE,9
+hhltools-1.2.7.dist-info/RECORD,,

hhltools-1.2.7.dist-info/WHEEL

@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.37.1)
+Root-Is-Purelib: true
+Tag: py2-none-any
+Tag: py3-none-any
+

hhltools-1.2.7.dist-info/top_level.txt

@@ -0,0 +1 @@
+HHLtools