def binary_exp(n):
"""Binary exponentiation algorithm"""
cur = base
res = 1
if not n:
return res
while True:
if n & 1:
res *= cur
if n == 1:
return res
cur *= cur
n >>= 1
def built_in(n):
return base ** n
if __name__ == '__main__':
common.run(
'power', None,
common.optimized(naive) + [
('binary', binary_exp),
('built-in', built_in),
],
[
(None, 'linear', common.linear_scale(10000, 15)),
],
)
with the redundant calculations removed."""
return _fast_doubling(n)[0]
if __name__ == '__main__':
# Test all functions on different testcases
common.run(
'fib',
None,
common.optimized(naive) + [
('matrices', classic_matrices),
('fast dbl', fast_doubling),
],
[
('small', 'linear', common.linear_scale(30000, 15)),
('big', 'linear', common.linear_scale(300000, 15)),
],
)
# Test optimized function with different settings
common.run(
'fib',
None,
common.optimized(naive),
[('demo', 'linear', common.linear_scale(60000, 30))],
)
common.run(
'fib',
None,
common.optimized(naive, iters_limit=10000),
def fast_doubling(n):
"""Fast doubling - implementation via matrix exponentiation
with the redundant calculations removed."""
return _fast_doubling(n)[0]
if __name__ == '__main__':
# Test all functions on different testcases
common.run(
'fib', None,
common.optimized(naive) + [
('matrices', classic_matrices),
('fast dbl', fast_doubling),
],
[
('small', 'linear', common.linear_scale(30000, 15)),
('big', 'linear', common.linear_scale(300000, 15)),
],
)
# Test optimized function with different settings
common.run(
'fib', None,
common.optimized(naive),
[('demo', 'linear', common.linear_scale(60000, 30))],
)
common.run(
'fib', None,
common.optimized(naive, iters_limit=10000),
[('border', 'linear', common.linear_scale(60000, 30))],
)
res += elem
return res
def formula(count):
return (start * 2 + step * (count - 1)) * count / 2
pow10_wrapper = lambda func: (lambda arg: func(10 ** arg))
if __name__ == '__main__':
common.run(
'arith_sum', 'N elements',
common.optimized(naive) + [
('formula', formula),
],
[
('linear', None, common.linear_scale(600000, 5)),
],
exec_compare=False, draw_plot=False,
)
common.run(
'arith_sum', '10 ** N elements',
[
('cpm', pow10_wrapper(cpmoptimize()(naive))),
('formula', pow10_wrapper(formula)),
],
[
('exp', None, common.linear_scale(10000, 5)),
],
exec_compare=False, draw_plot=False,
)
def _optimal(first, count):
# Returns (sum, coeff ** count)
if count & 1:
sub_sum, sub_pow = _optimal(first, count - 1)
return first + sub_sum * coeff, sub_pow * coeff
if not count:
return 0, 1
sub_sum, sub_pow = _optimal(first, count >> 1)
return sub_sum * (1 + sub_pow), sub_pow * sub_pow
def optimal(count):
"""Optimal algorithm based on the idea similar to the binary
exponentiation."""
return _optimal(start, count)[0]
if __name__ == '__main__':
common.run(
'geom_sum',
None,
common.optimized(naive) + [
('optimal', optimal),
],
[
(None, 'linear', common.linear_scale(10000, 15)),
],
)
