/Modules/_heapqmodule.c
C | 697 lines | 590 code | 73 blank | 34 comment | 123 complexity | bfadc4c23285f78f84403765a91c580d MD5 | raw file
1/* Drop in replacement for heapq.py 2 3C implementation derived directly from heapq.py in Py2.3 4which was written by Kevin O'Connor, augmented by Tim Peters, 5annotated by François Pinard, and converted to C by Raymond Hettinger. 6 7*/ 8 9#include "Python.h" 10 11/* Older implementations of heapq used Py_LE for comparisons. Now, it uses 12 Py_LT so it will match min(), sorted(), and bisect(). Unfortunately, some 13 client code (Twisted for example) relied on Py_LE, so this little function 14 restores compatability by trying both. 15*/ 16static int 17cmp_lt(PyObject *x, PyObject *y) 18{ 19 int cmp; 20 static PyObject *lt = NULL; 21 22 if (lt == NULL) { 23 lt = PyString_FromString("__lt__"); 24 if (lt == NULL) 25 return -1; 26 } 27 if (PyObject_HasAttr(x, lt)) 28 return PyObject_RichCompareBool(x, y, Py_LT); 29 cmp = PyObject_RichCompareBool(y, x, Py_LE); 30 if (cmp != -1) 31 cmp = 1 - cmp; 32 return cmp; 33} 34 35static int 36_siftdown(PyListObject *heap, Py_ssize_t startpos, Py_ssize_t pos) 37{ 38 PyObject *newitem, *parent; 39 int cmp; 40 Py_ssize_t parentpos; 41 42 assert(PyList_Check(heap)); 43 if (pos >= PyList_GET_SIZE(heap)) { 44 PyErr_SetString(PyExc_IndexError, "index out of range"); 45 return -1; 46 } 47 48 newitem = PyList_GET_ITEM(heap, pos); 49 Py_INCREF(newitem); 50 /* Follow the path to the root, moving parents down until finding 51 a place newitem fits. */ 52 while (pos > startpos){ 53 parentpos = (pos - 1) >> 1; 54 parent = PyList_GET_ITEM(heap, parentpos); 55 cmp = cmp_lt(newitem, parent); 56 if (cmp == -1) { 57 Py_DECREF(newitem); 58 return -1; 59 } 60 if (cmp == 0) 61 break; 62 Py_INCREF(parent); 63 Py_DECREF(PyList_GET_ITEM(heap, pos)); 64 PyList_SET_ITEM(heap, pos, parent); 65 pos = parentpos; 66 } 67 Py_DECREF(PyList_GET_ITEM(heap, pos)); 68 PyList_SET_ITEM(heap, pos, newitem); 69 return 0; 70} 71 72static int 73_siftup(PyListObject *heap, Py_ssize_t pos) 74{ 75 Py_ssize_t startpos, endpos, childpos, rightpos; 76 int cmp; 77 PyObject *newitem, *tmp; 78 79 assert(PyList_Check(heap)); 80 endpos = PyList_GET_SIZE(heap); 81 startpos = pos; 82 if (pos >= endpos) { 83 PyErr_SetString(PyExc_IndexError, "index out of range"); 84 return -1; 85 } 86 newitem = PyList_GET_ITEM(heap, pos); 87 Py_INCREF(newitem); 88 89 /* Bubble up the smaller child until hitting a leaf. */ 90 childpos = 2*pos + 1; /* leftmost child position */ 91 while (childpos < endpos) { 92 /* Set childpos to index of smaller child. */ 93 rightpos = childpos + 1; 94 if (rightpos < endpos) { 95 cmp = cmp_lt( 96 PyList_GET_ITEM(heap, childpos), 97 PyList_GET_ITEM(heap, rightpos)); 98 if (cmp == -1) { 99 Py_DECREF(newitem); 100 return -1; 101 } 102 if (cmp == 0) 103 childpos = rightpos; 104 } 105 /* Move the smaller child up. */ 106 tmp = PyList_GET_ITEM(heap, childpos); 107 Py_INCREF(tmp); 108 Py_DECREF(PyList_GET_ITEM(heap, pos)); 109 PyList_SET_ITEM(heap, pos, tmp); 110 pos = childpos; 111 childpos = 2*pos + 1; 112 } 113 114 /* The leaf at pos is empty now. Put newitem there, and and bubble 115 it up to its final resting place (by sifting its parents down). */ 116 Py_DECREF(PyList_GET_ITEM(heap, pos)); 117 PyList_SET_ITEM(heap, pos, newitem); 118 return _siftdown(heap, startpos, pos); 119} 120 121static PyObject * 122heappush(PyObject *self, PyObject *args) 123{ 124 PyObject *heap, *item; 125 126 if (!PyArg_UnpackTuple(args, "heappush", 2, 2, &heap, &item)) 127 return NULL; 128 129 if (!PyList_Check(heap)) { 130 PyErr_SetString(PyExc_TypeError, "heap argument must be a list"); 131 return NULL; 132 } 133 134 if (PyList_Append(heap, item) == -1) 135 return NULL; 136 137 if (_siftdown((PyListObject *)heap, 0, PyList_GET_SIZE(heap)-1) == -1) 138 return NULL; 139 Py_INCREF(Py_None); 140 return Py_None; 141} 142 143PyDoc_STRVAR(heappush_doc, 144"Push item onto heap, maintaining the heap invariant."); 145 146static PyObject * 147heappop(PyObject *self, PyObject *heap) 148{ 149 PyObject *lastelt, *returnitem; 150 Py_ssize_t n; 151 152 if (!PyList_Check(heap)) { 153 PyErr_SetString(PyExc_TypeError, "heap argument must be a list"); 154 return NULL; 155 } 156 157 /* # raises appropriate IndexError if heap is empty */ 158 n = PyList_GET_SIZE(heap); 159 if (n == 0) { 160 PyErr_SetString(PyExc_IndexError, "index out of range"); 161 return NULL; 162 } 163 164 lastelt = PyList_GET_ITEM(heap, n-1) ; 165 Py_INCREF(lastelt); 166 PyList_SetSlice(heap, n-1, n, NULL); 167 n--; 168 169 if (!n) 170 return lastelt; 171 returnitem = PyList_GET_ITEM(heap, 0); 172 PyList_SET_ITEM(heap, 0, lastelt); 173 if (_siftup((PyListObject *)heap, 0) == -1) { 174 Py_DECREF(returnitem); 175 return NULL; 176 } 177 return returnitem; 178} 179 180PyDoc_STRVAR(heappop_doc, 181"Pop the smallest item off the heap, maintaining the heap invariant."); 182 183static PyObject * 184heapreplace(PyObject *self, PyObject *args) 185{ 186 PyObject *heap, *item, *returnitem; 187 188 if (!PyArg_UnpackTuple(args, "heapreplace", 2, 2, &heap, &item)) 189 return NULL; 190 191 if (!PyList_Check(heap)) { 192 PyErr_SetString(PyExc_TypeError, "heap argument must be a list"); 193 return NULL; 194 } 195 196 if (PyList_GET_SIZE(heap) < 1) { 197 PyErr_SetString(PyExc_IndexError, "index out of range"); 198 return NULL; 199 } 200 201 returnitem = PyList_GET_ITEM(heap, 0); 202 Py_INCREF(item); 203 PyList_SET_ITEM(heap, 0, item); 204 if (_siftup((PyListObject *)heap, 0) == -1) { 205 Py_DECREF(returnitem); 206 return NULL; 207 } 208 return returnitem; 209} 210 211PyDoc_STRVAR(heapreplace_doc, 212"Pop and return the current smallest value, and add the new item.\n\ 213\n\ 214This is more efficient than heappop() followed by heappush(), and can be\n\ 215more appropriate when using a fixed-size heap. Note that the value\n\ 216returned may be larger than item! That constrains reasonable uses of\n\ 217this routine unless written as part of a conditional replacement:\n\n\ 218 if item > heap[0]:\n\ 219 item = heapreplace(heap, item)\n"); 220 221static PyObject * 222heappushpop(PyObject *self, PyObject *args) 223{ 224 PyObject *heap, *item, *returnitem; 225 int cmp; 226 227 if (!PyArg_UnpackTuple(args, "heappushpop", 2, 2, &heap, &item)) 228 return NULL; 229 230 if (!PyList_Check(heap)) { 231 PyErr_SetString(PyExc_TypeError, "heap argument must be a list"); 232 return NULL; 233 } 234 235 if (PyList_GET_SIZE(heap) < 1) { 236 Py_INCREF(item); 237 return item; 238 } 239 240 cmp = cmp_lt(PyList_GET_ITEM(heap, 0), item); 241 if (cmp == -1) 242 return NULL; 243 if (cmp == 0) { 244 Py_INCREF(item); 245 return item; 246 } 247 248 returnitem = PyList_GET_ITEM(heap, 0); 249 Py_INCREF(item); 250 PyList_SET_ITEM(heap, 0, item); 251 if (_siftup((PyListObject *)heap, 0) == -1) { 252 Py_DECREF(returnitem); 253 return NULL; 254 } 255 return returnitem; 256} 257 258PyDoc_STRVAR(heappushpop_doc, 259"Push item on the heap, then pop and return the smallest item\n\ 260from the heap. The combined action runs more efficiently than\n\ 261heappush() followed by a separate call to heappop()."); 262 263static PyObject * 264heapify(PyObject *self, PyObject *heap) 265{ 266 Py_ssize_t i, n; 267 268 if (!PyList_Check(heap)) { 269 PyErr_SetString(PyExc_TypeError, "heap argument must be a list"); 270 return NULL; 271 } 272 273 n = PyList_GET_SIZE(heap); 274 /* Transform bottom-up. The largest index there's any point to 275 looking at is the largest with a child index in-range, so must 276 have 2*i + 1 < n, or i < (n-1)/2. If n is even = 2*j, this is 277 (2*j-1)/2 = j-1/2 so j-1 is the largest, which is n//2 - 1. If 278 n is odd = 2*j+1, this is (2*j+1-1)/2 = j so j-1 is the largest, 279 and that's again n//2-1. 280 */ 281 for (i=n/2-1 ; i>=0 ; i--) 282 if(_siftup((PyListObject *)heap, i) == -1) 283 return NULL; 284 Py_INCREF(Py_None); 285 return Py_None; 286} 287 288PyDoc_STRVAR(heapify_doc, 289"Transform list into a heap, in-place, in O(len(heap)) time."); 290 291static PyObject * 292nlargest(PyObject *self, PyObject *args) 293{ 294 PyObject *heap=NULL, *elem, *iterable, *sol, *it, *oldelem; 295 Py_ssize_t i, n; 296 int cmp; 297 298 if (!PyArg_ParseTuple(args, "nO:nlargest", &n, &iterable)) 299 return NULL; 300 301 it = PyObject_GetIter(iterable); 302 if (it == NULL) 303 return NULL; 304 305 heap = PyList_New(0); 306 if (heap == NULL) 307 goto fail; 308 309 for (i=0 ; i<n ; i++ ){ 310 elem = PyIter_Next(it); 311 if (elem == NULL) { 312 if (PyErr_Occurred()) 313 goto fail; 314 else 315 goto sortit; 316 } 317 if (PyList_Append(heap, elem) == -1) { 318 Py_DECREF(elem); 319 goto fail; 320 } 321 Py_DECREF(elem); 322 } 323 if (PyList_GET_SIZE(heap) == 0) 324 goto sortit; 325 326 for (i=n/2-1 ; i>=0 ; i--) 327 if(_siftup((PyListObject *)heap, i) == -1) 328 goto fail; 329 330 sol = PyList_GET_ITEM(heap, 0); 331 while (1) { 332 elem = PyIter_Next(it); 333 if (elem == NULL) { 334 if (PyErr_Occurred()) 335 goto fail; 336 else 337 goto sortit; 338 } 339 cmp = cmp_lt(sol, elem); 340 if (cmp == -1) { 341 Py_DECREF(elem); 342 goto fail; 343 } 344 if (cmp == 0) { 345 Py_DECREF(elem); 346 continue; 347 } 348 oldelem = PyList_GET_ITEM(heap, 0); 349 PyList_SET_ITEM(heap, 0, elem); 350 Py_DECREF(oldelem); 351 if (_siftup((PyListObject *)heap, 0) == -1) 352 goto fail; 353 sol = PyList_GET_ITEM(heap, 0); 354 } 355sortit: 356 if (PyList_Sort(heap) == -1) 357 goto fail; 358 if (PyList_Reverse(heap) == -1) 359 goto fail; 360 Py_DECREF(it); 361 return heap; 362 363fail: 364 Py_DECREF(it); 365 Py_XDECREF(heap); 366 return NULL; 367} 368 369PyDoc_STRVAR(nlargest_doc, 370"Find the n largest elements in a dataset.\n\ 371\n\ 372Equivalent to: sorted(iterable, reverse=True)[:n]\n"); 373 374static int 375_siftdownmax(PyListObject *heap, Py_ssize_t startpos, Py_ssize_t pos) 376{ 377 PyObject *newitem, *parent; 378 int cmp; 379 Py_ssize_t parentpos; 380 381 assert(PyList_Check(heap)); 382 if (pos >= PyList_GET_SIZE(heap)) { 383 PyErr_SetString(PyExc_IndexError, "index out of range"); 384 return -1; 385 } 386 387 newitem = PyList_GET_ITEM(heap, pos); 388 Py_INCREF(newitem); 389 /* Follow the path to the root, moving parents down until finding 390 a place newitem fits. */ 391 while (pos > startpos){ 392 parentpos = (pos - 1) >> 1; 393 parent = PyList_GET_ITEM(heap, parentpos); 394 cmp = cmp_lt(parent, newitem); 395 if (cmp == -1) { 396 Py_DECREF(newitem); 397 return -1; 398 } 399 if (cmp == 0) 400 break; 401 Py_INCREF(parent); 402 Py_DECREF(PyList_GET_ITEM(heap, pos)); 403 PyList_SET_ITEM(heap, pos, parent); 404 pos = parentpos; 405 } 406 Py_DECREF(PyList_GET_ITEM(heap, pos)); 407 PyList_SET_ITEM(heap, pos, newitem); 408 return 0; 409} 410 411static int 412_siftupmax(PyListObject *heap, Py_ssize_t pos) 413{ 414 Py_ssize_t startpos, endpos, childpos, rightpos; 415 int cmp; 416 PyObject *newitem, *tmp; 417 418 assert(PyList_Check(heap)); 419 endpos = PyList_GET_SIZE(heap); 420 startpos = pos; 421 if (pos >= endpos) { 422 PyErr_SetString(PyExc_IndexError, "index out of range"); 423 return -1; 424 } 425 newitem = PyList_GET_ITEM(heap, pos); 426 Py_INCREF(newitem); 427 428 /* Bubble up the smaller child until hitting a leaf. */ 429 childpos = 2*pos + 1; /* leftmost child position */ 430 while (childpos < endpos) { 431 /* Set childpos to index of smaller child. */ 432 rightpos = childpos + 1; 433 if (rightpos < endpos) { 434 cmp = cmp_lt( 435 PyList_GET_ITEM(heap, rightpos), 436 PyList_GET_ITEM(heap, childpos)); 437 if (cmp == -1) { 438 Py_DECREF(newitem); 439 return -1; 440 } 441 if (cmp == 0) 442 childpos = rightpos; 443 } 444 /* Move the smaller child up. */ 445 tmp = PyList_GET_ITEM(heap, childpos); 446 Py_INCREF(tmp); 447 Py_DECREF(PyList_GET_ITEM(heap, pos)); 448 PyList_SET_ITEM(heap, pos, tmp); 449 pos = childpos; 450 childpos = 2*pos + 1; 451 } 452 453 /* The leaf at pos is empty now. Put newitem there, and and bubble 454 it up to its final resting place (by sifting its parents down). */ 455 Py_DECREF(PyList_GET_ITEM(heap, pos)); 456 PyList_SET_ITEM(heap, pos, newitem); 457 return _siftdownmax(heap, startpos, pos); 458} 459 460static PyObject * 461nsmallest(PyObject *self, PyObject *args) 462{ 463 PyObject *heap=NULL, *elem, *iterable, *los, *it, *oldelem; 464 Py_ssize_t i, n; 465 int cmp; 466 467 if (!PyArg_ParseTuple(args, "nO:nsmallest", &n, &iterable)) 468 return NULL; 469 470 it = PyObject_GetIter(iterable); 471 if (it == NULL) 472 return NULL; 473 474 heap = PyList_New(0); 475 if (heap == NULL) 476 goto fail; 477 478 for (i=0 ; i<n ; i++ ){ 479 elem = PyIter_Next(it); 480 if (elem == NULL) { 481 if (PyErr_Occurred()) 482 goto fail; 483 else 484 goto sortit; 485 } 486 if (PyList_Append(heap, elem) == -1) { 487 Py_DECREF(elem); 488 goto fail; 489 } 490 Py_DECREF(elem); 491 } 492 n = PyList_GET_SIZE(heap); 493 if (n == 0) 494 goto sortit; 495 496 for (i=n/2-1 ; i>=0 ; i--) 497 if(_siftupmax((PyListObject *)heap, i) == -1) 498 goto fail; 499 500 los = PyList_GET_ITEM(heap, 0); 501 while (1) { 502 elem = PyIter_Next(it); 503 if (elem == NULL) { 504 if (PyErr_Occurred()) 505 goto fail; 506 else 507 goto sortit; 508 } 509 cmp = cmp_lt(elem, los); 510 if (cmp == -1) { 511 Py_DECREF(elem); 512 goto fail; 513 } 514 if (cmp == 0) { 515 Py_DECREF(elem); 516 continue; 517 } 518 519 oldelem = PyList_GET_ITEM(heap, 0); 520 PyList_SET_ITEM(heap, 0, elem); 521 Py_DECREF(oldelem); 522 if (_siftupmax((PyListObject *)heap, 0) == -1) 523 goto fail; 524 los = PyList_GET_ITEM(heap, 0); 525 } 526 527sortit: 528 if (PyList_Sort(heap) == -1) 529 goto fail; 530 Py_DECREF(it); 531 return heap; 532 533fail: 534 Py_DECREF(it); 535 Py_XDECREF(heap); 536 return NULL; 537} 538 539PyDoc_STRVAR(nsmallest_doc, 540"Find the n smallest elements in a dataset.\n\ 541\n\ 542Equivalent to: sorted(iterable)[:n]\n"); 543 544static PyMethodDef heapq_methods[] = { 545 {"heappush", (PyCFunction)heappush, 546 METH_VARARGS, heappush_doc}, 547 {"heappushpop", (PyCFunction)heappushpop, 548 METH_VARARGS, heappushpop_doc}, 549 {"heappop", (PyCFunction)heappop, 550 METH_O, heappop_doc}, 551 {"heapreplace", (PyCFunction)heapreplace, 552 METH_VARARGS, heapreplace_doc}, 553 {"heapify", (PyCFunction)heapify, 554 METH_O, heapify_doc}, 555 {"nlargest", (PyCFunction)nlargest, 556 METH_VARARGS, nlargest_doc}, 557 {"nsmallest", (PyCFunction)nsmallest, 558 METH_VARARGS, nsmallest_doc}, 559 {NULL, NULL} /* sentinel */ 560}; 561 562PyDoc_STRVAR(module_doc, 563"Heap queue algorithm (a.k.a. priority queue).\n\ 564\n\ 565Heaps are arrays for which a[k] <= a[2*k+1] and a[k] <= a[2*k+2] for\n\ 566all k, counting elements from 0. For the sake of comparison,\n\ 567non-existing elements are considered to be infinite. The interesting\n\ 568property of a heap is that a[0] is always its smallest element.\n\ 569\n\ 570Usage:\n\ 571\n\ 572heap = [] # creates an empty heap\n\ 573heappush(heap, item) # pushes a new item on the heap\n\ 574item = heappop(heap) # pops the smallest item from the heap\n\ 575item = heap[0] # smallest item on the heap without popping it\n\ 576heapify(x) # transforms list into a heap, in-place, in linear time\n\ 577item = heapreplace(heap, item) # pops and returns smallest item, and adds\n\ 578 # new item; the heap size is unchanged\n\ 579\n\ 580Our API differs from textbook heap algorithms as follows:\n\ 581\n\ 582- We use 0-based indexing. This makes the relationship between the\n\ 583 index for a node and the indexes for its children slightly less\n\ 584 obvious, but is more suitable since Python uses 0-based indexing.\n\ 585\n\ 586- Our heappop() method returns the smallest item, not the largest.\n\ 587\n\ 588These two make it possible to view the heap as a regular Python list\n\ 589without surprises: heap[0] is the smallest item, and heap.sort()\n\ 590maintains the heap invariant!\n"); 591 592 593PyDoc_STRVAR(__about__, 594"Heap queues\n\ 595\n\ 596[explanation by François Pinard]\n\ 597\n\ 598Heaps are arrays for which a[k] <= a[2*k+1] and a[k] <= a[2*k+2] for\n\ 599all k, counting elements from 0. For the sake of comparison,\n\ 600non-existing elements are considered to be infinite. The interesting\n\ 601property of a heap is that a[0] is always its smallest element.\n" 602"\n\ 603The strange invariant above is meant to be an efficient memory\n\ 604representation for a tournament. The numbers below are `k', not a[k]:\n\ 605\n\ 606 0\n\ 607\n\ 608 1 2\n\ 609\n\ 610 3 4 5 6\n\ 611\n\ 612 7 8 9 10 11 12 13 14\n\ 613\n\ 614 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30\n\ 615\n\ 616\n\ 617In the tree above, each cell `k' is topping `2*k+1' and `2*k+2'. In\n\ 618an usual binary tournament we see in sports, each cell is the winner\n\ 619over the two cells it tops, and we can trace the winner down the tree\n\ 620to see all opponents s/he had. However, in many computer applications\n\ 621of such tournaments, we do not need to trace the history of a winner.\n\ 622To be more memory efficient, when a winner is promoted, we try to\n\ 623replace it by something else at a lower level, and the rule becomes\n\ 624that a cell and the two cells it tops contain three different items,\n\ 625but the top cell \"wins\" over the two topped cells.\n" 626"\n\ 627If this heap invariant is protected at all time, index 0 is clearly\n\ 628the overall winner. The simplest algorithmic way to remove it and\n\ 629find the \"next\" winner is to move some loser (let's say cell 30 in the\n\ 630diagram above) into the 0 position, and then percolate this new 0 down\n\ 631the tree, exchanging values, until the invariant is re-established.\n\ 632This is clearly logarithmic on the total number of items in the tree.\n\ 633By iterating over all items, you get an O(n ln n) sort.\n" 634"\n\ 635A nice feature of this sort is that you can efficiently insert new\n\ 636items while the sort is going on, provided that the inserted items are\n\ 637not \"better\" than the last 0'th element you extracted. This is\n\ 638especially useful in simulation contexts, where the tree holds all\n\ 639incoming events, and the \"win\" condition means the smallest scheduled\n\ 640time. When an event schedule other events for execution, they are\n\ 641scheduled into the future, so they can easily go into the heap. So, a\n\ 642heap is a good structure for implementing schedulers (this is what I\n\ 643used for my MIDI sequencer :-).\n" 644"\n\ 645Various structures for implementing schedulers have been extensively\n\ 646studied, and heaps are good for this, as they are reasonably speedy,\n\ 647the speed is almost constant, and the worst case is not much different\n\ 648than the average case. However, there are other representations which\n\ 649are more efficient overall, yet the worst cases might be terrible.\n" 650"\n\ 651Heaps are also very useful in big disk sorts. You most probably all\n\ 652know that a big sort implies producing \"runs\" (which are pre-sorted\n\ 653sequences, which size is usually related to the amount of CPU memory),\n\ 654followed by a merging passes for these runs, which merging is often\n\ 655very cleverly organised[1]. It is very important that the initial\n\ 656sort produces the longest runs possible. Tournaments are a good way\n\ 657to that. If, using all the memory available to hold a tournament, you\n\ 658replace and percolate items that happen to fit the current run, you'll\n\ 659produce runs which are twice the size of the memory for random input,\n\ 660and much better for input fuzzily ordered.\n" 661"\n\ 662Moreover, if you output the 0'th item on disk and get an input which\n\ 663may not fit in the current tournament (because the value \"wins\" over\n\ 664the last output value), it cannot fit in the heap, so the size of the\n\ 665heap decreases. The freed memory could be cleverly reused immediately\n\ 666for progressively building a second heap, which grows at exactly the\n\ 667same rate the first heap is melting. When the first heap completely\n\ 668vanishes, you switch heaps and start a new run. Clever and quite\n\ 669effective!\n\ 670\n\ 671In a word, heaps are useful memory structures to know. I use them in\n\ 672a few applications, and I think it is good to keep a `heap' module\n\ 673around. :-)\n" 674"\n\ 675--------------------\n\ 676[1] The disk balancing algorithms which are current, nowadays, are\n\ 677more annoying than clever, and this is a consequence of the seeking\n\ 678capabilities of the disks. On devices which cannot seek, like big\n\ 679tape drives, the story was quite different, and one had to be very\n\ 680clever to ensure (far in advance) that each tape movement will be the\n\ 681most effective possible (that is, will best participate at\n\ 682\"progressing\" the merge). Some tapes were even able to read\n\ 683backwards, and this was also used to avoid the rewinding time.\n\ 684Believe me, real good tape sorts were quite spectacular to watch!\n\ 685From all times, sorting has always been a Great Art! :-)\n"); 686 687PyMODINIT_FUNC 688init_heapq(void) 689{ 690 PyObject *m; 691 692 m = Py_InitModule3("_heapq", heapq_methods, module_doc); 693 if (m == NULL) 694 return; 695 PyModule_AddObject(m, "__about__", PyString_FromString(__about__)); 696} 697