mlir.dialects.complex

Classes

AbsOp	The abs op takes a single complex number and computes its absolute value.
AbsOpAdaptor
AddOp	The add operation takes two complex numbers and returns their sum.
AddOpAdaptor
AngleOp	The angle op takes a single complex number and computes its argument value with a branch cut along the negative real axis.
AngleOpAdaptor
Atan2Op	For complex numbers it is expressed using complex logarithm
Atan2OpAdaptor
BitcastOp	Example:
BitcastOpAdaptor
ConjOp	The conj op takes a single complex number and computes the
ConjOpAdaptor
ConstantOp	The complex.constant operation creates a constant complex number from an
ConstantOpAdaptor
CosOp	The cos op takes a single complex number and computes the cosine of
CosOpAdaptor
CreateOp	The complex.create operation creates a complex number from two
CreateOpAdaptor
DivOp	The div operation takes two complex numbers and returns result of their
DivOpAdaptor
EqualOp	The eq op takes two complex numbers and returns whether they are equal.
EqualOpAdaptor
ExpOp	The exp op takes a single complex number and computes the exponential of
ExpOpAdaptor
Expm1Op	complex.expm1(x) := complex.exp(x) - 1
Expm1OpAdaptor
ImOp	The im op takes a single complex number and extracts the imaginary part.
ImOpAdaptor
Log1pOp	The log op takes a single complex number and computes the natural
Log1pOpAdaptor
LogOp	The log op takes a single complex number and computes the natural
LogOpAdaptor
MulOp	The mul operation takes two complex numbers and returns their product:
MulOpAdaptor
NegOp	The neg op takes a single complex number complex and returns -complex.
NegOpAdaptor
NotEqualOp	The neq op takes two complex numbers and returns whether they are not
NotEqualOpAdaptor
PowOp	The pow operation takes a complex number raises it to the given complex
PowOpAdaptor
PowiOp	The powi operation takes a base operand of complex type and a power
PowiOpAdaptor
ReOp	The re op takes a single complex number and extracts the real part.
ReOpAdaptor
RsqrtOp	The rsqrt operation computes reciprocal of square root.
RsqrtOpAdaptor
SignOp	The sign op takes a single complex number and computes the sign of
SignOpAdaptor
SinOp	The sin op takes a single complex number and computes the sine of
SinOpAdaptor
SqrtOp	The sqrt operation takes a complex number and returns its square root.
SqrtOpAdaptor
SubOp	The sub operation takes two complex numbers and returns their difference.
SubOpAdaptor
TanOp	The tan op takes a single complex number and computes the tangent of
TanOpAdaptor
TanhOp	The tanh operation takes a complex number and returns its hyperbolic
TanhOpAdaptor

Functions

abs(→ _ods_ir[_ods_ir])
add(→ _ods_ir[_ods_ir])
angle(→ _ods_ir[_ods_ir])
atan2(→ _ods_ir[_ods_ir])
bitcast(→ _ods_ir)
conj(→ _ods_ir[_ods_ir])
constant(→ _ods_ir[_ods_ir])
cos(→ _ods_ir[_ods_ir])
create_(→ _ods_ir[_ods_ir])
div(→ _ods_ir[_ods_ir])
eq(→ _ods_ir[_ods_ir])
exp(→ _ods_ir[_ods_ir])
expm1(→ _ods_ir[_ods_ir])
im(→ _ods_ir[_ods_ir])
log1p(→ _ods_ir[_ods_ir])
log(→ _ods_ir[_ods_ir])
mul(→ _ods_ir[_ods_ir])
neg(→ _ods_ir[_ods_ir])
neq(→ _ods_ir[_ods_ir])
pow(→ _ods_ir[_ods_ir])
powi(→ _ods_ir[_ods_ir])
re(→ _ods_ir[_ods_ir])
rsqrt(→ _ods_ir[_ods_ir])
sign(→ _ods_ir[_ods_ir])
sin(→ _ods_ir[_ods_ir])
sqrt(→ _ods_ir[_ods_ir])
sub(→ _ods_ir[_ods_ir])
tan(→ _ods_ir[_ods_ir])
tanh(→ _ods_ir[_ods_ir])

Module Contents

class mlir.dialects.complex.AbsOp(complex: _ods_ir[_ods_ir], *, fastmath: Any | _ods_ir | None = None, results: Sequence[_ods_ir] | None = None, loc: _ods_ir | None = None, ip: _ods_ir | None = None)

Bases: _ods_ir

The abs op takes a single complex number and computes its absolute value.

Example:

%a = complex.abs %b : complex<f32>

OPERATION_NAME = 'complex.abs'

_ODS_REGIONS = (0, True)

complex() → _ods_ir[_ods_ir]

fastmath() → _ods_ir

result() → _ods_ir[_ods_ir]

class mlir.dialects.complex.AbsOpAdaptor

Bases: _ods_ir

OPERATION_NAME = 'complex.abs'

complex() → _ods_ir[_ods_ir]

fastmath() → _ods_ir

mlir.dialects.complex.abs(complex: _ods_ir[_ods_ir], *, fastmath: Any | _ods_ir | None = None, results: Sequence[_ods_ir] | None = None, loc: _ods_ir | None = None, ip: _ods_ir | None = None) → _ods_ir[_ods_ir]

class mlir.dialects.complex.AddOp(lhs: _ods_ir[_ods_ir], rhs: _ods_ir[_ods_ir], *, fastmath: Any | _ods_ir | None = None, results: Sequence[_ods_ir] | None = None, loc: _ods_ir | None = None, ip: _ods_ir | None = None)

Bases: _ods_ir

The add operation takes two complex numbers and returns their sum.

Example:

%a = complex.add %b, %c : complex<f32>

OPERATION_NAME = 'complex.add'

_ODS_REGIONS = (0, True)

lhs() → _ods_ir[_ods_ir]

rhs() → _ods_ir[_ods_ir]

fastmath() → _ods_ir

result() → _ods_ir[_ods_ir]

class mlir.dialects.complex.AddOpAdaptor

Bases: _ods_ir

OPERATION_NAME = 'complex.add'

lhs() → _ods_ir[_ods_ir]

rhs() → _ods_ir[_ods_ir]

fastmath() → _ods_ir

mlir.dialects.complex.add(lhs: _ods_ir[_ods_ir], rhs: _ods_ir[_ods_ir], *, fastmath: Any | _ods_ir | None = None, results: Sequence[_ods_ir] | None = None, loc: _ods_ir | None = None, ip: _ods_ir | None = None) → _ods_ir[_ods_ir]

class mlir.dialects.complex.AngleOp(complex: _ods_ir[_ods_ir], *, fastmath: Any | _ods_ir | None = None, results: Sequence[_ods_ir] | None = None, loc: _ods_ir | None = None, ip: _ods_ir | None = None)

Bases: _ods_ir

The angle op takes a single complex number and computes its argument value with a branch cut along the negative real axis.

Example:

%a = complex.angle %b : complex<f32>

OPERATION_NAME = 'complex.angle'

_ODS_REGIONS = (0, True)

complex() → _ods_ir[_ods_ir]

fastmath() → _ods_ir

result() → _ods_ir[_ods_ir]

class mlir.dialects.complex.AngleOpAdaptor

Bases: _ods_ir

OPERATION_NAME = 'complex.angle'

complex() → _ods_ir[_ods_ir]

fastmath() → _ods_ir

mlir.dialects.complex.angle(complex: _ods_ir[_ods_ir], *, fastmath: Any | _ods_ir | None = None, results: Sequence[_ods_ir] | None = None, loc: _ods_ir | None = None, ip: _ods_ir | None = None) → _ods_ir[_ods_ir]

class mlir.dialects.complex.Atan2Op(lhs: _ods_ir[_ods_ir], rhs: _ods_ir[_ods_ir], *, fastmath: Any | _ods_ir | None = None, results: Sequence[_ods_ir] | None = None, loc: _ods_ir | None = None, ip: _ods_ir | None = None)

Bases: _ods_ir

For complex numbers it is expressed using complex logarithm atan2(y, x) = -i * log((x + i * y) / sqrt(x**2 + y**2))

Example:

%a = complex.atan2 %b, %c : complex<f32>

OPERATION_NAME = 'complex.atan2'

_ODS_REGIONS = (0, True)

lhs() → _ods_ir[_ods_ir]

rhs() → _ods_ir[_ods_ir]

fastmath() → _ods_ir

result() → _ods_ir[_ods_ir]

class mlir.dialects.complex.Atan2OpAdaptor

Bases: _ods_ir

OPERATION_NAME = 'complex.atan2'

lhs() → _ods_ir[_ods_ir]

rhs() → _ods_ir[_ods_ir]

fastmath() → _ods_ir

mlir.dialects.complex.atan2(lhs: _ods_ir[_ods_ir], rhs: _ods_ir[_ods_ir], *, fastmath: Any | _ods_ir | None = None, results: Sequence[_ods_ir] | None = None, loc: _ods_ir | None = None, ip: _ods_ir | None = None) → _ods_ir[_ods_ir]

class mlir.dialects.complex.BitcastOp(result: _ods_ir, operand: _ods_ir, *, loc: _ods_ir | None = None, ip: _ods_ir | None = None)

Bases: _ods_ir

Example:

%a = complex.bitcast %b : complex<f32> -> i64

OPERATION_NAME = 'complex.bitcast'

_ODS_REGIONS = (0, True)

operand() → _ods_ir

result() → _ods_ir

class mlir.dialects.complex.BitcastOpAdaptor

Bases: _ods_ir

OPERATION_NAME = 'complex.bitcast'

operand() → _ods_ir

mlir.dialects.complex.bitcast(result: _ods_ir, operand: _ods_ir, *, loc: _ods_ir | None = None, ip: _ods_ir | None = None) → _ods_ir

class mlir.dialects.complex.ConjOp(complex: _ods_ir[_ods_ir], *, fastmath: Any | _ods_ir | None = None, results: Sequence[_ods_ir] | None = None, loc: _ods_ir | None = None, ip: _ods_ir | None = None)

Bases: _ods_ir

The conj op takes a single complex number and computes the complex conjugate.

Example:

%a = complex.conj %b: complex<f32>

OPERATION_NAME = 'complex.conj'

_ODS_REGIONS = (0, True)

complex() → _ods_ir[_ods_ir]

fastmath() → _ods_ir

result() → _ods_ir[_ods_ir]

class mlir.dialects.complex.ConjOpAdaptor

Bases: _ods_ir

OPERATION_NAME = 'complex.conj'

complex() → _ods_ir[_ods_ir]

fastmath() → _ods_ir

mlir.dialects.complex.conj(complex: _ods_ir[_ods_ir], *, fastmath: Any | _ods_ir | None = None, results: Sequence[_ods_ir] | None = None, loc: _ods_ir | None = None, ip: _ods_ir | None = None) → _ods_ir[_ods_ir]

class mlir.dialects.complex.ConstantOp(complex: _ods_ir, value: Sequence[_ods_ir] | _ods_ir, *, loc: _ods_ir | None = None, ip: _ods_ir | None = None)

Bases: _ods_ir

The complex.constant operation creates a constant complex number from an attribute containing the real and imaginary parts.

Example:

%a = complex.constant [0.1, -1.0] : complex<f64>

OPERATION_NAME = 'complex.constant'

_ODS_REGIONS = (0, True)

value() → _ods_ir

complex() → _ods_ir[_ods_ir]

class mlir.dialects.complex.ConstantOpAdaptor

Bases: _ods_ir

OPERATION_NAME = 'complex.constant'

value() → _ods_ir

mlir.dialects.complex.constant(complex: _ods_ir, value: Sequence[_ods_ir] | _ods_ir, *, loc: _ods_ir | None = None, ip: _ods_ir | None = None) → _ods_ir[_ods_ir]

class mlir.dialects.complex.CosOp(complex: _ods_ir[_ods_ir], *, fastmath: Any | _ods_ir | None = None, results: Sequence[_ods_ir] | None = None, loc: _ods_ir | None = None, ip: _ods_ir | None = None)

Bases: _ods_ir

The cos op takes a single complex number and computes the cosine of it, i.e. cos(x), where x is the input value.

Example:

%a = complex.cos %b : complex<f32>

OPERATION_NAME = 'complex.cos'

_ODS_REGIONS = (0, True)

complex() → _ods_ir[_ods_ir]

fastmath() → _ods_ir

result() → _ods_ir[_ods_ir]

class mlir.dialects.complex.CosOpAdaptor

Bases: _ods_ir

OPERATION_NAME = 'complex.cos'

complex() → _ods_ir[_ods_ir]

fastmath() → _ods_ir

mlir.dialects.complex.cos(complex: _ods_ir[_ods_ir], *, fastmath: Any | _ods_ir | None = None, results: Sequence[_ods_ir] | None = None, loc: _ods_ir | None = None, ip: _ods_ir | None = None) → _ods_ir[_ods_ir]

class mlir.dialects.complex.CreateOp(complex: _ods_ir, real: _ods_ir[_ods_ir], imaginary: _ods_ir[_ods_ir], *, loc: _ods_ir | None = None, ip: _ods_ir | None = None)

Bases: _ods_ir

The complex.create operation creates a complex number from two floating-point operands, the real and the imaginary part.

Example:

%a = complex.create %b, %c : complex<f32>

OPERATION_NAME = 'complex.create'

_ODS_REGIONS = (0, True)

real() → _ods_ir[_ods_ir]

imaginary() → _ods_ir[_ods_ir]

complex() → _ods_ir[_ods_ir]

class mlir.dialects.complex.CreateOpAdaptor

Bases: _ods_ir

OPERATION_NAME = 'complex.create'

real() → _ods_ir[_ods_ir]

imaginary() → _ods_ir[_ods_ir]

mlir.dialects.complex.create_(complex: _ods_ir, real: _ods_ir[_ods_ir], imaginary: _ods_ir[_ods_ir], *, loc: _ods_ir | None = None, ip: _ods_ir | None = None) → _ods_ir[_ods_ir]

class mlir.dialects.complex.DivOp(lhs: _ods_ir[_ods_ir], rhs: _ods_ir[_ods_ir], *, fastmath: Any | _ods_ir | None = None, results: Sequence[_ods_ir] | None = None, loc: _ods_ir | None = None, ip: _ods_ir | None = None)

Bases: _ods_ir

The div operation takes two complex numbers and returns result of their division:

%a = complex.div %b, %c : complex<f32>

OPERATION_NAME = 'complex.div'

_ODS_REGIONS = (0, True)

lhs() → _ods_ir[_ods_ir]

rhs() → _ods_ir[_ods_ir]

fastmath() → _ods_ir

result() → _ods_ir[_ods_ir]

class mlir.dialects.complex.DivOpAdaptor

Bases: _ods_ir

OPERATION_NAME = 'complex.div'

lhs() → _ods_ir[_ods_ir]

rhs() → _ods_ir[_ods_ir]

fastmath() → _ods_ir

mlir.dialects.complex.div(lhs: _ods_ir[_ods_ir], rhs: _ods_ir[_ods_ir], *, fastmath: Any | _ods_ir | None = None, results: Sequence[_ods_ir] | None = None, loc: _ods_ir | None = None, ip: _ods_ir | None = None) → _ods_ir[_ods_ir]

class mlir.dialects.complex.EqualOp(lhs: _ods_ir[_ods_ir], rhs: _ods_ir[_ods_ir], *, results: Sequence[_ods_ir] | None = None, loc: _ods_ir | None = None, ip: _ods_ir | None = None)

Bases: _ods_ir

The eq op takes two complex numbers and returns whether they are equal.

Example:

%a = complex.eq %b, %c : complex<f32>

OPERATION_NAME = 'complex.eq'

_ODS_REGIONS = (0, True)

lhs() → _ods_ir[_ods_ir]

rhs() → _ods_ir[_ods_ir]

result() → _ods_ir[_ods_ir]

class mlir.dialects.complex.EqualOpAdaptor

Bases: _ods_ir

OPERATION_NAME = 'complex.eq'

lhs() → _ods_ir[_ods_ir]

rhs() → _ods_ir[_ods_ir]

mlir.dialects.complex.eq(lhs: _ods_ir[_ods_ir], rhs: _ods_ir[_ods_ir], *, results: Sequence[_ods_ir] | None = None, loc: _ods_ir | None = None, ip: _ods_ir | None = None) → _ods_ir[_ods_ir]

class mlir.dialects.complex.ExpOp(complex: _ods_ir[_ods_ir], *, fastmath: Any | _ods_ir | None = None, results: Sequence[_ods_ir] | None = None, loc: _ods_ir | None = None, ip: _ods_ir | None = None)

Bases: _ods_ir

The exp op takes a single complex number and computes the exponential of it, i.e. exp(x) or e^(x), where x is the input value. e denotes Euler’s number and is approximately equal to 2.718281.

Example:

%a = complex.exp %b : complex<f32>

OPERATION_NAME = 'complex.exp'

_ODS_REGIONS = (0, True)

complex() → _ods_ir[_ods_ir]

fastmath() → _ods_ir

result() → _ods_ir[_ods_ir]

class mlir.dialects.complex.ExpOpAdaptor

Bases: _ods_ir

OPERATION_NAME = 'complex.exp'

complex() → _ods_ir[_ods_ir]

fastmath() → _ods_ir

mlir.dialects.complex.exp(complex: _ods_ir[_ods_ir], *, fastmath: Any | _ods_ir | None = None, results: Sequence[_ods_ir] | None = None, loc: _ods_ir | None = None, ip: _ods_ir | None = None) → _ods_ir[_ods_ir]

class mlir.dialects.complex.Expm1Op(complex: _ods_ir[_ods_ir], *, fastmath: Any | _ods_ir | None = None, results: Sequence[_ods_ir] | None = None, loc: _ods_ir | None = None, ip: _ods_ir | None = None)

Bases: _ods_ir

complex.expm1(x) := complex.exp(x) - 1

Example:

%a = complex.expm1 %b : complex<f32>

OPERATION_NAME = 'complex.expm1'

_ODS_REGIONS = (0, True)

complex() → _ods_ir[_ods_ir]

fastmath() → _ods_ir

result() → _ods_ir[_ods_ir]

class mlir.dialects.complex.Expm1OpAdaptor

Bases: _ods_ir

OPERATION_NAME = 'complex.expm1'

complex() → _ods_ir[_ods_ir]

fastmath() → _ods_ir

mlir.dialects.complex.expm1(complex: _ods_ir[_ods_ir], *, fastmath: Any | _ods_ir | None = None, results: Sequence[_ods_ir] | None = None, loc: _ods_ir | None = None, ip: _ods_ir | None = None) → _ods_ir[_ods_ir]

class mlir.dialects.complex.ImOp(complex: _ods_ir[_ods_ir], *, fastmath: Any | _ods_ir | None = None, results: Sequence[_ods_ir] | None = None, loc: _ods_ir | None = None, ip: _ods_ir | None = None)

Bases: _ods_ir

The im op takes a single complex number and extracts the imaginary part.

Example:

%a = complex.im %b : complex<f32>

OPERATION_NAME = 'complex.im'

_ODS_REGIONS = (0, True)

complex() → _ods_ir[_ods_ir]

fastmath() → _ods_ir

imaginary() → _ods_ir[_ods_ir]

class mlir.dialects.complex.ImOpAdaptor

Bases: _ods_ir

OPERATION_NAME = 'complex.im'

complex() → _ods_ir[_ods_ir]

fastmath() → _ods_ir

mlir.dialects.complex.im(complex: _ods_ir[_ods_ir], *, fastmath: Any | _ods_ir | None = None, results: Sequence[_ods_ir] | None = None, loc: _ods_ir | None = None, ip: _ods_ir | None = None) → _ods_ir[_ods_ir]

class mlir.dialects.complex.Log1pOp(complex: _ods_ir[_ods_ir], *, fastmath: Any | _ods_ir | None = None, results: Sequence[_ods_ir] | None = None, loc: _ods_ir | None = None, ip: _ods_ir | None = None)

Bases: _ods_ir

The log op takes a single complex number and computes the natural logarithm of one plus the given value, i.e. log(1 + x) or log_e(1 + x), where x is the input value. e denotes Euler’s number and is approximately equal to 2.718281.

Example:

%a = complex.log1p %b : complex<f32>

OPERATION_NAME = 'complex.log1p'

_ODS_REGIONS = (0, True)

complex() → _ods_ir[_ods_ir]

fastmath() → _ods_ir

result() → _ods_ir[_ods_ir]

class mlir.dialects.complex.Log1pOpAdaptor

Bases: _ods_ir

OPERATION_NAME = 'complex.log1p'

complex() → _ods_ir[_ods_ir]

fastmath() → _ods_ir

mlir.dialects.complex.log1p(complex: _ods_ir[_ods_ir], *, fastmath: Any | _ods_ir | None = None, results: Sequence[_ods_ir] | None = None, loc: _ods_ir | None = None, ip: _ods_ir | None = None) → _ods_ir[_ods_ir]

class mlir.dialects.complex.LogOp(complex: _ods_ir[_ods_ir], *, fastmath: Any | _ods_ir | None = None, results: Sequence[_ods_ir] | None = None, loc: _ods_ir | None = None, ip: _ods_ir | None = None)

Bases: _ods_ir

The log op takes a single complex number and computes the natural logarithm of it, i.e. log(x) or log_e(x), where x is the input value. e denotes Euler’s number and is approximately equal to 2.718281.

Example:

%a = complex.log %b : complex<f32>

OPERATION_NAME = 'complex.log'

_ODS_REGIONS = (0, True)

complex() → _ods_ir[_ods_ir]

fastmath() → _ods_ir

result() → _ods_ir[_ods_ir]

class mlir.dialects.complex.LogOpAdaptor

Bases: _ods_ir

OPERATION_NAME = 'complex.log'

complex() → _ods_ir[_ods_ir]

fastmath() → _ods_ir

mlir.dialects.complex.log(complex: _ods_ir[_ods_ir], *, fastmath: Any | _ods_ir | None = None, results: Sequence[_ods_ir] | None = None, loc: _ods_ir | None = None, ip: _ods_ir | None = None) → _ods_ir[_ods_ir]

class mlir.dialects.complex.MulOp(lhs: _ods_ir[_ods_ir], rhs: _ods_ir[_ods_ir], *, fastmath: Any | _ods_ir | None = None, results: Sequence[_ods_ir] | None = None, loc: _ods_ir | None = None, ip: _ods_ir | None = None)

Bases: _ods_ir

The mul operation takes two complex numbers and returns their product:

%a = complex.mul %b, %c : complex<f32>

OPERATION_NAME = 'complex.mul'

_ODS_REGIONS = (0, True)

lhs() → _ods_ir[_ods_ir]

rhs() → _ods_ir[_ods_ir]

fastmath() → _ods_ir

result() → _ods_ir[_ods_ir]

class mlir.dialects.complex.MulOpAdaptor

Bases: _ods_ir

OPERATION_NAME = 'complex.mul'

lhs() → _ods_ir[_ods_ir]

rhs() → _ods_ir[_ods_ir]

fastmath() → _ods_ir

mlir.dialects.complex.mul(lhs: _ods_ir[_ods_ir], rhs: _ods_ir[_ods_ir], *, fastmath: Any | _ods_ir | None = None, results: Sequence[_ods_ir] | None = None, loc: _ods_ir | None = None, ip: _ods_ir | None = None) → _ods_ir[_ods_ir]

class mlir.dialects.complex.NegOp(complex: _ods_ir[_ods_ir], *, fastmath: Any | _ods_ir | None = None, results: Sequence[_ods_ir] | None = None, loc: _ods_ir | None = None, ip: _ods_ir | None = None)

Bases: _ods_ir

The neg op takes a single complex number complex and returns -complex.

Example:

%a = complex.neg %b : complex<f32>

OPERATION_NAME = 'complex.neg'

_ODS_REGIONS = (0, True)

complex() → _ods_ir[_ods_ir]

fastmath() → _ods_ir

result() → _ods_ir[_ods_ir]

class mlir.dialects.complex.NegOpAdaptor

Bases: _ods_ir

OPERATION_NAME = 'complex.neg'

complex() → _ods_ir[_ods_ir]

fastmath() → _ods_ir

mlir.dialects.complex.neg(complex: _ods_ir[_ods_ir], *, fastmath: Any | _ods_ir | None = None, results: Sequence[_ods_ir] | None = None, loc: _ods_ir | None = None, ip: _ods_ir | None = None) → _ods_ir[_ods_ir]

class mlir.dialects.complex.NotEqualOp(lhs: _ods_ir[_ods_ir], rhs: _ods_ir[_ods_ir], *, results: Sequence[_ods_ir] | None = None, loc: _ods_ir | None = None, ip: _ods_ir | None = None)

Bases: _ods_ir

The neq op takes two complex numbers and returns whether they are not equal.

Example:

%a = complex.neq %b, %c : complex<f32>

OPERATION_NAME = 'complex.neq'

_ODS_REGIONS = (0, True)

lhs() → _ods_ir[_ods_ir]

rhs() → _ods_ir[_ods_ir]

result() → _ods_ir[_ods_ir]

class mlir.dialects.complex.NotEqualOpAdaptor

Bases: _ods_ir

OPERATION_NAME = 'complex.neq'

lhs() → _ods_ir[_ods_ir]

rhs() → _ods_ir[_ods_ir]

mlir.dialects.complex.neq(lhs: _ods_ir[_ods_ir], rhs: _ods_ir[_ods_ir], *, results: Sequence[_ods_ir] | None = None, loc: _ods_ir | None = None, ip: _ods_ir | None = None) → _ods_ir[_ods_ir]

class mlir.dialects.complex.PowOp(lhs: _ods_ir[_ods_ir], rhs: _ods_ir[_ods_ir], *, fastmath: Any | _ods_ir | None = None, results: Sequence[_ods_ir] | None = None, loc: _ods_ir | None = None, ip: _ods_ir | None = None)

Bases: _ods_ir

The pow operation takes a complex number raises it to the given complex exponent.

Example:

%a = complex.pow %b, %c : complex<f32>

OPERATION_NAME = 'complex.pow'

_ODS_REGIONS = (0, True)

lhs() → _ods_ir[_ods_ir]

rhs() → _ods_ir[_ods_ir]

fastmath() → _ods_ir

result() → _ods_ir[_ods_ir]

class mlir.dialects.complex.PowOpAdaptor

Bases: _ods_ir

OPERATION_NAME = 'complex.pow'

lhs() → _ods_ir[_ods_ir]

rhs() → _ods_ir[_ods_ir]

fastmath() → _ods_ir

mlir.dialects.complex.pow(lhs: _ods_ir[_ods_ir], rhs: _ods_ir[_ods_ir], *, fastmath: Any | _ods_ir | None = None, results: Sequence[_ods_ir] | None = None, loc: _ods_ir | None = None, ip: _ods_ir | None = None) → _ods_ir[_ods_ir]

class mlir.dialects.complex.PowiOp(lhs: _ods_ir[_ods_ir], rhs: _ods_ir[_ods_ir], *, fastmath: Any | _ods_ir | None = None, results: Sequence[_ods_ir] | None = None, loc: _ods_ir | None = None, ip: _ods_ir | None = None)

Bases: _ods_ir

The powi operation takes a base operand of complex type and a power operand of signed integer type and returns one result of the same type as base. The result is base raised to the power of power.

Example:

%a = complex.powi %b, %c : complex<f32>, i32

OPERATION_NAME = 'complex.powi'

_ODS_REGIONS = (0, True)

lhs() → _ods_ir[_ods_ir]

rhs() → _ods_ir[_ods_ir]

fastmath() → _ods_ir | None

result() → _ods_ir[_ods_ir]

class mlir.dialects.complex.PowiOpAdaptor

Bases: _ods_ir

OPERATION_NAME = 'complex.powi'

lhs() → _ods_ir[_ods_ir]

rhs() → _ods_ir[_ods_ir]

fastmath() → _ods_ir | None

mlir.dialects.complex.powi(lhs: _ods_ir[_ods_ir], rhs: _ods_ir[_ods_ir], *, fastmath: Any | _ods_ir | None = None, results: Sequence[_ods_ir] | None = None, loc: _ods_ir | None = None, ip: _ods_ir | None = None) → _ods_ir[_ods_ir]

class mlir.dialects.complex.ReOp(complex: _ods_ir[_ods_ir], *, fastmath: Any | _ods_ir | None = None, results: Sequence[_ods_ir] | None = None, loc: _ods_ir | None = None, ip: _ods_ir | None = None)

Bases: _ods_ir

The re op takes a single complex number and extracts the real part.

Example:

%a = complex.re %b : complex<f32>

OPERATION_NAME = 'complex.re'

_ODS_REGIONS = (0, True)

complex() → _ods_ir[_ods_ir]

fastmath() → _ods_ir

real() → _ods_ir[_ods_ir]

class mlir.dialects.complex.ReOpAdaptor

Bases: _ods_ir

OPERATION_NAME = 'complex.re'

complex() → _ods_ir[_ods_ir]

fastmath() → _ods_ir

mlir.dialects.complex.re(complex: _ods_ir[_ods_ir], *, fastmath: Any | _ods_ir | None = None, results: Sequence[_ods_ir] | None = None, loc: _ods_ir | None = None, ip: _ods_ir | None = None) → _ods_ir[_ods_ir]

class mlir.dialects.complex.RsqrtOp(complex: _ods_ir[_ods_ir], *, fastmath: Any | _ods_ir | None = None, results: Sequence[_ods_ir] | None = None, loc: _ods_ir | None = None, ip: _ods_ir | None = None)

Bases: _ods_ir

The rsqrt operation computes reciprocal of square root.

Example:

%a = complex.rsqrt %b : complex<f32>

OPERATION_NAME = 'complex.rsqrt'

_ODS_REGIONS = (0, True)

complex() → _ods_ir[_ods_ir]

fastmath() → _ods_ir

result() → _ods_ir[_ods_ir]

class mlir.dialects.complex.RsqrtOpAdaptor

Bases: _ods_ir

OPERATION_NAME = 'complex.rsqrt'

complex() → _ods_ir[_ods_ir]

fastmath() → _ods_ir

mlir.dialects.complex.rsqrt(complex: _ods_ir[_ods_ir], *, fastmath: Any | _ods_ir | None = None, results: Sequence[_ods_ir] | None = None, loc: _ods_ir | None = None, ip: _ods_ir | None = None) → _ods_ir[_ods_ir]

class mlir.dialects.complex.SignOp(complex: _ods_ir[_ods_ir], *, fastmath: Any | _ods_ir | None = None, results: Sequence[_ods_ir] | None = None, loc: _ods_ir | None = None, ip: _ods_ir | None = None)

Bases: _ods_ir

The sign op takes a single complex number and computes the sign of it, i.e. y = sign(x) = x / |x| if x != 0, otherwise y = 0.

Example:

%a = complex.sign %b : complex<f32>

OPERATION_NAME = 'complex.sign'

_ODS_REGIONS = (0, True)

complex() → _ods_ir[_ods_ir]

fastmath() → _ods_ir

result() → _ods_ir[_ods_ir]

class mlir.dialects.complex.SignOpAdaptor

Bases: _ods_ir

OPERATION_NAME = 'complex.sign'

complex() → _ods_ir[_ods_ir]

fastmath() → _ods_ir

mlir.dialects.complex.sign(complex: _ods_ir[_ods_ir], *, fastmath: Any | _ods_ir | None = None, results: Sequence[_ods_ir] | None = None, loc: _ods_ir | None = None, ip: _ods_ir | None = None) → _ods_ir[_ods_ir]

class mlir.dialects.complex.SinOp(complex: _ods_ir[_ods_ir], *, fastmath: Any | _ods_ir | None = None, results: Sequence[_ods_ir] | None = None, loc: _ods_ir | None = None, ip: _ods_ir | None = None)

Bases: _ods_ir

The sin op takes a single complex number and computes the sine of it, i.e. sin(x), where x is the input value.

Example:

%a = complex.sin %b : complex<f32>

OPERATION_NAME = 'complex.sin'

_ODS_REGIONS = (0, True)

complex() → _ods_ir[_ods_ir]

fastmath() → _ods_ir

result() → _ods_ir[_ods_ir]

class mlir.dialects.complex.SinOpAdaptor

Bases: _ods_ir

OPERATION_NAME = 'complex.sin'

complex() → _ods_ir[_ods_ir]

fastmath() → _ods_ir

mlir.dialects.complex.sin(complex: _ods_ir[_ods_ir], *, fastmath: Any | _ods_ir | None = None, results: Sequence[_ods_ir] | None = None, loc: _ods_ir | None = None, ip: _ods_ir | None = None) → _ods_ir[_ods_ir]

class mlir.dialects.complex.SqrtOp(complex: _ods_ir[_ods_ir], *, fastmath: Any | _ods_ir | None = None, results: Sequence[_ods_ir] | None = None, loc: _ods_ir | None = None, ip: _ods_ir | None = None)

Bases: _ods_ir

The sqrt operation takes a complex number and returns its square root.

Example:

%a = complex.sqrt %b : complex<f32>

OPERATION_NAME = 'complex.sqrt'

_ODS_REGIONS = (0, True)

complex() → _ods_ir[_ods_ir]

fastmath() → _ods_ir

result() → _ods_ir[_ods_ir]

class mlir.dialects.complex.SqrtOpAdaptor

Bases: _ods_ir

OPERATION_NAME = 'complex.sqrt'

complex() → _ods_ir[_ods_ir]

fastmath() → _ods_ir

mlir.dialects.complex.sqrt(complex: _ods_ir[_ods_ir], *, fastmath: Any | _ods_ir | None = None, results: Sequence[_ods_ir] | None = None, loc: _ods_ir | None = None, ip: _ods_ir | None = None) → _ods_ir[_ods_ir]

class mlir.dialects.complex.SubOp(lhs: _ods_ir[_ods_ir], rhs: _ods_ir[_ods_ir], *, fastmath: Any | _ods_ir | None = None, results: Sequence[_ods_ir] | None = None, loc: _ods_ir | None = None, ip: _ods_ir | None = None)

Bases: _ods_ir

The sub operation takes two complex numbers and returns their difference.

Example:

%a = complex.sub %b, %c : complex<f32>

OPERATION_NAME = 'complex.sub'

_ODS_REGIONS = (0, True)

lhs() → _ods_ir[_ods_ir]

rhs() → _ods_ir[_ods_ir]

fastmath() → _ods_ir

result() → _ods_ir[_ods_ir]

class mlir.dialects.complex.SubOpAdaptor

Bases: _ods_ir

OPERATION_NAME = 'complex.sub'

lhs() → _ods_ir[_ods_ir]

rhs() → _ods_ir[_ods_ir]

fastmath() → _ods_ir

mlir.dialects.complex.sub(lhs: _ods_ir[_ods_ir], rhs: _ods_ir[_ods_ir], *, fastmath: Any | _ods_ir | None = None, results: Sequence[_ods_ir] | None = None, loc: _ods_ir | None = None, ip: _ods_ir | None = None) → _ods_ir[_ods_ir]

class mlir.dialects.complex.TanOp(complex: _ods_ir[_ods_ir], *, fastmath: Any | _ods_ir | None = None, results: Sequence[_ods_ir] | None = None, loc: _ods_ir | None = None, ip: _ods_ir | None = None)

Bases: _ods_ir

The tan op takes a single complex number and computes the tangent of it, i.e. tan(x), where x is the input value.

Example:

%a = complex.tan %b : complex<f32>

OPERATION_NAME = 'complex.tan'

_ODS_REGIONS = (0, True)

complex() → _ods_ir[_ods_ir]

fastmath() → _ods_ir

result() → _ods_ir[_ods_ir]

class mlir.dialects.complex.TanOpAdaptor

Bases: _ods_ir

OPERATION_NAME = 'complex.tan'

complex() → _ods_ir[_ods_ir]

fastmath() → _ods_ir

mlir.dialects.complex.tan(complex: _ods_ir[_ods_ir], *, fastmath: Any | _ods_ir | None = None, results: Sequence[_ods_ir] | None = None, loc: _ods_ir | None = None, ip: _ods_ir | None = None) → _ods_ir[_ods_ir]

class mlir.dialects.complex.TanhOp(complex: _ods_ir[_ods_ir], *, fastmath: Any | _ods_ir | None = None, results: Sequence[_ods_ir] | None = None, loc: _ods_ir | None = None, ip: _ods_ir | None = None)

Bases: _ods_ir

The tanh operation takes a complex number and returns its hyperbolic tangent.

Example:

%a = complex.tanh %b : complex<f32>

OPERATION_NAME = 'complex.tanh'

_ODS_REGIONS = (0, True)

complex() → _ods_ir[_ods_ir]

fastmath() → _ods_ir

result() → _ods_ir[_ods_ir]

class mlir.dialects.complex.TanhOpAdaptor

Bases: _ods_ir

OPERATION_NAME = 'complex.tanh'

complex() → _ods_ir[_ods_ir]

fastmath() → _ods_ir

mlir.dialects.complex.tanh(complex: _ods_ir[_ods_ir], *, fastmath: Any | _ods_ir | None = None, results: Sequence[_ods_ir] | None = None, loc: _ods_ir | None = None, ip: _ods_ir | None = None) → _ods_ir[_ods_ir]