'math' Dialect

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

Operation definition ¶

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>

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>

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>

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>

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>

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>

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

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

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

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

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>

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.

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>

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>

Operands: ¶

Results: ¶

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

hyperbolic tangent of the specified value

Syntax:

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

Syntax:

operation ::= ssa-id `=` `std.tanh` ssa-use `:` type

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>

Operands: ¶

Results: ¶