istr-python 1.1.13__tar.gz → 1.1.16__tar.gz

{istr_python-1.1.13 → istr_python-1.1.16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: istr-python
-Version: 1.1.13
+Version: 1.1.16
 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
@@ -607,6 +607,17 @@ In contrast to `math.sumprod()`, `istr.sumprod()` supports a `strict` parameter
 Thus, `istr.sumprod("12", (3,4,5), strict=False)` is `istr(11)`, whereas `istr.sumprod("12", (3,4,5))` 
 raises a ValueError. 
 
+#### get all squares, cubes, power ofs or primes in a given range
+
+The class methods `istr.squares`, `istr.cubes` and `istr.primes` can be used to get a list of all squares, cubes or primes up to a given upperbound (non inclusive) or between a given lowerbound and upperbound (non inclusive), like:
+
+`istr.squares (100)` returns a list of all squares <100
+`istr.squares(50, 100)` return a list of all squares >=50 and <100
+
+Unless `cache=False` is specified, the result of the query is cached.
+
+The same functionality is available for cubes, power ofs and primes 
+
 #### 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.13 → istr_python-1.1.16}/README.md

@@ -594,6 +594,17 @@ In contrast to `math.sumprod()`, `istr.sumprod()` supports a `strict` parameter
 Thus, `istr.sumprod("12", (3,4,5), strict=False)` is `istr(11)`, whereas `istr.sumprod("12", (3,4,5))` 
 raises a ValueError. 
 
+#### get all squares, cubes, power ofs or primes in a given range
+
+The class methods `istr.squares`, `istr.cubes` and `istr.primes` can be used to get a list of all squares, cubes or primes up to a given upperbound (non inclusive) or between a given lowerbound and upperbound (non inclusive), like:
+
+`istr.squares (100)` returns a list of all squares <100
+`istr.squares(50, 100)` return a list of all squares >=50 and <100
+
+Unless `cache=False` is specified, the result of the query is cached.
+
+The same functionality is available for cubes, power ofs and primes 
+
 #### 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.13 → istr_python-1.1.16}/istr/istr.py

@@ -5,7 +5,7 @@
 #    |_||___/ \__||_|
 # strings you can count on
 
-__version__ = "1.1.13"
+__version__ = "1.1.16"
 import functools
 import itertools
 import types
@@ -397,13 +397,19 @@ class istr(str):
         return not istr.is_divisible_by(self, 2)
 
     def is_divisible_by(self, divisor):
-        return istr.interpret_as_int(self) % int(divisor) == 0
+        return divisor!=0 and istr.interpret_as_int(self) % int(divisor) == 0
 
     def is_square(self):
-        return istr.is_power_of(self, 2)
+        n = istr.interpret_as_int(self)
+        if n < 1000000:
+            return n in _squares_up_to_1_000_000()
+        return n == round(n ** (1 / 2)) ** 2
 
     def is_cube(self):
-        return istr.is_power_of(self, 3)
+        n = istr.interpret_as_int(self)
+        if n < 1000000:
+            return n in _cubes_up_to_1_000_000()
+        return n == round(n ** (1 / 3)) ** 3
 
     def is_power_of(self, exponent):
         n = istr.interpret_as_int(self)
@@ -411,7 +417,7 @@ class istr(str):
             raise ValueError(f"exponent must be >=1; not {exponent}")
         if not isinstance(exponent, int):
             raise TypeError(f"exponent must be int; not {type(exponent)}")
-        return n >= 0 and self == round(n ** (1 / exponent)) ** exponent
+        return n >= 0 and n == round(n ** (1 / exponent)) ** exponent
 
     def is_prime(self):
         n = istr.interpret_as_int(self)
@@ -421,12 +427,50 @@ class istr(str):
             return True
         if not n & 1:
             return False
-
+        if n < 1000000:
+            return n in _primes_up_to_1_000_000()
         for x in range(3, int(n**0.5) + 1, 2):
             if n % x == 0:
                 return False
         return True
 
+    @classmethod
+    def primes(cls, lb_or_ub, ub=None, cache=True):
+        """
+        returns all primes up to a given upperbound or between a given lowerbound and upperbound
+        """
+        if ("primes", lb_or_ub, ub) in _cache:
+            return _cache["primes", lb_or_ub, ub]
+        result = sorted(map(cls, _primes(lb_or_ub, ub)))
+        if cache:
+            _cache["primes", lb_or_ub, ub]=result
+        return result 
+
+    @classmethod
+    def squares(cls, lb_or_ub, ub=None, cache=True):
+        """
+        returns all squares up to a given upperbound or between a given lowerbound and upperbound
+        """
+        return istr.power_ofs(2,lb_or_ub, ub, cache=cache)
+
+    @classmethod
+    def cubes(cls, lb_or_ub, ub=None, cache=True):
+        return istr.power_ofs(3,lb_or_ub, ub, cache=cache)
+
+    @classmethod
+    def power_ofs(cls, n,lb_or_ub, ub=None, cache=True):
+        """
+        returns all power of n up to a given upperbound or between a given lowerbound and upperbound
+        """
+        if ("power_ofs", n, lb_or_ub, ub) in _cache:
+            return _cache["power_ofs", n, lb_or_ub, ub]
+        result = sorted(map(cls, _power_ofs(n,lb_or_ub, ub)))
+        if cache:
+            _cache["power_ofs", n, lb_or_ub, ub]=result
+        return result         
+
+
+
     def decompose(self, letters, namespace=None):
         """
         decompose one-letter variables into global variables
@@ -442,7 +486,7 @@ class istr(str):
             if letter in lookup and lookup[letter] != ch:
                 raise ValueError(f"multiple values found for variable {letter}")
             if not letter.isidentifier():
-                raise ValueError(f"{letter} cannot be used as a variable")
+                raise ValueError(f"{repr(letter)} cannot be used as a variable")
             lookup[str(letter)] = ch
         if len(letters) != len(self):
             raise ValueError(f"incorrect number of variables {len(letters)}; should be {len(self)}")
@@ -457,7 +501,7 @@ class istr(str):
             namespace = inspect.currentframe().f_back.f_globals
         for letter in letters:
             if letter not in namespace:
-                raise ValueError(f"variable {letter} not defined")
+                raise ValueError(f"variable {repr(letter)} not defined")
         s = "".join(str(namespace[letter]) for letter in letters)
         return istr(s)
 
@@ -504,7 +548,7 @@ class istr(str):
 
     def is_triangular(self):
         n = istr.interpret_as_int(self)
-        if n<=0:
+        if n <= 0:
             return False
         return istr.is_square(n * 8 + 1)
 
@@ -544,13 +588,13 @@ class istr(str):
         return self._as_int is not self._nan
 
     def join(self, iterable=None):
-        if isinstance(self,istr):
+        if isinstance(self, istr):
             return istr(str(self).join(iterable))
         else:
             if iterable is None:
-                return istr('').join(self)
+                return istr("").join(self)
             else:
-                if not isinstance(self,str):
+                if not isinstance(self, str):
                     raise TypeError(f"{self!r} should be str, not {type(self)}")
                 return istr(self).join(iterable)
 
@@ -596,7 +640,8 @@ class istr(str):
 
             cls._int_format = int_format
 
-        def __enter__(self): ...
+        def __enter__(self):
+            ...
 
         def __exit__(self, exc_type, exc_value, exc_tb):
             self.saved_cls._int_format = self.saved_int_format
@@ -617,7 +662,8 @@ class istr(str):
             self.saved_cls = cls
             cls._repr_mode = mode
 
-        def __enter__(self): ...
+        def __enter__(self):
+            ...
 
         def __exit__(self, exc_type, exc_value, exc_tb):
             self.saved_cls._repr_mode = self.saved_repr_mode
@@ -636,7 +682,8 @@ class istr(str):
             self.saved_cls = cls
             cls._base = base
 
-        def __enter__(self): ...
+        def __enter__(self):
+            ...
 
         def __exit__(self, exc_type, exc_value, exc_tb):
             self.saved_cls._base = self.saved_base
@@ -749,10 +796,52 @@ def _map(func, *iterables, strict=False):
 
         yield func(*values)
 
+_cache={}
 
-istr.type = type(istr(0))
+def _primes(lb_or_ub, ub=None):
+    lb, ub = (0, lb_or_ub) if ub is None else (lb_or_ub, ub)
+    sieve = bytearray(b"\x01") * (ub + 1)
+    sieve[0:2] = b"\x00\x00"
+
+    for i in range(2, int(ub**0.5)+1 ):
+        if sieve[i]:
+            sieve[i * i : ub + 1 : i] = b"\x00" * (((ub - i * i) // i) + 1)
+
+    return {i for i, is_prime in enumerate(sieve) if is_prime and lb<=i<ub}
+
+
+@functools.lru_cache(maxsize=1)
+def _primes_up_to_1_000_000():
+    return _primes(1000000)
 
 
+@functools.lru_cache(maxsize=1)
+def _squares_up_to_1_000_000():
+    return _power_ofs(2,1000000)
+
+@functools.lru_cache(maxsize=1)
+def _cubes_up_to_1_000_000():
+    return _power_ofs(3,1000000)
+
+
+def _power_ofs(n, lb_or_ub, ub=None):
+    lb, ub = (0, lb_or_ub) if ub is None else (lb_or_ub, ub)
+    result = set()
+    if n==0:
+        if lb<=1<ub:
+            result.add(1)
+    elif n==1:
+        result={*range(lb,ub)}
+    else:
+        i = int(lb ** (1 / n))
+        while (in_ := i**n) < ub:
+            if in_ >= lb:
+                result.add(in_)
+            i += 1
+    return result
+
+istr.type = type(istr(0))
+
 class istrModule(types.ModuleType):
     def __call__(self, *args, **kwargs):
         return istr(*args, **kwargs)
@@ -766,3 +855,4 @@ class istrModule(types.ModuleType):
 
 if __name__ != "__main__":
     sys.modules["istr"].__class__ = istrModule
+

{istr_python-1.1.13 → istr_python-1.1.16}/istr_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: istr-python
-Version: 1.1.13
+Version: 1.1.16
 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
@@ -607,6 +607,17 @@ In contrast to `math.sumprod()`, `istr.sumprod()` supports a `strict` parameter
 Thus, `istr.sumprod("12", (3,4,5), strict=False)` is `istr(11)`, whereas `istr.sumprod("12", (3,4,5))` 
 raises a ValueError. 
 
+#### get all squares, cubes, power ofs or primes in a given range
+
+The class methods `istr.squares`, `istr.cubes` and `istr.primes` can be used to get a list of all squares, cubes or primes up to a given upperbound (non inclusive) or between a given lowerbound and upperbound (non inclusive), like:
+
+`istr.squares (100)` returns a list of all squares <100
+`istr.squares(50, 100)` return a list of all squares >=50 and <100
+
+Unless `cache=False` is specified, the result of the query is cached.
+
+The same functionality is available for cubes, power ofs and primes 
+
 #### 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.13 → istr_python-1.1.16}/pyproject.toml

@@ -10,7 +10,7 @@ authors = [
     { name = "Ruud van der Ham", email = "rt.van.der.ham@gmail.com" },
 ]
 description = "istr - strings you can count on"
-version = "1.1.13"
+version = "1.1.16"
 readme = "README.md"
 requires-python = ">=3.8"
 dependencies = []

{istr_python-1.1.13 → istr_python-1.1.16}/tests/test_istr.py

@@ -6,6 +6,7 @@ import re
 
 if __name__ == "__main__":  # to make the tests run without the pytest cli
     import os, sys  # three lines to use the local package and chdir
+
     os.chdir(os.path.dirname(__file__))
     sys.path.insert(0, os.path.dirname(__file__) + "/../")
 
@@ -186,8 +187,8 @@ def test_range():
 
     with pytest.raises(IndexError):
         one_to_twelve[12]
-        
-    assert str(list(istr.range(5, base=2, repr_mode='str'))) == "['0', '1', '10', '11', '100']"
+
+    assert str(list(istr.range(5, base=2, repr_mode="str"))) == "['0', '1', '10', '11', '100']"
 
 
 def test_misc():
@@ -357,6 +358,9 @@ def test_is_square():
     assert not istr.is_square(2)
     assert istr.is_square(4)
     assert istr.is_square(16)
+    assert istr.is_square(1_000_000)
+    assert istr.is_square(12345**2)
+    assert not istr.is_square(12345**2 + 1)
 
 
 def test_is_cube():
@@ -374,6 +378,8 @@ def test_is_cube():
     assert not istr.is_cube(2)
     assert istr.is_cube(8)
     assert istr.is_cube(27)
+    assert istr.is_cube(12345**3)
+    assert not istr.is_cube(12345**3 + 1)
 
 
 def test_is_power_of():
@@ -414,6 +420,32 @@ def test_is_prime():
     assert not istr.is_prime(4)
     assert istr.is_prime(97)
     assert not istr.is_prime(99)
+    assert not istr(100000003).is_prime()
+    assert istr(100000007).is_prime()
+
+
+def test_primes():
+    assert istr.primes(17) == [istr("2"), istr("3"), istr("5"), istr("7"), istr("11"), istr("13")]
+    assert istr.primes(40, 50) == [istr("41"), istr("43"), istr("47")]
+    assert id(istr.primes(100)) == id(istr.primes(100))  # test caching
+
+
+def test_squares():
+    assert istr.squares(50) == [istr("0"), istr("1"), istr("4"), istr("9"), istr("16"), istr("25"), istr("36"), istr("49")]
+    assert istr.squares(40, 50) == [istr("49")]
+    assert id(istr.squares(100)) == id(istr.squares(100))  # test caching
+
+
+def test_cubes():
+    assert istr.cubes(50) == [istr("0"), istr("1"), istr("8"), istr("27")]
+    assert istr.cubes(27, 50) == [istr("27")]
+    assert id(istr.cubes(100)) == id(istr.cubes(100))  # test caching
+
+def test_power_ofs():
+    assert istr.power_ofs(3,1,50) == [istr("1"), istr("8"), istr("27")]
+    assert istr.power_ofs(5,1, 500) == [istr('1'), istr('32'), istr('243')]
+    assert id(istr.power_ofs(3,2000)) != id(istr.cubes(3,2000))  # test caching
+    assert id(istr.power_ofs(3,1000,cache=False)) != id(istr.cubes(3,1000,cache=False))  # test caching
 
 
 def test_join():
@@ -437,15 +469,15 @@ def test_join():
     assert type(s) is istr.type
 
     s = istr.join("123")
-    assert s =="123"
+    assert s == "123"
     assert type(s) is istr.type
 
-    s = istr.join(("1","2","3"))
-    assert s =="123"
+    s = istr.join(("1", "2", "3"))
+    assert s == "123"
     assert type(s) is istr.type
 
-    s = istr.join(", ", ("1","2","3"))
-    assert s =="1, 2, 3"
+    s = istr.join(", ", ("1", "2", "3"))
+    assert s == "1, 2, 3"
     assert type(s) is istr.type
 
     with pytest.raises(TypeError):
@@ -454,6 +486,7 @@ def test_join():
     with pytest.raises(TypeError):
         istr.join("a", 12)
 
+
 def test_or():
     assert (eleven | twelve).equals(istr("1112"))
     assert ("11" | twelve).equals(istr("1112"))
@@ -694,20 +727,22 @@ def test_base():
         assert istr(a, base=36) == "73"
         assert istr(x) == "?"
         assert istr(x, base=36) == "?"
-        
+
+
 def test_this_queries():
     a = istr(12, base=36, int_format="04", repr_mode="str")
-    assert repr(a)=="'C'"
-    assert a.this_base()==36
-    assert a.this_int_format()=='04'
-    assert a.this_repr_mode()=='str'
+    assert repr(a) == "'C'"
+    assert a.this_base() == 36
+    assert a.this_int_format() == "04"
+    assert a.this_repr_mode() == "str"
 
     a = istr(12, int_format="04", repr_mode="str")
-    assert repr(a)=="'0012'"
-    assert a.this_base()==10
-    assert a.this_int_format()=='04'
-    assert a.this_repr_mode()=='str'
-    
+    assert repr(a) == "'0012'"
+    assert a.this_base() == 10
+    assert a.this_int_format() == "04"
+    assert a.this_repr_mode() == "str"
+
+
 def test_digits():
     assert istr.digits().equals(istr("0123456789"))
     assert istr.digits("").equals(istr("0123456789"))
@@ -778,12 +813,13 @@ def test_all_distinct():
 
 
 def test_is_consecutive():
-    assert not istr('').is_consecutive()    
-    assert not istr(1).is_consecutive()    
-    assert istr('abc').is_consecutive()    
-    assert not istr(321).is_consecutive()                         
-    assert not istr(11111).is_consecutive() 
-    assert istr.is_consecutive(123)    
+    assert not istr("").is_consecutive()
+    assert not istr(1).is_consecutive()
+    assert istr("abc").is_consecutive()
+    assert not istr(321).is_consecutive()
+    assert not istr(11111).is_consecutive()
+    assert istr.is_consecutive(123)
+
 
 def test_is_triangular():
     assert istr(1).is_triangular()
@@ -793,7 +829,8 @@ def test_is_triangular():
     assert istr(6).is_triangular()
     assert istr(424581).is_triangular()
     assert not istr(424582).is_triangular()
-    assert istr.is_triangular(424581)    
+    assert istr.is_triangular(424581)
+
 
 def test_prod():
     assert istr.prod(range(1, 5)).equals(istr(24))
@@ -863,7 +900,7 @@ def test_compose():
     assert istr("=") == "="
 
     assert istr(["=xyz", "=y"]) == [istr(123), istr(2)]
- 
+
     assert istr(dict(xyz="=xyz", y="=y")) == {"xyz": istr(123), "y": istr(2)}
     assert istr(dict(xyz="=xyz", y="=y"), namespace=dict(x=3, y=4, z="z")) == {"xyz": istr("34z"), "y": istr(4)}
 
@@ -872,10 +909,10 @@ def test_compose():
     assert istr(":=xyz").equals(istr(123))
     assert xyz.equals(istr(123))
 
-    assert istr(":=")==":="
-    assert istr("=")=="="
-        
-    
+    assert istr(":=") == ":="
+    assert istr("=") == "="
+
+
 if __name__ == "__main__":
     pytest.main(["-vv", "-s", "-x", __file__])