
# Autogenerated by mlir-tblgen; don't manually edit.

from ._ods_common import _cext as _ods_cext
from ._ods_common import (
    equally_sized_accessor as _ods_equally_sized_accessor,
    get_default_loc_context as _ods_get_default_loc_context,
    get_op_results_or_values as _get_op_results_or_values,
    segmented_accessor as _ods_segmented_accessor,
)
_ods_ir = _ods_cext.ir
_ods_cext.globals.register_traceback_file_exclusion(__file__)

import builtins
from typing import Any as _Any, Sequence as _Sequence, Union as _Union, Optional as _Optional
import sys as _sys
if _sys.version_info >= (3, 12):
  from collections.abc import Buffer as _Buffer  # pytype: disable=not-supported-yet
else:
  try:
    from typing_extensions import Buffer as _Buffer
  except ImportError:
    _Buffer = _Any


@_ods_cext.register_dialect
class _Dialect(_ods_ir.Dialect):
  DIALECT_NAMESPACE = "math"

@_ods_cext.register_operation(_Dialect)
class AbsFOp(_ods_ir.OpView):
  r"""
  The `absf` operation computes the absolute value. It takes one operand of
  floating point type (i.e., scalar, tensor or vector) and returns one result
  of the same type.
  
  Example:
  
  ```mlir
  // Scalar absolute value.
  %a = math.absf %b : f64
  ```
  """

  OPERATION_NAME = "math.absf"

  _ODS_REGIONS = (0, True)

  def __init__(self, operand: _ods_ir.Value, *, fastmath: _Optional[_Union[_Any, _ods_ir.Attribute]] = None, results: _Optional[_Sequence[_ods_ir.Type]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None):
    operands = []
    attributes = {}
    regions = None
    operands.append(operand)
    _ods_context = _ods_get_default_loc_context(loc)
    if fastmath is not None: attributes["fastmath"] = (fastmath if (
        isinstance(fastmath, _ods_ir.Attribute) or
        not _ods_ir.AttrBuilder.contains('arith.Arith_FastMathAttr')) else
          _ods_ir.AttrBuilder.get('arith.Arith_FastMathAttr')(fastmath, context=_ods_context))
    if results is None: results = [operands[0].type] * 1
    _ods_successors = None
    super().__init__(self.OPERATION_NAME, self._ODS_REGIONS, self._ODS_OPERAND_SEGMENTS, self._ODS_RESULT_SEGMENTS, attributes=attributes, results=results, operands=operands, successors=_ods_successors, regions=regions, loc=loc, ip=ip)

  @builtins.property
  def operand(self) -> _ods_ir.Value:
    return self.operation.operands[0]

  @builtins.property
  def fastmath(self) -> _ods_ir.Attribute:
    return self.operation.attributes["fastmath"]

  @fastmath.setter
  def fastmath(self, value: _ods_ir.Attribute):
    if value is None:
      raise ValueError("'None' not allowed as value for mandatory attributes")
    self.operation.attributes["fastmath"] = value

  @builtins.property
  def result(self) -> _ods_ir.OpResult:
    return self.operation.results[0]

@_ods_cext.register_op_adaptor(AbsFOp)
class AbsFOpAdaptor(_ods_ir.OpAdaptor):
  OPERATION_NAME = "math.absf"

  @builtins.property
  def operand(self) -> _ods_ir.Value:
    return self.operands[0]

  @builtins.property
  def fastmath(self) -> _ods_ir.Attribute:
    return self.attributes["fastmath"]

def absf(operand: _ods_ir.Value, *, fastmath: _Optional[_Union[_Any, _ods_ir.Attribute]] = None, results: _Optional[_Sequence[_ods_ir.Type]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None) -> _ods_ir.OpResult:
  return AbsFOp(operand=operand, fastmath=fastmath, results=results, loc=loc, ip=ip).result

@_ods_cext.register_operation(_Dialect)
class AbsIOp(_ods_ir.OpView):
  r"""
  The `absi` operation computes the absolute value. It takes one operand of
  integer type (i.e., scalar, tensor or vector) and returns one result of the
  same type.
  
  Example:
  
  ```mlir
  // Scalar absolute value.
  %a = math.absi %b : i64
  ```
  """

  OPERATION_NAME = "math.absi"

  _ODS_REGIONS = (0, True)

  def __init__(self, operand: _ods_ir.Value, *, results: _Optional[_Sequence[_ods_ir.Type]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None):
    operands = []
    attributes = {}
    regions = None
    operands.append(operand)
    _ods_context = _ods_get_default_loc_context(loc)
    if results is None: results = [operands[0].type] * 1
    _ods_successors = None
    super().__init__(self.OPERATION_NAME, self._ODS_REGIONS, self._ODS_OPERAND_SEGMENTS, self._ODS_RESULT_SEGMENTS, attributes=attributes, results=results, operands=operands, successors=_ods_successors, regions=regions, loc=loc, ip=ip)

  @builtins.property
  def operand(self) -> _ods_ir.Value:
    return self.operation.operands[0]

  @builtins.property
  def result(self) -> _ods_ir.OpResult:
    return self.operation.results[0]

@_ods_cext.register_op_adaptor(AbsIOp)
class AbsIOpAdaptor(_ods_ir.OpAdaptor):
  OPERATION_NAME = "math.absi"

  @builtins.property
  def operand(self) -> _ods_ir.Value:
    return self.operands[0]

def absi(operand: _ods_ir.Value, *, results: _Optional[_Sequence[_ods_ir.Type]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None) -> _ods_ir.OpResult:
  return AbsIOp(operand=operand, results=results, loc=loc, ip=ip).result

@_ods_cext.register_operation(_Dialect)
class AcosOp(_ods_ir.OpView):
  r"""
  The `acos` operation computes the arcus cosine of a given value. It takes one
  operand of floating point type (i.e., scalar, tensor or vector) and returns one
  result of the same type.  It has no standard attributes.
  
  Example:
  
  ```mlir
  // Scalar arcus cosine value.
  %a = math.acos %b : f64
  ```
  """

  OPERATION_NAME = "math.acos"

  _ODS_REGIONS = (0, True)

  def __init__(self, operand: _ods_ir.Value, *, fastmath: _Optional[_Union[_Any, _ods_ir.Attribute]] = None, results: _Optional[_Sequence[_ods_ir.Type]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None):
    operands = []
    attributes = {}
    regions = None
    operands.append(operand)
    _ods_context = _ods_get_default_loc_context(loc)
    if fastmath is not None: attributes["fastmath"] = (fastmath if (
        isinstance(fastmath, _ods_ir.Attribute) or
        not _ods_ir.AttrBuilder.contains('arith.Arith_FastMathAttr')) else
          _ods_ir.AttrBuilder.get('arith.Arith_FastMathAttr')(fastmath, context=_ods_context))
    if results is None: results = [operands[0].type] * 1
    _ods_successors = None
    super().__init__(self.OPERATION_NAME, self._ODS_REGIONS, self._ODS_OPERAND_SEGMENTS, self._ODS_RESULT_SEGMENTS, attributes=attributes, results=results, operands=operands, successors=_ods_successors, regions=regions, loc=loc, ip=ip)

  @builtins.property
  def operand(self) -> _ods_ir.Value:
    return self.operation.operands[0]

  @builtins.property
  def fastmath(self) -> _ods_ir.Attribute:
    return self.operation.attributes["fastmath"]

  @fastmath.setter
  def fastmath(self, value: _ods_ir.Attribute):
    if value is None:
      raise ValueError("'None' not allowed as value for mandatory attributes")
    self.operation.attributes["fastmath"] = value

  @builtins.property
  def result(self) -> _ods_ir.OpResult:
    return self.operation.results[0]

@_ods_cext.register_op_adaptor(AcosOp)
class AcosOpAdaptor(_ods_ir.OpAdaptor):
  OPERATION_NAME = "math.acos"

  @builtins.property
  def operand(self) -> _ods_ir.Value:
    return self.operands[0]

  @builtins.property
  def fastmath(self) -> _ods_ir.Attribute:
    return self.attributes["fastmath"]

def acos(operand: _ods_ir.Value, *, fastmath: _Optional[_Union[_Any, _ods_ir.Attribute]] = None, results: _Optional[_Sequence[_ods_ir.Type]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None) -> _ods_ir.OpResult:
  return AcosOp(operand=operand, fastmath=fastmath, results=results, loc=loc, ip=ip).result

@_ods_cext.register_operation(_Dialect)
class AcoshOp(_ods_ir.OpView):
  r"""
  Syntax:
  
  ```
  operation ::= ssa-id `=` `math.acosh` ssa-use `:` type
  ```
  
  The `acosh` operation computes the arcus cosine of a given value.  It takes
  one operand of floating point type (i.e., scalar, tensor or vector) and returns
  one result of the same type. It has no standard attributes.
  
  Example:
  
  ```mlir
  // Hyperbolic arcus cosine of scalar value.
  %a = math.acosh %b : f64
  ```
  """

  OPERATION_NAME = "math.acosh"

  _ODS_REGIONS = (0, True)

  def __init__(self, operand: _ods_ir.Value, *, fastmath: _Optional[_Union[_Any, _ods_ir.Attribute]] = None, results: _Optional[_Sequence[_ods_ir.Type]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None):
    operands = []
    attributes = {}
    regions = None
    operands.append(operand)
    _ods_context = _ods_get_default_loc_context(loc)
    if fastmath is not None: attributes["fastmath"] = (fastmath if (
        isinstance(fastmath, _ods_ir.Attribute) or
        not _ods_ir.AttrBuilder.contains('arith.Arith_FastMathAttr')) else
          _ods_ir.AttrBuilder.get('arith.Arith_FastMathAttr')(fastmath, context=_ods_context))
    if results is None: results = [operands[0].type] * 1
    _ods_successors = None
    super().__init__(self.OPERATION_NAME, self._ODS_REGIONS, self._ODS_OPERAND_SEGMENTS, self._ODS_RESULT_SEGMENTS, attributes=attributes, results=results, operands=operands, successors=_ods_successors, regions=regions, loc=loc, ip=ip)

  @builtins.property
  def operand(self) -> _ods_ir.Value:
    return self.operation.operands[0]

  @builtins.property
  def fastmath(self) -> _ods_ir.Attribute:
    return self.operation.attributes["fastmath"]

  @fastmath.setter
  def fastmath(self, value: _ods_ir.Attribute):
    if value is None:
      raise ValueError("'None' not allowed as value for mandatory attributes")
    self.operation.attributes["fastmath"] = value

  @builtins.property
  def result(self) -> _ods_ir.OpResult:
    return self.operation.results[0]

@_ods_cext.register_op_adaptor(AcoshOp)
class AcoshOpAdaptor(_ods_ir.OpAdaptor):
  OPERATION_NAME = "math.acosh"

  @builtins.property
  def operand(self) -> _ods_ir.Value:
    return self.operands[0]

  @builtins.property
  def fastmath(self) -> _ods_ir.Attribute:
    return self.attributes["fastmath"]

def acosh(operand: _ods_ir.Value, *, fastmath: _Optional[_Union[_Any, _ods_ir.Attribute]] = None, results: _Optional[_Sequence[_ods_ir.Type]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None) -> _ods_ir.OpResult:
  return AcoshOp(operand=operand, fastmath=fastmath, results=results, loc=loc, ip=ip).result

@_ods_cext.register_operation(_Dialect)
class AsinOp(_ods_ir.OpView):
  r"""
  Syntax:
  
  ```
  operation ::= ssa-id `=` `math.asin` ssa-use `:` type
  ```
  
  The `asin` operation computes the arcus sine of a given value.  It takes
  one operand of floating point type (i.e., scalar, tensor or vector) and returns
  one result of the same type. It has no standard attributes.
  
  Example:
  
  ```mlir
  // Arcus sine of scalar value.
  %a = math.asin %b : f64
  ```
  """

  OPERATION_NAME = "math.asin"

  _ODS_REGIONS = (0, True)

  def __init__(self, operand: _ods_ir.Value, *, fastmath: _Optional[_Union[_Any, _ods_ir.Attribute]] = None, results: _Optional[_Sequence[_ods_ir.Type]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None):
    operands = []
    attributes = {}
    regions = None
    operands.append(operand)
    _ods_context = _ods_get_default_loc_context(loc)
    if fastmath is not None: attributes["fastmath"] = (fastmath if (
        isinstance(fastmath, _ods_ir.Attribute) or
        not _ods_ir.AttrBuilder.contains('arith.Arith_FastMathAttr')) else
          _ods_ir.AttrBuilder.get('arith.Arith_FastMathAttr')(fastmath, context=_ods_context))
    if results is None: results = [operands[0].type] * 1
    _ods_successors = None
    super().__init__(self.OPERATION_NAME, self._ODS_REGIONS, self._ODS_OPERAND_SEGMENTS, self._ODS_RESULT_SEGMENTS, attributes=attributes, results=results, operands=operands, successors=_ods_successors, regions=regions, loc=loc, ip=ip)

  @builtins.property
  def operand(self) -> _ods_ir.Value:
    return self.operation.operands[0]

  @builtins.property
  def fastmath(self) -> _ods_ir.Attribute:
    return self.operation.attributes["fastmath"]

  @fastmath.setter
  def fastmath(self, value: _ods_ir.Attribute):
    if value is None:
      raise ValueError("'None' not allowed as value for mandatory attributes")
    self.operation.attributes["fastmath"] = value

  @builtins.property
  def result(self) -> _ods_ir.OpResult:
    return self.operation.results[0]

@_ods_cext.register_op_adaptor(AsinOp)
class AsinOpAdaptor(_ods_ir.OpAdaptor):
  OPERATION_NAME = "math.asin"

  @builtins.property
  def operand(self) -> _ods_ir.Value:
    return self.operands[0]

  @builtins.property
  def fastmath(self) -> _ods_ir.Attribute:
    return self.attributes["fastmath"]

def asin(operand: _ods_ir.Value, *, fastmath: _Optional[_Union[_Any, _ods_ir.Attribute]] = None, results: _Optional[_Sequence[_ods_ir.Type]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None) -> _ods_ir.OpResult:
  return AsinOp(operand=operand, fastmath=fastmath, results=results, loc=loc, ip=ip).result

@_ods_cext.register_operation(_Dialect)
class AsinhOp(_ods_ir.OpView):
  r"""
  Syntax:
  
  ```
  operation ::= ssa-id `=` `math.asinh` ssa-use `:` type
  ```
  
  The `asinh` operation computes the hyperbolic arcus sine of a given value.  It takes
  one operand of floating point type (i.e., scalar, tensor or vector) and returns
  one result of the same type. It has no standard attributes.
  
  Example:
  
  ```mlir
  // Hyperbolic arcus sine of scalar value.
  %a = math.asinh %b : f64
  ```
  """

  OPERATION_NAME = "math.asinh"

  _ODS_REGIONS = (0, True)

  def __init__(self, operand: _ods_ir.Value, *, fastmath: _Optional[_Union[_Any, _ods_ir.Attribute]] = None, results: _Optional[_Sequence[_ods_ir.Type]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None):
    operands = []
    attributes = {}
    regions = None
    operands.append(operand)
    _ods_context = _ods_get_default_loc_context(loc)
    if fastmath is not None: attributes["fastmath"] = (fastmath if (
        isinstance(fastmath, _ods_ir.Attribute) or
        not _ods_ir.AttrBuilder.contains('arith.Arith_FastMathAttr')) else
          _ods_ir.AttrBuilder.get('arith.Arith_FastMathAttr')(fastmath, context=_ods_context))
    if results is None: results = [operands[0].type] * 1
    _ods_successors = None
    super().__init__(self.OPERATION_NAME, self._ODS_REGIONS, self._ODS_OPERAND_SEGMENTS, self._ODS_RESULT_SEGMENTS, attributes=attributes, results=results, operands=operands, successors=_ods_successors, regions=regions, loc=loc, ip=ip)

  @builtins.property
  def operand(self) -> _ods_ir.Value:
    return self.operation.operands[0]

  @builtins.property
  def fastmath(self) -> _ods_ir.Attribute:
    return self.operation.attributes["fastmath"]

  @fastmath.setter
  def fastmath(self, value: _ods_ir.Attribute):
    if value is None:
      raise ValueError("'None' not allowed as value for mandatory attributes")
    self.operation.attributes["fastmath"] = value

  @builtins.property
  def result(self) -> _ods_ir.OpResult:
    return self.operation.results[0]

@_ods_cext.register_op_adaptor(AsinhOp)
class AsinhOpAdaptor(_ods_ir.OpAdaptor):
  OPERATION_NAME = "math.asinh"

  @builtins.property
  def operand(self) -> _ods_ir.Value:
    return self.operands[0]

  @builtins.property
  def fastmath(self) -> _ods_ir.Attribute:
    return self.attributes["fastmath"]

def asinh(operand: _ods_ir.Value, *, fastmath: _Optional[_Union[_Any, _ods_ir.Attribute]] = None, results: _Optional[_Sequence[_ods_ir.Type]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None) -> _ods_ir.OpResult:
  return AsinhOp(operand=operand, fastmath=fastmath, results=results, loc=loc, ip=ip).result

@_ods_cext.register_operation(_Dialect)
class Atan2Op(_ods_ir.OpView):
  r"""
  The `atan2` operation takes two operands and returns one result, all of
  which must be of the same type.  The operands must be of floating point type
  (i.e., scalar, tensor or vector).
  
  The 2-argument arcus tangent `atan2(y, x)` returns the angle in the
  Euclidian plane between the positive x-axis and the ray through the point
  (x, y).  It is a generalization of the 1-argument arcus tangent which
  returns the angle on the basis of the ratio y/x.
  
  See also https://en.wikipedia.org/wiki/Atan2
  
  Example:
  
  ```mlir
  // Scalar variant.
  %a = math.atan2 %b, %c : f32
  ```
  """

  OPERATION_NAME = "math.atan2"

  _ODS_REGIONS = (0, True)

  def __init__(self, lhs: _ods_ir.Value, rhs: _ods_ir.Value, *, fastmath: _Optional[_Union[_Any, _ods_ir.Attribute]] = None, results: _Optional[_Sequence[_ods_ir.Type]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None):
    operands = []
    attributes = {}
    regions = None
    operands.append(lhs)
    operands.append(rhs)
    _ods_context = _ods_get_default_loc_context(loc)
    if fastmath is not None: attributes["fastmath"] = (fastmath if (
        isinstance(fastmath, _ods_ir.Attribute) or
        not _ods_ir.AttrBuilder.contains('arith.Arith_FastMathAttr')) else
          _ods_ir.AttrBuilder.get('arith.Arith_FastMathAttr')(fastmath, context=_ods_context))
    if results is None: results = [operands[0].type] * 1
    _ods_successors = None
    super().__init__(self.OPERATION_NAME, self._ODS_REGIONS, self._ODS_OPERAND_SEGMENTS, self._ODS_RESULT_SEGMENTS, attributes=attributes, results=results, operands=operands, successors=_ods_successors, regions=regions, loc=loc, ip=ip)

  @builtins.property
  def lhs(self) -> _ods_ir.Value:
    return self.operation.operands[0]

  @builtins.property
  def rhs(self) -> _ods_ir.Value:
    return self.operation.operands[1]

  @builtins.property
  def fastmath(self) -> _ods_ir.Attribute:
    return self.operation.attributes["fastmath"]

  @fastmath.setter
  def fastmath(self, value: _ods_ir.Attribute):
    if value is None:
      raise ValueError("'None' not allowed as value for mandatory attributes")
    self.operation.attributes["fastmath"] = value

  @builtins.property
  def result(self) -> _ods_ir.OpResult:
    return self.operation.results[0]

@_ods_cext.register_op_adaptor(Atan2Op)
class Atan2OpAdaptor(_ods_ir.OpAdaptor):
  OPERATION_NAME = "math.atan2"

  @builtins.property
  def lhs(self) -> _ods_ir.Value:
    return self.operands[0]

  @builtins.property
  def rhs(self) -> _ods_ir.Value:
    return self.operands[1]

  @builtins.property
  def fastmath(self) -> _ods_ir.Attribute:
    return self.attributes["fastmath"]

def atan2(lhs: _ods_ir.Value, rhs: _ods_ir.Value, *, fastmath: _Optional[_Union[_Any, _ods_ir.Attribute]] = None, results: _Optional[_Sequence[_ods_ir.Type]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None) -> _ods_ir.OpResult:
  return Atan2Op(lhs=lhs, rhs=rhs, fastmath=fastmath, results=results, loc=loc, ip=ip).result

@_ods_cext.register_operation(_Dialect)
class AtanOp(_ods_ir.OpView):
  r"""
  The `atan` operation computes the arcus tangent of a given value.  It takes
  one operand of floating point type (i.e., scalar, tensor or vector) and returns
  one result of the same type. It has no standard attributes.
  
  Example:
  
  ```mlir
  // Arcus tangent of scalar value.
  %a = math.atan %b : f64
  ```
  """

  OPERATION_NAME = "math.atan"

  _ODS_REGIONS = (0, True)

  def __init__(self, operand: _ods_ir.Value, *, fastmath: _Optional[_Union[_Any, _ods_ir.Attribute]] = None, results: _Optional[_Sequence[_ods_ir.Type]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None):
    operands = []
    attributes = {}
    regions = None
    operands.append(operand)
    _ods_context = _ods_get_default_loc_context(loc)
    if fastmath is not None: attributes["fastmath"] = (fastmath if (
        isinstance(fastmath, _ods_ir.Attribute) or
        not _ods_ir.AttrBuilder.contains('arith.Arith_FastMathAttr')) else
          _ods_ir.AttrBuilder.get('arith.Arith_FastMathAttr')(fastmath, context=_ods_context))
    if results is None: results = [operands[0].type] * 1
    _ods_successors = None
    super().__init__(self.OPERATION_NAME, self._ODS_REGIONS, self._ODS_OPERAND_SEGMENTS, self._ODS_RESULT_SEGMENTS, attributes=attributes, results=results, operands=operands, successors=_ods_successors, regions=regions, loc=loc, ip=ip)

  @builtins.property
  def operand(self) -> _ods_ir.Value:
    return self.operation.operands[0]

  @builtins.property
  def fastmath(self) -> _ods_ir.Attribute:
    return self.operation.attributes["fastmath"]

  @fastmath.setter
  def fastmath(self, value: _ods_ir.Attribute):
    if value is None:
      raise ValueError("'None' not allowed as value for mandatory attributes")
    self.operation.attributes["fastmath"] = value

  @builtins.property
  def result(self) -> _ods_ir.OpResult:
    return self.operation.results[0]

@_ods_cext.register_op_adaptor(AtanOp)
class AtanOpAdaptor(_ods_ir.OpAdaptor):
  OPERATION_NAME = "math.atan"

  @builtins.property
  def operand(self) -> _ods_ir.Value:
    return self.operands[0]

  @builtins.property
  def fastmath(self) -> _ods_ir.Attribute:
    return self.attributes["fastmath"]

def atan(operand: _ods_ir.Value, *, fastmath: _Optional[_Union[_Any, _ods_ir.Attribute]] = None, results: _Optional[_Sequence[_ods_ir.Type]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None) -> _ods_ir.OpResult:
  return AtanOp(operand=operand, fastmath=fastmath, results=results, loc=loc, ip=ip).result

@_ods_cext.register_operation(_Dialect)
class AtanhOp(_ods_ir.OpView):
  r"""
  Syntax:
  
  ```
  operation ::= ssa-id `=` `math.atanh` ssa-use `:` type
  ```
  
  The `atanh` operation computes the hyperbolic arcus tangent of a given value.  It takes
  one operand of floating point type (i.e., scalar, tensor or vector) and returns
  one result of the same type. It has no standard attributes.
  
  Example:
  
  ```mlir
  // Hyperbolic arcus tangent of scalar value.
  %a = math.atanh %b : f64
  ```
  """

  OPERATION_NAME = "math.atanh"

  _ODS_REGIONS = (0, True)

  def __init__(self, operand: _ods_ir.Value, *, fastmath: _Optional[_Union[_Any, _ods_ir.Attribute]] = None, results: _Optional[_Sequence[_ods_ir.Type]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None):
    operands = []
    attributes = {}
    regions = None
    operands.append(operand)
    _ods_context = _ods_get_default_loc_context(loc)
    if fastmath is not None: attributes["fastmath"] = (fastmath if (
        isinstance(fastmath, _ods_ir.Attribute) or
        not _ods_ir.AttrBuilder.contains('arith.Arith_FastMathAttr')) else
          _ods_ir.AttrBuilder.get('arith.Arith_FastMathAttr')(fastmath, context=_ods_context))
    if results is None: results = [operands[0].type] * 1
    _ods_successors = None
    super().__init__(self.OPERATION_NAME, self._ODS_REGIONS, self._ODS_OPERAND_SEGMENTS, self._ODS_RESULT_SEGMENTS, attributes=attributes, results=results, operands=operands, successors=_ods_successors, regions=regions, loc=loc, ip=ip)

  @builtins.property
  def operand(self) -> _ods_ir.Value:
    return self.operation.operands[0]

  @builtins.property
  def fastmath(self) -> _ods_ir.Attribute:
    return self.operation.attributes["fastmath"]

  @fastmath.setter
  def fastmath(self, value: _ods_ir.Attribute):
    if value is None:
      raise ValueError("'None' not allowed as value for mandatory attributes")
    self.operation.attributes["fastmath"] = value

  @builtins.property
  def result(self) -> _ods_ir.OpResult:
    return self.operation.results[0]

@_ods_cext.register_op_adaptor(AtanhOp)
class AtanhOpAdaptor(_ods_ir.OpAdaptor):
  OPERATION_NAME = "math.atanh"

  @builtins.property
  def operand(self) -> _ods_ir.Value:
    return self.operands[0]

  @builtins.property
  def fastmath(self) -> _ods_ir.Attribute:
    return self.attributes["fastmath"]

def atanh(operand: _ods_ir.Value, *, fastmath: _Optional[_Union[_Any, _ods_ir.Attribute]] = None, results: _Optional[_Sequence[_ods_ir.Type]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None) -> _ods_ir.OpResult:
  return AtanhOp(operand=operand, fastmath=fastmath, results=results, loc=loc, ip=ip).result

@_ods_cext.register_operation(_Dialect)
class CbrtOp(_ods_ir.OpView):
  r"""
  The `cbrt` operation computes the cube root. It takes one operand of
  floating point type (i.e., scalar, tensor or vector) and returns one result
  of the same type. It has no standard attributes.
  
  Example:
  
  ```mlir
  // Scalar cube root value.
  %a = math.cbrt %b : f64
  ```
  
  Note: This op is not equivalent to powf(..., 1/3.0).
  """

  OPERATION_NAME = "math.cbrt"

  _ODS_REGIONS = (0, True)

  def __init__(self, operand: _ods_ir.Value, *, fastmath: _Optional[_Union[_Any, _ods_ir.Attribute]] = None, results: _Optional[_Sequence[_ods_ir.Type]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None):
    operands = []
    attributes = {}
    regions = None
    operands.append(operand)
    _ods_context = _ods_get_default_loc_context(loc)
    if fastmath is not None: attributes["fastmath"] = (fastmath if (
        isinstance(fastmath, _ods_ir.Attribute) or
        not _ods_ir.AttrBuilder.contains('arith.Arith_FastMathAttr')) else
          _ods_ir.AttrBuilder.get('arith.Arith_FastMathAttr')(fastmath, context=_ods_context))
    if results is None: results = [operands[0].type] * 1
    _ods_successors = None
    super().__init__(self.OPERATION_NAME, self._ODS_REGIONS, self._ODS_OPERAND_SEGMENTS, self._ODS_RESULT_SEGMENTS, attributes=attributes, results=results, operands=operands, successors=_ods_successors, regions=regions, loc=loc, ip=ip)

  @builtins.property
  def operand(self) -> _ods_ir.Value:
    return self.operation.operands[0]

  @builtins.property
  def fastmath(self) -> _ods_ir.Attribute:
    return self.operation.attributes["fastmath"]

  @fastmath.setter
  def fastmath(self, value: _ods_ir.Attribute):
    if value is None:
      raise ValueError("'None' not allowed as value for mandatory attributes")
    self.operation.attributes["fastmath"] = value

  @builtins.property
  def result(self) -> _ods_ir.OpResult:
    return self.operation.results[0]

@_ods_cext.register_op_adaptor(CbrtOp)
class CbrtOpAdaptor(_ods_ir.OpAdaptor):
  OPERATION_NAME = "math.cbrt"

  @builtins.property
  def operand(self) -> _ods_ir.Value:
    return self.operands[0]

  @builtins.property
  def fastmath(self) -> _ods_ir.Attribute:
    return self.attributes["fastmath"]

def cbrt(operand: _ods_ir.Value, *, fastmath: _Optional[_Union[_Any, _ods_ir.Attribute]] = None, results: _Optional[_Sequence[_ods_ir.Type]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None) -> _ods_ir.OpResult:
  return CbrtOp(operand=operand, fastmath=fastmath, results=results, loc=loc, ip=ip).result

@_ods_cext.register_operation(_Dialect)
class CeilOp(_ods_ir.OpView):
  r"""
  The `ceil` operation computes the ceiling of a given value. It takes one
  operand of floating point type (i.e., scalar, tensor or vector) and returns one
  result of the same type.  It has no standard attributes.
  
  Example:
  
  ```mlir
  // Scalar ceiling value.
  %a = math.ceil %b : f64
  ```
  """

  OPERATION_NAME = "math.ceil"

  _ODS_REGIONS = (0, True)

  def __init__(self, operand: _ods_ir.Value, *, fastmath: _Optional[_Union[_Any, _ods_ir.Attribute]] = None, results: _Optional[_Sequence[_ods_ir.Type]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None):
    operands = []
    attributes = {}
    regions = None
    operands.append(operand)
    _ods_context = _ods_get_default_loc_context(loc)
    if fastmath is not None: attributes["fastmath"] = (fastmath if (
        isinstance(fastmath, _ods_ir.Attribute) or
        not _ods_ir.AttrBuilder.contains('arith.Arith_FastMathAttr')) else
          _ods_ir.AttrBuilder.get('arith.Arith_FastMathAttr')(fastmath, context=_ods_context))
    if results is None: results = [operands[0].type] * 1
    _ods_successors = None
    super().__init__(self.OPERATION_NAME, self._ODS_REGIONS, self._ODS_OPERAND_SEGMENTS, self._ODS_RESULT_SEGMENTS, attributes=attributes, results=results, operands=operands, successors=_ods_successors, regions=regions, loc=loc, ip=ip)

  @builtins.property
  def operand(self) -> _ods_ir.Value:
    return self.operation.operands[0]

  @builtins.property
  def fastmath(self) -> _ods_ir.Attribute:
    return self.operation.attributes["fastmath"]

  @fastmath.setter
  def fastmath(self, value: _ods_ir.Attribute):
    if value is None:
      raise ValueError("'None' not allowed as value for mandatory attributes")
    self.operation.attributes["fastmath"] = value

  @builtins.property
  def result(self) -> _ods_ir.OpResult:
    return self.operation.results[0]

@_ods_cext.register_op_adaptor(CeilOp)
class CeilOpAdaptor(_ods_ir.OpAdaptor):
  OPERATION_NAME = "math.ceil"

  @builtins.property
  def operand(self) -> _ods_ir.Value:
    return self.operands[0]

  @builtins.property
  def fastmath(self) -> _ods_ir.Attribute:
    return self.attributes["fastmath"]

def ceil(operand: _ods_ir.Value, *, fastmath: _Optional[_Union[_Any, _ods_ir.Attribute]] = None, results: _Optional[_Sequence[_ods_ir.Type]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None) -> _ods_ir.OpResult:
  return CeilOp(operand=operand, fastmath=fastmath, results=results, loc=loc, ip=ip).result

@_ods_cext.register_operation(_Dialect)
class ClampFOp(_ods_ir.OpView):
  r"""
  The `clampf` operation takes three operands and returns one result, each of
  these is required to be the same type. Operands must be of floating point type
  (i.e., scalar, tensor or vector).
  
  The semantics of the operation are described by:
  ```
    clampf(value, min, max) = maxf(minf(value, max), min)
  ```
  If `min > max` the resulting value is poison.
  
  Example:
  
  ```mlir
  %d = math.clampf %value to [%min, %max] : f64
  ```
  """

  OPERATION_NAME = "math.clampf"

  _ODS_REGIONS = (0, True)

  def __init__(self, value: _ods_ir.Value, min: _ods_ir.Value, max: _ods_ir.Value, *, fastmath: _Optional[_Union[_Any, _ods_ir.Attribute]] = None, results: _Optional[_Sequence[_ods_ir.Type]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None):
    operands = []
    attributes = {}
    regions = None
    operands.append(value)
    operands.append(min)
    operands.append(max)
    _ods_context = _ods_get_default_loc_context(loc)
    if fastmath is not None: attributes["fastmath"] = (fastmath if (
        isinstance(fastmath, _ods_ir.Attribute) or
        not _ods_ir.AttrBuilder.contains('arith.Arith_FastMathAttr')) else
          _ods_ir.AttrBuilder.get('arith.Arith_FastMathAttr')(fastmath, context=_ods_context))
    if results is None: results = [operands[0].type] * 1
    _ods_successors = None
    super().__init__(self.OPERATION_NAME, self._ODS_REGIONS, self._ODS_OPERAND_SEGMENTS, self._ODS_RESULT_SEGMENTS, attributes=attributes, results=results, operands=operands, successors=_ods_successors, regions=regions, loc=loc, ip=ip)

  @builtins.property
  def value(self) -> _ods_ir.Value:
    return self.operation.operands[0]

  @builtins.property
  def min(self) -> _ods_ir.Value:
    return self.operation.operands[1]

  @builtins.property
  def max(self) -> _ods_ir.Value:
    return self.operation.operands[2]

  @builtins.property
  def fastmath(self) -> _ods_ir.Attribute:
    return self.operation.attributes["fastmath"]

  @fastmath.setter
  def fastmath(self, value: _ods_ir.Attribute):
    if value is None:
      raise ValueError("'None' not allowed as value for mandatory attributes")
    self.operation.attributes["fastmath"] = value

  @builtins.property
  def result(self) -> _ods_ir.OpResult:
    return self.operation.results[0]

@_ods_cext.register_op_adaptor(ClampFOp)
class ClampFOpAdaptor(_ods_ir.OpAdaptor):
  OPERATION_NAME = "math.clampf"

  @builtins.property
  def value(self) -> _ods_ir.Value:
    return self.operands[0]

  @builtins.property
  def min(self) -> _ods_ir.Value:
    return self.operands[1]

  @builtins.property
  def max(self) -> _ods_ir.Value:
    return self.operands[2]

  @builtins.property
  def fastmath(self) -> _ods_ir.Attribute:
    return self.attributes["fastmath"]

def clampf(value: _ods_ir.Value, min: _ods_ir.Value, max: _ods_ir.Value, *, fastmath: _Optional[_Union[_Any, _ods_ir.Attribute]] = None, results: _Optional[_Sequence[_ods_ir.Type]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None) -> _ods_ir.OpResult:
  return ClampFOp(value=value, min=min, max=max, fastmath=fastmath, results=results, loc=loc, ip=ip).result

@_ods_cext.register_operation(_Dialect)
class CopySignOp(_ods_ir.OpView):
  r"""
  The `copysign` returns a value with the magnitude of the first operand and
  the sign of the second operand. It takes two operands and returns one result of
  the same type. The operands must be of floating point type (i.e., scalar,
  tensor or vector). It has no standard attributes.
  
  Example:
  
  ```mlir
  // Scalar copysign value.
  %a = math.copysign %b, %c : f64
  ```
  """

  OPERATION_NAME = "math.copysign"

  _ODS_REGIONS = (0, True)

  def __init__(self, lhs: _ods_ir.Value, rhs: _ods_ir.Value, *, fastmath: _Optional[_Union[_Any, _ods_ir.Attribute]] = None, results: _Optional[_Sequence[_ods_ir.Type]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None):
    operands = []
    attributes = {}
    regions = None
    operands.append(lhs)
    operands.append(rhs)
    _ods_context = _ods_get_default_loc_context(loc)
    if fastmath is not None: attributes["fastmath"] = (fastmath if (
        isinstance(fastmath, _ods_ir.Attribute) or
        not _ods_ir.AttrBuilder.contains('arith.Arith_FastMathAttr')) else
          _ods_ir.AttrBuilder.get('arith.Arith_FastMathAttr')(fastmath, context=_ods_context))
    if results is None: results = [operands[0].type] * 1
    _ods_successors = None
    super().__init__(self.OPERATION_NAME, self._ODS_REGIONS, self._ODS_OPERAND_SEGMENTS, self._ODS_RESULT_SEGMENTS, attributes=attributes, results=results, operands=operands, successors=_ods_successors, regions=regions, loc=loc, ip=ip)

  @builtins.property
  def lhs(self) -> _ods_ir.Value:
    return self.operation.operands[0]

  @builtins.property
  def rhs(self) -> _ods_ir.Value:
    return self.operation.operands[1]

  @builtins.property
  def fastmath(self) -> _ods_ir.Attribute:
    return self.operation.attributes["fastmath"]

  @fastmath.setter
  def fastmath(self, value: _ods_ir.Attribute):
    if value is None:
      raise ValueError("'None' not allowed as value for mandatory attributes")
    self.operation.attributes["fastmath"] = value

  @builtins.property
  def result(self) -> _ods_ir.OpResult:
    return self.operation.results[0]

@_ods_cext.register_op_adaptor(CopySignOp)
class CopySignOpAdaptor(_ods_ir.OpAdaptor):
  OPERATION_NAME = "math.copysign"

  @builtins.property
  def lhs(self) -> _ods_ir.Value:
    return self.operands[0]

  @builtins.property
  def rhs(self) -> _ods_ir.Value:
    return self.operands[1]

  @builtins.property
  def fastmath(self) -> _ods_ir.Attribute:
    return self.attributes["fastmath"]

def copysign(lhs: _ods_ir.Value, rhs: _ods_ir.Value, *, fastmath: _Optional[_Union[_Any, _ods_ir.Attribute]] = None, results: _Optional[_Sequence[_ods_ir.Type]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None) -> _ods_ir.OpResult:
  return CopySignOp(lhs=lhs, rhs=rhs, fastmath=fastmath, results=results, loc=loc, ip=ip).result

@_ods_cext.register_operation(_Dialect)
class CosOp(_ods_ir.OpView):
  r"""
  The `cos` operation computes the cosine of a given value. It takes one
  operand of floating point type (i.e., scalar, tensor or vector) and returns one
  result of the same type.  It has no standard attributes.
  
  Example:
  
  ```mlir
  // Scalar cosine value.
  %a = math.cos %b : f64
  ```
  """

  OPERATION_NAME = "math.cos"

  _ODS_REGIONS = (0, True)

  def __init__(self, operand: _ods_ir.Value, *, fastmath: _Optional[_Union[_Any, _ods_ir.Attribute]] = None, results: _Optional[_Sequence[_ods_ir.Type]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None):
    operands = []
    attributes = {}
    regions = None
    operands.append(operand)
    _ods_context = _ods_get_default_loc_context(loc)
    if fastmath is not None: attributes["fastmath"] = (fastmath if (
        isinstance(fastmath, _ods_ir.Attribute) or
        not _ods_ir.AttrBuilder.contains('arith.Arith_FastMathAttr')) else
          _ods_ir.AttrBuilder.get('arith.Arith_FastMathAttr')(fastmath, context=_ods_context))
    if results is None: results = [operands[0].type] * 1
    _ods_successors = None
    super().__init__(self.OPERATION_NAME, self._ODS_REGIONS, self._ODS_OPERAND_SEGMENTS, self._ODS_RESULT_SEGMENTS, attributes=attributes, results=results, operands=operands, successors=_ods_successors, regions=regions, loc=loc, ip=ip)

  @builtins.property
  def operand(self) -> _ods_ir.Value:
    return self.operation.operands[0]

  @builtins.property
  def fastmath(self) -> _ods_ir.Attribute:
    return self.operation.attributes["fastmath"]

  @fastmath.setter
  def fastmath(self, value: _ods_ir.Attribute):
    if value is None:
      raise ValueError("'None' not allowed as value for mandatory attributes")
    self.operation.attributes["fastmath"] = value

  @builtins.property
  def result(self) -> _ods_ir.OpResult:
    return self.operation.results[0]

@_ods_cext.register_op_adaptor(CosOp)
class CosOpAdaptor(_ods_ir.OpAdaptor):
  OPERATION_NAME = "math.cos"

  @builtins.property
  def operand(self) -> _ods_ir.Value:
    return self.operands[0]

  @builtins.property
  def fastmath(self) -> _ods_ir.Attribute:
    return self.attributes["fastmath"]

def cos(operand: _ods_ir.Value, *, fastmath: _Optional[_Union[_Any, _ods_ir.Attribute]] = None, results: _Optional[_Sequence[_ods_ir.Type]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None) -> _ods_ir.OpResult:
  return CosOp(operand=operand, fastmath=fastmath, results=results, loc=loc, ip=ip).result

@_ods_cext.register_operation(_Dialect)
class CoshOp(_ods_ir.OpView):
  r"""
  The `cosh` operation computes the hyperbolic cosine. It takes one operand
  of floating point type (i.e., scalar, tensor or vector) and returns one
  result of the same type. It has no standard attributes.
  
  Example:
  
  ```mlir
  // Scalar hyperbolic cosine value.
  %a = math.cosh %b : f64
  ```
  """

  OPERATION_NAME = "math.cosh"

  _ODS_REGIONS = (0, True)

  def __init__(self, operand: _ods_ir.Value, *, fastmath: _Optional[_Union[_Any, _ods_ir.Attribute]] = None, results: _Optional[_Sequence[_ods_ir.Type]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None):
    operands = []
    attributes = {}
    regions = None
    operands.append(operand)
    _ods_context = _ods_get_default_loc_context(loc)
    if fastmath is not None: attributes["fastmath"] = (fastmath if (
        isinstance(fastmath, _ods_ir.Attribute) or
        not _ods_ir.AttrBuilder.contains('arith.Arith_FastMathAttr')) else
          _ods_ir.AttrBuilder.get('arith.Arith_FastMathAttr')(fastmath, context=_ods_context))
    if results is None: results = [operands[0].type] * 1
    _ods_successors = None
    super().__init__(self.OPERATION_NAME, self._ODS_REGIONS, self._ODS_OPERAND_SEGMENTS, self._ODS_RESULT_SEGMENTS, attributes=attributes, results=results, operands=operands, successors=_ods_successors, regions=regions, loc=loc, ip=ip)

  @builtins.property
  def operand(self) -> _ods_ir.Value:
    return self.operation.operands[0]

  @builtins.property
  def fastmath(self) -> _ods_ir.Attribute:
    return self.operation.attributes["fastmath"]

  @fastmath.setter
  def fastmath(self, value: _ods_ir.Attribute):
    if value is None:
      raise ValueError("'None' not allowed as value for mandatory attributes")
    self.operation.attributes["fastmath"] = value

  @builtins.property
  def result(self) -> _ods_ir.OpResult:
    return self.operation.results[0]

@_ods_cext.register_op_adaptor(CoshOp)
class CoshOpAdaptor(_ods_ir.OpAdaptor):
  OPERATION_NAME = "math.cosh"

  @builtins.property
  def operand(self) -> _ods_ir.Value:
    return self.operands[0]

  @builtins.property
  def fastmath(self) -> _ods_ir.Attribute:
    return self.attributes["fastmath"]

def cosh(operand: _ods_ir.Value, *, fastmath: _Optional[_Union[_Any, _ods_ir.Attribute]] = None, results: _Optional[_Sequence[_ods_ir.Type]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None) -> _ods_ir.OpResult:
  return CoshOp(operand=operand, fastmath=fastmath, results=results, loc=loc, ip=ip).result

@_ods_cext.register_operation(_Dialect)
class CountLeadingZerosOp(_ods_ir.OpView):
  r"""
  The `ctlz` operation computes the number of leading zeros of an integer value.
  It operates on scalar, tensor or vector.
  
  Example:
  
  ```mlir
  // Scalar ctlz function value.
  %a = math.ctlz %b : i32
  ```
  """

  OPERATION_NAME = "math.ctlz"

  _ODS_REGIONS = (0, True)

  def __init__(self, operand: _ods_ir.Value, *, results: _Optional[_Sequence[_ods_ir.Type]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None):
    operands = []
    attributes = {}
    regions = None
    operands.append(operand)
    _ods_context = _ods_get_default_loc_context(loc)
    if results is None: results = [operands[0].type] * 1
    _ods_successors = None
    super().__init__(self.OPERATION_NAME, self._ODS_REGIONS, self._ODS_OPERAND_SEGMENTS, self._ODS_RESULT_SEGMENTS, attributes=attributes, results=results, operands=operands, successors=_ods_successors, regions=regions, loc=loc, ip=ip)

  @builtins.property
  def operand(self) -> _ods_ir.Value:
    return self.operation.operands[0]

  @builtins.property
  def result(self) -> _ods_ir.OpResult:
    return self.operation.results[0]

@_ods_cext.register_op_adaptor(CountLeadingZerosOp)
class CountLeadingZerosOpAdaptor(_ods_ir.OpAdaptor):
  OPERATION_NAME = "math.ctlz"

  @builtins.property
  def operand(self) -> _ods_ir.Value:
    return self.operands[0]

def ctlz(operand: _ods_ir.Value, *, results: _Optional[_Sequence[_ods_ir.Type]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None) -> _ods_ir.OpResult:
  return CountLeadingZerosOp(operand=operand, results=results, loc=loc, ip=ip).result

@_ods_cext.register_operation(_Dialect)
class CountTrailingZerosOp(_ods_ir.OpView):
  r"""
  The `cttz` operation computes the number of trailing zeros of an integer value.
  It operates on scalar, tensor or vector.
  
  Example:
  
  ```mlir
  // Scalar cttz function value.
  %a = math.cttz %b : i32
  ```
  """

  OPERATION_NAME = "math.cttz"

  _ODS_REGIONS = (0, True)

  def __init__(self, operand: _ods_ir.Value, *, results: _Optional[_Sequence[_ods_ir.Type]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None):
    operands = []
    attributes = {}
    regions = None
    operands.append(operand)
    _ods_context = _ods_get_default_loc_context(loc)
    if results is None: results = [operands[0].type] * 1
    _ods_successors = None
    super().__init__(self.OPERATION_NAME, self._ODS_REGIONS, self._ODS_OPERAND_SEGMENTS, self._ODS_RESULT_SEGMENTS, attributes=attributes, results=results, operands=operands, successors=_ods_successors, regions=regions, loc=loc, ip=ip)

  @builtins.property
  def operand(self) -> _ods_ir.Value:
    return self.operation.operands[0]

  @builtins.property
  def result(self) -> _ods_ir.OpResult:
    return self.operation.results[0]

@_ods_cext.register_op_adaptor(CountTrailingZerosOp)
class CountTrailingZerosOpAdaptor(_ods_ir.OpAdaptor):
  OPERATION_NAME = "math.cttz"

  @builtins.property
  def operand(self) -> _ods_ir.Value:
    return self.operands[0]

def cttz(operand: _ods_ir.Value, *, results: _Optional[_Sequence[_ods_ir.Type]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None) -> _ods_ir.OpResult:
  return CountTrailingZerosOp(operand=operand, results=results, loc=loc, ip=ip).result

@_ods_cext.register_operation(_Dialect)
class CtPopOp(_ods_ir.OpView):
  r"""
  The `ctpop` operation computes the number of set bits of an integer value.
  It operates on scalar, tensor or vector.
  
  Example:
  
  ```mlir
  // Scalar ctpop function value.
  %a = math.ctpop %b : i32
  ```
  """

  OPERATION_NAME = "math.ctpop"

  _ODS_REGIONS = (0, True)

  def __init__(self, operand: _ods_ir.Value, *, results: _Optional[_Sequence[_ods_ir.Type]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None):
    operands = []
    attributes = {}
    regions = None
    operands.append(operand)
    _ods_context = _ods_get_default_loc_context(loc)
    if results is None: results = [operands[0].type] * 1
    _ods_successors = None
    super().__init__(self.OPERATION_NAME, self._ODS_REGIONS, self._ODS_OPERAND_SEGMENTS, self._ODS_RESULT_SEGMENTS, attributes=attributes, results=results, operands=operands, successors=_ods_successors, regions=regions, loc=loc, ip=ip)

  @builtins.property
  def operand(self) -> _ods_ir.Value:
    return self.operation.operands[0]

  @builtins.property
  def result(self) -> _ods_ir.OpResult:
    return self.operation.results[0]

@_ods_cext.register_op_adaptor(CtPopOp)
class CtPopOpAdaptor(_ods_ir.OpAdaptor):
  OPERATION_NAME = "math.ctpop"

  @builtins.property
  def operand(self) -> _ods_ir.Value:
    return self.operands[0]

def ctpop(operand: _ods_ir.Value, *, results: _Optional[_Sequence[_ods_ir.Type]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None) -> _ods_ir.OpResult:
  return CtPopOp(operand=operand, results=results, loc=loc, ip=ip).result

@_ods_cext.register_operation(_Dialect)
class ErfOp(_ods_ir.OpView):
  r"""
  The `erf` operation computes the error function. It takes one operand of
  floating point type (i.e., scalar, tensor or vector) and returns one result of
  the same type. It has no standard attributes.
  
  Example:
  
  ```mlir
  // Scalar error function value.
  %a = math.erf %b : f64
  ```
  """

  OPERATION_NAME = "math.erf"

  _ODS_REGIONS = (0, True)

  def __init__(self, operand: _ods_ir.Value, *, fastmath: _Optional[_Union[_Any, _ods_ir.Attribute]] = None, results: _Optional[_Sequence[_ods_ir.Type]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None):
    operands = []
    attributes = {}
    regions = None
    operands.append(operand)
    _ods_context = _ods_get_default_loc_context(loc)
    if fastmath is not None: attributes["fastmath"] = (fastmath if (
        isinstance(fastmath, _ods_ir.Attribute) or
        not _ods_ir.AttrBuilder.contains('arith.Arith_FastMathAttr')) else
          _ods_ir.AttrBuilder.get('arith.Arith_FastMathAttr')(fastmath, context=_ods_context))
    if results is None: results = [operands[0].type] * 1
    _ods_successors = None
    super().__init__(self.OPERATION_NAME, self._ODS_REGIONS, self._ODS_OPERAND_SEGMENTS, self._ODS_RESULT_SEGMENTS, attributes=attributes, results=results, operands=operands, successors=_ods_successors, regions=regions, loc=loc, ip=ip)

  @builtins.property
  def operand(self) -> _ods_ir.Value:
    return self.operation.operands[0]

  @builtins.property
  def fastmath(self) -> _ods_ir.Attribute:
    return self.operation.attributes["fastmath"]

  @fastmath.setter
  def fastmath(self, value: _ods_ir.Attribute):
    if value is None:
      raise ValueError("'None' not allowed as value for mandatory attributes")
    self.operation.attributes["fastmath"] = value

  @builtins.property
  def result(self) -> _ods_ir.OpResult:
    return self.operation.results[0]

@_ods_cext.register_op_adaptor(ErfOp)
class ErfOpAdaptor(_ods_ir.OpAdaptor):
  OPERATION_NAME = "math.erf"

  @builtins.property
  def operand(self) -> _ods_ir.Value:
    return self.operands[0]

  @builtins.property
  def fastmath(self) -> _ods_ir.Attribute:
    return self.attributes["fastmath"]

def erf(operand: _ods_ir.Value, *, fastmath: _Optional[_Union[_Any, _ods_ir.Attribute]] = None, results: _Optional[_Sequence[_ods_ir.Type]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None) -> _ods_ir.OpResult:
  return ErfOp(operand=operand, fastmath=fastmath, results=results, loc=loc, ip=ip).result

@_ods_cext.register_operation(_Dialect)
class ErfcOp(_ods_ir.OpView):
  r"""
  The `erfc` operation computes the complementary error function, defined as
  1-erf(x). This function is part of libm and is needed for accuracy, since
  simply calculating 1-erf(x) when x is close to 1 will give inaccurate results.
  It takes one operand of floating point type (i.e., scalar,
  tensor or vector) and returns one result of the same type. It has no
  standard attributes.
  
  Example:
  
  ```mlir
  // Scalar error function value.
  %a = math.erfc %b : f64
  ```
  """

  OPERATION_NAME = "math.erfc"

  _ODS_REGIONS = (0, True)

  def __init__(self, operand: _ods_ir.Value, *, fastmath: _Optional[_Union[_Any, _ods_ir.Attribute]] = None, results: _Optional[_Sequence[_ods_ir.Type]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None):
    operands = []
    attributes = {}
    regions = None
    operands.append(operand)
    _ods_context = _ods_get_default_loc_context(loc)
    if fastmath is not None: attributes["fastmath"] = (fastmath if (
        isinstance(fastmath, _ods_ir.Attribute) or
        not _ods_ir.AttrBuilder.contains('arith.Arith_FastMathAttr')) else
          _ods_ir.AttrBuilder.get('arith.Arith_FastMathAttr')(fastmath, context=_ods_context))
    if results is None: results = [operands[0].type] * 1
    _ods_successors = None
    super().__init__(self.OPERATION_NAME, self._ODS_REGIONS, self._ODS_OPERAND_SEGMENTS, self._ODS_RESULT_SEGMENTS, attributes=attributes, results=results, operands=operands, successors=_ods_successors, regions=regions, loc=loc, ip=ip)

  @builtins.property
  def operand(self) -> _ods_ir.Value:
    return self.operation.operands[0]

  @builtins.property
  def fastmath(self) -> _ods_ir.Attribute:
    return self.operation.attributes["fastmath"]

  @fastmath.setter
  def fastmath(self, value: _ods_ir.Attribute):
    if value is None:
      raise ValueError("'None' not allowed as value for mandatory attributes")
    self.operation.attributes["fastmath"] = value

  @builtins.property
  def result(self) -> _ods_ir.OpResult:
    return self.operation.results[0]

@_ods_cext.register_op_adaptor(ErfcOp)
class ErfcOpAdaptor(_ods_ir.OpAdaptor):
  OPERATION_NAME = "math.erfc"

  @builtins.property
  def operand(self) -> _ods_ir.Value:
    return self.operands[0]

  @builtins.property
  def fastmath(self) -> _ods_ir.Attribute:
    return self.attributes["fastmath"]

def erfc(operand: _ods_ir.Value, *, fastmath: _Optional[_Union[_Any, _ods_ir.Attribute]] = None, results: _Optional[_Sequence[_ods_ir.Type]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None) -> _ods_ir.OpResult:
  return ErfcOp(operand=operand, fastmath=fastmath, results=results, loc=loc, ip=ip).result

@_ods_cext.register_operation(_Dialect)
class Exp2Op(_ods_ir.OpView):
  r"""
  The `exp` operation takes one operand of floating point type (i.e., scalar,
  tensor or vector) and returns one result of the same type. It has no standard
  attributes.
  
  Example:
  
  ```mlir
  // Scalar natural exponential.
  %a = math.exp2 %b : f64
  ```
  """

  OPERATION_NAME = "math.exp2"

  _ODS_REGIONS = (0, True)

  def __init__(self, operand: _ods_ir.Value, *, fastmath: _Optional[_Union[_Any, _ods_ir.Attribute]] = None, results: _Optional[_Sequence[_ods_ir.Type]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None):
    operands = []
    attributes = {}
    regions = None
    operands.append(operand)
    _ods_context = _ods_get_default_loc_context(loc)
    if fastmath is not None: attributes["fastmath"] = (fastmath if (
        isinstance(fastmath, _ods_ir.Attribute) or
        not _ods_ir.AttrBuilder.contains('arith.Arith_FastMathAttr')) else
          _ods_ir.AttrBuilder.get('arith.Arith_FastMathAttr')(fastmath, context=_ods_context))
    if results is None: results = [operands[0].type] * 1
    _ods_successors = None
    super().__init__(self.OPERATION_NAME, self._ODS_REGIONS, self._ODS_OPERAND_SEGMENTS, self._ODS_RESULT_SEGMENTS, attributes=attributes, results=results, operands=operands, successors=_ods_successors, regions=regions, loc=loc, ip=ip)

  @builtins.property
  def operand(self) -> _ods_ir.Value:
    return self.operation.operands[0]

  @builtins.property
  def fastmath(self) -> _ods_ir.Attribute:
    return self.operation.attributes["fastmath"]

  @fastmath.setter
  def fastmath(self, value: _ods_ir.Attribute):
    if value is None:
      raise ValueError("'None' not allowed as value for mandatory attributes")
    self.operation.attributes["fastmath"] = value

  @builtins.property
  def result(self) -> _ods_ir.OpResult:
    return self.operation.results[0]

@_ods_cext.register_op_adaptor(Exp2Op)
class Exp2OpAdaptor(_ods_ir.OpAdaptor):
  OPERATION_NAME = "math.exp2"

  @builtins.property
  def operand(self) -> _ods_ir.Value:
    return self.operands[0]

  @builtins.property
  def fastmath(self) -> _ods_ir.Attribute:
    return self.attributes["fastmath"]

def exp2(operand: _ods_ir.Value, *, fastmath: _Optional[_Union[_Any, _ods_ir.Attribute]] = None, results: _Optional[_Sequence[_ods_ir.Type]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None) -> _ods_ir.OpResult:
  return Exp2Op(operand=operand, fastmath=fastmath, results=results, loc=loc, ip=ip).result

@_ods_cext.register_operation(_Dialect)
class ExpM1Op(_ods_ir.OpView):
  r"""
  expm1(x) := exp(x) - 1
  
  The `expm1` operation takes one operand of floating point type (i.e.,
  scalar, tensor or vector) and returns one result of the same type. It has no
  standard attributes.
  
  Example:
  
  ```mlir
  // Scalar natural exponential minus 1.
  %a = math.expm1 %b : f64
  ```
  """

  OPERATION_NAME = "math.expm1"

  _ODS_REGIONS = (0, True)

  def __init__(self, operand: _ods_ir.Value, *, fastmath: _Optional[_Union[_Any, _ods_ir.Attribute]] = None, results: _Optional[_Sequence[_ods_ir.Type]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None):
    operands = []
    attributes = {}
    regions = None
    operands.append(operand)
    _ods_context = _ods_get_default_loc_context(loc)
    if fastmath is not None: attributes["fastmath"] = (fastmath if (
        isinstance(fastmath, _ods_ir.Attribute) or
        not _ods_ir.AttrBuilder.contains('arith.Arith_FastMathAttr')) else
          _ods_ir.AttrBuilder.get('arith.Arith_FastMathAttr')(fastmath, context=_ods_context))
    if results is None: results = [operands[0].type] * 1
    _ods_successors = None
    super().__init__(self.OPERATION_NAME, self._ODS_REGIONS, self._ODS_OPERAND_SEGMENTS, self._ODS_RESULT_SEGMENTS, attributes=attributes, results=results, operands=operands, successors=_ods_successors, regions=regions, loc=loc, ip=ip)

  @builtins.property
  def operand(self) -> _ods_ir.Value:
    return self.operation.operands[0]

  @builtins.property
  def fastmath(self) -> _ods_ir.Attribute:
    return self.operation.attributes["fastmath"]

  @fastmath.setter
  def fastmath(self, value: _ods_ir.Attribute):
    if value is None:
      raise ValueError("'None' not allowed as value for mandatory attributes")
    self.operation.attributes["fastmath"] = value

  @builtins.property
  def result(self) -> _ods_ir.OpResult:
    return self.operation.results[0]

@_ods_cext.register_op_adaptor(ExpM1Op)
class ExpM1OpAdaptor(_ods_ir.OpAdaptor):
  OPERATION_NAME = "math.expm1"

  @builtins.property
  def operand(self) -> _ods_ir.Value:
    return self.operands[0]

  @builtins.property
  def fastmath(self) -> _ods_ir.Attribute:
    return self.attributes["fastmath"]

def expm1(operand: _ods_ir.Value, *, fastmath: _Optional[_Union[_Any, _ods_ir.Attribute]] = None, results: _Optional[_Sequence[_ods_ir.Type]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None) -> _ods_ir.OpResult:
  return ExpM1Op(operand=operand, fastmath=fastmath, results=results, loc=loc, ip=ip).result

@_ods_cext.register_operation(_Dialect)
class ExpOp(_ods_ir.OpView):
  r"""
  The `exp` operation takes one operand of floating point type (i.e., scalar,
  tensor or vector) and returns one result of the same type. It has no standard
  attributes.
  
  Example:
  
  ```mlir
  // Scalar natural exponential.
  %a = math.exp %b : f64
  ```
  """

  OPERATION_NAME = "math.exp"

  _ODS_REGIONS = (0, True)

  def __init__(self, operand: _ods_ir.Value, *, fastmath: _Optional[_Union[_Any, _ods_ir.Attribute]] = None, results: _Optional[_Sequence[_ods_ir.Type]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None):
    operands = []
    attributes = {}
    regions = None
    operands.append(operand)
    _ods_context = _ods_get_default_loc_context(loc)
    if fastmath is not None: attributes["fastmath"] = (fastmath if (
        isinstance(fastmath, _ods_ir.Attribute) or
        not _ods_ir.AttrBuilder.contains('arith.Arith_FastMathAttr')) else
          _ods_ir.AttrBuilder.get('arith.Arith_FastMathAttr')(fastmath, context=_ods_context))
    if results is None: results = [operands[0].type] * 1
    _ods_successors = None
    super().__init__(self.OPERATION_NAME, self._ODS_REGIONS, self._ODS_OPERAND_SEGMENTS, self._ODS_RESULT_SEGMENTS, attributes=attributes, results=results, operands=operands, successors=_ods_successors, regions=regions, loc=loc, ip=ip)

  @builtins.property
  def operand(self) -> _ods_ir.Value:
    return self.operation.operands[0]

  @builtins.property
  def fastmath(self) -> _ods_ir.Attribute:
    return self.operation.attributes["fastmath"]

  @fastmath.setter
  def fastmath(self, value: _ods_ir.Attribute):
    if value is None:
      raise ValueError("'None' not allowed as value for mandatory attributes")
    self.operation.attributes["fastmath"] = value

  @builtins.property
  def result(self) -> _ods_ir.OpResult:
    return self.operation.results[0]

@_ods_cext.register_op_adaptor(ExpOp)
class ExpOpAdaptor(_ods_ir.OpAdaptor):
  OPERATION_NAME = "math.exp"

  @builtins.property
  def operand(self) -> _ods_ir.Value:
    return self.operands[0]

  @builtins.property
  def fastmath(self) -> _ods_ir.Attribute:
    return self.attributes["fastmath"]

def exp(operand: _ods_ir.Value, *, fastmath: _Optional[_Union[_Any, _ods_ir.Attribute]] = None, results: _Optional[_Sequence[_ods_ir.Type]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None) -> _ods_ir.OpResult:
  return ExpOp(operand=operand, fastmath=fastmath, results=results, loc=loc, ip=ip).result

@_ods_cext.register_operation(_Dialect)
class FPowIOp(_ods_ir.OpView):
  r"""
  The `fpowi` operation takes a `base` operand of floating point type
  (i.e. scalar, tensor or vector) and a `power` operand of integer type
  (also scalar, tensor or vector) and returns one result of the same type
  as `base`. The result is `base` raised to the power of `power`.
  The operation is elementwise for non-scalars, e.g.:
  
  ```mlir
  %v = math.fpowi %base, %power : vector<2xf32>, vector<2xi32>
  ```
  
  The result is a vector of:
  
  ```
  [<math.fpowi %base[0], %power[0]>, <math.fpowi %base[1], %power[1]>]
  ```
  
  Example:
  
  ```mlir
  // Scalar exponentiation.
  %a = math.fpowi %base, %power : f64, i32
  ```
  """

  OPERATION_NAME = "math.fpowi"

  _ODS_REGIONS = (0, True)

  def __init__(self, lhs: _ods_ir.Value, rhs: _ods_ir.Value, *, fastmath: _Optional[_Union[_Any, _ods_ir.Attribute]] = None, results: _Optional[_Sequence[_ods_ir.Type]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None):
    operands = []
    attributes = {}
    regions = None
    operands.append(lhs)
    operands.append(rhs)
    _ods_context = _ods_get_default_loc_context(loc)
    if fastmath is not None: attributes["fastmath"] = (fastmath if (
        isinstance(fastmath, _ods_ir.Attribute) or
        not _ods_ir.AttrBuilder.contains('arith.Arith_FastMathAttr')) else
          _ods_ir.AttrBuilder.get('arith.Arith_FastMathAttr')(fastmath, context=_ods_context))
    _ods_successors = None
    super().__init__(self.OPERATION_NAME, self._ODS_REGIONS, self._ODS_OPERAND_SEGMENTS, self._ODS_RESULT_SEGMENTS, attributes=attributes, results=results, operands=operands, successors=_ods_successors, regions=regions, loc=loc, ip=ip)

  @builtins.property
  def lhs(self) -> _ods_ir.Value:
    return self.operation.operands[0]

  @builtins.property
  def rhs(self) -> _ods_ir.Value:
    return self.operation.operands[1]

  @builtins.property
  def fastmath(self) -> _ods_ir.Attribute:
    return self.operation.attributes["fastmath"]

  @fastmath.setter
  def fastmath(self, value: _ods_ir.Attribute):
    if value is None:
      raise ValueError("'None' not allowed as value for mandatory attributes")
    self.operation.attributes["fastmath"] = value

  @builtins.property
  def result(self) -> _ods_ir.OpResult:
    return self.operation.results[0]

@_ods_cext.register_op_adaptor(FPowIOp)
class FPowIOpAdaptor(_ods_ir.OpAdaptor):
  OPERATION_NAME = "math.fpowi"

  @builtins.property
  def lhs(self) -> _ods_ir.Value:
    return self.operands[0]

  @builtins.property
  def rhs(self) -> _ods_ir.Value:
    return self.operands[1]

  @builtins.property
  def fastmath(self) -> _ods_ir.Attribute:
    return self.attributes["fastmath"]

def fpowi(lhs: _ods_ir.Value, rhs: _ods_ir.Value, *, fastmath: _Optional[_Union[_Any, _ods_ir.Attribute]] = None, results: _Optional[_Sequence[_ods_ir.Type]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None) -> _ods_ir.OpResult:
  return FPowIOp(lhs=lhs, rhs=rhs, fastmath=fastmath, results=results, loc=loc, ip=ip).result

@_ods_cext.register_operation(_Dialect)
class FloorOp(_ods_ir.OpView):
  r"""
  The `floor` operation computes the floor of a given value. It takes one
  operand of floating point type (i.e., scalar, tensor or vector) and returns one
  result of the same type.  It has no standard attributes.
  
  Example:
  
  ```mlir
  // Scalar floor value.
  %a = math.floor %b : f64
  ```
  """

  OPERATION_NAME = "math.floor"

  _ODS_REGIONS = (0, True)

  def __init__(self, operand: _ods_ir.Value, *, fastmath: _Optional[_Union[_Any, _ods_ir.Attribute]] = None, results: _Optional[_Sequence[_ods_ir.Type]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None):
    operands = []
    attributes = {}
    regions = None
    operands.append(operand)
    _ods_context = _ods_get_default_loc_context(loc)
    if fastmath is not None: attributes["fastmath"] = (fastmath if (
        isinstance(fastmath, _ods_ir.Attribute) or
        not _ods_ir.AttrBuilder.contains('arith.Arith_FastMathAttr')) else
          _ods_ir.AttrBuilder.get('arith.Arith_FastMathAttr')(fastmath, context=_ods_context))
    if results is None: results = [operands[0].type] * 1
    _ods_successors = None
    super().__init__(self.OPERATION_NAME, self._ODS_REGIONS, self._ODS_OPERAND_SEGMENTS, self._ODS_RESULT_SEGMENTS, attributes=attributes, results=results, operands=operands, successors=_ods_successors, regions=regions, loc=loc, ip=ip)

  @builtins.property
  def operand(self) -> _ods_ir.Value:
    return self.operation.operands[0]

  @builtins.property
  def fastmath(self) -> _ods_ir.Attribute:
    return self.operation.attributes["fastmath"]

  @fastmath.setter
  def fastmath(self, value: _ods_ir.Attribute):
    if value is None:
      raise ValueError("'None' not allowed as value for mandatory attributes")
    self.operation.attributes["fastmath"] = value

  @builtins.property
  def result(self) -> _ods_ir.OpResult:
    return self.operation.results[0]

@_ods_cext.register_op_adaptor(FloorOp)
class FloorOpAdaptor(_ods_ir.OpAdaptor):
  OPERATION_NAME = "math.floor"

  @builtins.property
  def operand(self) -> _ods_ir.Value:
    return self.operands[0]

  @builtins.property
  def fastmath(self) -> _ods_ir.Attribute:
    return self.attributes["fastmath"]

def floor(operand: _ods_ir.Value, *, fastmath: _Optional[_Union[_Any, _ods_ir.Attribute]] = None, results: _Optional[_Sequence[_ods_ir.Type]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None) -> _ods_ir.OpResult:
  return FloorOp(operand=operand, fastmath=fastmath, results=results, loc=loc, ip=ip).result

@_ods_cext.register_operation(_Dialect)
class FmaOp(_ods_ir.OpView):
  r"""
  The `fma` operation takes three operands and returns one result, each of
  these is required to be the same type. Operands must be of floating point type
  (i.e., scalar, tensor or vector).
  
  Example:
  
  ```mlir
  // Scalar fused multiply-add: d = a*b + c
  %d = math.fma %a, %b, %c : f64
  
  // With an explicit IEEE-754 rounding mode.
  %e = math.fma %a, %b, %c to_nearest_even : f64
  ```
  
  The semantics of the operation correspond to those of the `llvm.fma`
  [intrinsic](https://llvm.org/docs/LangRef.html#llvm-fma-intrinsic). When
  no rounding mode is set, lowering to LLVM is guaranteed to produce the
  `llvm.fma.*` intrinsic. When a rounding mode is set, the LLVM lowering
  instead produces `llvm.experimental.constrained.fma`.
  """

  OPERATION_NAME = "math.fma"

  _ODS_REGIONS = (0, True)

  def __init__(self, a: _ods_ir.Value, b: _ods_ir.Value, c: _ods_ir.Value, *, fastmath: _Optional[_Union[_Any, _ods_ir.Attribute]] = None, roundingmode: _Optional[_Union[_Any, _ods_ir.Attribute]] = None, results: _Optional[_Sequence[_ods_ir.Type]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None):
    operands = []
    attributes = {}
    regions = None
    operands.append(a)
    operands.append(b)
    operands.append(c)
    _ods_context = _ods_get_default_loc_context(loc)
    if fastmath is not None: attributes["fastmath"] = (fastmath if (
        isinstance(fastmath, _ods_ir.Attribute) or
        not _ods_ir.AttrBuilder.contains('arith.Arith_FastMathAttr')) else
          _ods_ir.AttrBuilder.get('arith.Arith_FastMathAttr')(fastmath, context=_ods_context))
    if roundingmode is not None: attributes["roundingmode"] = (roundingmode if (
        isinstance(roundingmode, _ods_ir.Attribute) or
        not _ods_ir.AttrBuilder.contains('Arith_RoundingModeAttr')) else
          _ods_ir.AttrBuilder.get('Arith_RoundingModeAttr')(roundingmode, context=_ods_context))
    if results is None: results = [operands[0].type] * 1
    _ods_successors = None
    super().__init__(self.OPERATION_NAME, self._ODS_REGIONS, self._ODS_OPERAND_SEGMENTS, self._ODS_RESULT_SEGMENTS, attributes=attributes, results=results, operands=operands, successors=_ods_successors, regions=regions, loc=loc, ip=ip)

  @builtins.property
  def a(self) -> _ods_ir.Value:
    return self.operation.operands[0]

  @builtins.property
  def b(self) -> _ods_ir.Value:
    return self.operation.operands[1]

  @builtins.property
  def c(self) -> _ods_ir.Value:
    return self.operation.operands[2]

  @builtins.property
  def fastmath(self) -> _ods_ir.Attribute:
    return self.operation.attributes["fastmath"]

  @fastmath.setter
  def fastmath(self, value: _ods_ir.Attribute):
    if value is None:
      raise ValueError("'None' not allowed as value for mandatory attributes")
    self.operation.attributes["fastmath"] = value

  @builtins.property
  def roundingmode(self) -> _Optional[_ods_ir.Attribute]:
    if "roundingmode" not in self.operation.attributes:
      return None
    return self.operation.attributes["roundingmode"]

  @roundingmode.setter
  def roundingmode(self, value: _Optional[_ods_ir.Attribute]):
    if value is not None:
      self.operation.attributes["roundingmode"] = value
    elif "roundingmode" in self.operation.attributes:
      del self.operation.attributes["roundingmode"]

  @roundingmode.deleter
  def roundingmode(self):
    del self.operation.attributes["roundingmode"]

  @builtins.property
  def result(self) -> _ods_ir.OpResult:
    return self.operation.results[0]

@_ods_cext.register_op_adaptor(FmaOp)
class FmaOpAdaptor(_ods_ir.OpAdaptor):
  OPERATION_NAME = "math.fma"

  @builtins.property
  def a(self) -> _ods_ir.Value:
    return self.operands[0]

  @builtins.property
  def b(self) -> _ods_ir.Value:
    return self.operands[1]

  @builtins.property
  def c(self) -> _ods_ir.Value:
    return self.operands[2]

  @builtins.property
  def fastmath(self) -> _ods_ir.Attribute:
    return self.attributes["fastmath"]

  @builtins.property
  def roundingmode(self) -> _Optional[_ods_ir.Attribute]:
    if "roundingmode" not in self.attributes:
      return None
    return self.attributes["roundingmode"]

def fma(a: _ods_ir.Value, b: _ods_ir.Value, c: _ods_ir.Value, *, fastmath: _Optional[_Union[_Any, _ods_ir.Attribute]] = None, roundingmode: _Optional[_Union[_Any, _ods_ir.Attribute]] = None, results: _Optional[_Sequence[_ods_ir.Type]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None) -> _ods_ir.OpResult:
  return FmaOp(a=a, b=b, c=c, fastmath=fastmath, roundingmode=roundingmode, results=results, loc=loc, ip=ip).result

@_ods_cext.register_operation(_Dialect)
class IPowIOp(_ods_ir.OpView):
  r"""
  The `ipowi` operation takes two operands of integer type (i.e., scalar,
  tensor or vector) and returns one result of the same type. Operands
  must have the same type.
  
  Example:
  
  ```mlir
  // Scalar signed integer exponentiation.
  %a = math.ipowi %b, %c : i32
  ```
  """

  OPERATION_NAME = "math.ipowi"

  _ODS_REGIONS = (0, True)

  def __init__(self, lhs: _ods_ir.Value, rhs: _ods_ir.Value, *, results: _Optional[_Sequence[_ods_ir.Type]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None):
    operands = []
    attributes = {}
    regions = None
    operands.append(lhs)
    operands.append(rhs)
    _ods_context = _ods_get_default_loc_context(loc)
    if results is None: results = [operands[0].type] * 1
    _ods_successors = None
    super().__init__(self.OPERATION_NAME, self._ODS_REGIONS, self._ODS_OPERAND_SEGMENTS, self._ODS_RESULT_SEGMENTS, attributes=attributes, results=results, operands=operands, successors=_ods_successors, regions=regions, loc=loc, ip=ip)

  @builtins.property
  def lhs(self) -> _ods_ir.Value:
    return self.operation.operands[0]

  @builtins.property
  def rhs(self) -> _ods_ir.Value:
    return self.operation.operands[1]

  @builtins.property
  def result(self) -> _ods_ir.OpResult:
    return self.operation.results[0]

@_ods_cext.register_op_adaptor(IPowIOp)
class IPowIOpAdaptor(_ods_ir.OpAdaptor):
  OPERATION_NAME = "math.ipowi"

  @builtins.property
  def lhs(self) -> _ods_ir.Value:
    return self.operands[0]

  @builtins.property
  def rhs(self) -> _ods_ir.Value:
    return self.operands[1]

def ipowi(lhs: _ods_ir.Value, rhs: _ods_ir.Value, *, results: _Optional[_Sequence[_ods_ir.Type]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None) -> _ods_ir.OpResult:
  return IPowIOp(lhs=lhs, rhs=rhs, results=results, loc=loc, ip=ip).result

@_ods_cext.register_operation(_Dialect)
class IsFiniteOp(_ods_ir.OpView):
  r"""
  Determines if the given floating-point number has finite value i.e. it
  is normal, subnormal or zero, but not infinite or NaN.
  
  Example:
  
  ```mlir
  %f = math.isfinite %a : f32
  ```
  """

  OPERATION_NAME = "math.isfinite"

  _ODS_REGIONS = (0, True)

  def __init__(self, operand: _ods_ir.Value, *, fastmath: _Optional[_Union[_Any, _ods_ir.Attribute]] = None, results: _Optional[_Sequence[_ods_ir.Type]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None):
    operands = []
    attributes = {}
    regions = None
    operands.append(operand)
    _ods_context = _ods_get_default_loc_context(loc)
    if fastmath is not None: attributes["fastmath"] = (fastmath if (
        isinstance(fastmath, _ods_ir.Attribute) or
        not _ods_ir.AttrBuilder.contains('arith.Arith_FastMathAttr')) else
          _ods_ir.AttrBuilder.get('arith.Arith_FastMathAttr')(fastmath, context=_ods_context))
    _ods_successors = None
    super().__init__(self.OPERATION_NAME, self._ODS_REGIONS, self._ODS_OPERAND_SEGMENTS, self._ODS_RESULT_SEGMENTS, attributes=attributes, results=results, operands=operands, successors=_ods_successors, regions=regions, loc=loc, ip=ip)

  @builtins.property
  def operand(self) -> _ods_ir.Value:
    return self.operation.operands[0]

  @builtins.property
  def fastmath(self) -> _ods_ir.Attribute:
    return self.operation.attributes["fastmath"]

  @fastmath.setter
  def fastmath(self, value: _ods_ir.Attribute):
    if value is None:
      raise ValueError("'None' not allowed as value for mandatory attributes")
    self.operation.attributes["fastmath"] = value

  @builtins.property
  def result(self) -> _ods_ir.OpResult:
    return self.operation.results[0]

@_ods_cext.register_op_adaptor(IsFiniteOp)
class IsFiniteOpAdaptor(_ods_ir.OpAdaptor):
  OPERATION_NAME = "math.isfinite"

  @builtins.property
  def operand(self) -> _ods_ir.Value:
    return self.operands[0]

  @builtins.property
  def fastmath(self) -> _ods_ir.Attribute:
    return self.attributes["fastmath"]

def isfinite(operand: _ods_ir.Value, *, fastmath: _Optional[_Union[_Any, _ods_ir.Attribute]] = None, results: _Optional[_Sequence[_ods_ir.Type]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None) -> _ods_ir.OpResult:
  return IsFiniteOp(operand=operand, fastmath=fastmath, results=results, loc=loc, ip=ip).result

@_ods_cext.register_operation(_Dialect)
class IsInfOp(_ods_ir.OpView):
  r"""
  Determines if the given floating-point number is positive or negative
  infinity.
  
  Example:
  
  ```mlir
  %f = math.isinf %a : f32
  ```
  """

  OPERATION_NAME = "math.isinf"

  _ODS_REGIONS = (0, True)

  def __init__(self, operand: _ods_ir.Value, *, fastmath: _Optional[_Union[_Any, _ods_ir.Attribute]] = None, results: _Optional[_Sequence[_ods_ir.Type]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None):
    operands = []
    attributes = {}
    regions = None
    operands.append(operand)
    _ods_context = _ods_get_default_loc_context(loc)
    if fastmath is not None: attributes["fastmath"] = (fastmath if (
        isinstance(fastmath, _ods_ir.Attribute) or
        not _ods_ir.AttrBuilder.contains('arith.Arith_FastMathAttr')) else
          _ods_ir.AttrBuilder.get('arith.Arith_FastMathAttr')(fastmath, context=_ods_context))
    _ods_successors = None
    super().__init__(self.OPERATION_NAME, self._ODS_REGIONS, self._ODS_OPERAND_SEGMENTS, self._ODS_RESULT_SEGMENTS, attributes=attributes, results=results, operands=operands, successors=_ods_successors, regions=regions, loc=loc, ip=ip)

  @builtins.property
  def operand(self) -> _ods_ir.Value:
    return self.operation.operands[0]

  @builtins.property
  def fastmath(self) -> _ods_ir.Attribute:
    return self.operation.attributes["fastmath"]

  @fastmath.setter
  def fastmath(self, value: _ods_ir.Attribute):
    if value is None:
      raise ValueError("'None' not allowed as value for mandatory attributes")
    self.operation.attributes["fastmath"] = value

  @builtins.property
  def result(self) -> _ods_ir.OpResult:
    return self.operation.results[0]

@_ods_cext.register_op_adaptor(IsInfOp)
class IsInfOpAdaptor(_ods_ir.OpAdaptor):
  OPERATION_NAME = "math.isinf"

  @builtins.property
  def operand(self) -> _ods_ir.Value:
    return self.operands[0]

  @builtins.property
  def fastmath(self) -> _ods_ir.Attribute:
    return self.attributes["fastmath"]

def isinf(operand: _ods_ir.Value, *, fastmath: _Optional[_Union[_Any, _ods_ir.Attribute]] = None, results: _Optional[_Sequence[_ods_ir.Type]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None) -> _ods_ir.OpResult:
  return IsInfOp(operand=operand, fastmath=fastmath, results=results, loc=loc, ip=ip).result

@_ods_cext.register_operation(_Dialect)
class IsNaNOp(_ods_ir.OpView):
  r"""
  Determines if the given floating-point number is a not-a-number (NaN)
  value.
  
  Example:
  
  ```mlir
  %f = math.isnan %a : f32
  ```
  """

  OPERATION_NAME = "math.isnan"

  _ODS_REGIONS = (0, True)

  def __init__(self, operand: _ods_ir.Value, *, fastmath: _Optional[_Union[_Any, _ods_ir.Attribute]] = None, results: _Optional[_Sequence[_ods_ir.Type]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None):
    operands = []
    attributes = {}
    regions = None
    operands.append(operand)
    _ods_context = _ods_get_default_loc_context(loc)
    if fastmath is not None: attributes["fastmath"] = (fastmath if (
        isinstance(fastmath, _ods_ir.Attribute) or
        not _ods_ir.AttrBuilder.contains('arith.Arith_FastMathAttr')) else
          _ods_ir.AttrBuilder.get('arith.Arith_FastMathAttr')(fastmath, context=_ods_context))
    _ods_successors = None
    super().__init__(self.OPERATION_NAME, self._ODS_REGIONS, self._ODS_OPERAND_SEGMENTS, self._ODS_RESULT_SEGMENTS, attributes=attributes, results=results, operands=operands, successors=_ods_successors, regions=regions, loc=loc, ip=ip)

  @builtins.property
  def operand(self) -> _ods_ir.Value:
    return self.operation.operands[0]

  @builtins.property
  def fastmath(self) -> _ods_ir.Attribute:
    return self.operation.attributes["fastmath"]

  @fastmath.setter
  def fastmath(self, value: _ods_ir.Attribute):
    if value is None:
      raise ValueError("'None' not allowed as value for mandatory attributes")
    self.operation.attributes["fastmath"] = value

  @builtins.property
  def result(self) -> _ods_ir.OpResult:
    return self.operation.results[0]

@_ods_cext.register_op_adaptor(IsNaNOp)
class IsNaNOpAdaptor(_ods_ir.OpAdaptor):
  OPERATION_NAME = "math.isnan"

  @builtins.property
  def operand(self) -> _ods_ir.Value:
    return self.operands[0]

  @builtins.property
  def fastmath(self) -> _ods_ir.Attribute:
    return self.attributes["fastmath"]

def isnan(operand: _ods_ir.Value, *, fastmath: _Optional[_Union[_Any, _ods_ir.Attribute]] = None, results: _Optional[_Sequence[_ods_ir.Type]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None) -> _ods_ir.OpResult:
  return IsNaNOp(operand=operand, fastmath=fastmath, results=results, loc=loc, ip=ip).result

@_ods_cext.register_operation(_Dialect)
class IsNormalOp(_ods_ir.OpView):
  r"""
  Determines if the given floating-point number is normal, i.e. is neither
  zero, subnormal, infinite, nor NaN.
  
  Example:
  
  ```mlir
  %f = math.isnormal %a : f32
  ```
  """

  OPERATION_NAME = "math.isnormal"

  _ODS_REGIONS = (0, True)

  def __init__(self, operand: _ods_ir.Value, *, fastmath: _Optional[_Union[_Any, _ods_ir.Attribute]] = None, results: _Optional[_Sequence[_ods_ir.Type]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None):
    operands = []
    attributes = {}
    regions = None
    operands.append(operand)
    _ods_context = _ods_get_default_loc_context(loc)
    if fastmath is not None: attributes["fastmath"] = (fastmath if (
        isinstance(fastmath, _ods_ir.Attribute) or
        not _ods_ir.AttrBuilder.contains('arith.Arith_FastMathAttr')) else
          _ods_ir.AttrBuilder.get('arith.Arith_FastMathAttr')(fastmath, context=_ods_context))
    _ods_successors = None
    super().__init__(self.OPERATION_NAME, self._ODS_REGIONS, self._ODS_OPERAND_SEGMENTS, self._ODS_RESULT_SEGMENTS, attributes=attributes, results=results, operands=operands, successors=_ods_successors, regions=regions, loc=loc, ip=ip)

  @builtins.property
  def operand(self) -> _ods_ir.Value:
    return self.operation.operands[0]

  @builtins.property
  def fastmath(self) -> _ods_ir.Attribute:
    return self.operation.attributes["fastmath"]

  @fastmath.setter
  def fastmath(self, value: _ods_ir.Attribute):
    if value is None:
      raise ValueError("'None' not allowed as value for mandatory attributes")
    self.operation.attributes["fastmath"] = value

  @builtins.property
  def result(self) -> _ods_ir.OpResult:
    return self.operation.results[0]

@_ods_cext.register_op_adaptor(IsNormalOp)
class IsNormalOpAdaptor(_ods_ir.OpAdaptor):
  OPERATION_NAME = "math.isnormal"

  @builtins.property
  def operand(self) -> _ods_ir.Value:
    return self.operands[0]

  @builtins.property
  def fastmath(self) -> _ods_ir.Attribute:
    return self.attributes["fastmath"]

def isnormal(operand: _ods_ir.Value, *, fastmath: _Optional[_Union[_Any, _ods_ir.Attribute]] = None, results: _Optional[_Sequence[_ods_ir.Type]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None) -> _ods_ir.OpResult:
  return IsNormalOp(operand=operand, fastmath=fastmath, results=results, loc=loc, ip=ip).result

@_ods_cext.register_operation(_Dialect)
class Log1pOp(_ods_ir.OpView):
  r"""
  Computes the base-e logarithm of one plus the given value. It takes one
  operand of floating point type (i.e., scalar, tensor or vector) and returns one
  result of the same type.
  
  log1p(x) := log(1 + x)
  
  Example:
  
  ```mlir
  // Scalar log1p operation.
  %y = math.log1p %x : f64
  ```
  """

  OPERATION_NAME = "math.log1p"

  _ODS_REGIONS = (0, True)

  def __init__(self, operand: _ods_ir.Value, *, fastmath: _Optional[_Union[_Any, _ods_ir.Attribute]] = None, results: _Optional[_Sequence[_ods_ir.Type]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None):
    operands = []
    attributes = {}
    regions = None
    operands.append(operand)
    _ods_context = _ods_get_default_loc_context(loc)
    if fastmath is not None: attributes["fastmath"] = (fastmath if (
        isinstance(fastmath, _ods_ir.Attribute) or
        not _ods_ir.AttrBuilder.contains('arith.Arith_FastMathAttr')) else
          _ods_ir.AttrBuilder.get('arith.Arith_FastMathAttr')(fastmath, context=_ods_context))
    if results is None: results = [operands[0].type] * 1
    _ods_successors = None
    super().__init__(self.OPERATION_NAME, self._ODS_REGIONS, self._ODS_OPERAND_SEGMENTS, self._ODS_RESULT_SEGMENTS, attributes=attributes, results=results, operands=operands, successors=_ods_successors, regions=regions, loc=loc, ip=ip)

  @builtins.property
  def operand(self) -> _ods_ir.Value:
    return self.operation.operands[0]

  @builtins.property
  def fastmath(self) -> _ods_ir.Attribute:
    return self.operation.attributes["fastmath"]

  @fastmath.setter
  def fastmath(self, value: _ods_ir.Attribute):
    if value is None:
      raise ValueError("'None' not allowed as value for mandatory attributes")
    self.operation.attributes["fastmath"] = value

  @builtins.property
  def result(self) -> _ods_ir.OpResult:
    return self.operation.results[0]

@_ods_cext.register_op_adaptor(Log1pOp)
class Log1pOpAdaptor(_ods_ir.OpAdaptor):
  OPERATION_NAME = "math.log1p"

  @builtins.property
  def operand(self) -> _ods_ir.Value:
    return self.operands[0]

  @builtins.property
  def fastmath(self) -> _ods_ir.Attribute:
    return self.attributes["fastmath"]

def log1p(operand: _ods_ir.Value, *, fastmath: _Optional[_Union[_Any, _ods_ir.Attribute]] = None, results: _Optional[_Sequence[_ods_ir.Type]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None) -> _ods_ir.OpResult:
  return Log1pOp(operand=operand, fastmath=fastmath, results=results, loc=loc, ip=ip).result

@_ods_cext.register_operation(_Dialect)
class Log2Op(_ods_ir.OpView):
  r"""
  Computes the base-2 logarithm of the given value. It takes one operand of
  floating point type (i.e., scalar, tensor or vector) and returns one result of
  the same type.
  
  Example:
  
  ```mlir
  // Scalar log2 operation.
  %y = math.log2 %x : f64
  ```
  """

  OPERATION_NAME = "math.log2"

  _ODS_REGIONS = (0, True)

  def __init__(self, operand: _ods_ir.Value, *, fastmath: _Optional[_Union[_Any, _ods_ir.Attribute]] = None, results: _Optional[_Sequence[_ods_ir.Type]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None):
    operands = []
    attributes = {}
    regions = None
    operands.append(operand)
    _ods_context = _ods_get_default_loc_context(loc)
    if fastmath is not None: attributes["fastmath"] = (fastmath if (
        isinstance(fastmath, _ods_ir.Attribute) or
        not _ods_ir.AttrBuilder.contains('arith.Arith_FastMathAttr')) else
          _ods_ir.AttrBuilder.get('arith.Arith_FastMathAttr')(fastmath, context=_ods_context))
    if results is None: results = [operands[0].type] * 1
    _ods_successors = None
    super().__init__(self.OPERATION_NAME, self._ODS_REGIONS, self._ODS_OPERAND_SEGMENTS, self._ODS_RESULT_SEGMENTS, attributes=attributes, results=results, operands=operands, successors=_ods_successors, regions=regions, loc=loc, ip=ip)

  @builtins.property
  def operand(self) -> _ods_ir.Value:
    return self.operation.operands[0]

  @builtins.property
  def fastmath(self) -> _ods_ir.Attribute:
    return self.operation.attributes["fastmath"]

  @fastmath.setter
  def fastmath(self, value: _ods_ir.Attribute):
    if value is None:
      raise ValueError("'None' not allowed as value for mandatory attributes")
    self.operation.attributes["fastmath"] = value

  @builtins.property
  def result(self) -> _ods_ir.OpResult:
    return self.operation.results[0]

@_ods_cext.register_op_adaptor(Log2Op)
class Log2OpAdaptor(_ods_ir.OpAdaptor):
  OPERATION_NAME = "math.log2"

  @builtins.property
  def operand(self) -> _ods_ir.Value:
    return self.operands[0]

  @builtins.property
  def fastmath(self) -> _ods_ir.Attribute:
    return self.attributes["fastmath"]

def log2(operand: _ods_ir.Value, *, fastmath: _Optional[_Union[_Any, _ods_ir.Attribute]] = None, results: _Optional[_Sequence[_ods_ir.Type]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None) -> _ods_ir.OpResult:
  return Log2Op(operand=operand, fastmath=fastmath, results=results, loc=loc, ip=ip).result

@_ods_cext.register_operation(_Dialect)
class Log10Op(_ods_ir.OpView):
  r"""
  Computes the base-10 logarithm of the given value. It takes one operand of
  floating point type (i.e., scalar, tensor or vector) and returns one result of
  the same type.
  
  Example:
  
  ```mlir
  // Scalar log10 operation.
  %y = math.log10 %x : f64
  ```
  """

  OPERATION_NAME = "math.log10"

  _ODS_REGIONS = (0, True)

  def __init__(self, operand: _ods_ir.Value, *, fastmath: _Optional[_Union[_Any, _ods_ir.Attribute]] = None, results: _Optional[_Sequence[_ods_ir.Type]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None):
    operands = []
    attributes = {}
    regions = None
    operands.append(operand)
    _ods_context = _ods_get_default_loc_context(loc)
    if fastmath is not None: attributes["fastmath"] = (fastmath if (
        isinstance(fastmath, _ods_ir.Attribute) or
        not _ods_ir.AttrBuilder.contains('arith.Arith_FastMathAttr')) else
          _ods_ir.AttrBuilder.get('arith.Arith_FastMathAttr')(fastmath, context=_ods_context))
    if results is None: results = [operands[0].type] * 1
    _ods_successors = None
    super().__init__(self.OPERATION_NAME, self._ODS_REGIONS, self._ODS_OPERAND_SEGMENTS, self._ODS_RESULT_SEGMENTS, attributes=attributes, results=results, operands=operands, successors=_ods_successors, regions=regions, loc=loc, ip=ip)

  @builtins.property
  def operand(self) -> _ods_ir.Value:
    return self.operation.operands[0]

  @builtins.property
  def fastmath(self) -> _ods_ir.Attribute:
    return self.operation.attributes["fastmath"]

  @fastmath.setter
  def fastmath(self, value: _ods_ir.Attribute):
    if value is None:
      raise ValueError("'None' not allowed as value for mandatory attributes")
    self.operation.attributes["fastmath"] = value

  @builtins.property
  def result(self) -> _ods_ir.OpResult:
    return self.operation.results[0]

@_ods_cext.register_op_adaptor(Log10Op)
class Log10OpAdaptor(_ods_ir.OpAdaptor):
  OPERATION_NAME = "math.log10"

  @builtins.property
  def operand(self) -> _ods_ir.Value:
    return self.operands[0]

  @builtins.property
  def fastmath(self) -> _ods_ir.Attribute:
    return self.attributes["fastmath"]

def log10(operand: _ods_ir.Value, *, fastmath: _Optional[_Union[_Any, _ods_ir.Attribute]] = None, results: _Optional[_Sequence[_ods_ir.Type]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None) -> _ods_ir.OpResult:
  return Log10Op(operand=operand, fastmath=fastmath, results=results, loc=loc, ip=ip).result

@_ods_cext.register_operation(_Dialect)
class LogOp(_ods_ir.OpView):
  r"""
  Computes the base-e logarithm of the given value. It takes one operand of
  floating point type (i.e., scalar, tensor or vector) and returns one result of
  the same type.
  
  Example:
  
  ```mlir
  // Scalar log operation.
  %y = math.log %x : f64
  ```
  """

  OPERATION_NAME = "math.log"

  _ODS_REGIONS = (0, True)

  def __init__(self, operand: _ods_ir.Value, *, fastmath: _Optional[_Union[_Any, _ods_ir.Attribute]] = None, results: _Optional[_Sequence[_ods_ir.Type]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None):
    operands = []
    attributes = {}
    regions = None
    operands.append(operand)
    _ods_context = _ods_get_default_loc_context(loc)
    if fastmath is not None: attributes["fastmath"] = (fastmath if (
        isinstance(fastmath, _ods_ir.Attribute) or
        not _ods_ir.AttrBuilder.contains('arith.Arith_FastMathAttr')) else
          _ods_ir.AttrBuilder.get('arith.Arith_FastMathAttr')(fastmath, context=_ods_context))
    if results is None: results = [operands[0].type] * 1
    _ods_successors = None
    super().__init__(self.OPERATION_NAME, self._ODS_REGIONS, self._ODS_OPERAND_SEGMENTS, self._ODS_RESULT_SEGMENTS, attributes=attributes, results=results, operands=operands, successors=_ods_successors, regions=regions, loc=loc, ip=ip)

  @builtins.property
  def operand(self) -> _ods_ir.Value:
    return self.operation.operands[0]

  @builtins.property
  def fastmath(self) -> _ods_ir.Attribute:
    return self.operation.attributes["fastmath"]

  @fastmath.setter
  def fastmath(self, value: _ods_ir.Attribute):
    if value is None:
      raise ValueError("'None' not allowed as value for mandatory attributes")
    self.operation.attributes["fastmath"] = value

  @builtins.property
  def result(self) -> _ods_ir.OpResult:
    return self.operation.results[0]

@_ods_cext.register_op_adaptor(LogOp)
class LogOpAdaptor(_ods_ir.OpAdaptor):
  OPERATION_NAME = "math.log"

  @builtins.property
  def operand(self) -> _ods_ir.Value:
    return self.operands[0]

  @builtins.property
  def fastmath(self) -> _ods_ir.Attribute:
    return self.attributes["fastmath"]

def log(operand: _ods_ir.Value, *, fastmath: _Optional[_Union[_Any, _ods_ir.Attribute]] = None, results: _Optional[_Sequence[_ods_ir.Type]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None) -> _ods_ir.OpResult:
  return LogOp(operand=operand, fastmath=fastmath, results=results, loc=loc, ip=ip).result

@_ods_cext.register_operation(_Dialect)
class PowFOp(_ods_ir.OpView):
  r"""
  The `powf` operation takes two operands of floating point type (i.e.,
  scalar, tensor or vector) and returns one result of the same type. Operands
  must have the same type.
  
  Example:
  
  ```mlir
  // Scalar exponentiation.
  %a = math.powf %b, %c : f64
  ```
  """

  OPERATION_NAME = "math.powf"

  _ODS_REGIONS = (0, True)

  def __init__(self, lhs: _ods_ir.Value, rhs: _ods_ir.Value, *, fastmath: _Optional[_Union[_Any, _ods_ir.Attribute]] = None, results: _Optional[_Sequence[_ods_ir.Type]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None):
    operands = []
    attributes = {}
    regions = None
    operands.append(lhs)
    operands.append(rhs)
    _ods_context = _ods_get_default_loc_context(loc)
    if fastmath is not None: attributes["fastmath"] = (fastmath if (
        isinstance(fastmath, _ods_ir.Attribute) or
        not _ods_ir.AttrBuilder.contains('arith.Arith_FastMathAttr')) else
          _ods_ir.AttrBuilder.get('arith.Arith_FastMathAttr')(fastmath, context=_ods_context))
    if results is None: results = [operands[0].type] * 1
    _ods_successors = None
    super().__init__(self.OPERATION_NAME, self._ODS_REGIONS, self._ODS_OPERAND_SEGMENTS, self._ODS_RESULT_SEGMENTS, attributes=attributes, results=results, operands=operands, successors=_ods_successors, regions=regions, loc=loc, ip=ip)

  @builtins.property
  def lhs(self) -> _ods_ir.Value:
    return self.operation.operands[0]

  @builtins.property
  def rhs(self) -> _ods_ir.Value:
    return self.operation.operands[1]

  @builtins.property
  def fastmath(self) -> _ods_ir.Attribute:
    return self.operation.attributes["fastmath"]

  @fastmath.setter
  def fastmath(self, value: _ods_ir.Attribute):
    if value is None:
      raise ValueError("'None' not allowed as value for mandatory attributes")
    self.operation.attributes["fastmath"] = value

  @builtins.property
  def result(self) -> _ods_ir.OpResult:
    return self.operation.results[0]

@_ods_cext.register_op_adaptor(PowFOp)
class PowFOpAdaptor(_ods_ir.OpAdaptor):
  OPERATION_NAME = "math.powf"

  @builtins.property
  def lhs(self) -> _ods_ir.Value:
    return self.operands[0]

  @builtins.property
  def rhs(self) -> _ods_ir.Value:
    return self.operands[1]

  @builtins.property
  def fastmath(self) -> _ods_ir.Attribute:
    return self.attributes["fastmath"]

def powf(lhs: _ods_ir.Value, rhs: _ods_ir.Value, *, fastmath: _Optional[_Union[_Any, _ods_ir.Attribute]] = None, results: _Optional[_Sequence[_ods_ir.Type]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None) -> _ods_ir.OpResult:
  return PowFOp(lhs=lhs, rhs=rhs, fastmath=fastmath, results=results, loc=loc, ip=ip).result

@_ods_cext.register_operation(_Dialect)
class RoundEvenOp(_ods_ir.OpView):
  r"""
  The `roundeven` operation returns the operand rounded to the nearest integer
  value in floating-point format. It takes one operand of floating point type
  (i.e., scalar, tensor or vector) and produces one result of the same type.  The
  operation rounds the argument to the nearest integer value in floating-point
  format, rounding halfway cases to even, regardless of the current
  rounding direction.
  
  Example:
  
  ```mlir
  // Scalar round operation.
  %a = math.roundeven %b : f64
  ```
  """

  OPERATION_NAME = "math.roundeven"

  _ODS_REGIONS = (0, True)

  def __init__(self, operand: _ods_ir.Value, *, fastmath: _Optional[_Union[_Any, _ods_ir.Attribute]] = None, results: _Optional[_Sequence[_ods_ir.Type]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None):
    operands = []
    attributes = {}
    regions = None
    operands.append(operand)
    _ods_context = _ods_get_default_loc_context(loc)
    if fastmath is not None: attributes["fastmath"] = (fastmath if (
        isinstance(fastmath, _ods_ir.Attribute) or
        not _ods_ir.AttrBuilder.contains('arith.Arith_FastMathAttr')) else
          _ods_ir.AttrBuilder.get('arith.Arith_FastMathAttr')(fastmath, context=_ods_context))
    if results is None: results = [operands[0].type] * 1
    _ods_successors = None
    super().__init__(self.OPERATION_NAME, self._ODS_REGIONS, self._ODS_OPERAND_SEGMENTS, self._ODS_RESULT_SEGMENTS, attributes=attributes, results=results, operands=operands, successors=_ods_successors, regions=regions, loc=loc, ip=ip)

  @builtins.property
  def operand(self) -> _ods_ir.Value:
    return self.operation.operands[0]

  @builtins.property
  def fastmath(self) -> _ods_ir.Attribute:
    return self.operation.attributes["fastmath"]

  @fastmath.setter
  def fastmath(self, value: _ods_ir.Attribute):
    if value is None:
      raise ValueError("'None' not allowed as value for mandatory attributes")
    self.operation.attributes["fastmath"] = value

  @builtins.property
  def result(self) -> _ods_ir.OpResult:
    return self.operation.results[0]

@_ods_cext.register_op_adaptor(RoundEvenOp)
class RoundEvenOpAdaptor(_ods_ir.OpAdaptor):
  OPERATION_NAME = "math.roundeven"

  @builtins.property
  def operand(self) -> _ods_ir.Value:
    return self.operands[0]

  @builtins.property
  def fastmath(self) -> _ods_ir.Attribute:
    return self.attributes["fastmath"]

def roundeven(operand: _ods_ir.Value, *, fastmath: _Optional[_Union[_Any, _ods_ir.Attribute]] = None, results: _Optional[_Sequence[_ods_ir.Type]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None) -> _ods_ir.OpResult:
  return RoundEvenOp(operand=operand, fastmath=fastmath, results=results, loc=loc, ip=ip).result

@_ods_cext.register_operation(_Dialect)
class RoundOp(_ods_ir.OpView):
  r"""
  The `round` operation returns the operand rounded to the nearest integer
  value in floating-point format. It takes one operand of floating point type
  (i.e., scalar, tensor or vector) and produces one result of the same type.  The
  operation rounds the argument to the nearest integer value in floating-point
  format, rounding halfway cases away from zero, regardless of the current
  rounding direction.
  
  Example:
  
  ```mlir
  // Scalar round operation.
  %a = math.round %b : f64
  ```
  """

  OPERATION_NAME = "math.round"

  _ODS_REGIONS = (0, True)

  def __init__(self, operand: _ods_ir.Value, *, fastmath: _Optional[_Union[_Any, _ods_ir.Attribute]] = None, results: _Optional[_Sequence[_ods_ir.Type]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None):
    operands = []
    attributes = {}
    regions = None
    operands.append(operand)
    _ods_context = _ods_get_default_loc_context(loc)
    if fastmath is not None: attributes["fastmath"] = (fastmath if (
        isinstance(fastmath, _ods_ir.Attribute) or
        not _ods_ir.AttrBuilder.contains('arith.Arith_FastMathAttr')) else
          _ods_ir.AttrBuilder.get('arith.Arith_FastMathAttr')(fastmath, context=_ods_context))
    if results is None: results = [operands[0].type] * 1
    _ods_successors = None
    super().__init__(self.OPERATION_NAME, self._ODS_REGIONS, self._ODS_OPERAND_SEGMENTS, self._ODS_RESULT_SEGMENTS, attributes=attributes, results=results, operands=operands, successors=_ods_successors, regions=regions, loc=loc, ip=ip)

  @builtins.property
  def operand(self) -> _ods_ir.Value:
    return self.operation.operands[0]

  @builtins.property
  def fastmath(self) -> _ods_ir.Attribute:
    return self.operation.attributes["fastmath"]

  @fastmath.setter
  def fastmath(self, value: _ods_ir.Attribute):
    if value is None:
      raise ValueError("'None' not allowed as value for mandatory attributes")
    self.operation.attributes["fastmath"] = value

  @builtins.property
  def result(self) -> _ods_ir.OpResult:
    return self.operation.results[0]

@_ods_cext.register_op_adaptor(RoundOp)
class RoundOpAdaptor(_ods_ir.OpAdaptor):
  OPERATION_NAME = "math.round"

  @builtins.property
  def operand(self) -> _ods_ir.Value:
    return self.operands[0]

  @builtins.property
  def fastmath(self) -> _ods_ir.Attribute:
    return self.attributes["fastmath"]

def round(operand: _ods_ir.Value, *, fastmath: _Optional[_Union[_Any, _ods_ir.Attribute]] = None, results: _Optional[_Sequence[_ods_ir.Type]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None) -> _ods_ir.OpResult:
  return RoundOp(operand=operand, fastmath=fastmath, results=results, loc=loc, ip=ip).result

@_ods_cext.register_operation(_Dialect)
class RsqrtOp(_ods_ir.OpView):
  r"""
  The `rsqrt` operation computes the reciprocal of the square root. It takes
  one operand of floating point type (i.e., scalar, tensor or vector) and returns
  one result of the same type. It has no standard attributes.
  
  Example:
  
  ```mlir
  // Scalar reciprocal square root value.
  %a = math.rsqrt %b : f64
  ```
  """

  OPERATION_NAME = "math.rsqrt"

  _ODS_REGIONS = (0, True)

  def __init__(self, operand: _ods_ir.Value, *, fastmath: _Optional[_Union[_Any, _ods_ir.Attribute]] = None, results: _Optional[_Sequence[_ods_ir.Type]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None):
    operands = []
    attributes = {}
    regions = None
    operands.append(operand)
    _ods_context = _ods_get_default_loc_context(loc)
    if fastmath is not None: attributes["fastmath"] = (fastmath if (
        isinstance(fastmath, _ods_ir.Attribute) or
        not _ods_ir.AttrBuilder.contains('arith.Arith_FastMathAttr')) else
          _ods_ir.AttrBuilder.get('arith.Arith_FastMathAttr')(fastmath, context=_ods_context))
    if results is None: results = [operands[0].type] * 1
    _ods_successors = None
    super().__init__(self.OPERATION_NAME, self._ODS_REGIONS, self._ODS_OPERAND_SEGMENTS, self._ODS_RESULT_SEGMENTS, attributes=attributes, results=results, operands=operands, successors=_ods_successors, regions=regions, loc=loc, ip=ip)

  @builtins.property
  def operand(self) -> _ods_ir.Value:
    return self.operation.operands[0]

  @builtins.property
  def fastmath(self) -> _ods_ir.Attribute:
    return self.operation.attributes["fastmath"]

  @fastmath.setter
  def fastmath(self, value: _ods_ir.Attribute):
    if value is None:
      raise ValueError("'None' not allowed as value for mandatory attributes")
    self.operation.attributes["fastmath"] = value

  @builtins.property
  def result(self) -> _ods_ir.OpResult:
    return self.operation.results[0]

@_ods_cext.register_op_adaptor(RsqrtOp)
class RsqrtOpAdaptor(_ods_ir.OpAdaptor):
  OPERATION_NAME = "math.rsqrt"

  @builtins.property
  def operand(self) -> _ods_ir.Value:
    return self.operands[0]

  @builtins.property
  def fastmath(self) -> _ods_ir.Attribute:
    return self.attributes["fastmath"]

def rsqrt(operand: _ods_ir.Value, *, fastmath: _Optional[_Union[_Any, _ods_ir.Attribute]] = None, results: _Optional[_Sequence[_ods_ir.Type]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None) -> _ods_ir.OpResult:
  return RsqrtOp(operand=operand, fastmath=fastmath, results=results, loc=loc, ip=ip).result

@_ods_cext.register_operation(_Dialect)
class SinOp(_ods_ir.OpView):
  r"""
  The `sin` operation computes the sine of a given value. It takes one
  operand of floating point type (i.e., scalar, tensor or vector) and returns one
  result of the same type.  It has no standard attributes.
  
  Example:
  
  ```mlir
  // Scalar sine value.
  %a = math.sin %b : f64
  ```
  """

  OPERATION_NAME = "math.sin"

  _ODS_REGIONS = (0, True)

  def __init__(self, operand: _ods_ir.Value, *, fastmath: _Optional[_Union[_Any, _ods_ir.Attribute]] = None, results: _Optional[_Sequence[_ods_ir.Type]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None):
    operands = []
    attributes = {}
    regions = None
    operands.append(operand)
    _ods_context = _ods_get_default_loc_context(loc)
    if fastmath is not None: attributes["fastmath"] = (fastmath if (
        isinstance(fastmath, _ods_ir.Attribute) or
        not _ods_ir.AttrBuilder.contains('arith.Arith_FastMathAttr')) else
          _ods_ir.AttrBuilder.get('arith.Arith_FastMathAttr')(fastmath, context=_ods_context))
    if results is None: results = [operands[0].type] * 1
    _ods_successors = None
    super().__init__(self.OPERATION_NAME, self._ODS_REGIONS, self._ODS_OPERAND_SEGMENTS, self._ODS_RESULT_SEGMENTS, attributes=attributes, results=results, operands=operands, successors=_ods_successors, regions=regions, loc=loc, ip=ip)

  @builtins.property
  def operand(self) -> _ods_ir.Value:
    return self.operation.operands[0]

  @builtins.property
  def fastmath(self) -> _ods_ir.Attribute:
    return self.operation.attributes["fastmath"]

  @fastmath.setter
  def fastmath(self, value: _ods_ir.Attribute):
    if value is None:
      raise ValueError("'None' not allowed as value for mandatory attributes")
    self.operation.attributes["fastmath"] = value

  @builtins.property
  def result(self) -> _ods_ir.OpResult:
    return self.operation.results[0]

@_ods_cext.register_op_adaptor(SinOp)
class SinOpAdaptor(_ods_ir.OpAdaptor):
  OPERATION_NAME = "math.sin"

  @builtins.property
  def operand(self) -> _ods_ir.Value:
    return self.operands[0]

  @builtins.property
  def fastmath(self) -> _ods_ir.Attribute:
    return self.attributes["fastmath"]

def sin(operand: _ods_ir.Value, *, fastmath: _Optional[_Union[_Any, _ods_ir.Attribute]] = None, results: _Optional[_Sequence[_ods_ir.Type]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None) -> _ods_ir.OpResult:
  return SinOp(operand=operand, fastmath=fastmath, results=results, loc=loc, ip=ip).result

@_ods_cext.register_operation(_Dialect)
class SincosOp(_ods_ir.OpView):
  r"""
  The `sincos` operation computes both the sine and cosine of a given value
  simultaneously. It takes one operand of floating point type (i.e., scalar,
  tensor or vector) and returns two results of the same type. This operation
  can be more efficient than computing sine and cosine separately when both
  values are needed.
  
  Example:
  
  ```mlir
  // Scalar sine and cosine values.
  %sin, %cos = math.sincos %input : f64
  ```
  """

  OPERATION_NAME = "math.sincos"

  _ODS_REGIONS = (0, True)

  def __init__(self, operand: _ods_ir.Value, *, fastmath: _Optional[_Union[_Any, _ods_ir.Attribute]] = None, results: _Optional[_Sequence[_ods_ir.Type]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None):
    operands = []
    attributes = {}
    regions = None
    operands.append(operand)
    _ods_context = _ods_get_default_loc_context(loc)
    if fastmath is not None: attributes["fastmath"] = (fastmath if (
        isinstance(fastmath, _ods_ir.Attribute) or
        not _ods_ir.AttrBuilder.contains('arith.Arith_FastMathAttr')) else
          _ods_ir.AttrBuilder.get('arith.Arith_FastMathAttr')(fastmath, context=_ods_context))
    if results is None: results = [operands[0].type] * 2
    _ods_successors = None
    super().__init__(self.OPERATION_NAME, self._ODS_REGIONS, self._ODS_OPERAND_SEGMENTS, self._ODS_RESULT_SEGMENTS, attributes=attributes, results=results, operands=operands, successors=_ods_successors, regions=regions, loc=loc, ip=ip)

  @builtins.property
  def operand(self) -> _ods_ir.Value:
    return self.operation.operands[0]

  @builtins.property
  def fastmath(self) -> _ods_ir.Attribute:
    return self.operation.attributes["fastmath"]

  @fastmath.setter
  def fastmath(self, value: _ods_ir.Attribute):
    if value is None:
      raise ValueError("'None' not allowed as value for mandatory attributes")
    self.operation.attributes["fastmath"] = value

  @builtins.property
  def sin(self) -> _ods_ir.OpResult:
    return self.operation.results[0]

  @builtins.property
  def cos(self) -> _ods_ir.OpResult:
    return self.operation.results[1]

@_ods_cext.register_op_adaptor(SincosOp)
class SincosOpAdaptor(_ods_ir.OpAdaptor):
  OPERATION_NAME = "math.sincos"

  @builtins.property
  def operand(self) -> _ods_ir.Value:
    return self.operands[0]

  @builtins.property
  def fastmath(self) -> _ods_ir.Attribute:
    return self.attributes["fastmath"]

def sincos(operand: _ods_ir.Value, *, fastmath: _Optional[_Union[_Any, _ods_ir.Attribute]] = None, results: _Optional[_Sequence[_ods_ir.Type]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None) -> _ods_ir.OpResultList:
  return SincosOp(operand=operand, fastmath=fastmath, results=results, loc=loc, ip=ip).results

@_ods_cext.register_operation(_Dialect)
class SinhOp(_ods_ir.OpView):
  r"""
  The `sinh` operation computes the hyperbolic sine. It takes one operand
  of floating point type (i.e., scalar, tensor or vector) and returns one
  result of the same type. It has no standard attributes.
  
  Example:
  
  ```mlir
  // Scalar hyperbolic sine value.
  %a = math.sinh %b : f64
  ```
  """

  OPERATION_NAME = "math.sinh"

  _ODS_REGIONS = (0, True)

  def __init__(self, operand: _ods_ir.Value, *, fastmath: _Optional[_Union[_Any, _ods_ir.Attribute]] = None, results: _Optional[_Sequence[_ods_ir.Type]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None):
    operands = []
    attributes = {}
    regions = None
    operands.append(operand)
    _ods_context = _ods_get_default_loc_context(loc)
    if fastmath is not None: attributes["fastmath"] = (fastmath if (
        isinstance(fastmath, _ods_ir.Attribute) or
        not _ods_ir.AttrBuilder.contains('arith.Arith_FastMathAttr')) else
          _ods_ir.AttrBuilder.get('arith.Arith_FastMathAttr')(fastmath, context=_ods_context))
    if results is None: results = [operands[0].type] * 1
    _ods_successors = None
    super().__init__(self.OPERATION_NAME, self._ODS_REGIONS, self._ODS_OPERAND_SEGMENTS, self._ODS_RESULT_SEGMENTS, attributes=attributes, results=results, operands=operands, successors=_ods_successors, regions=regions, loc=loc, ip=ip)

  @builtins.property
  def operand(self) -> _ods_ir.Value:
    return self.operation.operands[0]

  @builtins.property
  def fastmath(self) -> _ods_ir.Attribute:
    return self.operation.attributes["fastmath"]

  @fastmath.setter
  def fastmath(self, value: _ods_ir.Attribute):
    if value is None:
      raise ValueError("'None' not allowed as value for mandatory attributes")
    self.operation.attributes["fastmath"] = value

  @builtins.property
  def result(self) -> _ods_ir.OpResult:
    return self.operation.results[0]

@_ods_cext.register_op_adaptor(SinhOp)
class SinhOpAdaptor(_ods_ir.OpAdaptor):
  OPERATION_NAME = "math.sinh"

  @builtins.property
  def operand(self) -> _ods_ir.Value:
    return self.operands[0]

  @builtins.property
  def fastmath(self) -> _ods_ir.Attribute:
    return self.attributes["fastmath"]

def sinh(operand: _ods_ir.Value, *, fastmath: _Optional[_Union[_Any, _ods_ir.Attribute]] = None, results: _Optional[_Sequence[_ods_ir.Type]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None) -> _ods_ir.OpResult:
  return SinhOp(operand=operand, fastmath=fastmath, results=results, loc=loc, ip=ip).result

@_ods_cext.register_operation(_Dialect)
class SqrtOp(_ods_ir.OpView):
  r"""
  The `sqrt` operation computes the square root. It takes one operand of
  floating point type (i.e., scalar, tensor or vector) and returns one result of
  the same type. It has no standard attributes.
  
  Example:
  
  ```mlir
  // Scalar square root value.
  %a = math.sqrt %b : f64
  ```
  """

  OPERATION_NAME = "math.sqrt"

  _ODS_REGIONS = (0, True)

  def __init__(self, operand: _ods_ir.Value, *, fastmath: _Optional[_Union[_Any, _ods_ir.Attribute]] = None, results: _Optional[_Sequence[_ods_ir.Type]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None):
    operands = []
    attributes = {}
    regions = None
    operands.append(operand)
    _ods_context = _ods_get_default_loc_context(loc)
    if fastmath is not None: attributes["fastmath"] = (fastmath if (
        isinstance(fastmath, _ods_ir.Attribute) or
        not _ods_ir.AttrBuilder.contains('arith.Arith_FastMathAttr')) else
          _ods_ir.AttrBuilder.get('arith.Arith_FastMathAttr')(fastmath, context=_ods_context))
    if results is None: results = [operands[0].type] * 1
    _ods_successors = None
    super().__init__(self.OPERATION_NAME, self._ODS_REGIONS, self._ODS_OPERAND_SEGMENTS, self._ODS_RESULT_SEGMENTS, attributes=attributes, results=results, operands=operands, successors=_ods_successors, regions=regions, loc=loc, ip=ip)

  @builtins.property
  def operand(self) -> _ods_ir.Value:
    return self.operation.operands[0]

  @builtins.property
  def fastmath(self) -> _ods_ir.Attribute:
    return self.operation.attributes["fastmath"]

  @fastmath.setter
  def fastmath(self, value: _ods_ir.Attribute):
    if value is None:
      raise ValueError("'None' not allowed as value for mandatory attributes")
    self.operation.attributes["fastmath"] = value

  @builtins.property
  def result(self) -> _ods_ir.OpResult:
    return self.operation.results[0]

@_ods_cext.register_op_adaptor(SqrtOp)
class SqrtOpAdaptor(_ods_ir.OpAdaptor):
  OPERATION_NAME = "math.sqrt"

  @builtins.property
  def operand(self) -> _ods_ir.Value:
    return self.operands[0]

  @builtins.property
  def fastmath(self) -> _ods_ir.Attribute:
    return self.attributes["fastmath"]

def sqrt(operand: _ods_ir.Value, *, fastmath: _Optional[_Union[_Any, _ods_ir.Attribute]] = None, results: _Optional[_Sequence[_ods_ir.Type]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None) -> _ods_ir.OpResult:
  return SqrtOp(operand=operand, fastmath=fastmath, results=results, loc=loc, ip=ip).result

@_ods_cext.register_operation(_Dialect)
class TanOp(_ods_ir.OpView):
  r"""
  The `tan` operation computes the tangent. It takes one operand
  of floating point type (i.e., scalar, tensor or vector) and returns one
  result of the same type. It has no standard attributes.
  
  Example:
  
  ```mlir
  // Scalar tangent value.
  %a = math.tan %b : f64
  ```
  """

  OPERATION_NAME = "math.tan"

  _ODS_REGIONS = (0, True)

  def __init__(self, operand: _ods_ir.Value, *, fastmath: _Optional[_Union[_Any, _ods_ir.Attribute]] = None, results: _Optional[_Sequence[_ods_ir.Type]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None):
    operands = []
    attributes = {}
    regions = None
    operands.append(operand)
    _ods_context = _ods_get_default_loc_context(loc)
    if fastmath is not None: attributes["fastmath"] = (fastmath if (
        isinstance(fastmath, _ods_ir.Attribute) or
        not _ods_ir.AttrBuilder.contains('arith.Arith_FastMathAttr')) else
          _ods_ir.AttrBuilder.get('arith.Arith_FastMathAttr')(fastmath, context=_ods_context))
    if results is None: results = [operands[0].type] * 1
    _ods_successors = None
    super().__init__(self.OPERATION_NAME, self._ODS_REGIONS, self._ODS_OPERAND_SEGMENTS, self._ODS_RESULT_SEGMENTS, attributes=attributes, results=results, operands=operands, successors=_ods_successors, regions=regions, loc=loc, ip=ip)

  @builtins.property
  def operand(self) -> _ods_ir.Value:
    return self.operation.operands[0]

  @builtins.property
  def fastmath(self) -> _ods_ir.Attribute:
    return self.operation.attributes["fastmath"]

  @fastmath.setter
  def fastmath(self, value: _ods_ir.Attribute):
    if value is None:
      raise ValueError("'None' not allowed as value for mandatory attributes")
    self.operation.attributes["fastmath"] = value

  @builtins.property
  def result(self) -> _ods_ir.OpResult:
    return self.operation.results[0]

@_ods_cext.register_op_adaptor(TanOp)
class TanOpAdaptor(_ods_ir.OpAdaptor):
  OPERATION_NAME = "math.tan"

  @builtins.property
  def operand(self) -> _ods_ir.Value:
    return self.operands[0]

  @builtins.property
  def fastmath(self) -> _ods_ir.Attribute:
    return self.attributes["fastmath"]

def tan(operand: _ods_ir.Value, *, fastmath: _Optional[_Union[_Any, _ods_ir.Attribute]] = None, results: _Optional[_Sequence[_ods_ir.Type]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None) -> _ods_ir.OpResult:
  return TanOp(operand=operand, fastmath=fastmath, results=results, loc=loc, ip=ip).result

@_ods_cext.register_operation(_Dialect)
class TanhOp(_ods_ir.OpView):
  r"""
  The `tanh` operation computes the hyperbolic tangent. It takes one operand
  of floating point type (i.e., scalar, tensor or vector) and returns one
  result of the same type. It has no standard attributes.
  
  Example:
  
  ```mlir
  // Scalar hyperbolic tangent value.
  %a = math.tanh %b : f64
  ```
  """

  OPERATION_NAME = "math.tanh"

  _ODS_REGIONS = (0, True)

  def __init__(self, operand: _ods_ir.Value, *, fastmath: _Optional[_Union[_Any, _ods_ir.Attribute]] = None, results: _Optional[_Sequence[_ods_ir.Type]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None):
    operands = []
    attributes = {}
    regions = None
    operands.append(operand)
    _ods_context = _ods_get_default_loc_context(loc)
    if fastmath is not None: attributes["fastmath"] = (fastmath if (
        isinstance(fastmath, _ods_ir.Attribute) or
        not _ods_ir.AttrBuilder.contains('arith.Arith_FastMathAttr')) else
          _ods_ir.AttrBuilder.get('arith.Arith_FastMathAttr')(fastmath, context=_ods_context))
    if results is None: results = [operands[0].type] * 1
    _ods_successors = None
    super().__init__(self.OPERATION_NAME, self._ODS_REGIONS, self._ODS_OPERAND_SEGMENTS, self._ODS_RESULT_SEGMENTS, attributes=attributes, results=results, operands=operands, successors=_ods_successors, regions=regions, loc=loc, ip=ip)

  @builtins.property
  def operand(self) -> _ods_ir.Value:
    return self.operation.operands[0]

  @builtins.property
  def fastmath(self) -> _ods_ir.Attribute:
    return self.operation.attributes["fastmath"]

  @fastmath.setter
  def fastmath(self, value: _ods_ir.Attribute):
    if value is None:
      raise ValueError("'None' not allowed as value for mandatory attributes")
    self.operation.attributes["fastmath"] = value

  @builtins.property
  def result(self) -> _ods_ir.OpResult:
    return self.operation.results[0]

@_ods_cext.register_op_adaptor(TanhOp)
class TanhOpAdaptor(_ods_ir.OpAdaptor):
  OPERATION_NAME = "math.tanh"

  @builtins.property
  def operand(self) -> _ods_ir.Value:
    return self.operands[0]

  @builtins.property
  def fastmath(self) -> _ods_ir.Attribute:
    return self.attributes["fastmath"]

def tanh(operand: _ods_ir.Value, *, fastmath: _Optional[_Union[_Any, _ods_ir.Attribute]] = None, results: _Optional[_Sequence[_ods_ir.Type]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None) -> _ods_ir.OpResult:
  return TanhOp(operand=operand, fastmath=fastmath, results=results, loc=loc, ip=ip).result

@_ods_cext.register_operation(_Dialect)
class TruncOp(_ods_ir.OpView):
  r"""
  The `trunc` operation returns the operand rounded to the nearest integer
  value in floating-point format. It takes one operand of floating point type
  (i.e., scalar, tensor or vector) and produces one result of the same type.
  The operation always rounds to the nearest integer not larger in magnitude
  than the operand, regardless of the current rounding direction.
  
  Example:
  
  ```mlir
  // Scalar trunc operation.
  %a = math.trunc %b : f64
  ```
  """

  OPERATION_NAME = "math.trunc"

  _ODS_REGIONS = (0, True)

  def __init__(self, operand: _ods_ir.Value, *, fastmath: _Optional[_Union[_Any, _ods_ir.Attribute]] = None, results: _Optional[_Sequence[_ods_ir.Type]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None):
    operands = []
    attributes = {}
    regions = None
    operands.append(operand)
    _ods_context = _ods_get_default_loc_context(loc)
    if fastmath is not None: attributes["fastmath"] = (fastmath if (
        isinstance(fastmath, _ods_ir.Attribute) or
        not _ods_ir.AttrBuilder.contains('arith.Arith_FastMathAttr')) else
          _ods_ir.AttrBuilder.get('arith.Arith_FastMathAttr')(fastmath, context=_ods_context))
    if results is None: results = [operands[0].type] * 1
    _ods_successors = None
    super().__init__(self.OPERATION_NAME, self._ODS_REGIONS, self._ODS_OPERAND_SEGMENTS, self._ODS_RESULT_SEGMENTS, attributes=attributes, results=results, operands=operands, successors=_ods_successors, regions=regions, loc=loc, ip=ip)

  @builtins.property
  def operand(self) -> _ods_ir.Value:
    return self.operation.operands[0]

  @builtins.property
  def fastmath(self) -> _ods_ir.Attribute:
    return self.operation.attributes["fastmath"]

  @fastmath.setter
  def fastmath(self, value: _ods_ir.Attribute):
    if value is None:
      raise ValueError("'None' not allowed as value for mandatory attributes")
    self.operation.attributes["fastmath"] = value

  @builtins.property
  def result(self) -> _ods_ir.OpResult:
    return self.operation.results[0]

@_ods_cext.register_op_adaptor(TruncOp)
class TruncOpAdaptor(_ods_ir.OpAdaptor):
  OPERATION_NAME = "math.trunc"

  @builtins.property
  def operand(self) -> _ods_ir.Value:
    return self.operands[0]

  @builtins.property
  def fastmath(self) -> _ods_ir.Attribute:
    return self.attributes["fastmath"]

def trunc(operand: _ods_ir.Value, *, fastmath: _Optional[_Union[_Any, _ods_ir.Attribute]] = None, results: _Optional[_Sequence[_ods_ir.Type]] = None, loc: _Optional[_ods_ir.Location] = None, ip: _Optional[_ods_ir.InsertionPoint] = None) -> _ods_ir.OpResult:
  return TruncOp(operand=operand, fastmath=fastmath, results=results, loc=loc, ip=ip).result
