DeclareOpInterfaceMethods<VectorUnrollOpInterface>] #
ElementwiseMappable.traits>;
-// Base class for unary math operations on integer types. Require a operand and
-// result of the same type. This type can be an integer type, or vector or tensor
-// thereof.
+// Base class for unary math operations on integer types. Require an operand
+// and result of the same type. This type can be an integer type, vector or
+// tensor thereof.
class Math_IntegerUnaryOp<string mnemonic, list<Trait> traits = []> :
Math_Op<mnemonic, traits # [SameOperandsAndResultType]> {
let arguments = (ins SignlessIntegerLike:$operand);
let assemblyFormat = "$operand attr-dict `:` type($result)";
}
-// Base class for unary math operations on floating point types. Require a
+// Base class for unary math operations on floating point types. Require an
// operand and result of the same type. This type can be a floating point type,
-// or vector or tensor thereof.
+// vector or tensor thereof.
class Math_FloatUnaryOp<string mnemonic, list<Trait> traits = []> :
Math_Op<mnemonic, traits # [SameOperandsAndResultType]> {
let arguments = (ins FloatLike:$operand);
// Base class for binary math operations on floating point types. Require two
// operands and one result of the same type. This type can be a floating point
-// type, or a vector or tensor thereof.
+// type, vector or tensor thereof.
class Math_FloatBinaryOp<string mnemonic, list<Trait> traits = []> :
Math_Op<mnemonic, traits # [SameOperandsAndResultType]> {
let arguments = (ins FloatLike:$lhs, FloatLike:$rhs);
}
// Base class for floating point ternary operations. Require three operands and
-// one result of the same type. This type can be a floating point type, or a
-// vector or tensor thereof.
+// one result of the same type. This type can be a floating point type, vector
+// or tensor thereof.
class Math_FloatTernaryOp<string mnemonic, list<Trait> traits = []> :
Math_Op<mnemonic, traits # [SameOperandsAndResultType]> {
let arguments = (ins FloatLike:$a, FloatLike:$b, FloatLike:$c);
def Math_AbsOp : Math_FloatUnaryOp<"abs"> {
let summary = "floating point absolute-value operation";
let description = [{
- 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.
+ The `abs` 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.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>
```
}];
let hasFolder = 1;
```
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.
+ 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
-
- // SIMD vector element-wise arcus tangent.
- %f = math.atan %g : vector<4xf32>
-
- // Tensor element-wise arcus tangent.
- %x = math.atan %y : tensor<4x?xf8>
```
}];
}
```
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.
+ 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
```mlir
// 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>
```
}];
}
```
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.
+ 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
-
- // SIMD vector element-wise ceiling value.
- %f = math.ceil %g : vector<4xf32>
-
- // Tensor element-wise ceiling value.
- %x = math.ceil %y : tensor<4x?xf8>
```
}];
let hasFolder = 1;
```
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.
+ 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
-
- // 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>
```
}];
let hasFolder = 1;
```
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.
+ 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
-
- // SIMD vector element-wise cosine value.
- %f = math.cos %g : vector<4xf32>
-
- // Tensor element-wise cosine value.
- %x = math.cos %y : tensor<4x?xf8>
```
}];
}
```
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.
+ 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
-
- // SIMD vector element-wise sine value.
- %f = math.sin %g : vector<4xf32>
-
- // Tensor element-wise sine value.
- %x = math.sin %y : tensor<4x?xf8>
```
}];
}
let summary = "counts the leading zeros an integer value";
let description = [{
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
-
- // 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>
```
}];
let hasFolder = 1;
let summary = "counts the trailing zeros an integer value";
let description = [{
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
-
- // 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>
```
}];
let hasFolder = 1;
let summary = "counts the number of set bits of an integer value";
let description = [{
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
-
- // 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>
```
}];
let hasFolder = 1;
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.
+ 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
-
- // 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>
```
}];
}
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.
+ 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
-
- // SIMD vector element-wise natural exponential.
- %f = math.exp %g : vector<4xf32>
-
- // Tensor element-wise natural exponential.
- %x = math.exp %y : tensor<4x?xf8>
```
}];
}
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.
+ 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
-
- // SIMD vector element-wise natural exponential.
- %f = math.exp2 %g : vector<4xf32>
-
- // Tensor element-wise natural exponential.
- %x = math.exp2 %y : tensor<4x?xf8>
```
}];
}
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.
+ 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
-
- // 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>
```
}];
}
```
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.
+ 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
-
- // SIMD vector element-wise floor value.
- %f = math.floor %g : vector<4xf32>
-
- // Tensor element-wise floor value.
- %x = math.floor %y : tensor<4x?xf8>
+ %a = math.floor %b : f64
```
}];
}
```
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.
+ 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
-
- // 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`
let summary = "base-e logarithm of the specified value";
let description = [{
- Computes the base-e logarithm of the given value. It takes one operand and
- returns one result of the same type.
+ 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
```
}];
let summary = "base-10 logarithm of the specified value";
let description = [{
- Computes the base-10 logarithm of the given value. It takes one operand and
- returns one result of the same type.
+ 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
```
}];
let description = [{
Computes the base-e logarithm of one plus the given value. It takes one
- operand and returns one result of the same type.
+ 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
```
}];
let summary = "base-2 logarithm of the specified value";
let description = [{
- Computes the base-2 logarithm of the given value. It takes one operand and
- returns one result of the same type.
+ 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 ::= 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.
+ 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
-
- // SIMD pointwise vector exponentiation
- %f = math.powf %g, %h : vector<4xf32>
-
- // Tensor pointwise exponentiation.
- %x = math.powf %y, %z : tensor<4x?xbf16>
```
}];
let hasFolder = 1;
let summary = "reciprocal of sqrt (1 / sqrt of the specified value)";
let description = [{
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.
+ 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
+ ```
}];
}
def Math_SqrtOp : Math_FloatUnaryOp<"sqrt"> {
let summary = "sqrt of the specified value";
let description = [{
- 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.
+ 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
- // 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>
```
}];
let hasFolder = 1;
let summary = "hyperbolic tangent of the specified value";
let description = [{
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.
+ 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
-
- // 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>
```
}];
}