Bigint

bigint

Dialect for unlimited precision integers with Python int semantics.

bigint = BigIntegerType() module-attribute

BigInt = Dialect('bigint', [AddOp, SubOp, MulOp, FloorDivOp, ModOp, PowOp, LShiftOp, RShiftOp, BitOrOp, BitXorOp, BitAndOp, DivOp, EqOp, NeqOp, GtOp, GteOp, LtOp, LteOp], [BigIntegerType]) module-attribute

BigIntegerType dataclass

Bases: ParametrizedAttribute, TypeAttribute

Type for unlimited precision integers, with Python int semantics.

Source code in xdsl/dialects/bigint.py

@irdl_attr_definition
class BigIntegerType(ParametrizedAttribute, TypeAttribute):
    """Type for unlimited precision integers, with Python `int` semantics."""

    name = "bigint.bigint"

name = 'bigint.bigint' class-attribute instance-attribute

BinaryOperation

Bases: IRDLOperation, ABC

Binary operation where all operands and results are bigints.

Source code in xdsl/dialects/bigint.py

class BinaryOperation(IRDLOperation, abc.ABC):
    """Binary operation where all operands and results are `bigint`s."""

    lhs = operand_def(bigint)
    rhs = operand_def(bigint)
    result = result_def(bigint)

    assembly_format = "$lhs `,` $rhs attr-dict `:` type($result)"

    def __init__(
        self,
        operand1: Operation | SSAValue,
        operand2: Operation | SSAValue,
    ):
        super().__init__(operands=[operand1, operand2], result_types=[bigint])

lhs = operand_def(bigint) class-attribute instance-attribute

rhs = operand_def(bigint) class-attribute instance-attribute

result = result_def(bigint) class-attribute instance-attribute

assembly_format = '$lhs `,` $rhs attr-dict `:` type($result)' class-attribute instance-attribute

__init__(operand1: Operation | SSAValue, operand2: Operation | SSAValue)

Source code in xdsl/dialects/bigint.py

def __init__(
    self,
    operand1: Operation | SSAValue,
    operand2: Operation | SSAValue,
):
    super().__init__(operands=[operand1, operand2], result_types=[bigint])

AddOp dataclass

Bases: BinaryOperation

Add two bigints.

Source code in xdsl/dialects/bigint.py

@irdl_op_definition
class AddOp(BinaryOperation):
    """Add two `bigint`s."""

    name = "bigint.add"

    traits = traits_def(
        Pure(),
        Commutative(),
        SameOperandsAndResultType(),
    )

name = 'bigint.add' class-attribute instance-attribute

traits = traits_def(Pure(), Commutative(), SameOperandsAndResultType()) class-attribute instance-attribute

SubOp dataclass

Bases: BinaryOperation

Subtract two bigints.

Source code in xdsl/dialects/bigint.py

@irdl_op_definition
class SubOp(BinaryOperation):
    """Subtract two `bigint`s."""

    name = "bigint.sub"

    traits = traits_def(
        Pure(),
        Commutative(),
        SameOperandsAndResultType(),
    )

name = 'bigint.sub' class-attribute instance-attribute

traits = traits_def(Pure(), Commutative(), SameOperandsAndResultType()) class-attribute instance-attribute

MulOp dataclass

Bases: BinaryOperation

Multiply two bigints.

Source code in xdsl/dialects/bigint.py

@irdl_op_definition
class MulOp(BinaryOperation):
    """Multiply two `bigint`s."""

    name = "bigint.mul"

    traits = traits_def(
        Pure(),
        Commutative(),
        SameOperandsAndResultType(),
    )

name = 'bigint.mul' class-attribute instance-attribute

traits = traits_def(Pure(), Commutative(), SameOperandsAndResultType()) class-attribute instance-attribute

FloorDivOp dataclass

Bases: BinaryOperation

Floor divide two bigints, rounding down to the nearest integer.

Source code in xdsl/dialects/bigint.py

@irdl_op_definition
class FloorDivOp(BinaryOperation):
    """Floor divide two `bigint`s, rounding down to the nearest integer."""

    name = "bigint.floordiv"

    traits = traits_def(
        Pure(),
        SameOperandsAndResultType(),
    )

name = 'bigint.floordiv' class-attribute instance-attribute

traits = traits_def(Pure(), SameOperandsAndResultType()) class-attribute instance-attribute

ModOp dataclass

Bases: BinaryOperation

Modulo two bigints, taking the sign of the divisor.

Source code in xdsl/dialects/bigint.py

@irdl_op_definition
class ModOp(BinaryOperation):
    """Modulo two `bigint`s, taking the sign of the divisor."""

    name = "bigint.mod"

    traits = traits_def(
        Pure(),
        SameOperandsAndResultType(),
    )

name = 'bigint.mod' class-attribute instance-attribute

traits = traits_def(Pure(), SameOperandsAndResultType()) class-attribute instance-attribute

PowOp dataclass

Bases: BinaryOperation

Exponentiate a bigint by another.

Source code in xdsl/dialects/bigint.py

@irdl_op_definition
class PowOp(BinaryOperation):
    """Exponentiate a `bigint` by another."""

    name = "bigint.pow"

    traits = traits_def(
        Pure(),
        SameOperandsAndResultType(),
    )

name = 'bigint.pow' class-attribute instance-attribute

traits = traits_def(Pure(), SameOperandsAndResultType()) class-attribute instance-attribute

LShiftOp dataclass

Bases: BinaryOperation

Left shift a bigint by another.

Source code in xdsl/dialects/bigint.py

@irdl_op_definition
class LShiftOp(BinaryOperation):
    """Left shift a `bigint` by another."""

    name = "bigint.lshift"

    traits = traits_def(
        Pure(),
        SameOperandsAndResultType(),
    )

name = 'bigint.lshift' class-attribute instance-attribute

traits = traits_def(Pure(), SameOperandsAndResultType()) class-attribute instance-attribute

RShiftOp dataclass

Bases: BinaryOperation

Right shift a bigint by another.

Source code in xdsl/dialects/bigint.py

@irdl_op_definition
class RShiftOp(BinaryOperation):
    """Right shift a `bigint` by another."""

    name = "bigint.rshift"

    traits = traits_def(
        Pure(),
        SameOperandsAndResultType(),
    )

name = 'bigint.rshift' class-attribute instance-attribute

traits = traits_def(Pure(), SameOperandsAndResultType()) class-attribute instance-attribute

BitOrOp dataclass

Bases: BinaryOperation

Bitwise OR a bigint with another.

Source code in xdsl/dialects/bigint.py

@irdl_op_definition
class BitOrOp(BinaryOperation):
    """Bitwise OR a `bigint` with another."""

    name = "bigint.bitor"

    traits = traits_def(
        Pure(),
        Commutative(),
        SameOperandsAndResultType(),
    )

name = 'bigint.bitor' class-attribute instance-attribute

traits = traits_def(Pure(), Commutative(), SameOperandsAndResultType()) class-attribute instance-attribute

BitXorOp dataclass

Bases: BinaryOperation

Bitwise XOR a bigint with another.

Source code in xdsl/dialects/bigint.py

@irdl_op_definition
class BitXorOp(BinaryOperation):
    """Bitwise XOR a `bigint` with another."""

    name = "bigint.bitxor"

    traits = traits_def(
        Pure(),
        Commutative(),
        SameOperandsAndResultType(),
    )

name = 'bigint.bitxor' class-attribute instance-attribute

traits = traits_def(Pure(), Commutative(), SameOperandsAndResultType()) class-attribute instance-attribute

BitAndOp dataclass

Bases: BinaryOperation

Bitwise AND a bigint with another.

Source code in xdsl/dialects/bigint.py

@irdl_op_definition
class BitAndOp(BinaryOperation):
    """Bitwise AND a `bigint` with another."""

    name = "bigint.bitand"

    traits = traits_def(
        Pure(),
        Commutative(),
        SameOperandsAndResultType(),
    )

name = 'bigint.bitand' class-attribute instance-attribute

traits = traits_def(Pure(), Commutative(), SameOperandsAndResultType()) class-attribute instance-attribute

DivOp

Bases: IRDLOperation

Divide two bigints, yielding a 64-bit floating point type.

Note that this operation follows Python semantics, for example by rounding to minus infinity.

Source code in xdsl/dialects/bigint.py

@irdl_op_definition
class DivOp(IRDLOperation):
    """Divide two `bigint`s, yielding a 64-bit floating point type.

    Note that this operation follows Python semantics, for example by rounding
    to minus infinity.
    """

    name = "bigint.div"

    lhs = operand_def(bigint)
    rhs = operand_def(bigint)
    result = result_def(f64)

    assembly_format = "$lhs `,` $rhs attr-dict `:` type($result)"

    traits = traits_def(
        Pure(),
    )

    def __init__(
        self,
        operand1: Operation | SSAValue,
        operand2: Operation | SSAValue,
    ):
        super().__init__(operands=[operand1, operand2], result_types=[f64])

name = 'bigint.div' class-attribute instance-attribute

lhs = operand_def(bigint) class-attribute instance-attribute

rhs = operand_def(bigint) class-attribute instance-attribute

result = result_def(f64) class-attribute instance-attribute

assembly_format = '$lhs `,` $rhs attr-dict `:` type($result)' class-attribute instance-attribute

traits = traits_def(Pure()) class-attribute instance-attribute

__init__(operand1: Operation | SSAValue, operand2: Operation | SSAValue)

Source code in xdsl/dialects/bigint.py

def __init__(
    self,
    operand1: Operation | SSAValue,
    operand2: Operation | SSAValue,
):
    super().__init__(operands=[operand1, operand2], result_types=[f64])

ComparisonOperation

Bases: IRDLOperation, ABC

Binary operation comparing two bigints and returning a boolean.

Source code in xdsl/dialects/bigint.py

class ComparisonOperation(IRDLOperation, abc.ABC):
    """Binary operation comparing two `bigint`s and returning a boolean."""

    lhs = operand_def(bigint)
    rhs = operand_def(bigint)
    result = result_def(i1)

    assembly_format = "$lhs `,` $rhs attr-dict `:` type($result)"

    def __init__(
        self,
        operand1: Operation | SSAValue,
        operand2: Operation | SSAValue,
    ):
        super().__init__(operands=[operand1, operand2], result_types=[i1])

lhs = operand_def(bigint) class-attribute instance-attribute

rhs = operand_def(bigint) class-attribute instance-attribute

result = result_def(i1) class-attribute instance-attribute

assembly_format = '$lhs `,` $rhs attr-dict `:` type($result)' class-attribute instance-attribute

__init__(operand1: Operation | SSAValue, operand2: Operation | SSAValue)

Source code in xdsl/dialects/bigint.py

def __init__(
    self,
    operand1: Operation | SSAValue,
    operand2: Operation | SSAValue,
):
    super().__init__(operands=[operand1, operand2], result_types=[i1])

EqOp dataclass

Bases: ComparisonOperation

Check equality of two bigints.

Source code in xdsl/dialects/bigint.py

@irdl_op_definition
class EqOp(ComparisonOperation):
    """Check equality of two `bigint`s."""

    name = "bigint.eq"

    traits = traits_def(
        Pure(),
        Commutative(),
    )

name = 'bigint.eq' class-attribute instance-attribute

traits = traits_def(Pure(), Commutative()) class-attribute instance-attribute

NeqOp dataclass

Bases: ComparisonOperation

Check inequality of two bigints.

Source code in xdsl/dialects/bigint.py

@irdl_op_definition
class NeqOp(ComparisonOperation):
    """Check inequality of two `bigint`s."""

    name = "bigint.neq"

    traits = traits_def(
        Pure(),
        Commutative(),
    )

name = 'bigint.neq' class-attribute instance-attribute

traits = traits_def(Pure(), Commutative()) class-attribute instance-attribute

GtOp dataclass

Bases: ComparisonOperation

Check if one bigint is greater than another.

Source code in xdsl/dialects/bigint.py

@irdl_op_definition
class GtOp(ComparisonOperation):
    """Check if one `bigint` is greater than another."""

    name = "bigint.gt"

    traits = traits_def(
        Pure(),
    )

name = 'bigint.gt' class-attribute instance-attribute

traits = traits_def(Pure()) class-attribute instance-attribute

GteOp dataclass

Bases: ComparisonOperation

Check if one bigint is greater than or equal to another.

Source code in xdsl/dialects/bigint.py

@irdl_op_definition
class GteOp(ComparisonOperation):
    """Check if one `bigint` is greater than or equal to another."""

    name = "bigint.gte"

    traits = traits_def(
        Pure(),
    )

name = 'bigint.gte' class-attribute instance-attribute

traits = traits_def(Pure()) class-attribute instance-attribute

LtOp dataclass

Bases: ComparisonOperation

Check if one bigint is less than another.

Source code in xdsl/dialects/bigint.py

@irdl_op_definition
class LtOp(ComparisonOperation):
    """Check if one `bigint` is less than another."""

    name = "bigint.lt"

    traits = traits_def(
        Pure(),
    )

name = 'bigint.lt' class-attribute instance-attribute

traits = traits_def(Pure()) class-attribute instance-attribute

LteOp dataclass

Bases: ComparisonOperation

Check if one bigint is less than or equal to another.

Source code in xdsl/dialects/bigint.py

@irdl_op_definition
class LteOp(ComparisonOperation):
    """Check if one `bigint` is less than or equal to another."""

    name = "bigint.lte"

    traits = traits_def(
        Pure(),
    )

name = 'bigint.lte' class-attribute instance-attribute

traits = traits_def(Pure()) class-attribute instance-attribute