updated from Atlas repo

Author: ramalho

iterables/aritprog_v1b.py iterables/almost_aritprog_v0.pyiterables/aritprog_v1b.py renamed to iterables/almost_aritprog_v0.py

@@ -8,9 +8,9 @@
 
 """
 
-import array
 from collections import abc
 
+
 class ArithmeticProgression:
 
     def __init__(self, begin, step, end):
@@ -29,7 +29,8 @@ def __init__(self, arithmetic_progression):
         self._index = 0
 
     def __next__(self):
-        result = self._ap.begin + self._ap.step * self._index
+        first = type(self._ap.begin + self._ap.step)(self._ap.begin)
+        result = first + self._ap.step * self._index
         if result < self._ap.end:
             self._index += 1
             return result

iterables/almost_aritprog_v6.py

@@ -0,0 +1,35 @@
+"""
+Arithmetic progression generator function.
+
+This is almost correct. The only problem is that the first
+item in the series may not be of the same type as the rest,
+an this may be important to the user::
+
+    >>> ap = aritprog_gen(1, .5, 3)
+    >>> list(ap)
+    [1, 1.5, 2.0, 2.5]
+    >>> ap = aritprog_gen(0, 1/3, 1)
+    >>> list(ap)
+    [0, 0.3333333333333333, 0.6666666666666666]
+    >>> from fractions import Fraction
+    >>> ap = aritprog_gen(0, Fraction(1, 3), 1)
+    >>> list(ap)
+    [0, Fraction(1, 3), Fraction(2, 3)]
+    >>> from decimal import Decimal
+    >>> ap = aritprog_gen(0, Decimal('.1'), .3)
+    >>> list(ap)
+    [0, Decimal('0.1'), Decimal('0.2')]
+
+
+"""
+
+# BEGIN ALMOST_ARITPROG_ITERTOOLS
+import itertools
+
+
+def aritprog_gen(begin, step, end=None):
+    ap_gen = itertools.count(begin, step)
+    if end is not None:
+        ap_gen = itertools.takewhile(lambda n: n < end, ap_gen)
+    return ap_gen
+# END ALMOST_ARITPROG_ITERTOOLS

iterables/aritprog.rst

@@ -0,0 +1,31 @@
+===========================================
+Tests for arithmetic progression generators
+===========================================
+
+Tests with built-in numeric types::
+
+    >>> ap = aritprog_gen(1, .5, 3)
+    >>> list(ap)
+    [1.0, 1.5, 2.0, 2.5]
+    >>> ap = aritprog_gen(0, 1/3, 1)
+    >>> list(ap)
+    [0.0, 0.3333333333333333, 0.6666666666666666]
+
+
+Tests with standard library numeric types::
+
+    >>> from fractions import Fraction
+    >>> ap = aritprog_gen(0, Fraction(1, 3), 1)
+    >>> list(ap)
+    [Fraction(0, 1), Fraction(1, 3), Fraction(2, 3)]
+    >>> from decimal import Decimal
+    >>> ap = aritprog_gen(0, Decimal('.1'), .3)
+    >>> list(ap)
+    [Decimal('0'), Decimal('0.1'), Decimal('0.2')]
+
+
+Test producing an empty series::
+
+    >>> ap = aritprog_gen(0, 1, 0)
+    >>> list(ap)
+    []

iterables/aritprog_float_error.py

@@ -0,0 +1,26 @@
+"""
+Demonstrate difference between Arithmetic Progression calculated
+as a series of increments accumulating errors versus one addition
+and one multiplication.
+"""
+
+from fractions import Fraction
+from aritprog_v0 import ArithmeticProgression as APv0
+from aritprog_v1 import ArithmeticProgression as APv1
+
+if __name__ == '__main__':
+
+    ap0 = iter(APv0(1, .1))
+    ap1 = iter(APv1(1, .1))
+    ap_frac = iter(APv1(Fraction(1, 1), Fraction(1, 10)))
+    epsilon = 10**-10
+    iteration = 0
+    delta = next(ap0) - next(ap1)
+    frac = next(ap_frac)
+    while abs(delta) <= epsilon:
+        delta = next(ap0) - next(ap1)
+        frac = next(ap_frac)
+        iteration +=1
+
+    print('iteration: {}\tfraction: {}\tepsilon: {}\tdelta: {}'.
+          format(iteration, frac, epsilon, delta))

iterables/aritprog_runner.py

@@ -0,0 +1,37 @@
+import doctest
+import importlib
+import glob
+
+
+TARGET_GLOB = 'aritprog*.py'
+TEST_FILE = 'aritprog.rst'
+TEST_MSG = '{0:16} {1.attempted:2} tests, {1.failed:2} failed - {2}'
+
+
+def main(argv):
+    verbose = '-v' in argv
+    for module_file_name in sorted(glob.glob(TARGET_GLOB)):
+        module_name = module_file_name.replace('.py', '')
+        module = importlib.import_module(module_name)
+        gen_factory = getattr(module, 'ArithmeticProgression', None)
+        if gen_factory is None:
+            gen_factory = getattr(module, 'aritprog_gen', None)
+        if gen_factory is None:
+            continue
+
+        test(gen_factory, verbose)
+
+
+def test(gen_factory, verbose=False):
+    res = doctest.testfile(
+            TEST_FILE,
+            globs={'aritprog_gen': gen_factory},
+            verbose=verbose,
+            optionflags=doctest.REPORT_ONLY_FIRST_FAILURE)
+    tag = 'FAIL' if res.failed else 'OK'
+    print(TEST_MSG.format(gen_factory.__module__, res, tag))
+
+
+if __name__ == '__main__':
+    import sys
+    main(sys.argv)

iterables/aritprog_v0.py

@@ -0,0 +1,24 @@
+"""
+Arithmetic progression class
+
+    >>> ap = ArithmeticProgression(1, .5, 3)
+    >>> list(ap)
+    [1.0, 1.5, 2.0, 2.5]
+
+
+"""
+
+
+class ArithmeticProgression:
+
+    def __init__(self, begin, step, end=None):
+        self.begin = begin
+        self.step = step
+        self.end = end  # None -> "infinite" series
+
+    def __iter__(self):
+        result = type(self.begin + self.step)(self.begin)
+        forever = self.end is None
+        while forever or result < self.end:
+            yield result
+            result += self.step

iterables/aritprog_v1.py

@@ -1,48 +1,44 @@
 """
 Arithmetic progression class
 
+# BEGIN ARITPROG_CLASS_DEMO
+
+    >>> ap = ArithmeticProgression(0, 1, 3)
+    >>> list(ap)
+    [0, 1, 2]
     >>> ap = ArithmeticProgression(1, .5, 3)
     >>> list(ap)
     [1.0, 1.5, 2.0, 2.5]
+    >>> ap = ArithmeticProgression(0, 1/3, 1)
+    >>> list(ap)
+    [0.0, 0.3333333333333333, 0.6666666666666666]
+    >>> from fractions import Fraction
+    >>> ap = ArithmeticProgression(0, Fraction(1, 3), 1)
+    >>> list(ap)
+    [Fraction(0, 1), Fraction(1, 3), Fraction(2, 3)]
+    >>> from decimal import Decimal
+    >>> ap = ArithmeticProgression(0, Decimal('.1'), .3)
+    >>> list(ap)
+    [Decimal('0.0'), Decimal('0.1'), Decimal('0.2')]
 
-
+# END ARITPROG_CLASS_DEMO
 """
 
-import array
-from collections import abc
 
+# BEGIN ARITPROG_CLASS
 class ArithmeticProgression:
 
-    def __init__(self, begin, step, end):
+    def __init__(self, begin, step, end=None):  # <1>
         self.begin = begin
         self.step = step
-        self.end = end
-        self._build()
-
-    def _build(self):
-        self._numbers = array.array('d')
-        n = self.begin
-        while n < self.end:
-            self._numbers.append(n)
-            n += self.step
+        self.end = end  # None -> "infinite" series
 
     def __iter__(self):
-        return ArithmeticProgressionIterator(self._numbers)
-
-
-class ArithmeticProgressionIterator(abc.Iterator):
-
-    def __init__(self, series):
-        self._series = series
-        self._index = 0
-
-    def __next__(self):
-        if self._index < len(self._series):
-            item = self._series[self._index]
-            self._index += 1
-            return item
-        else:
-            raise StopIteration
-
-
-
+        result = type(self.begin + self.step)(self.begin)  # <2>
+        forever = self.end is None  # <3>
+        index = 0
+        while forever or result < self.end:  # <4>
+            yield result  # <5>
+            index += 1
+            result = self.begin + self.step * index  # <6>
+# END ARITPROG_CLASS

iterables/aritprog_v2.py

@@ -1,32 +1,31 @@
 """
-Arithmetic progression class
+Arithmetic progression generator function::
 
-    >>> ap = ArithmeticProgression(1, .5, 3)
+    >>> ap = aritprog_gen(1, .5, 3)
     >>> list(ap)
     [1.0, 1.5, 2.0, 2.5]
-
+    >>> ap = aritprog_gen(0, 1/3, 1)
+    >>> list(ap)
+    [0.0, 0.3333333333333333, 0.6666666666666666]
+    >>> from fractions import Fraction
+    >>> ap = aritprog_gen(0, Fraction(1, 3), 1)
+    >>> list(ap)
+    [Fraction(0, 1), Fraction(1, 3), Fraction(2, 3)]
+    >>> from decimal import Decimal
+    >>> ap = aritprog_gen(0, Decimal('.1'), .3)
+    >>> list(ap)
+    [Decimal('0.0'), Decimal('0.1'), Decimal('0.2')]
 
 """
 
-import array
-from collections import abc
-
-class ArithmeticProgression:
-
-    def __init__(self, begin, step, end):
-        self.begin = begin
-        self.step = step
-        self.end = end
-        self._build()
-
-    def _build(self):
-        self._numbers = array.array('d')
-        n = self.begin
-        while n < self.end:
-            self._numbers.append(n)
-            n += self.step
 
-    def __iter__(self):
-        for item in self._numbers:
-            yield item
-        return StopIteration
+# BEGIN ARITPROG_GENFUNC
+def aritprog_gen(begin, step, end=None):
+    result = type(begin + step)(begin)
+    forever = end is None
+    index = 0
+    while forever or result < end:
+        yield result
+        index += 1
+        result = begin + step * index
+# END ARITPROG_GENFUNC

iterables/aritprog_v3.py

@@ -1,27 +1,11 @@
-"""
-Arithmetic progression class
+# BEGIN ARITPROG_ITERTOOLS
+import itertools
 
-    >>> ap = ArithmeticProgression(1, .5, 3)
-    >>> list(ap)
-    [1.0, 1.5, 2.0, 2.5]
 
-
-"""
-
-import array
-from collections import abc
-
-class ArithmeticProgression:
-
-    def __init__(self, begin, step, end=None):
-        self.begin = float(begin)
-        self.step = float(step)
-        self.end = end  # None -> "infinite" series
-
-    def __iter__(self):
-        result = self.begin
-        forever = self.end is None
-        while forever or result < self.end:
-            yield result
-            result += self.step
-        raise StopIteration
+def aritprog_gen(begin, step, end=None):
+    first = type(begin + step)(begin)
+    ap_gen = itertools.count(first, step)
+    if end is not None:
+        ap_gen = itertools.takewhile(lambda n: n < end, ap_gen)
+    return ap_gen
+# END ARITPROG_ITERTOOLS

iterables/aritprog_v4.py

@@ -1,29 +1,14 @@
-"""
-Arithmetic progression class
-
-    >>> ap = ArithmeticProgression(1, .5, 3)
-    >>> list(ap)
-    [1.0, 1.5, 2.0, 2.5]
-
-
-"""
-
-import array
-from collections import abc
-
-class ArithmeticProgression:
-
-    def __init__(self, begin, step, end=None):
-        self.begin = begin
-        self.step = step
-        self.end = end  # None -> "infinite" series
-
-    def __iter__(self):
-        result = type(self.step)(self.begin)
-        forever = self.end is None
-        index = 0
-        while forever or result < self.end:
-            yield result
-            index += 1
-            result = self.begin + self.step * index
-        raise StopIteration
+# BEGIN ARITPROG_ITERTOOLS
+import itertools
+
+
+def aritprog_gen(begin, step, end=None):
+    if end is not None and begin >= end:
+        return
+    yield type(begin + step)(begin)
+    tail_gen = itertools.count(begin+step, step)
+    if end is not None:
+        tail_gen = itertools.takewhile(lambda n: n < end, tail_gen)
+    for x in tail_gen:
+        yield x
+# END ARITPROG_ITERTOOLS