'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: ¶
Operand | Description |
---|---|
lhs | floating-point-like |
rhs | floating-point-like |
Results: ¶
Result | Description |
---|---|
result | floating-point-like |
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: ¶
Operand | Description |
---|---|
operand | floating-point-like |
Results: ¶
Result | Description |
---|---|
result | floating-point-like |
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: ¶
Operand | Description |
---|---|
operand | floating-point-like |
Results: ¶
Result | Description |
---|---|
result | floating-point-like |
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: ¶
Operand | Description |
---|---|
operand | floating-point-like |
Results: ¶
Result | Description |
---|---|
result | floating-point-like |
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: ¶
Operand | Description |
---|---|
operand | floating-point-like |
Results: ¶
Result | Description |
---|---|
result | floating-point-like |
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: ¶
Operand | Description |
---|---|
operand | floating-point-like |
Results: ¶
Result | Description |
---|---|
result | floating-point-like |
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: ¶
Operand | Description |
---|---|
operand | floating-point-like |
Results: ¶
Result | Description |
---|---|
result | floating-point-like |
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: ¶
Operand | Description |
---|---|
operand | floating-point-like |
Results: ¶
Result | Description |
---|---|
result | floating-point-like |
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: ¶
Operand | Description |
---|---|
operand | floating-point-like |
Results: ¶
Result | Description |
---|---|
result | floating-point-like |
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: ¶
Operand | Description |
---|---|
operand | floating-point-like |
Results: ¶
Result | Description |
---|---|
result | floating-point-like |
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: ¶
Operand | Description |
---|---|
lhs | floating-point-like |
rhs | floating-point-like |
Results: ¶
Result | Description |
---|---|
result | floating-point-like |
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: ¶
Operand | Description |
---|---|
operand | floating-point-like |
Results: ¶
Result | Description |
---|---|
result | floating-point-like |
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: ¶
Operand | Description |
---|---|
operand | floating-point-like |
Results: ¶
Result | Description |
---|---|
result | floating-point-like |
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: ¶
Operand | Description |
---|---|
operand | floating-point-like |
Results: ¶
Result | Description |
---|---|
result | floating-point-like |
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: ¶
Operand | Description |
---|---|
operand | floating-point-like |
Results: ¶
Result | Description |
---|---|
result | floating-point-like |