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
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
|
from .object cimport PyObject
cdef extern from "Python.h":
#####################################################################
# 6.2 Number Protocol
#####################################################################
bint PyNumber_Check(object o)
# Returns 1 if the object o provides numeric protocols, and false
# otherwise. This function always succeeds.
object PyNumber_Add(object o1, object o2)
# Return value: New reference.
# Returns the result of adding o1 and o2, or NULL on failure. This
# is the equivalent of the Python expression "o1 + o2".
object PyNumber_Subtract(object o1, object o2)
# Return value: New reference.
# Returns the result of subtracting o2 from o1, or NULL on
# failure. This is the equivalent of the Python expression "o1 -
# o2".
object PyNumber_Multiply(object o1, object o2)
# Return value: New reference.
# Returns the result of multiplying o1 and o2, or NULL on
# failure. This is the equivalent of the Python expression "o1 *
# o2".
object PyNumber_MatrixMultiply(object o1, object o2)
# Return value: New reference.
# Returns the result of matrix multiplication on o1 and o2, or
# NULL on failure. This is the equivalent of the Python
# expression "o1 @ o2".
# New in version 3.5.
object PyNumber_Divide(object o1, object o2)
# Return value: New reference.
# Returns the result of dividing o1 by o2, or NULL on
# failure. This is the equivalent of the Python expression "o1 /
# o2".
object PyNumber_FloorDivide(object o1, object o2)
# Return value: New reference.
# Return the floor of o1 divided by o2, or NULL on failure. This
# is equivalent to the ``classic'' division of integers.
object PyNumber_TrueDivide(object o1, object o2)
# Return value: New reference.
# Return a reasonable approximation for the mathematical value of
# o1 divided by o2, or NULL on failure. The return value is
# ``approximate'' because binary floating point numbers are
# approximate; it is not possible to represent all real numbers in
# base two. This function can return a floating point value when
# passed two integers.
object PyNumber_Remainder(object o1, object o2)
# Return value: New reference.
# Returns the remainder of dividing o1 by o2, or NULL on
# failure. This is the equivalent of the Python expression "o1 %
# o2".
object PyNumber_Divmod(object o1, object o2)
# Return value: New reference.
# See the built-in function divmod(). Returns NULL on
# failure. This is the equivalent of the Python expression
# "divmod(o1, o2)".
object PyNumber_Power(object o1, object o2, object o3)
# Return value: New reference.
# See the built-in function pow(). Returns NULL on failure. This
# is the equivalent of the Python expression "pow(o1, o2, o3)",
# where o3 is optional. If o3 is to be ignored, pass Py_None in
# its place (passing NULL for o3 would cause an illegal memory
# access).
object PyNumber_Negative(object o)
# Return value: New reference.
# Returns the negation of o on success, or NULL on failure. This
# is the equivalent of the Python expression "-o".
object PyNumber_Positive(object o)
# Return value: New reference.
# Returns o on success, or NULL on failure. This is the equivalent
# of the Python expression "+o".
object PyNumber_Absolute(object o)
# Return value: New reference.
# Returns the absolute value of o, or NULL on failure. This is the
# equivalent of the Python expression "abs(o)".
object PyNumber_Invert(object o)
# Return value: New reference.
# Returns the bitwise negation of o on success, or NULL on
# failure. This is the equivalent of the Python expression "~o".
object PyNumber_Lshift(object o1, object o2)
# Return value: New reference.
# Returns the result of left shifting o1 by o2 on success, or NULL
# on failure. This is the equivalent of the Python expression "o1
# << o2".
object PyNumber_Rshift(object o1, object o2)
# Return value: New reference.
# Returns the result of right shifting o1 by o2 on success, or
# NULL on failure. This is the equivalent of the Python expression
# "o1 >> o2".
object PyNumber_And(object o1, object o2)
# Return value: New reference.
# Returns the ``bitwise and'' of o1 and o2 on success and NULL on
# failure. This is the equivalent of the Python expression "o1 &
# o2".
object PyNumber_Xor(object o1, object o2)
# Return value: New reference.
# Returns the ``bitwise exclusive or'' of o1 by o2 on success, or
# NULL on failure. This is the equivalent of the Python expression
# "o1 ^ o2".
object PyNumber_Or(object o1, object o2)
# Return value: New reference.
# Returns the ``bitwise or'' of o1 and o2 on success, or NULL on failure. This is the equivalent of the Python expression "o1 | o2".
object PyNumber_InPlaceAdd(object o1, object o2)
# Return value: New reference.
# Returns the result of adding o1 and o2, or NULL on failure. The
# operation is done in-place when o1 supports it. This is the
# equivalent of the Python statement "o1 += o2".
object PyNumber_InPlaceSubtract(object o1, object o2)
# Return value: New reference.
# Returns the result of subtracting o2 from o1, or NULL on
# failure. The operation is done in-place when o1 supports
# it. This is the equivalent of the Python statement "o1 -= o2".
object PyNumber_InPlaceMultiply(object o1, object o2)
# Return value: New reference.
# Returns the result of multiplying o1 and o2, or NULL on
# failure. The operation is done in-place when o1 supports
# it. This is the equivalent of the Python statement "o1 *= o2".
object PyNumber_InPlaceMatrixMultiply(object o1, object o2)
# Return value: New reference.
# Returns the result of matrix multiplication on o1 and o2, or
# NULL on failure. The operation is done in-place when o1 supports
# it. This is the equivalent of the Python statement "o1 @= o2".
# New in version 3.5.
object PyNumber_InPlaceDivide(object o1, object o2)
# Return value: New reference.
# Returns the result of dividing o1 by o2, or NULL on failure. The
# operation is done in-place when o1 supports it. This is the
# equivalent of the Python statement "o1 /= o2".
object PyNumber_InPlaceFloorDivide(object o1, object o2)
# Return value: New reference.
# Returns the mathematical floor of dividing o1 by o2, or NULL on
# failure. The operation is done in-place when o1 supports
# it. This is the equivalent of the Python statement "o1 //=
# o2".
object PyNumber_InPlaceTrueDivide(object o1, object o2)
# Return value: New reference.
# Return a reasonable approximation for the mathematical value of
# o1 divided by o2, or NULL on failure. The return value is
# ``approximate'' because binary floating point numbers are
# approximate; it is not possible to represent all real numbers in
# base two. This function can return a floating point value when
# passed two integers. The operation is done in-place when o1
# supports it.
object PyNumber_InPlaceRemainder(object o1, object o2)
# Return value: New reference.
# Returns the remainder of dividing o1 by o2, or NULL on
# failure. The operation is done in-place when o1 supports
# it. This is the equivalent of the Python statement "o1 %= o2".
object PyNumber_InPlacePower(object o1, object o2, object o3)
# Return value: New reference.
# See the built-in function pow(). Returns NULL on failure. The
# operation is done in-place when o1 supports it. This is the
# equivalent of the Python statement "o1 **= o2" when o3 is
# Py_None, or an in-place variant of "pow(o1, o2, o3)"
# otherwise. If o3 is to be ignored, pass Py_None in its place
# (passing NULL for o3 would cause an illegal memory access).
object PyNumber_InPlaceLshift(object o1, object o2)
# Return value: New reference.
# Returns the result of left shifting o1 by o2 on success, or NULL
# on failure. The operation is done in-place when o1 supports
# it. This is the equivalent of the Python statement "o1 <<= o2".
object PyNumber_InPlaceRshift(object o1, object o2)
# Return value: New reference.
# Returns the result of right shifting o1 by o2 on success, or
# NULL on failure. The operation is done in-place when o1 supports
# it. This is the equivalent of the Python statement "o1 >>= o2".
object PyNumber_InPlaceAnd(object o1, object o2)
# Return value: New reference.
# Returns the ``bitwise and'' of o1 and o2 on success and NULL on
# failure. The operation is done in-place when o1 supports
# it. This is the equivalent of the Python statement "o1 &= o2".
object PyNumber_InPlaceXor(object o1, object o2)
# Return value: New reference.
# Returns the ``bitwise exclusive or'' of o1 by o2 on success, or
# NULL on failure. The operation is done in-place when o1 supports
# it. This is the equivalent of the Python statement "o1 ^= o2".
object PyNumber_InPlaceOr(object o1, object o2)
# Return value: New reference.
# Returns the ``bitwise or'' of o1 and o2 on success, or NULL on
# failure. The operation is done in-place when o1 supports
# it. This is the equivalent of the Python statement "o1 |= o2".
int PyNumber_Coerce(PyObject **p1, PyObject **p2) except -1
# This function takes the addresses of two variables of type
# PyObject*. If the objects pointed to by *p1 and *p2 have the
# same type, increment their reference count and return 0
# (success). If the objects can be converted to a common numeric
# type, replace *p1 and *p2 by their converted value (with 'new'
# reference counts), and return 0. If no conversion is possible,
# or if some other error occurs, return -1 (failure) and don't
# increment the reference counts. The call PyNumber_Coerce(&o1,
# &o2) is equivalent to the Python statement "o1, o2 = coerce(o1,
# o2)".
object PyNumber_Int(object o)
# Return value: New reference.
# Returns the o converted to an integer object on success, or NULL
# on failure. If the argument is outside the integer range a long
# object will be returned instead. This is the equivalent of the
# Python expression "int(o)".
object PyNumber_Long(object o)
# Return value: New reference.
# Returns the o converted to a long integer object on success, or
# NULL on failure. This is the equivalent of the Python expression
# "long(o)".
object PyNumber_Float(object o)
# Return value: New reference.
# Returns the o converted to a float object on success, or NULL on
# failure. This is the equivalent of the Python expression
# "float(o)".
object PyNumber_Index(object o)
# Returns the o converted to a Python int or long on success or
# NULL with a TypeError exception raised on failure.
Py_ssize_t PyNumber_AsSsize_t(object o, object exc) except? -1
# Returns o converted to a Py_ssize_t value if o can be
# interpreted as an integer. If o can be converted to a Python int
# or long but the attempt to convert to a Py_ssize_t value would
# raise an OverflowError, then the exc argument is the type of
# exception that will be raised (usually IndexError or
# OverflowError). If exc is NULL, then the exception is cleared
# and the value is clipped to PY_SSIZE_T_MIN for a negative
# integer or PY_SSIZE_T_MAX for a positive integer.
bint PyIndex_Check(object)
# Returns True if o is an index integer (has the nb_index slot of
# the tp_as_number structure filled in).
|
