converting base class instance to derived class instance

[Gerrit]

Fran�ois Pinard wrote:
> By the way, what is a "heap type"?

I don't know, but:

http://foldoc.doc.ic.ac.uk/foldoc/foldoc.cgi?query=heap&action=Search

heap

1. <programming> An area of memory used for dynamic memory allocation
where blocks of memory are allocated and freed in an arbitrary order and
the pattern of allocation and size of blocks is not known until run
time. Typically, a program has one heap which it may use for several
different purposes.

Heap is required by languages in which functions can return arbitrary
data structures or functions with free variables (see closure). In C
functions malloc and free provide access to the heap.

Contrast stack. See also dangling pointer.

2. <programming> A data structure with its elements partially ordered
(sorted) such that finding either the minimum or the maximum (but not
both) of the elements is computationally inexpensive (independent of the
number of elements), while both adding a new item and finding each
subsequent smallest/largest element can be done in O(log n) time, where
n is the number of elements.

Formally, a heap is a binary tree with a key in each node, such that all
the leaves of the tree are on two adjacent levels; all leaves on the
lowest level occur to the left and all levels, except possibly the
lowest, are filled; and the key in the root is at least as large as the
keys in its children (if any), and the left and right subtrees (if they
exist) are again heaps.

Note that the last condition assumes that the goal is finding the
minimum quickly.

Heaps are often implemented as one-dimensional arrays. Still assuming
that the goal is finding the minimum quickly the invariant is

   heap[i] <= heap[2*i] and heap[i] <= heap[2*i+1] for all i,


where heap[i] denotes the i-th element, heap[1] being the first.
Heaps can be used to implement priority queues or in sort algorithms.


And:

http://www.python.org/dev/doc/devel/lib/module-heapq.html
Heaps are arrays for which heap[k] <= heap[2*k+1] and heap[k] <=
heap[2*k+2] for all k, counting elements from zero. For the sake of
comparison, non-existing elements are considered to be infinite. The
interesting property of a heap is that heap[0] is always its smallest
element.

Gerrit.

-- 
PrePEP: Builtin path type
    http://people.nl.linux.org/~gerrit/creaties/path/pep-xxxx.html
Asperger's Syndrome - a personal approach:
	http://people.nl.linux.org/~gerrit/english/