def test_equility():
for args in _get_lranges_args():
a, b = lrange(*args), lrange(*args)
yield nose.tools.ok_, a is not b
yield nose.tools.assert_not_equals, a, b
yield nose.tools.eq_, a.length, b.length
if a.length < LENGTH_CUTOFF: # skip long
yield nose.tools.eq_, list(a), list(b), (a, b)
yield eq_lrange, a, b
def test_contains():
class IntSubclass(int):
pass
for r in [lrange(10), lrange(9,-1,-1)]:
for i in range(10):
yield nose.tools.ok_, i in r
yield nose.tools.ok_, IntSubclass(i) in r
yield nose.tools.ok_, 10 not in r
yield nose.tools.ok_, -1 not in r
yield nose.tools.ok_, IntSubclass(10) not in r
yield nose.tools.ok_, IntSubclass(-1) not in r
def __getitem__(self, slices):
# make sure slices is iterable
try: slices = list(iter(slices))
except TypeError:
slices = [slices]
# behaviour for short and long integers must be the same
for N in (None, 2**101):
for s in slices:
if type(s) == slice:
start, stop, step = s.start, s.stop, s.step
if N is not None:
start = start and start+N
stop = stop and stop+N
step = step
# try from 0 to 3 arguments
for args in [(), (stop,), (start, stop),
(start, stop, step)]:
try:
lr = lrange(*args)
if len(args) == 1:
nstart, nstep, nstop = 0, 1, stop
assert stop is not None
if len(args) == 2:
nstart, nstop, nstep = start, stop, 1
assert start is not None
assert stop is not None
if len(args) == 3:
nstart, nstop, nstep = start, stop, step
assert start is not None
assert stop is not None
assert step is not None
assert 0 <= len(args) < 4
nose.tools.eq_(lr._start, nstart)
nose.tools.eq_(lr._stop, nstop)
nose.tools.eq_(lr._step, nstep)
if lr.length < LENGTH_CUTOFF:
nose.tools.eq_(list(lr),
list(range(nstart, nstop, nstep)))
except TypeError:
# expected if any of the arguments is None
if len(args) > 0:
assert start is None or stop is None or \
step is None
else: # s is not slice
assert s is not None
if N is not None:
s = s + N
lr = lrange(s)
nose.tools.eq_(lr.length, s)
def test_len_overflow24():
# __len__() should return 0 <= outcome < 2**31 on py2.4
try: len(lrange(MAXINT))
except OverflowError:
if sys.version_info[:2] == (2,4):
pass
else:
raise
def test_getitem():
r = lrange(MAXINT-2, MAXINT+3)
for i in range(5):
yield nose.tools.eq_, r[i], MAXINT-2+i
for i in range(-1, -5, -1):
yield nose.tools.eq_, r[i], MAXINT+3+i
L = []
L[:] = r
yield nose.tools.eq_, len(L), len(r)
yield nose.tools.eq_, L, list(r)
def problem_3(self, num):
"""
The prime factors of 13195 are 5, 7, 13 and 29.
What is the largest prime factor of the number 600851475143
"""
result = []
for n in lrange(2, num):
while(num%n==0):
if(num%n==0):
num = num/n
result.append(n)
return result
def test_empty_range():
for args in (
"-3",
"1 3 -1",
"1 1",
"1 1 1",
"-3 -4",
"-3 -2 -1",
"-3 -3 -1",
"-3 -3",
):
r = lrange(*[int(a) for a in args.split()])
yield nose.tools.eq_, len(r), 0
L = list(r)
yield nose.tools.eq_, len(L), 0
def test_big_ints():
N = 10**100
for args, len_ in [
[(N,), N],
[(N, N+10), 10],
[(N, N-10, -2), 5],
]:
ir = lrange(*args)
#
ir[ir.length-1]
#
if len(args) >= 2:
r = range(*args)
yield nose.tools.eq_, list(ir), list(r)
yield nose.tools.eq_, ir[ir.length-1], r[-1]
yield nose.tools.eq_, list(reversed(ir)), list(reversed(r))
def invmodp(a, p):
'''
The multiplicitive inverse of a in the integers modulo p.
Return b s.t.
a * b == 1 mod p
From: http://code.activestate.com/recipes/576737-inverse-modulo-p/
'''
r = a
d = 1L
for count in lrange.lrange(p):
d = ((p // r + 1L) * d) % p
r = (d * a) % p
if r == 1L:
break
else:
raise ValueError('%d has no inverse mod %d' % (a, p))
return d
def invmodp(a, p):
'''
The multiplicitive inverse of a in the integers modulo p.
Return b s.t.
a * b == 1 mod p
From: http://code.activestate.com/recipes/576737-inverse-modulo-p/
'''
r = a
d = 1L
for count in lrange.lrange(p):
d = ((p // r + 1L) * d) % p
r = (d * a) % p
if r == 1L:
break
else:
raise ValueError('%d has no inverse mod %d' % (a, p))
return d
def test_new_none():
lrange(None)
def _get_lranges():
return (_get_short_lranges() +
[lrange(*args) for args in _get_lranges_args()])
def test_repr():
yield nose.tools.eq_, repr(lrange(True)), repr(lrange(1))
for r in _get_lranges():
yield eq_lrange, eval(repr(r)), r
def test_kwarg():
lrange(stop=10)
def test_len_overflow():
len(lrange(MAXINT+1))
def test_negative_index():
yield nose.tools.eq_, lrange(10)[-1], 9
yield nose.tools.eq_, lrange(2**100+1)[-1], 2**100
def _test(args):
lrange(*map(int, args)) # args work as ints
# args raise TypeError as floats
nose.tools.assert_raises(TypeError, lrange, *args)
def test_overflow():
lo, hi, step = MAXINT-2, 4*MAXINT+3, MAXINT // 10
lr = lrange(lo, hi, step)
xr = lrange(MAXINT//4, MAXINT//2, MAXINT // 10)
nose.tools.eq_(list(lr), list(range(lo, hi, step)))
def test_empty_args():
lrange()
def test_index_error():
r = lrange(10)
for i in [-11, 10, 11]:
yield nose.tools.assert_raises, IndexError, r.__getitem__, i
def test_small_ints():
for args in _get_short_lranges_args():
ir, r = lrange(*args), xrange(*args)
yield nose.tools.eq_, len(ir), len(r)
yield nose.tools.eq_, list(ir), list(r)
def setUp(self):
self.lr = lrange(BIGINT)
def test_len_type():
ir = lrange(10)
yield nose.tools.eq_, type(len(ir)), int
yield nose.tools.eq_, type(len(xrange(10))), int
yield nose.tools.eq_, type(len(range(10))), int
def interval_iter(self):
for n in lrange(self.begin, self.end):
yield n
from lrange import lrange
print(lrange(11))
print(lrange(5, 11))
print(lrange(5, 11, 2))
print(lrange(0, 10, 0.5))
# Errors:
# print(lrange())
# print(lrange(0, 10, -1))
# print(lrange("2"))
