mlir.dialects._complex_ops_gen ============================== .. py:module:: mlir.dialects._complex_ops_gen Attributes ---------- .. autoapisummary:: mlir.dialects._complex_ops_gen._ods_ir mlir.dialects._complex_ops_gen._Buffer Classes ------- .. autoapisummary:: mlir.dialects._complex_ops_gen._Dialect mlir.dialects._complex_ops_gen.AbsOp mlir.dialects._complex_ops_gen.AbsOpAdaptor mlir.dialects._complex_ops_gen.AddOp mlir.dialects._complex_ops_gen.AddOpAdaptor mlir.dialects._complex_ops_gen.AngleOp mlir.dialects._complex_ops_gen.AngleOpAdaptor mlir.dialects._complex_ops_gen.Atan2Op mlir.dialects._complex_ops_gen.Atan2OpAdaptor mlir.dialects._complex_ops_gen.BitcastOp mlir.dialects._complex_ops_gen.BitcastOpAdaptor mlir.dialects._complex_ops_gen.ConjOp mlir.dialects._complex_ops_gen.ConjOpAdaptor mlir.dialects._complex_ops_gen.ConstantOp mlir.dialects._complex_ops_gen.ConstantOpAdaptor mlir.dialects._complex_ops_gen.CosOp mlir.dialects._complex_ops_gen.CosOpAdaptor mlir.dialects._complex_ops_gen.CreateOp mlir.dialects._complex_ops_gen.CreateOpAdaptor mlir.dialects._complex_ops_gen.DivOp mlir.dialects._complex_ops_gen.DivOpAdaptor mlir.dialects._complex_ops_gen.EqualOp mlir.dialects._complex_ops_gen.EqualOpAdaptor mlir.dialects._complex_ops_gen.ExpOp mlir.dialects._complex_ops_gen.ExpOpAdaptor mlir.dialects._complex_ops_gen.Expm1Op mlir.dialects._complex_ops_gen.Expm1OpAdaptor mlir.dialects._complex_ops_gen.ImOp mlir.dialects._complex_ops_gen.ImOpAdaptor mlir.dialects._complex_ops_gen.Log1pOp mlir.dialects._complex_ops_gen.Log1pOpAdaptor mlir.dialects._complex_ops_gen.LogOp mlir.dialects._complex_ops_gen.LogOpAdaptor mlir.dialects._complex_ops_gen.MulOp mlir.dialects._complex_ops_gen.MulOpAdaptor mlir.dialects._complex_ops_gen.NegOp mlir.dialects._complex_ops_gen.NegOpAdaptor mlir.dialects._complex_ops_gen.NotEqualOp mlir.dialects._complex_ops_gen.NotEqualOpAdaptor mlir.dialects._complex_ops_gen.PowOp mlir.dialects._complex_ops_gen.PowOpAdaptor mlir.dialects._complex_ops_gen.PowiOp mlir.dialects._complex_ops_gen.PowiOpAdaptor mlir.dialects._complex_ops_gen.ReOp mlir.dialects._complex_ops_gen.ReOpAdaptor mlir.dialects._complex_ops_gen.RsqrtOp mlir.dialects._complex_ops_gen.RsqrtOpAdaptor mlir.dialects._complex_ops_gen.SignOp mlir.dialects._complex_ops_gen.SignOpAdaptor mlir.dialects._complex_ops_gen.SinOp mlir.dialects._complex_ops_gen.SinOpAdaptor mlir.dialects._complex_ops_gen.SqrtOp mlir.dialects._complex_ops_gen.SqrtOpAdaptor mlir.dialects._complex_ops_gen.SubOp mlir.dialects._complex_ops_gen.SubOpAdaptor mlir.dialects._complex_ops_gen.TanOp mlir.dialects._complex_ops_gen.TanOpAdaptor mlir.dialects._complex_ops_gen.TanhOp mlir.dialects._complex_ops_gen.TanhOpAdaptor Functions --------- .. autoapisummary:: mlir.dialects._complex_ops_gen.abs mlir.dialects._complex_ops_gen.add mlir.dialects._complex_ops_gen.angle mlir.dialects._complex_ops_gen.atan2 mlir.dialects._complex_ops_gen.bitcast mlir.dialects._complex_ops_gen.conj mlir.dialects._complex_ops_gen.constant mlir.dialects._complex_ops_gen.cos mlir.dialects._complex_ops_gen.create_ mlir.dialects._complex_ops_gen.div mlir.dialects._complex_ops_gen.eq mlir.dialects._complex_ops_gen.exp mlir.dialects._complex_ops_gen.expm1 mlir.dialects._complex_ops_gen.im mlir.dialects._complex_ops_gen.log1p mlir.dialects._complex_ops_gen.log mlir.dialects._complex_ops_gen.mul mlir.dialects._complex_ops_gen.neg mlir.dialects._complex_ops_gen.neq mlir.dialects._complex_ops_gen.pow mlir.dialects._complex_ops_gen.powi mlir.dialects._complex_ops_gen.re mlir.dialects._complex_ops_gen.rsqrt mlir.dialects._complex_ops_gen.sign mlir.dialects._complex_ops_gen.sin mlir.dialects._complex_ops_gen.sqrt mlir.dialects._complex_ops_gen.sub mlir.dialects._complex_ops_gen.tan mlir.dialects._complex_ops_gen.tanh Module Contents --------------- .. py:data:: _ods_ir .. py:data:: _Buffer .. py:class:: _Dialect(descriptor: object) Bases: :py:obj:`_ods_ir` .. py:attribute:: DIALECT_NAMESPACE :value: 'complex' .. py:class:: AbsOp(complex: _ods_ir[_ods_ir], *, fastmath: Optional[Union[Any, _ods_ir]] = None, results: Optional[Sequence[_ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) Bases: :py:obj:`_ods_ir` The ``abs`` op takes a single complex number and computes its absolute value. Example: .. code:: mlir %a = complex.abs %b : complex .. py:attribute:: OPERATION_NAME :value: 'complex.abs' .. py:attribute:: _ODS_REGIONS :value: (0, True) .. py:method:: complex() -> _ods_ir[_ods_ir] .. py:method:: fastmath() -> _ods_ir .. py:method:: result() -> _ods_ir[_ods_ir] Shortcut to get an op result if it has only one (throws an error otherwise). .. py:class:: AbsOpAdaptor(operands: list[Value], attributes: OpAttributeMap) AbsOpAdaptor(operands: list[Value], opview: OpView) Bases: :py:obj:`_ods_ir` .. py:attribute:: OPERATION_NAME :value: 'complex.abs' .. py:method:: complex() -> _ods_ir[_ods_ir] .. py:method:: fastmath() -> _ods_ir .. py:function:: abs(complex: _ods_ir[_ods_ir], *, fastmath: Optional[Union[Any, _ods_ir]] = None, results: Optional[Sequence[_ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) -> _ods_ir[_ods_ir] .. py:class:: AddOp(lhs: _ods_ir[_ods_ir], rhs: _ods_ir[_ods_ir], *, fastmath: Optional[Union[Any, _ods_ir]] = None, results: Optional[Sequence[_ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) Bases: :py:obj:`_ods_ir` The ``add`` operation takes two complex numbers and returns their sum. Example: .. code:: mlir %a = complex.add %b, %c : complex .. py:attribute:: OPERATION_NAME :value: 'complex.add' .. py:attribute:: _ODS_REGIONS :value: (0, True) .. py:method:: lhs() -> _ods_ir[_ods_ir] .. py:method:: rhs() -> _ods_ir[_ods_ir] .. py:method:: fastmath() -> _ods_ir .. py:method:: result() -> _ods_ir[_ods_ir] Shortcut to get an op result if it has only one (throws an error otherwise). .. py:class:: AddOpAdaptor(operands: list[Value], attributes: OpAttributeMap) AddOpAdaptor(operands: list[Value], opview: OpView) Bases: :py:obj:`_ods_ir` .. py:attribute:: OPERATION_NAME :value: 'complex.add' .. py:method:: lhs() -> _ods_ir[_ods_ir] .. py:method:: rhs() -> _ods_ir[_ods_ir] .. py:method:: fastmath() -> _ods_ir .. py:function:: add(lhs: _ods_ir[_ods_ir], rhs: _ods_ir[_ods_ir], *, fastmath: Optional[Union[Any, _ods_ir]] = None, results: Optional[Sequence[_ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) -> _ods_ir[_ods_ir] .. py:class:: AngleOp(complex: _ods_ir[_ods_ir], *, fastmath: Optional[Union[Any, _ods_ir]] = None, results: Optional[Sequence[_ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) Bases: :py:obj:`_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: .. code:: mlir %a = complex.angle %b : complex .. py:attribute:: OPERATION_NAME :value: 'complex.angle' .. py:attribute:: _ODS_REGIONS :value: (0, True) .. py:method:: complex() -> _ods_ir[_ods_ir] .. py:method:: fastmath() -> _ods_ir .. py:method:: result() -> _ods_ir[_ods_ir] Shortcut to get an op result if it has only one (throws an error otherwise). .. py:class:: AngleOpAdaptor(operands: list[Value], attributes: OpAttributeMap) AngleOpAdaptor(operands: list[Value], opview: OpView) Bases: :py:obj:`_ods_ir` .. py:attribute:: OPERATION_NAME :value: 'complex.angle' .. py:method:: complex() -> _ods_ir[_ods_ir] .. py:method:: fastmath() -> _ods_ir .. py:function:: angle(complex: _ods_ir[_ods_ir], *, fastmath: Optional[Union[Any, _ods_ir]] = None, results: Optional[Sequence[_ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) -> _ods_ir[_ods_ir] .. py:class:: Atan2Op(lhs: _ods_ir[_ods_ir], rhs: _ods_ir[_ods_ir], *, fastmath: Optional[Union[Any, _ods_ir]] = None, results: Optional[Sequence[_ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) Bases: :py:obj:`_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: .. code:: mlir %a = complex.atan2 %b, %c : complex .. py:attribute:: OPERATION_NAME :value: 'complex.atan2' .. py:attribute:: _ODS_REGIONS :value: (0, True) .. py:method:: lhs() -> _ods_ir[_ods_ir] .. py:method:: rhs() -> _ods_ir[_ods_ir] .. py:method:: fastmath() -> _ods_ir .. py:method:: result() -> _ods_ir[_ods_ir] Shortcut to get an op result if it has only one (throws an error otherwise). .. py:class:: Atan2OpAdaptor(operands: list[Value], attributes: OpAttributeMap) Atan2OpAdaptor(operands: list[Value], opview: OpView) Bases: :py:obj:`_ods_ir` .. py:attribute:: OPERATION_NAME :value: 'complex.atan2' .. py:method:: lhs() -> _ods_ir[_ods_ir] .. py:method:: rhs() -> _ods_ir[_ods_ir] .. py:method:: fastmath() -> _ods_ir .. py:function:: atan2(lhs: _ods_ir[_ods_ir], rhs: _ods_ir[_ods_ir], *, fastmath: Optional[Union[Any, _ods_ir]] = None, results: Optional[Sequence[_ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) -> _ods_ir[_ods_ir] .. py:class:: BitcastOp(result: _ods_ir, operand: _ods_ir, *, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) Bases: :py:obj:`_ods_ir` Example: .. code:: mlir %a = complex.bitcast %b : complex -> i64 .. py:attribute:: OPERATION_NAME :value: 'complex.bitcast' .. py:attribute:: _ODS_REGIONS :value: (0, True) .. py:method:: operand() -> _ods_ir .. py:method:: result() -> _ods_ir Shortcut to get an op result if it has only one (throws an error otherwise). .. py:class:: BitcastOpAdaptor(operands: list[Value], attributes: OpAttributeMap) BitcastOpAdaptor(operands: list[Value], opview: OpView) Bases: :py:obj:`_ods_ir` .. py:attribute:: OPERATION_NAME :value: 'complex.bitcast' .. py:method:: operand() -> _ods_ir .. py:function:: bitcast(result: _ods_ir, operand: _ods_ir, *, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) -> _ods_ir .. py:class:: ConjOp(complex: _ods_ir[_ods_ir], *, fastmath: Optional[Union[Any, _ods_ir]] = None, results: Optional[Sequence[_ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) Bases: :py:obj:`_ods_ir` The ``conj`` op takes a single complex number and computes the complex conjugate. Example: .. code:: mlir %a = complex.conj %b: complex .. py:attribute:: OPERATION_NAME :value: 'complex.conj' .. py:attribute:: _ODS_REGIONS :value: (0, True) .. py:method:: complex() -> _ods_ir[_ods_ir] .. py:method:: fastmath() -> _ods_ir .. py:method:: result() -> _ods_ir[_ods_ir] Shortcut to get an op result if it has only one (throws an error otherwise). .. py:class:: ConjOpAdaptor(operands: list[Value], attributes: OpAttributeMap) ConjOpAdaptor(operands: list[Value], opview: OpView) Bases: :py:obj:`_ods_ir` .. py:attribute:: OPERATION_NAME :value: 'complex.conj' .. py:method:: complex() -> _ods_ir[_ods_ir] .. py:method:: fastmath() -> _ods_ir .. py:function:: conj(complex: _ods_ir[_ods_ir], *, fastmath: Optional[Union[Any, _ods_ir]] = None, results: Optional[Sequence[_ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) -> _ods_ir[_ods_ir] .. py:class:: ConstantOp(complex: _ods_ir, value: Union[Sequence[_ods_ir], _ods_ir], *, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) Bases: :py:obj:`_ods_ir` The ``complex.constant`` operation creates a constant complex number from an attribute containing the real and imaginary parts. Example: .. code:: mlir %a = complex.constant [0.1, -1.0] : complex .. py:attribute:: OPERATION_NAME :value: 'complex.constant' .. py:attribute:: _ODS_REGIONS :value: (0, True) .. py:method:: value() -> _ods_ir .. py:method:: complex() -> _ods_ir[_ods_ir] .. py:class:: ConstantOpAdaptor(operands: list[Value], attributes: OpAttributeMap) ConstantOpAdaptor(operands: list[Value], opview: OpView) Bases: :py:obj:`_ods_ir` .. py:attribute:: OPERATION_NAME :value: 'complex.constant' .. py:method:: value() -> _ods_ir .. py:function:: constant(complex: _ods_ir, value: Union[Sequence[_ods_ir], _ods_ir], *, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) -> _ods_ir[_ods_ir] .. py:class:: CosOp(complex: _ods_ir[_ods_ir], *, fastmath: Optional[Union[Any, _ods_ir]] = None, results: Optional[Sequence[_ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) Bases: :py:obj:`_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: .. code:: mlir %a = complex.cos %b : complex .. py:attribute:: OPERATION_NAME :value: 'complex.cos' .. py:attribute:: _ODS_REGIONS :value: (0, True) .. py:method:: complex() -> _ods_ir[_ods_ir] .. py:method:: fastmath() -> _ods_ir .. py:method:: result() -> _ods_ir[_ods_ir] Shortcut to get an op result if it has only one (throws an error otherwise). .. py:class:: CosOpAdaptor(operands: list[Value], attributes: OpAttributeMap) CosOpAdaptor(operands: list[Value], opview: OpView) Bases: :py:obj:`_ods_ir` .. py:attribute:: OPERATION_NAME :value: 'complex.cos' .. py:method:: complex() -> _ods_ir[_ods_ir] .. py:method:: fastmath() -> _ods_ir .. py:function:: cos(complex: _ods_ir[_ods_ir], *, fastmath: Optional[Union[Any, _ods_ir]] = None, results: Optional[Sequence[_ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) -> _ods_ir[_ods_ir] .. py:class:: CreateOp(complex: _ods_ir, real: _ods_ir[_ods_ir], imaginary: _ods_ir[_ods_ir], *, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) Bases: :py:obj:`_ods_ir` The ``complex.create`` operation creates a complex number from two floating-point operands, the real and the imaginary part. Example: .. code:: mlir %a = complex.create %b, %c : complex .. py:attribute:: OPERATION_NAME :value: 'complex.create' .. py:attribute:: _ODS_REGIONS :value: (0, True) .. py:method:: real() -> _ods_ir[_ods_ir] .. py:method:: imaginary() -> _ods_ir[_ods_ir] .. py:method:: complex() -> _ods_ir[_ods_ir] .. py:class:: CreateOpAdaptor(operands: list[Value], attributes: OpAttributeMap) CreateOpAdaptor(operands: list[Value], opview: OpView) Bases: :py:obj:`_ods_ir` .. py:attribute:: OPERATION_NAME :value: 'complex.create' .. py:method:: real() -> _ods_ir[_ods_ir] .. py:method:: imaginary() -> _ods_ir[_ods_ir] .. py:function:: create_(complex: _ods_ir, real: _ods_ir[_ods_ir], imaginary: _ods_ir[_ods_ir], *, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) -> _ods_ir[_ods_ir] .. py:class:: DivOp(lhs: _ods_ir[_ods_ir], rhs: _ods_ir[_ods_ir], *, fastmath: Optional[Union[Any, _ods_ir]] = None, results: Optional[Sequence[_ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) Bases: :py:obj:`_ods_ir` The ``div`` operation takes two complex numbers and returns result of their division: .. code:: mlir %a = complex.div %b, %c : complex .. py:attribute:: OPERATION_NAME :value: 'complex.div' .. py:attribute:: _ODS_REGIONS :value: (0, True) .. py:method:: lhs() -> _ods_ir[_ods_ir] .. py:method:: rhs() -> _ods_ir[_ods_ir] .. py:method:: fastmath() -> _ods_ir .. py:method:: result() -> _ods_ir[_ods_ir] Shortcut to get an op result if it has only one (throws an error otherwise). .. py:class:: DivOpAdaptor(operands: list[Value], attributes: OpAttributeMap) DivOpAdaptor(operands: list[Value], opview: OpView) Bases: :py:obj:`_ods_ir` .. py:attribute:: OPERATION_NAME :value: 'complex.div' .. py:method:: lhs() -> _ods_ir[_ods_ir] .. py:method:: rhs() -> _ods_ir[_ods_ir] .. py:method:: fastmath() -> _ods_ir .. py:function:: div(lhs: _ods_ir[_ods_ir], rhs: _ods_ir[_ods_ir], *, fastmath: Optional[Union[Any, _ods_ir]] = None, results: Optional[Sequence[_ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) -> _ods_ir[_ods_ir] .. py:class:: EqualOp(lhs: _ods_ir[_ods_ir], rhs: _ods_ir[_ods_ir], *, results: Optional[Sequence[_ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) Bases: :py:obj:`_ods_ir` The ``eq`` op takes two complex numbers and returns whether they are equal. Example: .. code:: mlir %a = complex.eq %b, %c : complex .. py:attribute:: OPERATION_NAME :value: 'complex.eq' .. py:attribute:: _ODS_REGIONS :value: (0, True) .. py:method:: lhs() -> _ods_ir[_ods_ir] .. py:method:: rhs() -> _ods_ir[_ods_ir] .. py:method:: result() -> _ods_ir[_ods_ir] Shortcut to get an op result if it has only one (throws an error otherwise). .. py:class:: EqualOpAdaptor(operands: list[Value], attributes: OpAttributeMap) EqualOpAdaptor(operands: list[Value], opview: OpView) Bases: :py:obj:`_ods_ir` .. py:attribute:: OPERATION_NAME :value: 'complex.eq' .. py:method:: lhs() -> _ods_ir[_ods_ir] .. py:method:: rhs() -> _ods_ir[_ods_ir] .. py:function:: eq(lhs: _ods_ir[_ods_ir], rhs: _ods_ir[_ods_ir], *, results: Optional[Sequence[_ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) -> _ods_ir[_ods_ir] .. py:class:: ExpOp(complex: _ods_ir[_ods_ir], *, fastmath: Optional[Union[Any, _ods_ir]] = None, results: Optional[Sequence[_ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) Bases: :py:obj:`_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: .. code:: mlir %a = complex.exp %b : complex .. py:attribute:: OPERATION_NAME :value: 'complex.exp' .. py:attribute:: _ODS_REGIONS :value: (0, True) .. py:method:: complex() -> _ods_ir[_ods_ir] .. py:method:: fastmath() -> _ods_ir .. py:method:: result() -> _ods_ir[_ods_ir] Shortcut to get an op result if it has only one (throws an error otherwise). .. py:class:: ExpOpAdaptor(operands: list[Value], attributes: OpAttributeMap) ExpOpAdaptor(operands: list[Value], opview: OpView) Bases: :py:obj:`_ods_ir` .. py:attribute:: OPERATION_NAME :value: 'complex.exp' .. py:method:: complex() -> _ods_ir[_ods_ir] .. py:method:: fastmath() -> _ods_ir .. py:function:: exp(complex: _ods_ir[_ods_ir], *, fastmath: Optional[Union[Any, _ods_ir]] = None, results: Optional[Sequence[_ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) -> _ods_ir[_ods_ir] .. py:class:: Expm1Op(complex: _ods_ir[_ods_ir], *, fastmath: Optional[Union[Any, _ods_ir]] = None, results: Optional[Sequence[_ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) Bases: :py:obj:`_ods_ir` complex.expm1(x) := complex.exp(x) - 1 Example: .. code:: mlir %a = complex.expm1 %b : complex .. py:attribute:: OPERATION_NAME :value: 'complex.expm1' .. py:attribute:: _ODS_REGIONS :value: (0, True) .. py:method:: complex() -> _ods_ir[_ods_ir] .. py:method:: fastmath() -> _ods_ir .. py:method:: result() -> _ods_ir[_ods_ir] Shortcut to get an op result if it has only one (throws an error otherwise). .. py:class:: Expm1OpAdaptor(operands: list[Value], attributes: OpAttributeMap) Expm1OpAdaptor(operands: list[Value], opview: OpView) Bases: :py:obj:`_ods_ir` .. py:attribute:: OPERATION_NAME :value: 'complex.expm1' .. py:method:: complex() -> _ods_ir[_ods_ir] .. py:method:: fastmath() -> _ods_ir .. py:function:: expm1(complex: _ods_ir[_ods_ir], *, fastmath: Optional[Union[Any, _ods_ir]] = None, results: Optional[Sequence[_ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) -> _ods_ir[_ods_ir] .. py:class:: ImOp(complex: _ods_ir[_ods_ir], *, fastmath: Optional[Union[Any, _ods_ir]] = None, results: Optional[Sequence[_ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) Bases: :py:obj:`_ods_ir` The ``im`` op takes a single complex number and extracts the imaginary part. Example: .. code:: mlir %a = complex.im %b : complex .. py:attribute:: OPERATION_NAME :value: 'complex.im' .. py:attribute:: _ODS_REGIONS :value: (0, True) .. py:method:: complex() -> _ods_ir[_ods_ir] .. py:method:: fastmath() -> _ods_ir .. py:method:: imaginary() -> _ods_ir[_ods_ir] .. py:class:: ImOpAdaptor(operands: list[Value], attributes: OpAttributeMap) ImOpAdaptor(operands: list[Value], opview: OpView) Bases: :py:obj:`_ods_ir` .. py:attribute:: OPERATION_NAME :value: 'complex.im' .. py:method:: complex() -> _ods_ir[_ods_ir] .. py:method:: fastmath() -> _ods_ir .. py:function:: im(complex: _ods_ir[_ods_ir], *, fastmath: Optional[Union[Any, _ods_ir]] = None, results: Optional[Sequence[_ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) -> _ods_ir[_ods_ir] .. py:class:: Log1pOp(complex: _ods_ir[_ods_ir], *, fastmath: Optional[Union[Any, _ods_ir]] = None, results: Optional[Sequence[_ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) Bases: :py:obj:`_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: .. code:: mlir %a = complex.log1p %b : complex .. py:attribute:: OPERATION_NAME :value: 'complex.log1p' .. py:attribute:: _ODS_REGIONS :value: (0, True) .. py:method:: complex() -> _ods_ir[_ods_ir] .. py:method:: fastmath() -> _ods_ir .. py:method:: result() -> _ods_ir[_ods_ir] Shortcut to get an op result if it has only one (throws an error otherwise). .. py:class:: Log1pOpAdaptor(operands: list[Value], attributes: OpAttributeMap) Log1pOpAdaptor(operands: list[Value], opview: OpView) Bases: :py:obj:`_ods_ir` .. py:attribute:: OPERATION_NAME :value: 'complex.log1p' .. py:method:: complex() -> _ods_ir[_ods_ir] .. py:method:: fastmath() -> _ods_ir .. py:function:: log1p(complex: _ods_ir[_ods_ir], *, fastmath: Optional[Union[Any, _ods_ir]] = None, results: Optional[Sequence[_ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) -> _ods_ir[_ods_ir] .. py:class:: LogOp(complex: _ods_ir[_ods_ir], *, fastmath: Optional[Union[Any, _ods_ir]] = None, results: Optional[Sequence[_ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) Bases: :py:obj:`_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: .. code:: mlir %a = complex.log %b : complex .. py:attribute:: OPERATION_NAME :value: 'complex.log' .. py:attribute:: _ODS_REGIONS :value: (0, True) .. py:method:: complex() -> _ods_ir[_ods_ir] .. py:method:: fastmath() -> _ods_ir .. py:method:: result() -> _ods_ir[_ods_ir] Shortcut to get an op result if it has only one (throws an error otherwise). .. py:class:: LogOpAdaptor(operands: list[Value], attributes: OpAttributeMap) LogOpAdaptor(operands: list[Value], opview: OpView) Bases: :py:obj:`_ods_ir` .. py:attribute:: OPERATION_NAME :value: 'complex.log' .. py:method:: complex() -> _ods_ir[_ods_ir] .. py:method:: fastmath() -> _ods_ir .. py:function:: log(complex: _ods_ir[_ods_ir], *, fastmath: Optional[Union[Any, _ods_ir]] = None, results: Optional[Sequence[_ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) -> _ods_ir[_ods_ir] .. py:class:: MulOp(lhs: _ods_ir[_ods_ir], rhs: _ods_ir[_ods_ir], *, fastmath: Optional[Union[Any, _ods_ir]] = None, results: Optional[Sequence[_ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) Bases: :py:obj:`_ods_ir` The ``mul`` operation takes two complex numbers and returns their product: .. code:: mlir %a = complex.mul %b, %c : complex .. py:attribute:: OPERATION_NAME :value: 'complex.mul' .. py:attribute:: _ODS_REGIONS :value: (0, True) .. py:method:: lhs() -> _ods_ir[_ods_ir] .. py:method:: rhs() -> _ods_ir[_ods_ir] .. py:method:: fastmath() -> _ods_ir .. py:method:: result() -> _ods_ir[_ods_ir] Shortcut to get an op result if it has only one (throws an error otherwise). .. py:class:: MulOpAdaptor(operands: list[Value], attributes: OpAttributeMap) MulOpAdaptor(operands: list[Value], opview: OpView) Bases: :py:obj:`_ods_ir` .. py:attribute:: OPERATION_NAME :value: 'complex.mul' .. py:method:: lhs() -> _ods_ir[_ods_ir] .. py:method:: rhs() -> _ods_ir[_ods_ir] .. py:method:: fastmath() -> _ods_ir .. py:function:: mul(lhs: _ods_ir[_ods_ir], rhs: _ods_ir[_ods_ir], *, fastmath: Optional[Union[Any, _ods_ir]] = None, results: Optional[Sequence[_ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) -> _ods_ir[_ods_ir] .. py:class:: NegOp(complex: _ods_ir[_ods_ir], *, fastmath: Optional[Union[Any, _ods_ir]] = None, results: Optional[Sequence[_ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) Bases: :py:obj:`_ods_ir` The ``neg`` op takes a single complex number ``complex`` and returns ``-complex``. Example: .. code:: mlir %a = complex.neg %b : complex .. py:attribute:: OPERATION_NAME :value: 'complex.neg' .. py:attribute:: _ODS_REGIONS :value: (0, True) .. py:method:: complex() -> _ods_ir[_ods_ir] .. py:method:: fastmath() -> _ods_ir .. py:method:: result() -> _ods_ir[_ods_ir] Shortcut to get an op result if it has only one (throws an error otherwise). .. py:class:: NegOpAdaptor(operands: list[Value], attributes: OpAttributeMap) NegOpAdaptor(operands: list[Value], opview: OpView) Bases: :py:obj:`_ods_ir` .. py:attribute:: OPERATION_NAME :value: 'complex.neg' .. py:method:: complex() -> _ods_ir[_ods_ir] .. py:method:: fastmath() -> _ods_ir .. py:function:: neg(complex: _ods_ir[_ods_ir], *, fastmath: Optional[Union[Any, _ods_ir]] = None, results: Optional[Sequence[_ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) -> _ods_ir[_ods_ir] .. py:class:: NotEqualOp(lhs: _ods_ir[_ods_ir], rhs: _ods_ir[_ods_ir], *, results: Optional[Sequence[_ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) Bases: :py:obj:`_ods_ir` The ``neq`` op takes two complex numbers and returns whether they are not equal. Example: .. code:: mlir %a = complex.neq %b, %c : complex .. py:attribute:: OPERATION_NAME :value: 'complex.neq' .. py:attribute:: _ODS_REGIONS :value: (0, True) .. py:method:: lhs() -> _ods_ir[_ods_ir] .. py:method:: rhs() -> _ods_ir[_ods_ir] .. py:method:: result() -> _ods_ir[_ods_ir] Shortcut to get an op result if it has only one (throws an error otherwise). .. py:class:: NotEqualOpAdaptor(operands: list[Value], attributes: OpAttributeMap) NotEqualOpAdaptor(operands: list[Value], opview: OpView) Bases: :py:obj:`_ods_ir` .. py:attribute:: OPERATION_NAME :value: 'complex.neq' .. py:method:: lhs() -> _ods_ir[_ods_ir] .. py:method:: rhs() -> _ods_ir[_ods_ir] .. py:function:: neq(lhs: _ods_ir[_ods_ir], rhs: _ods_ir[_ods_ir], *, results: Optional[Sequence[_ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) -> _ods_ir[_ods_ir] .. py:class:: PowOp(lhs: _ods_ir[_ods_ir], rhs: _ods_ir[_ods_ir], *, fastmath: Optional[Union[Any, _ods_ir]] = None, results: Optional[Sequence[_ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) Bases: :py:obj:`_ods_ir` The ``pow`` operation takes a complex number raises it to the given complex exponent. Example: .. code:: mlir %a = complex.pow %b, %c : complex .. py:attribute:: OPERATION_NAME :value: 'complex.pow' .. py:attribute:: _ODS_REGIONS :value: (0, True) .. py:method:: lhs() -> _ods_ir[_ods_ir] .. py:method:: rhs() -> _ods_ir[_ods_ir] .. py:method:: fastmath() -> _ods_ir .. py:method:: result() -> _ods_ir[_ods_ir] Shortcut to get an op result if it has only one (throws an error otherwise). .. py:class:: PowOpAdaptor(operands: list[Value], attributes: OpAttributeMap) PowOpAdaptor(operands: list[Value], opview: OpView) Bases: :py:obj:`_ods_ir` .. py:attribute:: OPERATION_NAME :value: 'complex.pow' .. py:method:: lhs() -> _ods_ir[_ods_ir] .. py:method:: rhs() -> _ods_ir[_ods_ir] .. py:method:: fastmath() -> _ods_ir .. py:function:: pow(lhs: _ods_ir[_ods_ir], rhs: _ods_ir[_ods_ir], *, fastmath: Optional[Union[Any, _ods_ir]] = None, results: Optional[Sequence[_ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) -> _ods_ir[_ods_ir] .. py:class:: PowiOp(lhs: _ods_ir[_ods_ir], rhs: _ods_ir[_ods_ir], *, fastmath: Optional[Union[Any, _ods_ir]] = None, results: Optional[Sequence[_ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) Bases: :py:obj:`_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: .. code:: mlir %a = complex.powi %b, %c : complex, i32 .. py:attribute:: OPERATION_NAME :value: 'complex.powi' .. py:attribute:: _ODS_REGIONS :value: (0, True) .. py:method:: lhs() -> _ods_ir[_ods_ir] .. py:method:: rhs() -> _ods_ir[_ods_ir] .. py:method:: fastmath() -> Optional[_ods_ir] .. py:method:: result() -> _ods_ir[_ods_ir] Shortcut to get an op result if it has only one (throws an error otherwise). .. py:class:: PowiOpAdaptor(operands: list[Value], attributes: OpAttributeMap) PowiOpAdaptor(operands: list[Value], opview: OpView) Bases: :py:obj:`_ods_ir` .. py:attribute:: OPERATION_NAME :value: 'complex.powi' .. py:method:: lhs() -> _ods_ir[_ods_ir] .. py:method:: rhs() -> _ods_ir[_ods_ir] .. py:method:: fastmath() -> Optional[_ods_ir] .. py:function:: powi(lhs: _ods_ir[_ods_ir], rhs: _ods_ir[_ods_ir], *, fastmath: Optional[Union[Any, _ods_ir]] = None, results: Optional[Sequence[_ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) -> _ods_ir[_ods_ir] .. py:class:: ReOp(complex: _ods_ir[_ods_ir], *, fastmath: Optional[Union[Any, _ods_ir]] = None, results: Optional[Sequence[_ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) Bases: :py:obj:`_ods_ir` The ``re`` op takes a single complex number and extracts the real part. Example: .. code:: mlir %a = complex.re %b : complex .. py:attribute:: OPERATION_NAME :value: 'complex.re' .. py:attribute:: _ODS_REGIONS :value: (0, True) .. py:method:: complex() -> _ods_ir[_ods_ir] .. py:method:: fastmath() -> _ods_ir .. py:method:: real() -> _ods_ir[_ods_ir] .. py:class:: ReOpAdaptor(operands: list[Value], attributes: OpAttributeMap) ReOpAdaptor(operands: list[Value], opview: OpView) Bases: :py:obj:`_ods_ir` .. py:attribute:: OPERATION_NAME :value: 'complex.re' .. py:method:: complex() -> _ods_ir[_ods_ir] .. py:method:: fastmath() -> _ods_ir .. py:function:: re(complex: _ods_ir[_ods_ir], *, fastmath: Optional[Union[Any, _ods_ir]] = None, results: Optional[Sequence[_ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) -> _ods_ir[_ods_ir] .. py:class:: RsqrtOp(complex: _ods_ir[_ods_ir], *, fastmath: Optional[Union[Any, _ods_ir]] = None, results: Optional[Sequence[_ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) Bases: :py:obj:`_ods_ir` The ``rsqrt`` operation computes reciprocal of square root. Example: .. code:: mlir %a = complex.rsqrt %b : complex .. py:attribute:: OPERATION_NAME :value: 'complex.rsqrt' .. py:attribute:: _ODS_REGIONS :value: (0, True) .. py:method:: complex() -> _ods_ir[_ods_ir] .. py:method:: fastmath() -> _ods_ir .. py:method:: result() -> _ods_ir[_ods_ir] Shortcut to get an op result if it has only one (throws an error otherwise). .. py:class:: RsqrtOpAdaptor(operands: list[Value], attributes: OpAttributeMap) RsqrtOpAdaptor(operands: list[Value], opview: OpView) Bases: :py:obj:`_ods_ir` .. py:attribute:: OPERATION_NAME :value: 'complex.rsqrt' .. py:method:: complex() -> _ods_ir[_ods_ir] .. py:method:: fastmath() -> _ods_ir .. py:function:: rsqrt(complex: _ods_ir[_ods_ir], *, fastmath: Optional[Union[Any, _ods_ir]] = None, results: Optional[Sequence[_ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) -> _ods_ir[_ods_ir] .. py:class:: SignOp(complex: _ods_ir[_ods_ir], *, fastmath: Optional[Union[Any, _ods_ir]] = None, results: Optional[Sequence[_ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) Bases: :py:obj:`_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: .. code:: mlir %a = complex.sign %b : complex .. py:attribute:: OPERATION_NAME :value: 'complex.sign' .. py:attribute:: _ODS_REGIONS :value: (0, True) .. py:method:: complex() -> _ods_ir[_ods_ir] .. py:method:: fastmath() -> _ods_ir .. py:method:: result() -> _ods_ir[_ods_ir] Shortcut to get an op result if it has only one (throws an error otherwise). .. py:class:: SignOpAdaptor(operands: list[Value], attributes: OpAttributeMap) SignOpAdaptor(operands: list[Value], opview: OpView) Bases: :py:obj:`_ods_ir` .. py:attribute:: OPERATION_NAME :value: 'complex.sign' .. py:method:: complex() -> _ods_ir[_ods_ir] .. py:method:: fastmath() -> _ods_ir .. py:function:: sign(complex: _ods_ir[_ods_ir], *, fastmath: Optional[Union[Any, _ods_ir]] = None, results: Optional[Sequence[_ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) -> _ods_ir[_ods_ir] .. py:class:: SinOp(complex: _ods_ir[_ods_ir], *, fastmath: Optional[Union[Any, _ods_ir]] = None, results: Optional[Sequence[_ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) Bases: :py:obj:`_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: .. code:: mlir %a = complex.sin %b : complex .. py:attribute:: OPERATION_NAME :value: 'complex.sin' .. py:attribute:: _ODS_REGIONS :value: (0, True) .. py:method:: complex() -> _ods_ir[_ods_ir] .. py:method:: fastmath() -> _ods_ir .. py:method:: result() -> _ods_ir[_ods_ir] Shortcut to get an op result if it has only one (throws an error otherwise). .. py:class:: SinOpAdaptor(operands: list[Value], attributes: OpAttributeMap) SinOpAdaptor(operands: list[Value], opview: OpView) Bases: :py:obj:`_ods_ir` .. py:attribute:: OPERATION_NAME :value: 'complex.sin' .. py:method:: complex() -> _ods_ir[_ods_ir] .. py:method:: fastmath() -> _ods_ir .. py:function:: sin(complex: _ods_ir[_ods_ir], *, fastmath: Optional[Union[Any, _ods_ir]] = None, results: Optional[Sequence[_ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) -> _ods_ir[_ods_ir] .. py:class:: SqrtOp(complex: _ods_ir[_ods_ir], *, fastmath: Optional[Union[Any, _ods_ir]] = None, results: Optional[Sequence[_ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) Bases: :py:obj:`_ods_ir` The ``sqrt`` operation takes a complex number and returns its square root. Example: .. code:: mlir %a = complex.sqrt %b : complex .. py:attribute:: OPERATION_NAME :value: 'complex.sqrt' .. py:attribute:: _ODS_REGIONS :value: (0, True) .. py:method:: complex() -> _ods_ir[_ods_ir] .. py:method:: fastmath() -> _ods_ir .. py:method:: result() -> _ods_ir[_ods_ir] Shortcut to get an op result if it has only one (throws an error otherwise). .. py:class:: SqrtOpAdaptor(operands: list[Value], attributes: OpAttributeMap) SqrtOpAdaptor(operands: list[Value], opview: OpView) Bases: :py:obj:`_ods_ir` .. py:attribute:: OPERATION_NAME :value: 'complex.sqrt' .. py:method:: complex() -> _ods_ir[_ods_ir] .. py:method:: fastmath() -> _ods_ir .. py:function:: sqrt(complex: _ods_ir[_ods_ir], *, fastmath: Optional[Union[Any, _ods_ir]] = None, results: Optional[Sequence[_ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) -> _ods_ir[_ods_ir] .. py:class:: SubOp(lhs: _ods_ir[_ods_ir], rhs: _ods_ir[_ods_ir], *, fastmath: Optional[Union[Any, _ods_ir]] = None, results: Optional[Sequence[_ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) Bases: :py:obj:`_ods_ir` The ``sub`` operation takes two complex numbers and returns their difference. Example: .. code:: mlir %a = complex.sub %b, %c : complex .. py:attribute:: OPERATION_NAME :value: 'complex.sub' .. py:attribute:: _ODS_REGIONS :value: (0, True) .. py:method:: lhs() -> _ods_ir[_ods_ir] .. py:method:: rhs() -> _ods_ir[_ods_ir] .. py:method:: fastmath() -> _ods_ir .. py:method:: result() -> _ods_ir[_ods_ir] Shortcut to get an op result if it has only one (throws an error otherwise). .. py:class:: SubOpAdaptor(operands: list[Value], attributes: OpAttributeMap) SubOpAdaptor(operands: list[Value], opview: OpView) Bases: :py:obj:`_ods_ir` .. py:attribute:: OPERATION_NAME :value: 'complex.sub' .. py:method:: lhs() -> _ods_ir[_ods_ir] .. py:method:: rhs() -> _ods_ir[_ods_ir] .. py:method:: fastmath() -> _ods_ir .. py:function:: sub(lhs: _ods_ir[_ods_ir], rhs: _ods_ir[_ods_ir], *, fastmath: Optional[Union[Any, _ods_ir]] = None, results: Optional[Sequence[_ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) -> _ods_ir[_ods_ir] .. py:class:: TanOp(complex: _ods_ir[_ods_ir], *, fastmath: Optional[Union[Any, _ods_ir]] = None, results: Optional[Sequence[_ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) Bases: :py:obj:`_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: .. code:: mlir %a = complex.tan %b : complex .. py:attribute:: OPERATION_NAME :value: 'complex.tan' .. py:attribute:: _ODS_REGIONS :value: (0, True) .. py:method:: complex() -> _ods_ir[_ods_ir] .. py:method:: fastmath() -> _ods_ir .. py:method:: result() -> _ods_ir[_ods_ir] Shortcut to get an op result if it has only one (throws an error otherwise). .. py:class:: TanOpAdaptor(operands: list[Value], attributes: OpAttributeMap) TanOpAdaptor(operands: list[Value], opview: OpView) Bases: :py:obj:`_ods_ir` .. py:attribute:: OPERATION_NAME :value: 'complex.tan' .. py:method:: complex() -> _ods_ir[_ods_ir] .. py:method:: fastmath() -> _ods_ir .. py:function:: tan(complex: _ods_ir[_ods_ir], *, fastmath: Optional[Union[Any, _ods_ir]] = None, results: Optional[Sequence[_ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) -> _ods_ir[_ods_ir] .. py:class:: TanhOp(complex: _ods_ir[_ods_ir], *, fastmath: Optional[Union[Any, _ods_ir]] = None, results: Optional[Sequence[_ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) Bases: :py:obj:`_ods_ir` The ``tanh`` operation takes a complex number and returns its hyperbolic tangent. Example: .. code:: mlir %a = complex.tanh %b : complex .. py:attribute:: OPERATION_NAME :value: 'complex.tanh' .. py:attribute:: _ODS_REGIONS :value: (0, True) .. py:method:: complex() -> _ods_ir[_ods_ir] .. py:method:: fastmath() -> _ods_ir .. py:method:: result() -> _ods_ir[_ods_ir] Shortcut to get an op result if it has only one (throws an error otherwise). .. py:class:: TanhOpAdaptor(operands: list[Value], attributes: OpAttributeMap) TanhOpAdaptor(operands: list[Value], opview: OpView) Bases: :py:obj:`_ods_ir` .. py:attribute:: OPERATION_NAME :value: 'complex.tanh' .. py:method:: complex() -> _ods_ir[_ods_ir] .. py:method:: fastmath() -> _ods_ir .. py:function:: tanh(complex: _ods_ir[_ods_ir], *, fastmath: Optional[Union[Any, _ods_ir]] = None, results: Optional[Sequence[_ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) -> _ods_ir[_ods_ir]