'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: ¶
Operand | Description |
---|---|
operand | floating-point-like |
Results: ¶
Result | Description |
---|---|
result | floating-point-like |
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: ¶
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>
Traits: Elementwise, SameOperandsAndResultType, Scalarizable, Tensorizable, Vectorizable
Interfaces: InferTypeOpInterface, NoSideEffect (MemoryEffectOpInterface), VectorUnrollOpInterface
Effects: MemoryEffects::Effect{}
Operands: ¶
Operand | Description |
---|---|
operand | floating-point-like |
Results: ¶
Result | Description |
---|---|
result | floating-point-like |
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: ¶
Operand | Description |
---|---|
operand | floating-point-like |
Results: ¶
Result | Description |
---|---|
result | floating-point-like |
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: ¶
Operand | Description |
---|---|
lhs | floating-point-like |
rhs | 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>
Traits: Elementwise, SameOperandsAndResultType, Scalarizable, Tensorizable, Vectorizable
Interfaces: InferTypeOpInterface, NoSideEffect (MemoryEffectOpInterface), VectorUnrollOpInterface
Effects: MemoryEffects::Effect{}
Operands: ¶
Operand | Description |
---|---|
operand | floating-point-like |
Results: ¶
Result | Description |
---|---|
result | floating-point-like |
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: ¶
Operand | Description |
---|---|
operand | signless-integer-like |
Results: ¶
Result | Description |
---|---|
result | signless-integer-like |
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: ¶
Operand | Description |
---|---|
operand | signless-integer-like |
Results: ¶
Result | Description |
---|---|
result | signless-integer-like |
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: ¶
Operand | Description |
---|---|
operand | signless-integer-like |
Results: ¶
Result | Description |
---|---|
result | signless-integer-like |
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: ¶
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>
Traits: Elementwise, SameOperandsAndResultType, Scalarizable, Tensorizable, Vectorizable
Interfaces: InferTypeOpInterface, NoSideEffect (MemoryEffectOpInterface), VectorUnrollOpInterface
Effects: MemoryEffects::Effect{}
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>
Traits: Elementwise, SameOperandsAndResultType, Scalarizable, Tensorizable, Vectorizable
Interfaces: InferTypeOpInterface, NoSideEffect (MemoryEffectOpInterface), VectorUnrollOpInterface
Effects: MemoryEffects::Effect{}
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>
Traits: Elementwise, SameOperandsAndResultType, Scalarizable, Tensorizable, Vectorizable
Interfaces: InferTypeOpInterface, NoSideEffect (MemoryEffectOpInterface), VectorUnrollOpInterface
Effects: MemoryEffects::Effect{}
Operands: ¶
Operand | Description |
---|---|
operand | floating-point-like |
Results: ¶
Result | Description |
---|---|
result | floating-point-like |
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: ¶
Operand | Description |
---|---|
operand | floating-point-like |
Results: ¶
Result | Description |
---|---|
result | floating-point-like |
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: ¶
Operand | Description |
---|---|
a | floating-point-like |
b | floating-point-like |
c | 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
Traits: Elementwise, SameOperandsAndResultType, Scalarizable, Tensorizable, Vectorizable
Interfaces: InferTypeOpInterface, NoSideEffect (MemoryEffectOpInterface), VectorUnrollOpInterface
Effects: MemoryEffects::Effect{}
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
Traits: Elementwise, SameOperandsAndResultType, Scalarizable, Tensorizable, Vectorizable
Interfaces: InferTypeOpInterface, NoSideEffect (MemoryEffectOpInterface), VectorUnrollOpInterface
Effects: MemoryEffects::Effect{}
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
Traits: Elementwise, SameOperandsAndResultType, Scalarizable, Tensorizable, Vectorizable
Interfaces: InferTypeOpInterface, NoSideEffect (MemoryEffectOpInterface), VectorUnrollOpInterface
Effects: MemoryEffects::Effect{}
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
Traits: Elementwise, SameOperandsAndResultType, Scalarizable, Tensorizable, Vectorizable
Interfaces: InferTypeOpInterface, NoSideEffect (MemoryEffectOpInterface), VectorUnrollOpInterface
Effects: MemoryEffects::Effect{}
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>
Traits: Elementwise, SameOperandsAndResultType, Scalarizable, Tensorizable, Vectorizable
Interfaces: InferTypeOpInterface, NoSideEffect (MemoryEffectOpInterface), VectorUnrollOpInterface
Effects: MemoryEffects::Effect{}
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.
Traits: Elementwise, SameOperandsAndResultType, Scalarizable, Tensorizable, Vectorizable
Interfaces: InferTypeOpInterface, NoSideEffect (MemoryEffectOpInterface), VectorUnrollOpInterface
Effects: MemoryEffects::Effect{}
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>
Traits: Elementwise, SameOperandsAndResultType, Scalarizable, Tensorizable, Vectorizable
Interfaces: InferTypeOpInterface, NoSideEffect (MemoryEffectOpInterface), VectorUnrollOpInterface
Effects: MemoryEffects::Effect{}
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>
Traits: Elementwise, SameOperandsAndResultType, Scalarizable, Tensorizable, Vectorizable
Interfaces: InferTypeOpInterface, NoSideEffect (MemoryEffectOpInterface), VectorUnrollOpInterface
Effects: MemoryEffects::Effect{}
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)
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: ¶
Operand | Description |
---|---|
operand | floating-point-like |
Results: ¶
Result | Description |
---|---|
result | floating-point-like |