istr-python 1.1.41__tar.gz → 1.1.43__tar.gz

{istr_python-1.1.41 → istr_python-1.1.43}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: istr-python
-Version: 1.1.41
+Version: 1.1.43
 Summary: istr - strings you can count on
 Author-email: Ruud van der Ham <rt.van.der.ham@gmail.com>
 Project-URL: Homepage, https://github.com/salabim/istr
@@ -589,9 +589,6 @@ map(istr.join,filter(istr.prime, istr.combinations(range(10),2)))
     ==> istr('02'), istr('03'), ... istr('89')
 ```
 
-#### version 1.1.30 2026-05-19
-
-
 #### reverse an istr
 
 The method `reversed()` will return an istr with the reversed content:
@@ -855,16 +852,24 @@ istr.getitem('1234',5, None) ==> None
 Note that this method has the advantage that it can accept an istr as index, in contrast to normal indexing.
 
 #### long square root
-The method `long_sqrt` gives a list of  the lines of a long square root. Both the result (root) and the original number, possibly with a trailing 0 are returned, along with the calculated values.
-  E.g. `istr.long_sqrt(123 ** 2)` results in
+The method `long_sqrt` returns an instance of a class with attributes `lines`, `line_lengths` and `output`.  
+
+`lines` is list of the lines of a long square root. Both the result (root) and the original number, possibly with a trailing 0 are returned, along with the calculated values.
+ E.g. `istr.long_sqrt(123 ** 2).lines` results in
 
 `[istr('123'), istr('15129'), istr('1'), istr('51'), istr('44'), istr('729'), istr('729'), istr('0')]`
 
 Note the final `istr('0')` is included to support also long square roots that are not perfect.
 
-The method `long_sqrt`has an optional parameter `as_str`, that can be used to get a nice string representation of the long square root lines.
+`line_lengths` returns a list of the length of the lines (not istr-ed). E.g.:
+
+ E.g. `istr.long_sqrt(123 ** 2).line_lengths` results in
 
-E.g. `print(istr.long_sqrt(123 ** 2, as_str=True))` will print
+`[3, 5, 1, 2, 2, 3, 3, 1]`
+
+`output` can be used to get a nice string representation of the long square root lines.
+
+E.g. `print(istr.long_sqrt(123 ** 2).output)` will print
 ```
   1 2 3
   -----
@@ -882,18 +887,26 @@ E.g. `print(istr.long_sqrt(123 ** 2, as_str=True))` will print
 
 #### long multiplication
 
-The method `long_multiplication` gives a list of all lines to do a long multiplition.
+The method `long_multiplication` returns an instance of a class with attributes `lines`, `line_lengths` and `output`.  
+
+`lines` is list of the lines of a long multiplication.
+
+E.g. `print(istr.long_multiplication(1234,567).lines` will print 
 
-E.g. `print(istr.long_multiplication(1234,567)` will print 
- 
   `[istr('1234'), istr('567'), istr('8638'), istr('7404'), istr('6170'), istr('699678')]`
-  
-The method has an optional parameter `as_str`, that can be used t0 get a nice representation of the long multiplication lines.
-  
-E.g. `print(istr.long_multiplication(1234,567, as_str=True)` will print
+
+`line_lengths` returns a list of the length of the lines (not istr-ed). E.g.:
+
+ E. g. `print(istr.long_multiplication(1234,567).line_lengths` results in
+
+`[4, 3, 4, 4, 4, 6]`
+
+`output` can be used to get a nice string representation of the long multiplication lines.
+
+E.g. `print(istr.long_multiplication(1234, 567).output)` will print
 
 ```
-  1234
+ 1234
    567
 ------ x
   8638
@@ -905,15 +918,23 @@ E.g. `print(istr.long_multiplication(1234,567, as_str=True)` will print
 
 #### long division
 
-The method `long_division` gives a list of all lines to do a long division (note that the divisor and dividend count as separate lines).
+The method `long_division` returns an instance of a class with attributes `lines`, `line_lengths` and `output`.  
 
-E.g. `print(istr.long_division(1395, 45)` will print 
+`lines` is a list of the lines of a long division.
 
-[istr('31'), istr('45'), istr('1395'), istr('135'), istr('45'), istr('45'), istr('0')]
-  
-The method has an optional parameter `as_str`, that can be used to get a nice representation of the long multiplication lines.
-  
-E.g. `print(istr.long_division(1395, 45, as_str=True)` will print 
+E.g. `print(istr.long_division(1395, 45).lines` will print 
+
+`[istr('31'), istr('45'), istr('1395'), istr('135'), istr('45'), istr('45'), istr('0')]`
+
+Note the final `istr('0')` is included to support also long divisions roots that are not perfect.
+
+E.g. `print(istr.long_division(1395, 45).line_lengths` will print 
+
+`[2, 2, 4, 3, 2, 2, 1]`
+
+`output` can be used to get a nice string representation of the long divsion lines.
+
+E.g. `print(istr.long_division(1395, 45).output` will print 
 
 ```
        31
@@ -925,8 +946,8 @@ E.g. `print(istr.long_division(1395, 45, as_str=True)` will print
        45
        --
         0
-```  
-  
+```
+
 #### generate istr with digits
 
 The class method `digits` can be used to return an istr of digits according to a given specification.

{istr_python-1.1.41 → istr_python-1.1.43}/README.md

@@ -576,9 +576,6 @@ map(istr.join,filter(istr.prime, istr.combinations(range(10),2)))
     ==> istr('02'), istr('03'), ... istr('89')
 ```
 
-#### version 1.1.30 2026-05-19
-
-
 #### reverse an istr
 
 The method `reversed()` will return an istr with the reversed content:
@@ -842,16 +839,24 @@ istr.getitem('1234',5, None) ==> None
 Note that this method has the advantage that it can accept an istr as index, in contrast to normal indexing.
 
 #### long square root
-The method `long_sqrt` gives a list of  the lines of a long square root. Both the result (root) and the original number, possibly with a trailing 0 are returned, along with the calculated values.
-  E.g. `istr.long_sqrt(123 ** 2)` results in
+The method `long_sqrt` returns an instance of a class with attributes `lines`, `line_lengths` and `output`.  
+
+`lines` is list of the lines of a long square root. Both the result (root) and the original number, possibly with a trailing 0 are returned, along with the calculated values.
+ E.g. `istr.long_sqrt(123 ** 2).lines` results in
 
 `[istr('123'), istr('15129'), istr('1'), istr('51'), istr('44'), istr('729'), istr('729'), istr('0')]`
 
 Note the final `istr('0')` is included to support also long square roots that are not perfect.
 
-The method `long_sqrt`has an optional parameter `as_str`, that can be used to get a nice string representation of the long square root lines.
+`line_lengths` returns a list of the length of the lines (not istr-ed). E.g.:
+
+ E.g. `istr.long_sqrt(123 ** 2).line_lengths` results in
 
-E.g. `print(istr.long_sqrt(123 ** 2, as_str=True))` will print
+`[3, 5, 1, 2, 2, 3, 3, 1]`
+
+`output` can be used to get a nice string representation of the long square root lines.
+
+E.g. `print(istr.long_sqrt(123 ** 2).output)` will print
 ```
   1 2 3
   -----
@@ -869,18 +874,26 @@ E.g. `print(istr.long_sqrt(123 ** 2, as_str=True))` will print
 
 #### long multiplication
 
-The method `long_multiplication` gives a list of all lines to do a long multiplition.
+The method `long_multiplication` returns an instance of a class with attributes `lines`, `line_lengths` and `output`.  
+
+`lines` is list of the lines of a long multiplication.
+
+E.g. `print(istr.long_multiplication(1234,567).lines` will print 
 
-E.g. `print(istr.long_multiplication(1234,567)` will print 
- 
   `[istr('1234'), istr('567'), istr('8638'), istr('7404'), istr('6170'), istr('699678')]`
-  
-The method has an optional parameter `as_str`, that can be used t0 get a nice representation of the long multiplication lines.
-  
-E.g. `print(istr.long_multiplication(1234,567, as_str=True)` will print
+
+`line_lengths` returns a list of the length of the lines (not istr-ed). E.g.:
+
+ E. g. `print(istr.long_multiplication(1234,567).line_lengths` results in
+
+`[4, 3, 4, 4, 4, 6]`
+
+`output` can be used to get a nice string representation of the long multiplication lines.
+
+E.g. `print(istr.long_multiplication(1234, 567).output)` will print
 
 ```
-  1234
+ 1234
    567
 ------ x
   8638
@@ -892,15 +905,23 @@ E.g. `print(istr.long_multiplication(1234,567, as_str=True)` will print
 
 #### long division
 
-The method `long_division` gives a list of all lines to do a long division (note that the divisor and dividend count as separate lines).
+The method `long_division` returns an instance of a class with attributes `lines`, `line_lengths` and `output`.  
 
-E.g. `print(istr.long_division(1395, 45)` will print 
+`lines` is a list of the lines of a long division.
 
-[istr('31'), istr('45'), istr('1395'), istr('135'), istr('45'), istr('45'), istr('0')]
-  
-The method has an optional parameter `as_str`, that can be used to get a nice representation of the long multiplication lines.
-  
-E.g. `print(istr.long_division(1395, 45, as_str=True)` will print 
+E.g. `print(istr.long_division(1395, 45).lines` will print 
+
+`[istr('31'), istr('45'), istr('1395'), istr('135'), istr('45'), istr('45'), istr('0')]`
+
+Note the final `istr('0')` is included to support also long divisions roots that are not perfect.
+
+E.g. `print(istr.long_division(1395, 45).line_lengths` will print 
+
+`[2, 2, 4, 3, 2, 2, 1]`
+
+`output` can be used to get a nice string representation of the long divsion lines.
+
+E.g. `print(istr.long_division(1395, 45).output` will print 
 
 ```
        31
@@ -912,8 +933,8 @@ E.g. `print(istr.long_division(1395, 45, as_str=True)` will print
        45
        --
         0
-```  
-  
+```
+
 #### generate istr with digits
 
 The class method `digits` can be used to return an istr of digits according to a given specification.

{istr_python-1.1.41 → istr_python-1.1.43}/istr/istr.py

@@ -5,7 +5,7 @@
 #    |_||___/ \__||_|
 # strings you can count on
 
-__version__ = "1.1.41"
+__version__ = "1.1.43"
 import functools
 import itertools
 import types
@@ -727,19 +727,16 @@ class istr(str):
         return self[::-1]
 
     def ceil(self, divisible_by=1):
-        if divisible_by <= 0:
-            raise ValueError(f"step has to be >0, not {divisible_by}")
-        if divisible_by != int(divisible_by):
-            raise ValueError(f"step has to be an integer value, not {divisible_by}")
+        if divisible_by != int(divisible_by) or divisible_by < 1:
+            raise ValueError(f"divisible_by has to be an integer value >=1 , not {divisible_by}")
         n = istr.interpret_as_float(self)
         return istr((math.ceil(n / divisible_by)) * divisible_by)
 
     def floor(self, divisible_by=1):
-        if divisible_by <= 0:
-            raise ValueError(f"step has to be >0, not {divisible_by}")
-        if divisible_by != int(divisible_by):
-            raise ValueError(f"step has to be an integer value, not {divisible_by}")
-        return istr((math.floor(self / divisible_by)) * divisible_by)
+        if divisible_by != int(divisible_by) or divisible_by < 1:
+            raise ValueError(f"divisible_by has to be an integer value >=1 , not {divisible_by}")
+        n = istr.interpret_as_float(self)
+        return istr((math.floor(n / divisible_by)) * divisible_by)
 
     def interpret_as_int(self):
         if isinstance(self, istr):
@@ -767,13 +764,13 @@ class istr(str):
 
         return str(self)
 
-    def interpret_as_istr(self): 
+    def interpret_as_istr(self):
         # ignore leading zeroes
         if isinstance(self, collections.abc.Iterable) and not isinstance(self, str):
-            return istr.join(self)*1
+            return istr.join(self) * 1
+
+        return istr(self) * 1
 
-        return istr(self)*1
-        
     def _str_method(self, name, *args, **kwargs):
         return self.__class__(getattr(super(), name)(*args, **kwargs))
 
@@ -863,22 +860,15 @@ class istr(str):
         for i, value in enumerate(iterable, int(start)):
             yield cls(i), value
 
-    def long_sqrt(self, as_str=False):
-        """
-        this function does long squre root and returns all the lines to be written.
-        (modified from a ChatGPT code suggestion)
-        returns root, number and the lines below the number, all istr-ed
-        if as_str is True, a formatted output will be returned
-        """
-
-        number = istr.interpret_as_istr(self)
-
+    @staticmethod
+    @functools.lru_cache(maxsize=1)
+    def _long_sqrt(number):
         lines = []
-        if len(number)%2==1:            
-            pairs=istr.chain(number[0],istr.batched(number[1:],2,join=True))
-        else:       
-            pairs=istr.batched(number,2,join=True)
-            
+        if len(number) % 2 == 1:
+            pairs = istr.chain(number[0], istr.batched(number[1:], 2, join=True))
+        else:
+            pairs = istr.batched(number, 2, join=True)
+
         root = istr(0)
         remainder = 0
 
@@ -896,123 +886,186 @@ class istr(str):
             remainder = dividend - trial
 
             root = root * 10 + x
-            lines.append(dividend)
-            lines.append(trial)
+            if trial:
+                lines.append(dividend)
+                lines.append(trial)
 
         lines.append(remainder)
         lines = [root] + [number] + lines[1:]
-        if as_str:
-            result = []
-            extra = len(number)%2==0
-            result.append(f"  {extra*' '}{' '.join(lines[0])}")
-            result.append(f"  {len(lines[1])*'-'}")
-            result.append(f"\/{lines[1]}")
-
-            last_len=len(lines[2])
-            for i, line in enumerate(lines):
-
-                if i >= 2:
-                    if i == len(lines) - 1:
-                        n = i - 2 + extra
-                    else:
-                        n = i + extra
+        return lines
 
-                    if i % 2 == 0:
-                        result.append(f" {line:>{n}}")
-                        result.append(f" {last_len*'-':>{n}}")
-                    else:
-                        result.append(f" {line:>{n+1}}")
-                        last_len=len(line)
-            return "\n".join(result)
-        else:
-            return lines
-            
-    def long_multiplication(self, number,as_str=False):
-        number0 = istr.interpret_as_istr(self)   
-        number1=istr.interpret_as_istr(number)
-        lines=[number0,number1]
+    def long_sqrt(self):
+        """
+        this function does long squre root and returns all the lines to be written.
+        (modified from a ChatGPT code suggestion)
+        returns root, number and the lines below the number, all istr-ed
+        if as_str is True, a formatted output will be returned
+        """
+
+        class NumberHolder:
+            def __init__(self, number):
+                self.number = number
+
+            def __getattr__(self, attr):
+                match attr:
+                    case "lines":
+                        return istr._long_sqrt(self.number)
+                    case "line_lengths":
+                        return [*map(len, istr._long_sqrt(self.number))]
+                    case "output":
+                        lines = istr._long_sqrt(self.number)
+                        result = []
+                        extra = len(number) % 2 == 0
+                        result.append(f"  {extra*' '}{' '.join(lines[0])}")
+                        result.append(f"  {len(lines[1])*'-'}")
+                        result.append(f"\/{lines[1]}")
+
+                        last_len = len(lines[2])
+                        for i, line in enumerate(lines):
+                            if i >= 2:
+                                if i == len(lines) - 1:
+                                    n = i - 2 + extra
+                                else:
+                                    n = i + extra
+
+                                if i % 2 == 0:
+                                    result.append(f" {line:>{n}}")
+                                    result.append(f" {last_len*'-':>{n}}")
+                                else:
+                                    result.append(f" {line:>{n+1}}")
+                                    last_len = len(line)
+                        return "\n".join(result)
+                    case _:
+                        raise AttributeError()
+
+        number = istr.interpret_as_istr(self)
+
+        return NumberHolder(number)
+
+    @staticmethod
+    @functools.lru_cache(maxsize=1)
+    def _long_multiplication(number0, number1):
+        lines = [number0, number1]
         for i in number1.reversed():
-            lines.append(number0*i)
-        lines.append(number0*number1)
-        if as_str:
-            result=[]
-            n=len(lines[-1])
-            result.append(f'{lines[0]:>{n}}')
-            result.append(f'{lines[1]:>{n}}')      
-            result.append(f"{n*'-'} x")    
-            for i,line in enumerate(lines[2:-1]):
-                result.append(f"{line:>{n-i}}")
-            result.append(f"{n*'-'}")             
-            result.append(lines[-1])
-            return '\n'.join(result)
-        else:
-            return lines
-        
-    def long_division(self, divisor, as_str=False):
-        dividend = istr.interpret_as_istr(self)
-        divisor = istr.interpret_as_istr(divisor)
-    
+            lines.append(number0 * i)
+        lines.append(number0 * number1)
+
+        return lines
+
+    def long_multiplication(self, number, as_str=False):
+        class NumbersHolder:
+            def __init__(self, number0, number1):
+                self.number0 = number0
+                self.number1 = number1
+
+            def __getattr__(self, attr):
+                match attr:
+                    case "lines":
+                        return istr._long_multiplication(self.number0, self.number1)
+                    case "line_lengths":
+                        return [*map(len, istr._long_multiplication(self.number0, self.number1))]
+                    case "output":
+                        lines = istr._long_multiplication(self.number0, self.number1)
+                        result = []
+
+                        n = len(lines[-1])
+                        result.append(f"{lines[0]:>{n}}")
+                        result.append(f"{lines[1]:>{n}}")
+                        result.append(f"{n*'-'} x")
+                        for i, line in enumerate(lines[2:-1]):
+                            result.append(f"{line:>{n-i}}")
+                        result.append(f"{n*'-'}")
+                        result.append(lines[-1])
+                        return "\n".join(result)
+                    case _:
+                        raise AttributeError()
+
+        number0 = istr.interpret_as_istr(self)
+        number1 = istr.interpret_as_istr(number)
+        return NumbersHolder(number0, number1)
+
+    @staticmethod
+    @functools.lru_cache(maxsize=1)
+    def _long_division(dividend, divisor, as_str=False):
         if dividend < 0:
             raise ValueError("dividend must be non-negative.")
-    
+
         if divisor <= 0:
             raise ValueError("divisor must be positive.")
-    
+
         dividend_start = len(divisor) + 3
         total_width = dividend_start + len(dividend)
-    
+
         quotient_characters = [" "] * len(dividend)
-    
+
         remainder = 0
         division_started = False
-        lines=[]
-    
+        lines = []
+
         for digit_index, digit_character in enumerate(dividend):
             current = remainder * 10 + digit_character
             quotient_digit = current // divisor
-    
+
             if quotient_digit != 0 or division_started:
                 division_started = True
-    
+
             if digit_index == len(dividend) - 1:
                 division_started = True
-    
+
             if not division_started:
                 remainder = current
                 continue
-    
+
             quotient_characters[digit_index] = quotient_digit
-    
+
             product = quotient_digit * divisor
             remainder = current - product
-    
+
             if as_str:
                 end_column = dividend_start + digit_index
                 current_start = end_column - len(current) + 1
-                product_start = end_column - len(product) + 1   
+                product_start = end_column - len(product) + 1
                 bar_start = min(current_start, product_start)
                 bar_length = end_column - bar_start + 1
                 lines.append(" " * current_start | current)
                 lines.append(" " * product_start | product)
                 lines.append(" " * bar_start + "-" * bar_length)
-        
+
             else:
                 lines.append(current)
                 lines.append(product)
-    
+
         quotient = istr.join(quotient_characters).rstrip()
         if as_str:
             remainder_start = total_width - len(remainder)
             lines.append(" " * remainder_start | remainder)
-            lines=[" " * dividend_start | quotient," " * dividend_start + "-" * len(dividend),f"{divisor} ) {dividend}",*lines[1:]]
+            lines = [" " * dividend_start | quotient, " " * dividend_start + "-" * len(dividend), f"{divisor} ) {dividend}", *lines[1:]]
             return "\n".join(lines)
-    
+
         else:
             lines.append(remainder)
-            lines=[istr(quotient),divisor,dividend,*lines[1:]]
-            return lines        
-            
-    
+            lines = [istr(quotient), divisor, dividend, *lines[1:]]
+            return lines
+
+    def long_division(self, divisor):
+        class NumbersHolder:
+            def __init__(self, dividend, divisor):
+                self.dividend = dividend
+                self.divisor = divisor
+
+            def __getattr__(self, attr):
+                match attr:
+                    case "lines":
+                        return istr._long_division(self.dividend, self.divisor)
+                    case "line_lengths":
+                        return [*map(len, istr._long_division(self.dividend, self.divisor))]
+                    case "output":
+                        return istr._long_division(self.dividend, self.divisor, as_str=True)
+
+        dividend = istr.interpret_as_istr(self)
+        divisor = istr.interpret_as_istr(divisor)
+        return NumbersHolder(dividend, divisor)
+
     def this_base(self):
         return self._this_base