Module adseq.implementations.fifo_ring

Assumes sorted inputs, ie homogeneous delays

Classes

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

Expand source code

class FIFORing(typing.NamedTuple):
    buffer: jax.Array
    head: int | 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, floatx if grad else 'int32'),
                0, 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)

FIFORing(buffer, head, 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 FIFORing(typing.NamedTuple):
    buffer: jax.Array
    head: int | 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, floatx if grad else 'int32'),
                0, 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 head : int | jax.Array

Expand source code

class FIFORing(typing.NamedTuple):
    buffer: jax.Array
    head: int | 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, floatx if grad else 'int32'),
                0, 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

var size : int | jax.Array

Expand source code

class FIFORing(typing.NamedTuple):
    buffer: jax.Array
    head: int | 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, floatx if grad else 'int32'),
                0, 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 2

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)