Branch data Line data Source code
1 : : /*[clinic input]
2 : : preserve
3 : : [clinic start generated code]*/
4 : :
5 : : PyDoc_STRVAR(_heapq_heappush__doc__,
6 : : "heappush($module, heap, item, /)\n"
7 : : "--\n"
8 : : "\n"
9 : : "Push item onto heap, maintaining the heap invariant.");
10 : :
11 : : #define _HEAPQ_HEAPPUSH_METHODDEF \
12 : : {"heappush", _PyCFunction_CAST(_heapq_heappush), METH_FASTCALL, _heapq_heappush__doc__},
13 : :
14 : : static PyObject *
15 : : _heapq_heappush_impl(PyObject *module, PyObject *heap, PyObject *item);
16 : :
17 : : static PyObject *
18 : 12797 : _heapq_heappush(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
19 : : {
20 : 12797 : PyObject *return_value = NULL;
21 : : PyObject *heap;
22 : : PyObject *item;
23 : :
24 [ + + - + : 12797 : if (!_PyArg_CheckPositional("heappush", nargs, 2, 2)) {
+ - ]
25 : 2 : goto exit;
26 : : }
27 [ + + ]: 12795 : if (!PyList_Check(args[0])) {
28 : 3 : _PyArg_BadArgument("heappush", "argument 1", "list", args[0]);
29 : 3 : goto exit;
30 : : }
31 : 12792 : heap = args[0];
32 : 12792 : item = args[1];
33 : 12792 : return_value = _heapq_heappush_impl(module, heap, item);
34 : :
35 : 12797 : exit:
36 : 12797 : return return_value;
37 : : }
38 : :
39 : : PyDoc_STRVAR(_heapq_heappop__doc__,
40 : : "heappop($module, heap, /)\n"
41 : : "--\n"
42 : : "\n"
43 : : "Pop the smallest item off the heap, maintaining the heap invariant.");
44 : :
45 : : #define _HEAPQ_HEAPPOP_METHODDEF \
46 : : {"heappop", (PyCFunction)_heapq_heappop, METH_O, _heapq_heappop__doc__},
47 : :
48 : : static PyObject *
49 : : _heapq_heappop_impl(PyObject *module, PyObject *heap);
50 : :
51 : : static PyObject *
52 : 14022 : _heapq_heappop(PyObject *module, PyObject *arg)
53 : : {
54 : 14022 : PyObject *return_value = NULL;
55 : : PyObject *heap;
56 : :
57 [ + + ]: 14022 : if (!PyList_Check(arg)) {
58 : 4 : _PyArg_BadArgument("heappop", "argument", "list", arg);
59 : 4 : goto exit;
60 : : }
61 : 14018 : heap = arg;
62 : 14018 : return_value = _heapq_heappop_impl(module, heap);
63 : :
64 : 14022 : exit:
65 : 14022 : return return_value;
66 : : }
67 : :
68 : : PyDoc_STRVAR(_heapq_heapreplace__doc__,
69 : : "heapreplace($module, heap, item, /)\n"
70 : : "--\n"
71 : : "\n"
72 : : "Pop and return the current smallest value, and add the new item.\n"
73 : : "\n"
74 : : "This is more efficient than heappop() followed by heappush(), and can be\n"
75 : : "more appropriate when using a fixed-size heap. Note that the value\n"
76 : : "returned may be larger than item! That constrains reasonable uses of\n"
77 : : "this routine unless written as part of a conditional replacement:\n"
78 : : "\n"
79 : : " if item > heap[0]:\n"
80 : : " item = heapreplace(heap, item)");
81 : :
82 : : #define _HEAPQ_HEAPREPLACE_METHODDEF \
83 : : {"heapreplace", _PyCFunction_CAST(_heapq_heapreplace), METH_FASTCALL, _heapq_heapreplace__doc__},
84 : :
85 : : static PyObject *
86 : : _heapq_heapreplace_impl(PyObject *module, PyObject *heap, PyObject *item);
87 : :
88 : : static PyObject *
89 : 33129 : _heapq_heapreplace(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
90 : : {
91 : 33129 : PyObject *return_value = NULL;
92 : : PyObject *heap;
93 : : PyObject *item;
94 : :
95 [ + + - + : 33129 : if (!_PyArg_CheckPositional("heapreplace", nargs, 2, 2)) {
+ - ]
96 : 2 : goto exit;
97 : : }
98 [ + + ]: 33127 : if (!PyList_Check(args[0])) {
99 : 3 : _PyArg_BadArgument("heapreplace", "argument 1", "list", args[0]);
100 : 3 : goto exit;
101 : : }
102 : 33124 : heap = args[0];
103 : 33124 : item = args[1];
104 : 33124 : return_value = _heapq_heapreplace_impl(module, heap, item);
105 : :
106 : 33129 : exit:
107 : 33129 : return return_value;
108 : : }
109 : :
110 : : PyDoc_STRVAR(_heapq_heappushpop__doc__,
111 : : "heappushpop($module, heap, item, /)\n"
112 : : "--\n"
113 : : "\n"
114 : : "Push item on the heap, then pop and return the smallest item from the heap.\n"
115 : : "\n"
116 : : "The combined action runs more efficiently than heappush() followed by\n"
117 : : "a separate call to heappop().");
118 : :
119 : : #define _HEAPQ_HEAPPUSHPOP_METHODDEF \
120 : : {"heappushpop", _PyCFunction_CAST(_heapq_heappushpop), METH_FASTCALL, _heapq_heappushpop__doc__},
121 : :
122 : : static PyObject *
123 : : _heapq_heappushpop_impl(PyObject *module, PyObject *heap, PyObject *item);
124 : :
125 : : static PyObject *
126 : 996 : _heapq_heappushpop(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
127 : : {
128 : 996 : PyObject *return_value = NULL;
129 : : PyObject *heap;
130 : : PyObject *item;
131 : :
132 [ + - - + : 996 : if (!_PyArg_CheckPositional("heappushpop", nargs, 2, 2)) {
- - ]
133 : 0 : goto exit;
134 : : }
135 [ - + ]: 996 : if (!PyList_Check(args[0])) {
136 : 0 : _PyArg_BadArgument("heappushpop", "argument 1", "list", args[0]);
137 : 0 : goto exit;
138 : : }
139 : 996 : heap = args[0];
140 : 996 : item = args[1];
141 : 996 : return_value = _heapq_heappushpop_impl(module, heap, item);
142 : :
143 : 996 : exit:
144 : 996 : return return_value;
145 : : }
146 : :
147 : : PyDoc_STRVAR(_heapq_heapify__doc__,
148 : : "heapify($module, heap, /)\n"
149 : : "--\n"
150 : : "\n"
151 : : "Transform list into a heap, in-place, in O(len(heap)) time.");
152 : :
153 : : #define _HEAPQ_HEAPIFY_METHODDEF \
154 : : {"heapify", (PyCFunction)_heapq_heapify, METH_O, _heapq_heapify__doc__},
155 : :
156 : : static PyObject *
157 : : _heapq_heapify_impl(PyObject *module, PyObject *heap);
158 : :
159 : : static PyObject *
160 : 172 : _heapq_heapify(PyObject *module, PyObject *arg)
161 : : {
162 : 172 : PyObject *return_value = NULL;
163 : : PyObject *heap;
164 : :
165 [ + + ]: 172 : if (!PyList_Check(arg)) {
166 : 4 : _PyArg_BadArgument("heapify", "argument", "list", arg);
167 : 4 : goto exit;
168 : : }
169 : 168 : heap = arg;
170 : 168 : return_value = _heapq_heapify_impl(module, heap);
171 : :
172 : 172 : exit:
173 : 172 : return return_value;
174 : : }
175 : :
176 : : PyDoc_STRVAR(_heapq__heappop_max__doc__,
177 : : "_heappop_max($module, heap, /)\n"
178 : : "--\n"
179 : : "\n"
180 : : "Maxheap variant of heappop.");
181 : :
182 : : #define _HEAPQ__HEAPPOP_MAX_METHODDEF \
183 : : {"_heappop_max", (PyCFunction)_heapq__heappop_max, METH_O, _heapq__heappop_max__doc__},
184 : :
185 : : static PyObject *
186 : : _heapq__heappop_max_impl(PyObject *module, PyObject *heap);
187 : :
188 : : static PyObject *
189 : 2 : _heapq__heappop_max(PyObject *module, PyObject *arg)
190 : : {
191 : 2 : PyObject *return_value = NULL;
192 : : PyObject *heap;
193 : :
194 [ - + ]: 2 : if (!PyList_Check(arg)) {
195 : 0 : _PyArg_BadArgument("_heappop_max", "argument", "list", arg);
196 : 0 : goto exit;
197 : : }
198 : 2 : heap = arg;
199 : 2 : return_value = _heapq__heappop_max_impl(module, heap);
200 : :
201 : 2 : exit:
202 : 2 : return return_value;
203 : : }
204 : :
205 : : PyDoc_STRVAR(_heapq__heapreplace_max__doc__,
206 : : "_heapreplace_max($module, heap, item, /)\n"
207 : : "--\n"
208 : : "\n"
209 : : "Maxheap variant of heapreplace.");
210 : :
211 : : #define _HEAPQ__HEAPREPLACE_MAX_METHODDEF \
212 : : {"_heapreplace_max", _PyCFunction_CAST(_heapq__heapreplace_max), METH_FASTCALL, _heapq__heapreplace_max__doc__},
213 : :
214 : : static PyObject *
215 : : _heapq__heapreplace_max_impl(PyObject *module, PyObject *heap,
216 : : PyObject *item);
217 : :
218 : : static PyObject *
219 : 2590 : _heapq__heapreplace_max(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
220 : : {
221 : 2590 : PyObject *return_value = NULL;
222 : : PyObject *heap;
223 : : PyObject *item;
224 : :
225 [ + - - + : 2590 : if (!_PyArg_CheckPositional("_heapreplace_max", nargs, 2, 2)) {
- - ]
226 : 0 : goto exit;
227 : : }
228 [ - + ]: 2590 : if (!PyList_Check(args[0])) {
229 : 0 : _PyArg_BadArgument("_heapreplace_max", "argument 1", "list", args[0]);
230 : 0 : goto exit;
231 : : }
232 : 2590 : heap = args[0];
233 : 2590 : item = args[1];
234 : 2590 : return_value = _heapq__heapreplace_max_impl(module, heap, item);
235 : :
236 : 2590 : exit:
237 : 2590 : return return_value;
238 : : }
239 : :
240 : : PyDoc_STRVAR(_heapq__heapify_max__doc__,
241 : : "_heapify_max($module, heap, /)\n"
242 : : "--\n"
243 : : "\n"
244 : : "Maxheap variant of heapify.");
245 : :
246 : : #define _HEAPQ__HEAPIFY_MAX_METHODDEF \
247 : : {"_heapify_max", (PyCFunction)_heapq__heapify_max, METH_O, _heapq__heapify_max__doc__},
248 : :
249 : : static PyObject *
250 : : _heapq__heapify_max_impl(PyObject *module, PyObject *heap);
251 : :
252 : : static PyObject *
253 : 60 : _heapq__heapify_max(PyObject *module, PyObject *arg)
254 : : {
255 : 60 : PyObject *return_value = NULL;
256 : : PyObject *heap;
257 : :
258 [ - + ]: 60 : if (!PyList_Check(arg)) {
259 : 0 : _PyArg_BadArgument("_heapify_max", "argument", "list", arg);
260 : 0 : goto exit;
261 : : }
262 : 60 : heap = arg;
263 : 60 : return_value = _heapq__heapify_max_impl(module, heap);
264 : :
265 : 60 : exit:
266 : 60 : return return_value;
267 : : }
268 : : /*[clinic end generated code: output=9a22715a8bf0c91d input=a9049054013a1b77]*/
|