'math' Dialect

The math dialect is intended to hold mathematical operations on integer and floating type beyond simple arithmetics.

Operation definition ¶

math.abs (::mlir::math::AbsOp) ¶

floating point absolute-value operation

Syntax:

operation ::= `math.abs` $operand attr-dict `:` type($result)

The abs operation computes the absolute value. It takes one operand and returns one result of the same type. This type may be a float scalar type, a vector whose element type is float, or a tensor of floats.

Example:

// Scalar absolute value.
%a = math.abs %b : f64

// SIMD vector element-wise absolute value.
%f = math.abs %g : vector<4xf32>

// Tensor element-wise absolute value.
%x = math.abs %y : tensor<4x?xf8>

Traits: Elementwise, SameOperandsAndResultType, Scalarizable, Tensorizable, Vectorizable

Interfaces: InferTypeOpInterface, NoSideEffect (MemoryEffectOpInterface), VectorUnrollOpInterface

Effects: MemoryEffects::Effect{}

Operands: ¶

Results: ¶

math.atan2 (::mlir::math::Atan2Op) ¶

2-argument arcus tangent of the given values

Syntax:

operation ::= `math.atan2` $lhs `,` $rhs attr-dict `:` type($result)

Syntax:

operation ::= ssa-id `=` `math.atan2` ssa-use `,` ssa-use `:` type

The atan2 operation takes two operands and returns one result, all of which must be of the same type. This type may be a floating point scalar type, a vector whose element type is a floating point type, or a floating point tensor.

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:

// Scalar variant.
%a = math.atan2 %b, %c : f32

// SIMD vector variant.
%f = math.atan2 %g, %h : vector<4xf32>

// Tensor variant.
%x = math.atan2 %y, %z : tensor<4x?xf32>

Traits: Elementwise, SameOperandsAndResultType, Scalarizable, Tensorizable, Vectorizable

Interfaces: InferTypeOpInterface, NoSideEffect (MemoryEffectOpInterface), VectorUnrollOpInterface

Effects: MemoryEffects::Effect{}

Operands: ¶

Results: ¶

math.atan (::mlir::math::AtanOp) ¶

arcus tangent of the given value

Syntax:

operation ::= `math.atan` $operand attr-dict `:` type($result)

Syntax:

operation ::= ssa-id `=` `math.atan` ssa-use `:` type

The atan operation computes the arcus tangent of a given value. It takes one operand and returns one result of the same type. This type may be a float scalar type, a vector whose element type is float, or a tensor of floats. It has no standard attributes.

Example:

// Arcus tangent of scalar value.
%a = math.atan %b : f64

// SIMD vector element-wise arcus tangent.
%f = math.atan %g : vector<4xf32>

// Tensor element-wise arcus tangent.
%x = math.atan %y : tensor<4x?xf8>

Traits: Elementwise, SameOperandsAndResultType, Scalarizable, Tensorizable, Vectorizable

Interfaces: InferTypeOpInterface, NoSideEffect (MemoryEffectOpInterface), VectorUnrollOpInterface

Effects: MemoryEffects::Effect{}

Operands: ¶

Results: ¶

math.ceil (::mlir::math::CeilOp) ¶

ceiling of the specified value

Syntax:

operation ::= `math.ceil` $operand attr-dict `:` type($result)

Syntax:

operation ::= ssa-id `=` `math.ceil` ssa-use `:` type

The ceil operation computes the ceiling of a given value. It takes one operand and returns one result of the same type. This type may be a float scalar type, a vector whose element type is float, or a tensor of floats. It has no standard attributes.

Example:

// Scalar ceiling value.
%a = math.ceil %b : f64

// SIMD vector element-wise ceiling value.
%f = math.ceil %g : vector<4xf32>

// Tensor element-wise ceiling value.
%x = math.ceil %y : tensor<4x?xf8>

Traits: Elementwise, SameOperandsAndResultType, Scalarizable, Tensorizable, Vectorizable

Interfaces: InferTypeOpInterface, NoSideEffect (MemoryEffectOpInterface), VectorUnrollOpInterface

Effects: MemoryEffects::Effect{}

Operands: ¶

Results: ¶

math.copysign (::mlir::math::CopySignOp) ¶

A copysign operation

Syntax:

operation ::= `math.copysign` $lhs `,` $rhs attr-dict `:` type($result)

Syntax:

operation ::= ssa-id `=` `math.copysign` ssa-use `,` ssa-use `:` type

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. This type may be a float scalar type, a vector whose element type is float, or a tensor of floats. It has no standard attributes.

Example:

// Scalar copysign value.
%a = math.copysign %b, %c : f64

// SIMD vector element-wise copysign value.
%f = math.copysign %g, %h : vector<4xf32>

// Tensor element-wise copysign value.
%x = math.copysign %y, %z : tensor<4x?xf8>

Traits: Elementwise, SameOperandsAndResultType, Scalarizable, Tensorizable, Vectorizable

Interfaces: InferTypeOpInterface, NoSideEffect (MemoryEffectOpInterface), VectorUnrollOpInterface

Effects: MemoryEffects::Effect{}

Operands: ¶

Results: ¶

math.cos (::mlir::math::CosOp) ¶

cosine of the specified value

Syntax:

operation ::= `math.cos` $operand attr-dict `:` type($result)

Syntax:

operation ::= ssa-id `=` `math.cos` ssa-use `:` type

The cos operation computes the cosine of a given value. It takes one operand and returns one result of the same type. This type may be a float scalar type, a vector whose element type is float, or a tensor of floats. It has no standard attributes.

Example:

// Scalar cosine value.
%a = math.cos %b : f64

// SIMD vector element-wise cosine value.
%f = math.cos %g : vector<4xf32>

// Tensor element-wise cosine value.
%x = math.cos %y : tensor<4x?xf8>

Traits: Elementwise, SameOperandsAndResultType, Scalarizable, Tensorizable, Vectorizable

Interfaces: InferTypeOpInterface, NoSideEffect (MemoryEffectOpInterface), VectorUnrollOpInterface

Effects: MemoryEffects::Effect{}

Operands: ¶

Results: ¶

math.ctlz (::mlir::math::CountLeadingZerosOp) ¶

counts the leading zeros an integer value

Syntax:

operation ::= `math.ctlz` $operand attr-dict `:` type($result)

The ctlz operation computes the number of leading zeros of an integer value.

Example:

// Scalar ctlz function value.
%a = math.ctlz %b : i32

// SIMD vector element-wise ctlz function value.
%f = math.ctlz %g : vector<4xi16>

// Tensor element-wise ctlz function value.
%x = math.ctlz %y : tensor<4x?xi8>

Traits: Elementwise, SameOperandsAndResultType, Scalarizable, Tensorizable, Vectorizable

Interfaces: InferTypeOpInterface, NoSideEffect (MemoryEffectOpInterface), VectorUnrollOpInterface

Effects: MemoryEffects::Effect{}

Operands: ¶

Results: ¶

math.cttz (::mlir::math::CountTrailingZerosOp) ¶

counts the trailing zeros an integer value

Syntax:

operation ::= `math.cttz` $operand attr-dict `:` type($result)

The cttz operation computes the number of trailing zeros of an integer value.

Example:

// Scalar cttz function value.
%a = math.cttz %b : i32

// SIMD vector element-wise cttz function value.
%f = math.cttz %g : vector<4xi16>

// Tensor element-wise cttz function value.
%x = math.cttz %y : tensor<4x?xi8>

Traits: Elementwise, SameOperandsAndResultType, Scalarizable, Tensorizable, Vectorizable

Interfaces: InferTypeOpInterface, NoSideEffect (MemoryEffectOpInterface), VectorUnrollOpInterface

Effects: MemoryEffects::Effect{}

Operands: ¶

Results: ¶

math.ctpop (::mlir::math::CtPopOp) ¶

counts the number of set bits of an integer value

Syntax:

operation ::= `math.ctpop` $operand attr-dict `:` type($result)

The ctpop operation computes the number of set bits of an integer value.

Example:

// Scalar ctpop function value.
%a = math.ctpop %b : i32

// SIMD vector element-wise ctpop function value.
%f = math.ctpop %g : vector<4xi16>

// Tensor element-wise ctpop function value.
%x = math.ctpop %y : tensor<4x?xi8>

Traits: Elementwise, SameOperandsAndResultType, Scalarizable, Tensorizable, Vectorizable

Interfaces: InferTypeOpInterface, NoSideEffect (MemoryEffectOpInterface), VectorUnrollOpInterface

Effects: MemoryEffects::Effect{}

Operands: ¶

Results: ¶

math.erf (::mlir::math::ErfOp) ¶

error function of the specified value

Syntax:

operation ::= `math.erf` $operand attr-dict `:` type($result)

Syntax:

operation ::= ssa-id `=` `math.erf` ssa-use `:` type

The erf operation computes the error function. It takes one operand and returns one result of the same type. This type may be a float scalar type, a vector whose element type is float, or a tensor of floats. It has no standard attributes.

Example:

// Scalar error function value.
%a = math.erf %b : f64

// SIMD vector element-wise error function value.
%f = math.erf %g : vector<4xf32>

// Tensor element-wise error function value.
%x = math.erf %y : tensor<4x?xf8>

Traits: Elementwise, SameOperandsAndResultType, Scalarizable, Tensorizable, Vectorizable

Interfaces: InferTypeOpInterface, NoSideEffect (MemoryEffectOpInterface), VectorUnrollOpInterface

Effects: MemoryEffects::Effect{}

Operands: ¶

Results: ¶

math.exp2 (::mlir::math::Exp2Op) ¶

base-2 exponential of the specified value

Syntax:

operation ::= `math.exp2` $operand attr-dict `:` type($result)

Syntax:

operation ::= ssa-id `=` `math.exp2` ssa-use `:` type

The exp operation takes one operand and returns one result of the same type. This type may be a float scalar type, a vector whose element type is float, or a tensor of floats. It has no standard attributes.

Example:

// Scalar natural exponential.
%a = math.exp2 %b : f64

// SIMD vector element-wise natural exponential.
%f = math.exp2 %g : vector<4xf32>

// Tensor element-wise natural exponential.
%x = math.exp2 %y : tensor<4x?xf8>

Traits: Elementwise, SameOperandsAndResultType, Scalarizable, Tensorizable, Vectorizable

Interfaces: InferTypeOpInterface, NoSideEffect (MemoryEffectOpInterface), VectorUnrollOpInterface

Effects: MemoryEffects::Effect{}

Operands: ¶

Results: ¶

math.expm1 (::mlir::math::ExpM1Op) ¶

base-e exponential of the specified value minus 1

Syntax:

operation ::= `math.expm1` $operand attr-dict `:` type($result)

Syntax:

operation ::= ssa-id `=` `math.expm1` ssa-use `:` type

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

The expm1 operation takes one operand and returns one result of the same type. This type may be a float scalar type, a vector whose element type is float, or a tensor of floats. It has no standard attributes.

Example:

// Scalar natural exponential minus 1.
%a = math.expm1 %b : f64

// SIMD vector element-wise natural exponential minus 1.
%f = math.expm1 %g : vector<4xf32>

// Tensor element-wise natural exponential minus 1.
%x = math.expm1 %y : tensor<4x?xf8>

Traits: Elementwise, SameOperandsAndResultType, Scalarizable, Tensorizable, Vectorizable

Interfaces: InferTypeOpInterface, NoSideEffect (MemoryEffectOpInterface), VectorUnrollOpInterface

Effects: MemoryEffects::Effect{}

Operands: ¶

Results: ¶

math.exp (::mlir::math::ExpOp) ¶

base-e exponential of the specified value

Syntax:

operation ::= `math.exp` $operand attr-dict `:` type($result)

Syntax:

operation ::= ssa-id `=` `math.exp` ssa-use `:` type

The exp operation takes one operand and returns one result of the same type. This type may be a float scalar type, a vector whose element type is float, or a tensor of floats. It has no standard attributes.

Example:

// Scalar natural exponential.
%a = math.exp %b : f64

// SIMD vector element-wise natural exponential.
%f = math.exp %g : vector<4xf32>

// Tensor element-wise natural exponential.
%x = math.exp %y : tensor<4x?xf8>

Traits: Elementwise, SameOperandsAndResultType, Scalarizable, Tensorizable, Vectorizable

Interfaces: InferTypeOpInterface, NoSideEffect (MemoryEffectOpInterface), VectorUnrollOpInterface

Effects: MemoryEffects::Effect{}

Operands: ¶

Results: ¶

math.floor (::mlir::math::FloorOp) ¶

floor of the specified value

Syntax:

operation ::= `math.floor` $operand attr-dict `:` type($result)

Syntax:

operation ::= ssa-id `=` `math.floor` ssa-use `:` type

The floor operation computes the floor of a given value. It takes one operand and returns one result of the same type. This type may be a float scalar type, a vector whose element type is float, or a tensor of floats. It has no standard attributes.

Example:

// Scalar floor value.
%a = math.floor %b : f64

// SIMD vector element-wise floor value.
%f = math.floor %g : vector<4xf32>

// Tensor element-wise floor value.
%x = math.floor %y : tensor<4x?xf8>

Traits: Elementwise, SameOperandsAndResultType, Scalarizable, Tensorizable, Vectorizable

Interfaces: InferTypeOpInterface, NoSideEffect (MemoryEffectOpInterface), VectorUnrollOpInterface

Effects: MemoryEffects::Effect{}

Operands: ¶

Results: ¶

math.fma (::mlir::math::FmaOp) ¶

floating point fused multipy-add operation

Syntax:

operation ::= `math.fma` $a `,` $b `,` $c attr-dict `:` type($result)

Syntax:

operation ::= ssa-id `=` `math.fma` ssa-use `,` ssa-use `,` ssa-use `:` type

The fma operation takes three operands and returns one result, each of these is required to be the same type. This type may be a floating point scalar type, a vector whose element type is a floating point type, or a floating point tensor.

Example:

// Scalar fused multiply-add: d = a*b + c
%d = math.fma %a, %b, %c : f64

// SIMD vector fused multiply-add, e.g. for Intel SSE.
%i = math.fma %f, %g, %h : vector<4xf32>

// Tensor fused multiply-add.
%w = math.fma %x, %y, %z : tensor<4x?xbf16>

The semantics of the operation correspond to those of the llvm.fma intrinsic. In the particular case of lowering to LLVM, this is guaranteed to lower to the llvm.fma.* intrinsic.

Traits: Elementwise, SameOperandsAndResultType, Scalarizable, Tensorizable, Vectorizable

Interfaces: InferTypeOpInterface, NoSideEffect (MemoryEffectOpInterface), VectorUnrollOpInterface

Effects: MemoryEffects::Effect{}

Operands: ¶

Results: ¶

math.log10 (::mlir::math::Log10Op) ¶

base-10 logarithm of the specified value

Syntax:

operation ::= `math.log10` $operand attr-dict `:` type($result)

Computes the base-10 logarithm of the given value. It takes one operand and returns one result of the same type.

Example:

%y = math.log10 %x : f64

Traits: Elementwise, SameOperandsAndResultType, Scalarizable, Tensorizable, Vectorizable

Interfaces: InferTypeOpInterface, NoSideEffect (MemoryEffectOpInterface), VectorUnrollOpInterface

Effects: MemoryEffects::Effect{}

Operands: ¶

Results: ¶

math.log1p (::mlir::math::Log1pOp) ¶

Computes the natural logarithm of one plus the given value

Syntax:

operation ::= `math.log1p` $operand attr-dict `:` type($result)

Computes the base-e logarithm of one plus the given value. It takes one operand and returns one result of the same type.

log1p(x) := log(1 + x)

Example:

%y = math.log1p %x : f64

Traits: Elementwise, SameOperandsAndResultType, Scalarizable, Tensorizable, Vectorizable

Interfaces: InferTypeOpInterface, NoSideEffect (MemoryEffectOpInterface), VectorUnrollOpInterface

Effects: MemoryEffects::Effect{}

Operands: ¶

Results: ¶

math.log2 (::mlir::math::Log2Op) ¶

base-2 logarithm of the specified value

Syntax:

operation ::= `math.log2` $operand attr-dict `:` type($result)

Computes the base-2 logarithm of the given value. It takes one operand and returns one result of the same type.

Example:

%y = math.log2 %x : f64

Traits: Elementwise, SameOperandsAndResultType, Scalarizable, Tensorizable, Vectorizable

Interfaces: InferTypeOpInterface, NoSideEffect (MemoryEffectOpInterface), VectorUnrollOpInterface

Effects: MemoryEffects::Effect{}

Operands: ¶

Results: ¶

math.log (::mlir::math::LogOp) ¶

base-e logarithm of the specified value

Syntax:

operation ::= `math.log` $operand attr-dict `:` type($result)

Computes the base-e logarithm of the given value. It takes one operand and returns one result of the same type.

Example:

%y = math.log %x : f64

Traits: Elementwise, SameOperandsAndResultType, Scalarizable, Tensorizable, Vectorizable

Interfaces: InferTypeOpInterface, NoSideEffect (MemoryEffectOpInterface), VectorUnrollOpInterface

Effects: MemoryEffects::Effect{}

Operands: ¶

Results: ¶

math.powf (::mlir::math::PowFOp) ¶

floating point raised to the power of operation

Syntax:

operation ::= `math.powf` $lhs `,` $rhs attr-dict `:` type($result)

Syntax:

operation ::= ssa-id `=` `math.powf` ssa-use `,` ssa-use `:` type

The powf operation takes two operands and returns one result, each of these is required to be the same type. This type may be a floating point scalar type, a vector whose element type is a floating point type, or a floating point tensor.

Example:

// Scalar exponentiation.
%a = math.powf %b, %c : f64

// SIMD pointwise vector exponentiation
%f = math.powf %g, %h : vector<4xf32>

// Tensor pointwise exponentiation.
%x = math.powf %y, %z : tensor<4x?xbf16>

Traits: Elementwise, SameOperandsAndResultType, Scalarizable, Tensorizable, Vectorizable

Interfaces: InferTypeOpInterface, NoSideEffect (MemoryEffectOpInterface), VectorUnrollOpInterface

Effects: MemoryEffects::Effect{}

Operands: ¶

Results: ¶

math.rsqrt (::mlir::math::RsqrtOp) ¶

reciprocal of sqrt (1 / sqrt of the specified value)

Syntax:

operation ::= `math.rsqrt` $operand attr-dict `:` type($result)

The rsqrt operation computes the reciprocal of the square root. It takes one operand and returns one result of the same type. This type may be a float scalar type, a vector whose element type is float, or a tensor of floats. It has no standard attributes.

Traits: Elementwise, SameOperandsAndResultType, Scalarizable, Tensorizable, Vectorizable

Interfaces: InferTypeOpInterface, NoSideEffect (MemoryEffectOpInterface), VectorUnrollOpInterface

Effects: MemoryEffects::Effect{}

Operands: ¶

Results: ¶

math.sin (::mlir::math::SinOp) ¶

sine of the specified value

Syntax:

operation ::= `math.sin` $operand attr-dict `:` type($result)

Syntax:

operation ::= ssa-id `=` `math.sin` ssa-use `:` type

The sin operation computes the sine of a given value. It takes one operand and returns one result of the same type. This type may be a float scalar type, a vector whose element type is float, or a tensor of floats. It has no standard attributes.

Example:

// Scalar sine value.
%a = math.sin %b : f64

// SIMD vector element-wise sine value.
%f = math.sin %g : vector<4xf32>

// Tensor element-wise sine value.
%x = math.sin %y : tensor<4x?xf8>

Traits: Elementwise, SameOperandsAndResultType, Scalarizable, Tensorizable, Vectorizable

Interfaces: InferTypeOpInterface, NoSideEffect (MemoryEffectOpInterface), VectorUnrollOpInterface

Effects: MemoryEffects::Effect{}

Operands: ¶

Results: ¶

math.sqrt (::mlir::math::SqrtOp) ¶

sqrt of the specified value

Syntax:

operation ::= `math.sqrt` $operand attr-dict `:` type($result)

The sqrt operation computes the square root. It takes one operand and returns one result of the same type. This type may be a float scalar type, a vector whose element type is float, or a tensor of floats. It has no standard attributes.

Example:

// Scalar square root value.
%a = math.sqrt %b : f64
// SIMD vector element-wise square root value.
%f = math.sqrt %g : vector<4xf32>
// Tensor element-wise square root value.
%x = math.sqrt %y : tensor<4x?xf32>

Traits: Elementwise, SameOperandsAndResultType, Scalarizable, Tensorizable, Vectorizable

Interfaces: InferTypeOpInterface, NoSideEffect (MemoryEffectOpInterface), VectorUnrollOpInterface

Effects: MemoryEffects::Effect{}

Operands: ¶

Results: ¶

math.tanh (::mlir::math::TanhOp) ¶

hyperbolic tangent of the specified value

Syntax:

operation ::= `math.tanh` $operand attr-dict `:` type($result)

The tanh operation computes the hyperbolic tangent. It takes one operand and returns one result of the same type. This type may be a float scalar type, a vector whose element type is float, or a tensor of floats. It has no standard attributes.

Example:

// Scalar hyperbolic tangent value.
%a = math.tanh %b : f64

// SIMD vector element-wise hyperbolic tangent value.
%f = math.tanh %g : vector<4xf32>

// Tensor element-wise hyperbolic tangent value.
%x = math.tanh %y : tensor<4x?xf8>

Traits: Elementwise, SameOperandsAndResultType, Scalarizable, Tensorizable, Vectorizable

Interfaces: InferTypeOpInterface, NoSideEffect (MemoryEffectOpInterface), VectorUnrollOpInterface

Effects: MemoryEffects::Effect{}

Operands: ¶

Results: ¶