Module adseq.implementations.binary_heap

Assumes sorted inputs, ie homogeneous delays

Classes

class BinaryHeap (buffer: jax.Array, size: int | jax.Array)

Expand source code

class BinaryHeap(typing.NamedTuple):
    buffer: jax.Array
    size: int | jax.Array
    @classmethod
    def init(cls, delay, capacity=None, grad=False):
        return cls(
                jnp.full(
                    delay if capacity is None else capacity,
                    INT_MAX,
                    'float32'
                    ),
                0,
                )
    @classmethod
    def sized(cls, n):
        'wish I could use __class_getitem__'
        return type(f'{cls.__name__}[{n}]',
                    cls.__bases__,
                    {**cls.__dict__,
                     'init': functools.partial(cls.init, capacity=n)})
    def enqueue(self, n):
        return _enqueue(self, n)
    def pop(self, n):
        return _pop(self, n)

BinaryHeap(buffer, size)

Ancestors

• builtins.tuple

Static methods

def init(delay, capacity=None, grad=False)

def sized(n)

wish I could use class_getitem

Instance variables

var buffer : jax.Array

Expand source code

class BinaryHeap(typing.NamedTuple):
    buffer: jax.Array
    size: int | jax.Array
    @classmethod
    def init(cls, delay, capacity=None, grad=False):
        return cls(
                jnp.full(
                    delay if capacity is None else capacity,
                    INT_MAX,
                    'float32'
                    ),
                0,
                )
    @classmethod
    def sized(cls, n):
        'wish I could use __class_getitem__'
        return type(f'{cls.__name__}[{n}]',
                    cls.__bases__,
                    {**cls.__dict__,
                     'init': functools.partial(cls.init, capacity=n)})
    def enqueue(self, n):
        return _enqueue(self, n)
    def pop(self, n):
        return _pop(self, n)

Alias for field number 0

var size : int | jax.Array

Expand source code

class BinaryHeap(typing.NamedTuple):
    buffer: jax.Array
    size: int | jax.Array
    @classmethod
    def init(cls, delay, capacity=None, grad=False):
        return cls(
                jnp.full(
                    delay if capacity is None else capacity,
                    INT_MAX,
                    'float32'
                    ),
                0,
                )
    @classmethod
    def sized(cls, n):
        'wish I could use __class_getitem__'
        return type(f'{cls.__name__}[{n}]',
                    cls.__bases__,
                    {**cls.__dict__,
                     'init': functools.partial(cls.init, capacity=n)})
    def enqueue(self, n):
        return _enqueue(self, n)
    def pop(self, n):
        return _pop(self, n)

Alias for field number 1

Methods

def enqueue(self, n)

Expand source code

def enqueue(self, n):
    return _enqueue(self, n)

def pop(self, n)

Expand source code

def pop(self, n):
    return _pop(self, n)