1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147
|
# mode: run
# tag: cpp, werror, cpp11
from libcpp.numeric cimport inner_product, iota, accumulate, adjacent_difference, partial_sum
from libcpp.vector cimport vector
from libcpp cimport bool
# Subtracts two integers.
cdef int subtract_integers(int lhs, int rhs):
return lhs - rhs
# Adds two integers.
cdef int add_integers(int lhs, int rhs):
return lhs + rhs
# Multiplies two integers.
cdef int multiply_integers(int lhs, int rhs):
return lhs * rhs
# Determines equality for two integers.
# If lhs == rhs, returns true. Returns false otherwise.
cdef bool is_equal(int lhs, int rhs):
return lhs == rhs
def test_inner_product(vector[int] v1, vector[int] v2, int init):
"""
Test inner_product with integer values.
>>> test_inner_product([1, 2, 3], [1, 2, 3], 1)
15
"""
return inner_product(v1.begin(), v1.end(), v2.begin(), init)
def test_inner_product_with_zero(vector[int] v1, vector[int] v2, int init):
"""
Test inner_product with a zero value in the container.
>>> test_inner_product_with_zero([1, 2, 0], [1, 1, 1], 0)
3
"""
return inner_product(v1.begin(), v1.end(), v2.begin(), init)
def test_inner_product_with_bin_op(vector[int] v1, vector[int] v2, int init):
"""
Test inner_product with two binary operations. In this case,
Looks at number of pairwise matches between v1 and v2.
[5, 1, 2, 3, 4]
[5, 4, 2, 3, 1]
There are 3 matches (5, 2, 3). So, 1 + 1 + 1 = 3.
>>> test_inner_product_with_bin_op([5, 1, 2, 3, 4], [5, 4, 2, 3, 1], 0)
3
"""
return inner_product(v1.begin(), v1.end(), v2.begin(), init, add_integers, is_equal)
def test_iota(vector[int] v, int value):
"""
Test iota with beginning value of 0.
>>> test_iota(range(6), 0)
[0, 1, 2, 3, 4, 5]
"""
iota(v.begin(), v.end(), value)
return v
def test_iota_negative_init(vector[int] v, int value):
"""
Test iota with a negative beginning value.
>>> test_iota_negative_init(range(7), -4)
[-4, -3, -2, -1, 0, 1, 2]
"""
iota(v.begin(), v.end(), value)
return v
def test_accumulate(vector[int] v, int init):
"""
Test accumulate.
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
>>> test_accumulate([1, 2, 3], 0)
6
"""
return accumulate(v.begin(), v.end(), init)
def test_accumulate_with_subtraction(vector[int] v, int init):
"""
Test accumulate with subtraction. Note that accumulate is a fold-left operation.
0 - 1 = -1
-1 - 2 = -3
-3 - 3 = -6
>>> test_accumulate_with_subtraction([1, 2, 3], 0)
-6
"""
return accumulate(v.begin(), v.end(), init, subtract_integers)
def test_adjacent_difference(vector[int] v):
"""
Test adjacent_difference with integer values.
2 - 0, -> 2
4 - 2, -> 2
6 - 4, -> 2
8 - 6, -> 2
10 - 8, -> 2
12 - 10 -> 2
>>> test_adjacent_difference([2, 4, 6, 8, 10, 12])
[2, 2, 2, 2, 2, 2]
"""
adjacent_difference(v.begin(), v.end(), v.begin())
return v
def test_adjacent_difference_with_bin_op(vector[int] v):
"""
Test adjacent_difference with a binary operation.
0 + 1 -> 1
1 + 2 -> 3
2 + 4 -> 6
4 + 5 -> 9
5 + 6 -> 11
>>> test_adjacent_difference_with_bin_op([1, 2, 4, 5, 6])
[1, 3, 6, 9, 11]
"""
adjacent_difference(v.begin(), v.end(), v.begin(), add_integers)
return v
def test_partial_sum(vector[int] v):
"""
Test partial_sum with integer values.
2 + 0 -> 2
2 + 2 -> 4
4 + 2 -> 6
6 + 2 -> 8
8 + 2 -> 10
10 + 2 -> 12
>>> test_partial_sum([2, 2, 2, 2, 2, 2])
[2, 4, 6, 8, 10, 12]
"""
partial_sum(v.begin(), v.end(), v.begin())
return v
def test_partial_sum_with_bin_op(vector[int] v):
"""
Test partial_sum with a binary operation.
Using multiply_integers, partial_sum will calculate the first 5 powers of 2.
>>> test_partial_sum_with_bin_op([2, 2, 2, 2, 2])
[2, 4, 8, 16, 32]
"""
partial_sum(v.begin(), v.end(), v.begin(), multiply_integers)
return v
|