module internal.types.float¶
Source: stdlib/internal/types/float.codon
float @extend Class is extended to add given methods ¶
Properties¶
real @property Method is a class property ¶
imag @property Method is a class property ¶
Magic methods¶
__new__()¶
__new__(what) @overload Function is overloaded ¶
__repr__(self)¶
__copy__(self)¶
__deepcopy__(self)¶
__int__(self) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
%0 = fptosi double %self to i64
ret i64 %0
__float__(self)¶
__bool__(self) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
%0 = fcmp une double %self, 0.000000e+00
%1 = zext i1 %0 to i8
ret i8 %1
__pos__(self)¶
__neg__(self) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
%0 = fneg double %self
ret double %0
__add__(a: float, b: float) @pure Function has no side effects and returns same value for same inputs @commutative Binary operator is commutative @llvm Function is implemented with inline LLVM IR ¶
%tmp = fadd double %a, %b
ret double %tmp
__sub__(a: float, b: float) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
%tmp = fsub double %a, %b
ret double %tmp
__mul__(a: float, b: float) @pure Function has no side effects and returns same value for same inputs @commutative Binary operator is commutative @llvm Function is implemented with inline LLVM IR ¶
%tmp = fmul double %a, %b
ret double %tmp
__floordiv__(self, other: float)¶
__truediv__(a: float, b: float) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
%tmp = fdiv double %a, %b
ret double %tmp
__mod__(a: float, b: float) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
%tmp = frem double %a, %b
ret double %tmp
__divmod__(self, other: float)¶
__eq__(a: float, b: float) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
%tmp = fcmp oeq double %a, %b
%res = zext i1 %tmp to i8
ret i8 %res
__ne__(a: float, b: float) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
%tmp = fcmp une double %a, %b
%res = zext i1 %tmp to i8
ret i8 %res
__lt__(a: float, b: float) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
%tmp = fcmp olt double %a, %b
%res = zext i1 %tmp to i8
ret i8 %res
__gt__(a: float, b: float) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
%tmp = fcmp ogt double %a, %b
%res = zext i1 %tmp to i8
ret i8 %res
__le__(a: float, b: float) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
%tmp = fcmp ole double %a, %b
%res = zext i1 %tmp to i8
ret i8 %res
__ge__(a: float, b: float) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
%tmp = fcmp oge double %a, %b
%res = zext i1 %tmp to i8
ret i8 %res
__abs__(a: float) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare double @llvm.fabs.f64(double %a)
%tmp = call double @llvm.fabs.f64(double %a)
ret double %tmp
__floor__(a: float) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare double @llvm.floor.f64(double %a)
%tmp = call double @llvm.floor.f64(double %a)
ret double %tmp
__ceil__(a: float) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare double @llvm.ceil.f64(double %a)
%tmp = call double @llvm.ceil.f64(double %a)
ret double %tmp
__trunc__(a: float) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare double @llvm.trunc.f64(double %a)
%tmp = call double @llvm.trunc.f64(double %a)
ret double %tmp
__round__(a: float) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare double @llvm.round.f64(double %a)
%tmp = call double @llvm.round.f64(double %a)
ret double %tmp
__pow__(a: float, b: float) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare double @llvm.pow.f64(double %a, double %b)
%tmp = call double @llvm.pow.f64(double %a, double %b)
ret double %tmp
__atomic_xchg__(d: Ptr[float], b: float) @nocapture Function does not capture arguments (return value might capture) @llvm Function is implemented with inline LLVM IR ¶
%tmp = atomicrmw xchg ptr %d, double %b seq_cst
ret {} {}
__atomic_add__(d: Ptr[float], b: float) @nocapture Function does not capture arguments (return value might capture) @llvm Function is implemented with inline LLVM IR ¶
0:
%1 = load atomic i64, ptr %d monotonic, align 8
%2 = bitcast i64 %1 to double
%3 = fadd double %2, %b
%4 = bitcast double %3 to i64
%5 = cmpxchg weak ptr %d, i64 %1, i64 %4 seq_cst monotonic, align 8
%6 = extractvalue { i64, i1 } %5, 1
br i1 %6, label %15, label %7
7: ; preds = %0, %7
%8 = phi { i64, i1 } [ %13, %7 ], [ %5, %0 ]
%9 = extractvalue { i64, i1 } %8, 0
%10 = bitcast i64 %9 to double
%11 = fadd double %10, %b
%12 = bitcast double %11 to i64
%13 = cmpxchg weak ptr %d, i64 %9, i64 %12 seq_cst monotonic, align 8
%14 = extractvalue { i64, i1 } %13, 1
br i1 %14, label %15, label %7
15: ; preds = %7, %0
%16 = phi double [ %2, %0 ], [ %10, %7 ]
ret double %16
__atomic_sub__(d: Ptr[float], b: float) @nocapture Function does not capture arguments (return value might capture) @llvm Function is implemented with inline LLVM IR ¶
0:
%1 = load atomic i64, ptr %d monotonic, align 8
%2 = bitcast i64 %1 to double
%3 = fsub double %2, %b
%4 = bitcast double %3 to i64
%5 = cmpxchg weak ptr %d, i64 %1, i64 %4 seq_cst monotonic, align 8
%6 = extractvalue { i64, i1 } %5, 1
br i1 %6, label %15, label %7
7: ; preds = %0, %7
%8 = phi { i64, i1 } [ %13, %7 ], [ %5, %0 ]
%9 = extractvalue { i64, i1 } %8, 0
%10 = bitcast i64 %9 to double
%11 = fsub double %10, %b
%12 = bitcast double %11 to i64
%13 = cmpxchg weak ptr %d, i64 %9, i64 %12 seq_cst monotonic, align 8
%14 = extractvalue { i64, i1 } %13, 1
br i1 %14, label %15, label %7
15: ; preds = %7, %0
%16 = phi double [ %2, %0 ], [ %10, %7 ]
ret double %16
__hash__(self)¶
__match__(self, obj: float)¶
__add__(self: float, b: int) @commutative Binary operator is commutative @overload Function is overloaded ¶
__sub__(self: float, b: int) @overload Function is overloaded ¶
__mul__(self: float, b: int) @commutative Binary operator is commutative @overload Function is overloaded ¶
__floordiv__(self, b: int) @overload Function is overloaded ¶
__truediv__(self: float, b: int) @overload Function is overloaded ¶
__mod__(self: float, b: int) @overload Function is overloaded ¶
__divmod__(self, b: int) @overload Function is overloaded ¶
__eq__(self: float, b: int) @overload Function is overloaded ¶
__ne__(self: float, b: int) @overload Function is overloaded ¶
__lt__(self: float, b: int) @overload Function is overloaded ¶
__gt__(self: float, b: int) @overload Function is overloaded ¶
__le__(self: float, b: int) @overload Function is overloaded ¶
__ge__(self: float, b: int) @overload Function is overloaded ¶
__pow__(self: float, b: int) @overload Function is overloaded ¶
Methods¶
sqrt(a: float) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare double @llvm.sqrt.f64(double %a)
%tmp = call double @llvm.sqrt.f64(double %a)
ret double %tmp
sin(a: float) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare double @llvm.sin.f64(double %a)
%tmp = call double @llvm.sin.f64(double %a)
ret double %tmp
cos(a: float) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare double @llvm.cos.f64(double %a)
%tmp = call double @llvm.cos.f64(double %a)
ret double %tmp
exp(a: float) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare double @llvm.exp.f64(double %a)
%tmp = call double @llvm.exp.f64(double %a)
ret double %tmp
exp2(a: float) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare double @llvm.exp2.f64(double %a)
%tmp = call double @llvm.exp2.f64(double %a)
ret double %tmp
log(a: float) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare double @llvm.log.f64(double %a)
%tmp = call double @llvm.log.f64(double %a)
ret double %tmp
log10(a: float) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare double @llvm.log10.f64(double %a)
%tmp = call double @llvm.log10.f64(double %a)
ret double %tmp
log2(a: float) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare double @llvm.log2.f64(double %a)
%tmp = call double @llvm.log2.f64(double %a)
ret double %tmp
rint(a: float) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare double @llvm.rint.f64(double %a)
%tmp = call double @llvm.rint.f64(double %a)
ret double %tmp
nearbyint(a: float) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare double @llvm.nearbyint.f64(double %a)
%tmp = call double @llvm.nearbyint.f64(double %a)
ret double %tmp
min(a: float, b: float) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare double @llvm.minnum.f64(double %a, double %b)
%tmp = call double @llvm.minnum.f64(double %a, double %b)
ret double %tmp
max(a: float, b: float) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare double @llvm.maxnum.f64(double %a, double %b)
%tmp = call double @llvm.maxnum.f64(double %a, double %b)
ret double %tmp
copysign(a: float, b: float) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare double @llvm.copysign.f64(double %a, double %b)
%tmp = call double @llvm.copysign.f64(double %a, double %b)
ret double %tmp
fma(a: float, b: float, c: float) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare double @llvm.fma.f64(double %a, double %b, double %c)
%tmp = call double @llvm.fma.f64(double %a, double %b, double %c)
ret double %tmp
float32 @extend Class is extended to add given methods ¶
Magic methods¶
__new__(self: float) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
%0 = fptrunc double %self to float
ret float %0
__new__(what: float32) @overload Function is overloaded ¶
__new__(what: str) @overload Function is overloaded ¶
__new__() @overload Function is overloaded ¶
__repr__(self)¶
__format__(self, format_spec: str)¶
__copy__(self)¶
__deepcopy__(self)¶
__int__(self) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
%0 = fptosi float %self to i64
ret i64 %0
__float__(self) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
%0 = fpext float %self to double
ret double %0
__bool__(self) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
%0 = fcmp une float %self, 0.000000e+00
%1 = zext i1 %0 to i8
ret i8 %1
__pos__(self)¶
__neg__(self) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
%0 = fneg float %self
ret float %0
__add__(a: float32, b: float32) @pure Function has no side effects and returns same value for same inputs @commutative Binary operator is commutative @llvm Function is implemented with inline LLVM IR ¶
%tmp = fadd float %a, %b
ret float %tmp
__sub__(a: float32, b: float32) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
%tmp = fsub float %a, %b
ret float %tmp
__mul__(a: float32, b: float32) @pure Function has no side effects and returns same value for same inputs @commutative Binary operator is commutative @llvm Function is implemented with inline LLVM IR ¶
%tmp = fmul float %a, %b
ret float %tmp
__floordiv__(self, other: float32)¶
__truediv__(a: float32, b: float32) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
%tmp = fdiv float %a, %b
ret float %tmp
__mod__(a: float32, b: float32) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
%tmp = frem float %a, %b
ret float %tmp
__divmod__(self, other: float32)¶
__eq__(a: float32, b: float32) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
%tmp = fcmp oeq float %a, %b
%res = zext i1 %tmp to i8
ret i8 %res
__ne__(a: float32, b: float32) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
%tmp = fcmp une float %a, %b
%res = zext i1 %tmp to i8
ret i8 %res
__lt__(a: float32, b: float32) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
%tmp = fcmp olt float %a, %b
%res = zext i1 %tmp to i8
ret i8 %res
__gt__(a: float32, b: float32) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
%tmp = fcmp ogt float %a, %b
%res = zext i1 %tmp to i8
ret i8 %res
__le__(a: float32, b: float32) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
%tmp = fcmp ole float %a, %b
%res = zext i1 %tmp to i8
ret i8 %res
__ge__(a: float32, b: float32) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
%tmp = fcmp oge float %a, %b
%res = zext i1 %tmp to i8
ret i8 %res
__abs__(a: float32) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare float @llvm.fabs.f32(float %a)
%tmp = call float @llvm.fabs.f32(float %a)
ret float %tmp
__floor__(a: float32) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare float @llvm.floor.f32(float %a)
%tmp = call float @llvm.floor.f32(float %a)
ret float %tmp
__ceil__(a: float32) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare float @llvm.ceil.f32(float %a)
%tmp = call float @llvm.ceil.f32(float %a)
ret float %tmp
__trunc__(a: float32) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare float @llvm.trunc.f32(float %a)
%tmp = call float @llvm.trunc.f32(float %a)
ret float %tmp
__round__(a: float32) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare float @llvm.round.f32(float %a)
%tmp = call float @llvm.round.f32(float %a)
ret float %tmp
__pow__(a: float32, b: float32) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare float @llvm.pow.f32(float %a, float %b)
%tmp = call float @llvm.pow.f32(float %a, float %b)
ret float %tmp
__atomic_xchg__(d: Ptr[float32], b: float32) @nocapture Function does not capture arguments (return value might capture) @llvm Function is implemented with inline LLVM IR ¶
%tmp = atomicrmw xchg ptr %d, float %b seq_cst
ret {} {}
__atomic_add__(d: Ptr[float32], b: float32) @nocapture Function does not capture arguments (return value might capture) @llvm Function is implemented with inline LLVM IR ¶
0:
%1 = load atomic i32, ptr %d monotonic, align 4
%2 = bitcast i32 %1 to float
%3 = fadd float %2, %b
%4 = bitcast float %3 to i32
%5 = cmpxchg weak ptr %d, i32 %1, i32 %4 seq_cst monotonic, align 4
%6 = extractvalue { i32, i1 } %5, 1
br i1 %6, label %15, label %7
7: ; preds = %0, %7
%8 = phi { i32, i1 } [ %13, %7 ], [ %5, %0 ]
%9 = extractvalue { i32, i1 } %8, 0
%10 = bitcast i32 %9 to float
%11 = fadd float %10, %b
%12 = bitcast float %11 to i32
%13 = cmpxchg weak ptr %d, i32 %9, i32 %12 seq_cst monotonic, align 4
%14 = extractvalue { i32, i1 } %13, 1
br i1 %14, label %15, label %7
15: ; preds = %7, %0
%16 = phi float [ %2, %0 ], [ %10, %7 ]
ret float %16
__atomic_sub__(d: Ptr[float32], b: float32) @nocapture Function does not capture arguments (return value might capture) @llvm Function is implemented with inline LLVM IR ¶
0:
%1 = load atomic i32, ptr %d monotonic, align 4
%2 = bitcast i32 %1 to float
%3 = fsub float %2, %b
%4 = bitcast float %3 to i32
%5 = cmpxchg weak ptr %d, i32 %1, i32 %4 seq_cst monotonic, align 4
%6 = extractvalue { i32, i1 } %5, 1
br i1 %6, label %15, label %7
7: ; preds = %0, %7
%8 = phi { i32, i1 } [ %13, %7 ], [ %5, %0 ]
%9 = extractvalue { i32, i1 } %8, 0
%10 = bitcast i32 %9 to float
%11 = fsub float %10, %b
%12 = bitcast float %11 to i32
%13 = cmpxchg weak ptr %d, i32 %9, i32 %12 seq_cst monotonic, align 4
%14 = extractvalue { i32, i1 } %13, 1
br i1 %14, label %15, label %7
15: ; preds = %7, %0
%16 = phi float [ %2, %0 ], [ %10, %7 ]
ret float %16
__hash__(self)¶
__match__(self, obj: float32)¶
__add__(self: float32, b: int) @commutative Binary operator is commutative @overload Function is overloaded ¶
__sub__(self: float32, b: int) @overload Function is overloaded ¶
__mul__(self: float32, b: int) @commutative Binary operator is commutative @overload Function is overloaded ¶
__floordiv__(self, b: int) @overload Function is overloaded ¶
__truediv__(self: float32, b: int) @overload Function is overloaded ¶
__mod__(self: float32, b: int) @overload Function is overloaded ¶
__divmod__(self, b: int) @overload Function is overloaded ¶
__eq__(self: float32, b: int) @overload Function is overloaded ¶
__ne__(self: float32, b: int) @overload Function is overloaded ¶
__lt__(self: float32, b: int) @overload Function is overloaded ¶
__gt__(self: float32, b: int) @overload Function is overloaded ¶
__le__(self: float32, b: int) @overload Function is overloaded ¶
__ge__(self: float32, b: int) @overload Function is overloaded ¶
__pow__(self: float32, b: int) @overload Function is overloaded ¶
Methods¶
sqrt(a: float32) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare float @llvm.sqrt.f32(float %a)
%tmp = call float @llvm.sqrt.f32(float %a)
ret float %tmp
sin(a: float32) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare float @llvm.sin.f32(float %a)
%tmp = call float @llvm.sin.f32(float %a)
ret float %tmp
cos(a: float32) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare float @llvm.cos.f32(float %a)
%tmp = call float @llvm.cos.f32(float %a)
ret float %tmp
exp(a: float32) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare float @llvm.exp.f32(float %a)
%tmp = call float @llvm.exp.f32(float %a)
ret float %tmp
exp2(a: float32) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare float @llvm.exp2.f32(float %a)
%tmp = call float @llvm.exp2.f32(float %a)
ret float %tmp
log(a: float32) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare float @llvm.log.f32(float %a)
%tmp = call float @llvm.log.f32(float %a)
ret float %tmp
log10(a: float32) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare float @llvm.log10.f32(float %a)
%tmp = call float @llvm.log10.f32(float %a)
ret float %tmp
log2(a: float32) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare float @llvm.log2.f32(float %a)
%tmp = call float @llvm.log2.f32(float %a)
ret float %tmp
rint(a: float32) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare float @llvm.rint.f32(float %a)
%tmp = call float @llvm.rint.f32(float %a)
ret float %tmp
nearbyint(a: float32) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare float @llvm.nearbyint.f32(float %a)
%tmp = call float @llvm.nearbyint.f32(float %a)
ret float %tmp
min(a: float32, b: float32) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare float @llvm.minnum.f32(float %a, float %b)
%tmp = call float @llvm.minnum.f32(float %a, float %b)
ret float %tmp
max(a: float32, b: float32) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare float @llvm.maxnum.f32(float %a, float %b)
%tmp = call float @llvm.maxnum.f32(float %a, float %b)
ret float %tmp
copysign(a: float32, b: float32) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare float @llvm.copysign.f32(float %a, float %b)
%tmp = call float @llvm.copysign.f32(float %a, float %b)
ret float %tmp
fma(a: float32, b: float32, c: float32) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare float @llvm.fma.f32(float %a, float %b, float %c)
%tmp = call float @llvm.fma.f32(float %a, float %b, float %c)
ret float %tmp
float16 @extend Class is extended to add given methods ¶
Magic methods¶
__new__(self: float) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
%0 = fptrunc double %self to half
ret half %0
__new__(what: float16) @overload Function is overloaded ¶
__new__(what: str) @overload Function is overloaded ¶
__new__() @overload Function is overloaded ¶
__repr__(self)¶
__format__(self, format_spec: str)¶
__copy__(self)¶
__deepcopy__(self)¶
__int__(self) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
%0 = fptosi half %self to i64
ret i64 %0
__float__(self) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
%0 = fpext half %self to double
ret double %0
__bool__(self) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
%0 = fcmp une half %self, 0.000000e+00
%1 = zext i1 %0 to i8
ret i8 %1
__pos__(self)¶
__neg__(self) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
%0 = fneg half %self
ret half %0
__add__(a: float16, b: float16) @pure Function has no side effects and returns same value for same inputs @commutative Binary operator is commutative @llvm Function is implemented with inline LLVM IR ¶
%tmp = fadd half %a, %b
ret half %tmp
__sub__(a: float16, b: float16) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
%tmp = fsub half %a, %b
ret half %tmp
__mul__(a: float16, b: float16) @pure Function has no side effects and returns same value for same inputs @commutative Binary operator is commutative @llvm Function is implemented with inline LLVM IR ¶
%tmp = fmul half %a, %b
ret half %tmp
__floordiv__(self, other: float16)¶
__truediv__(a: float16, b: float16) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
%tmp = fdiv half %a, %b
ret half %tmp
__mod__(a: float16, b: float16) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
%tmp = frem half %a, %b
ret half %tmp
__divmod__(self, other: float16)¶
__eq__(a: float16, b: float16) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
%tmp = fcmp oeq half %a, %b
%res = zext i1 %tmp to i8
ret i8 %res
__ne__(a: float16, b: float16) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
%tmp = fcmp une half %a, %b
%res = zext i1 %tmp to i8
ret i8 %res
__lt__(a: float16, b: float16) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
%tmp = fcmp olt half %a, %b
%res = zext i1 %tmp to i8
ret i8 %res
__gt__(a: float16, b: float16) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
%tmp = fcmp ogt half %a, %b
%res = zext i1 %tmp to i8
ret i8 %res
__le__(a: float16, b: float16) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
%tmp = fcmp ole half %a, %b
%res = zext i1 %tmp to i8
ret i8 %res
__ge__(a: float16, b: float16) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
%tmp = fcmp oge half %a, %b
%res = zext i1 %tmp to i8
ret i8 %res
__abs__(a: float16) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare half @llvm.fabs.f16(half %a)
%tmp = call half @llvm.fabs.f16(half %a)
ret half %tmp
__floor__(a: float16) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare half @llvm.floor.f16(half %a)
%tmp = call half @llvm.floor.f16(half %a)
ret half %tmp
__ceil__(a: float16) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare half @llvm.ceil.f16(half %a)
%tmp = call half @llvm.ceil.f16(half %a)
ret half %tmp
__trunc__(a: float16) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare half @llvm.trunc.f16(half %a)
%tmp = call half @llvm.trunc.f16(half %a)
ret half %tmp
__round__(a: float16) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare half @llvm.round.f16(half %a)
%tmp = call half @llvm.round.f16(half %a)
ret half %tmp
__pow__(a: float16, b: float16) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare half @llvm.pow.f16(half %a, half %b)
%tmp = call half @llvm.pow.f16(half %a, half %b)
ret half %tmp
__hash__(self)¶
__match__(self, obj: float16)¶
__add__(self: float16, b: int) @commutative Binary operator is commutative @overload Function is overloaded ¶
__sub__(self: float16, b: int) @overload Function is overloaded ¶
__mul__(self: float16, b: int) @commutative Binary operator is commutative @overload Function is overloaded ¶
__floordiv__(self, b: int) @overload Function is overloaded ¶
__truediv__(self: float16, b: int) @overload Function is overloaded ¶
__mod__(self: float16, b: int) @overload Function is overloaded ¶
__divmod__(self, b: int) @overload Function is overloaded ¶
__eq__(self: float16, b: int) @overload Function is overloaded ¶
__ne__(self: float16, b: int) @overload Function is overloaded ¶
__lt__(self: float16, b: int) @overload Function is overloaded ¶
__gt__(self: float16, b: int) @overload Function is overloaded ¶
__le__(self: float16, b: int) @overload Function is overloaded ¶
__ge__(self: float16, b: int) @overload Function is overloaded ¶
__pow__(self: float16, b: int) @overload Function is overloaded ¶
Methods¶
sqrt(a: float16) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare half @llvm.sqrt.f16(half %a)
%tmp = call half @llvm.sqrt.f16(half %a)
ret half %tmp
sin(a: float16) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare half @llvm.sin.f16(half %a)
%tmp = call half @llvm.sin.f16(half %a)
ret half %tmp
cos(a: float16) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare half @llvm.cos.f16(half %a)
%tmp = call half @llvm.cos.f16(half %a)
ret half %tmp
exp(a: float16) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare half @llvm.exp.f16(half %a)
%tmp = call half @llvm.exp.f16(half %a)
ret half %tmp
exp2(a: float16) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare half @llvm.exp2.f16(half %a)
%tmp = call half @llvm.exp2.f16(half %a)
ret half %tmp
log(a: float16) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare half @llvm.log.f16(half %a)
%tmp = call half @llvm.log.f16(half %a)
ret half %tmp
log10(a: float16) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare half @llvm.log10.f16(half %a)
%tmp = call half @llvm.log10.f16(half %a)
ret half %tmp
log2(a: float16) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare half @llvm.log2.f16(half %a)
%tmp = call half @llvm.log2.f16(half %a)
ret half %tmp
rint(a: float16) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare half @llvm.rint.f16(half %a)
%tmp = call half @llvm.rint.f16(half %a)
ret half %tmp
nearbyint(a: float16) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare half @llvm.nearbyint.f16(half %a)
%tmp = call half @llvm.nearbyint.f16(half %a)
ret half %tmp
min(a: float16, b: float16) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare half @llvm.minnum.f16(half %a, half %b)
%tmp = call half @llvm.minnum.f16(half %a, half %b)
ret half %tmp
max(a: float16, b: float16) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare half @llvm.maxnum.f16(half %a, half %b)
%tmp = call half @llvm.maxnum.f16(half %a, half %b)
ret half %tmp
copysign(a: float16, b: float16) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare half @llvm.copysign.f16(half %a, half %b)
%tmp = call half @llvm.copysign.f16(half %a, half %b)
ret half %tmp
fma(a: float16, b: float16, c: float16) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare half @llvm.fma.f16(half %a, half %b, half %c)
%tmp = call half @llvm.fma.f16(half %a, half %b, half %c)
ret half %tmp
bfloat16 @extend Class is extended to add given methods ¶
Magic methods¶
__new__(self: float) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
%0 = fptrunc double %self to bfloat
ret bfloat %0
__new__(what: bfloat16) @overload Function is overloaded ¶
__new__(what: str) @overload Function is overloaded ¶
__new__() @overload Function is overloaded ¶
__repr__(self)¶
__format__(self, format_spec: str)¶
__copy__(self)¶
__deepcopy__(self)¶
__int__(self) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
%0 = fptosi bfloat %self to i64
ret i64 %0
__float__(self) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
%0 = fpext bfloat %self to double
ret double %0
__bool__(self) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
%0 = fcmp une bfloat %self, 0.000000e+00
%1 = zext i1 %0 to i8
ret i8 %1
__pos__(self)¶
__neg__(self) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
%0 = fneg bfloat %self
ret bfloat %0
__add__(a: bfloat16, b: bfloat16) @pure Function has no side effects and returns same value for same inputs @commutative Binary operator is commutative @llvm Function is implemented with inline LLVM IR ¶
%tmp = fadd bfloat %a, %b
ret bfloat %tmp
__sub__(a: bfloat16, b: bfloat16) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
%tmp = fsub bfloat %a, %b
ret bfloat %tmp
__mul__(a: bfloat16, b: bfloat16) @pure Function has no side effects and returns same value for same inputs @commutative Binary operator is commutative @llvm Function is implemented with inline LLVM IR ¶
%tmp = fmul bfloat %a, %b
ret bfloat %tmp
__floordiv__(self, other: bfloat16)¶
__truediv__(a: bfloat16, b: bfloat16) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
%tmp = fdiv bfloat %a, %b
ret bfloat %tmp
__mod__(a: bfloat16, b: bfloat16) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
%tmp = frem bfloat %a, %b
ret bfloat %tmp
__divmod__(self, other: bfloat16)¶
__eq__(a: bfloat16, b: bfloat16) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
%tmp = fcmp oeq bfloat %a, %b
%res = zext i1 %tmp to i8
ret i8 %res
__ne__(a: bfloat16, b: bfloat16) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
%tmp = fcmp une bfloat %a, %b
%res = zext i1 %tmp to i8
ret i8 %res
__lt__(a: bfloat16, b: bfloat16) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
%tmp = fcmp olt bfloat %a, %b
%res = zext i1 %tmp to i8
ret i8 %res
__gt__(a: bfloat16, b: bfloat16) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
%tmp = fcmp ogt bfloat %a, %b
%res = zext i1 %tmp to i8
ret i8 %res
__le__(a: bfloat16, b: bfloat16) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
%tmp = fcmp ole bfloat %a, %b
%res = zext i1 %tmp to i8
ret i8 %res
__ge__(a: bfloat16, b: bfloat16) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
%tmp = fcmp oge bfloat %a, %b
%res = zext i1 %tmp to i8
ret i8 %res
__abs__(a: bfloat16) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare bfloat @llvm.fabs.bf16(bfloat %a)
%tmp = call bfloat @llvm.fabs.bf16(bfloat %a)
ret bfloat %tmp
__floor__(a: bfloat16) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare bfloat @llvm.floor.bf16(bfloat %a)
%tmp = call bfloat @llvm.floor.bf16(bfloat %a)
ret bfloat %tmp
__ceil__(a: bfloat16) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare bfloat @llvm.ceil.bf16(bfloat %a)
%tmp = call bfloat @llvm.ceil.bf16(bfloat %a)
ret bfloat %tmp
__trunc__(a: bfloat16) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare bfloat @llvm.trunc.bf16(bfloat %a)
%tmp = call bfloat @llvm.trunc.bf16(bfloat %a)
ret bfloat %tmp
__round__(a: bfloat16) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare bfloat @llvm.round.bf16(bfloat %a)
%tmp = call bfloat @llvm.round.bf16(bfloat %a)
ret bfloat %tmp
__pow__(a: bfloat16, b: bfloat16) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare bfloat @llvm.pow.bf16(bfloat %a, bfloat %b)
%tmp = call bfloat @llvm.pow.bf16(bfloat %a, bfloat %b)
ret bfloat %tmp
__hash__(self)¶
__match__(self, obj: bfloat16)¶
__add__(self: bfloat16, b: int) @commutative Binary operator is commutative @overload Function is overloaded ¶
__sub__(self: bfloat16, b: int) @overload Function is overloaded ¶
__mul__(self: bfloat16, b: int) @commutative Binary operator is commutative @overload Function is overloaded ¶
__floordiv__(self, b: int) @overload Function is overloaded ¶
__truediv__(self: bfloat16, b: int) @overload Function is overloaded ¶
__mod__(self: bfloat16, b: int) @overload Function is overloaded ¶
__divmod__(self, b: int) @overload Function is overloaded ¶
__eq__(self: bfloat16, b: int) @overload Function is overloaded ¶
__ne__(self: bfloat16, b: int) @overload Function is overloaded ¶
__lt__(self: bfloat16, b: int) @overload Function is overloaded ¶
__gt__(self: bfloat16, b: int) @overload Function is overloaded ¶
__le__(self: bfloat16, b: int) @overload Function is overloaded ¶
__ge__(self: bfloat16, b: int) @overload Function is overloaded ¶
__pow__(self: bfloat16, b: int) @overload Function is overloaded ¶
Methods¶
sqrt(a: bfloat16) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare bfloat @llvm.sqrt.bf16(bfloat %a)
%tmp = call bfloat @llvm.sqrt.bf16(bfloat %a)
ret bfloat %tmp
sin(a: bfloat16) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare bfloat @llvm.sin.bf16(bfloat %a)
%tmp = call bfloat @llvm.sin.bf16(bfloat %a)
ret bfloat %tmp
cos(a: bfloat16) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare bfloat @llvm.cos.bf16(bfloat %a)
%tmp = call bfloat @llvm.cos.bf16(bfloat %a)
ret bfloat %tmp
exp(a: bfloat16) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare bfloat @llvm.exp.bf16(bfloat %a)
%tmp = call bfloat @llvm.exp.bf16(bfloat %a)
ret bfloat %tmp
exp2(a: bfloat16) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare bfloat @llvm.exp2.bf16(bfloat %a)
%tmp = call bfloat @llvm.exp2.bf16(bfloat %a)
ret bfloat %tmp
log(a: bfloat16) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare bfloat @llvm.log.bf16(bfloat %a)
%tmp = call bfloat @llvm.log.bf16(bfloat %a)
ret bfloat %tmp
log10(a: bfloat16) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare bfloat @llvm.log10.bf16(bfloat %a)
%tmp = call bfloat @llvm.log10.bf16(bfloat %a)
ret bfloat %tmp
log2(a: bfloat16) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare bfloat @llvm.log2.bf16(bfloat %a)
%tmp = call bfloat @llvm.log2.bf16(bfloat %a)
ret bfloat %tmp
rint(a: bfloat16) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare bfloat @llvm.rint.bf16(bfloat %a)
%tmp = call bfloat @llvm.rint.bf16(bfloat %a)
ret bfloat %tmp
nearbyint(a: bfloat16) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare bfloat @llvm.nearbyint.bf16(bfloat %a)
%tmp = call bfloat @llvm.nearbyint.bf16(bfloat %a)
ret bfloat %tmp
min(a: bfloat16, b: bfloat16) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare bfloat @llvm.minnum.bf16(bfloat %a, bfloat %b)
%tmp = call bfloat @llvm.minnum.bf16(bfloat %a, bfloat %b)
ret bfloat %tmp
max(a: bfloat16, b: bfloat16) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare bfloat @llvm.maxnum.bf16(bfloat %a, bfloat %b)
%tmp = call bfloat @llvm.maxnum.bf16(bfloat %a, bfloat %b)
ret bfloat %tmp
copysign(a: bfloat16, b: bfloat16) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare bfloat @llvm.copysign.bf16(bfloat %a, bfloat %b)
%tmp = call bfloat @llvm.copysign.bf16(bfloat %a, bfloat %b)
ret bfloat %tmp
fma(a: bfloat16, b: bfloat16, c: bfloat16) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare bfloat @llvm.fma.bf16(bfloat %a, bfloat %b, bfloat %c)
%tmp = call bfloat @llvm.fma.bf16(bfloat %a, bfloat %b, bfloat %c)
ret bfloat %tmp
float128 @extend Class is extended to add given methods ¶
Magic methods¶
__new__(self: float) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
%0 = fpext double %self to fp128
ret fp128 %0
__new__(what: float128) @overload Function is overloaded ¶
__new__() @overload Function is overloaded ¶
__repr__(self)¶
__format__(self, format_spec: str)¶
__copy__(self)¶
__deepcopy__(self)¶
__int__(self) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
%0 = fptosi fp128 %self to i64
ret i64 %0
__float__(self) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
%0 = fptrunc fp128 %self to double
ret double %0
__bool__(self) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
%0 = fcmp une fp128 %self, 0xL00000000000000000000000000000000
%1 = zext i1 %0 to i8
ret i8 %1
__pos__(self)¶
__neg__(self) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
%0 = fneg fp128 %self
ret fp128 %0
__add__(a: float128, b: float128) @pure Function has no side effects and returns same value for same inputs @commutative Binary operator is commutative @llvm Function is implemented with inline LLVM IR ¶
%tmp = fadd fp128 %a, %b
ret fp128 %tmp
__sub__(a: float128, b: float128) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
%tmp = fsub fp128 %a, %b
ret fp128 %tmp
__mul__(a: float128, b: float128) @pure Function has no side effects and returns same value for same inputs @commutative Binary operator is commutative @llvm Function is implemented with inline LLVM IR ¶
%tmp = fmul fp128 %a, %b
ret fp128 %tmp
__floordiv__(self, other: float128)¶
__truediv__(a: float128, b: float128) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
%tmp = fdiv fp128 %a, %b
ret fp128 %tmp
__mod__(a: float128, b: float128) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
%tmp = frem fp128 %a, %b
ret fp128 %tmp
__divmod__(self, other: float128)¶
__eq__(a: float128, b: float128) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
%tmp = fcmp oeq fp128 %a, %b
%res = zext i1 %tmp to i8
ret i8 %res
__ne__(a: float128, b: float128) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
%tmp = fcmp une fp128 %a, %b
%res = zext i1 %tmp to i8
ret i8 %res
__lt__(a: float128, b: float128) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
%tmp = fcmp olt fp128 %a, %b
%res = zext i1 %tmp to i8
ret i8 %res
__gt__(a: float128, b: float128) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
%tmp = fcmp ogt fp128 %a, %b
%res = zext i1 %tmp to i8
ret i8 %res
__le__(a: float128, b: float128) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
%tmp = fcmp ole fp128 %a, %b
%res = zext i1 %tmp to i8
ret i8 %res
__ge__(a: float128, b: float128) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
%tmp = fcmp oge fp128 %a, %b
%res = zext i1 %tmp to i8
ret i8 %res
__abs__(a: float128) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare fp128 @llvm.fabs.f128(fp128 %a)
%tmp = call fp128 @llvm.fabs.f128(fp128 %a)
ret fp128 %tmp
__floor__(a: float128) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare fp128 @llvm.floor.f128(fp128 %a)
%tmp = call fp128 @llvm.floor.f128(fp128 %a)
ret fp128 %tmp
__ceil__(a: float128) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare fp128 @llvm.ceil.f128(fp128 %a)
%tmp = call fp128 @llvm.ceil.f128(fp128 %a)
ret fp128 %tmp
__trunc__(a: float128) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare fp128 @llvm.trunc.f128(fp128 %a)
%tmp = call fp128 @llvm.trunc.f128(fp128 %a)
ret fp128 %tmp
__round__(a: float128) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare fp128 @llvm.round.f128(fp128 %a)
%tmp = call fp128 @llvm.round.f128(fp128 %a)
ret fp128 %tmp
__pow__(a: float128, b: float128) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare fp128 @llvm.pow.f128(fp128 %a, fp128 %b)
%tmp = call fp128 @llvm.pow.f128(fp128 %a, fp128 %b)
ret fp128 %tmp
__hash__(self)¶
__match__(self, obj: float128)¶
__add__(self: float128, b: int) @commutative Binary operator is commutative @overload Function is overloaded ¶
__sub__(self: float128, b: int) @overload Function is overloaded ¶
__mul__(self: float128, b: int) @commutative Binary operator is commutative @overload Function is overloaded ¶
__floordiv__(self, b: int) @overload Function is overloaded ¶
__truediv__(self: float128, b: int) @overload Function is overloaded ¶
__mod__(self: float128, b: int) @overload Function is overloaded ¶
__divmod__(self, b: int) @overload Function is overloaded ¶
__eq__(self: float128, b: int) @overload Function is overloaded ¶
__ne__(self: float128, b: int) @overload Function is overloaded ¶
__lt__(self: float128, b: int) @overload Function is overloaded ¶
__gt__(self: float128, b: int) @overload Function is overloaded ¶
__le__(self: float128, b: int) @overload Function is overloaded ¶
__ge__(self: float128, b: int) @overload Function is overloaded ¶
__pow__(self: float128, b: int) @overload Function is overloaded ¶
Methods¶
sqrt(a: float128) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare fp128 @llvm.sqrt.f128(fp128 %a)
%tmp = call fp128 @llvm.sqrt.f128(fp128 %a)
ret fp128 %tmp
sin(a: float128) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare fp128 @llvm.sin.f128(fp128 %a)
%tmp = call fp128 @llvm.sin.f128(fp128 %a)
ret fp128 %tmp
cos(a: float128) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare fp128 @llvm.cos.f128(fp128 %a)
%tmp = call fp128 @llvm.cos.f128(fp128 %a)
ret fp128 %tmp
exp(a: float128) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare fp128 @llvm.exp.f128(fp128 %a)
%tmp = call fp128 @llvm.exp.f128(fp128 %a)
ret fp128 %tmp
exp2(a: float128) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare fp128 @llvm.exp2.f128(fp128 %a)
%tmp = call fp128 @llvm.exp2.f128(fp128 %a)
ret fp128 %tmp
log(a: float128) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare fp128 @llvm.log.f128(fp128 %a)
%tmp = call fp128 @llvm.log.f128(fp128 %a)
ret fp128 %tmp
log10(a: float128) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare fp128 @llvm.log10.f128(fp128 %a)
%tmp = call fp128 @llvm.log10.f128(fp128 %a)
ret fp128 %tmp
log2(a: float128) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare fp128 @llvm.log2.f128(fp128 %a)
%tmp = call fp128 @llvm.log2.f128(fp128 %a)
ret fp128 %tmp
rint(a: float128) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare fp128 @llvm.rint.f128(fp128 %a)
%tmp = call fp128 @llvm.rint.f128(fp128 %a)
ret fp128 %tmp
nearbyint(a: float128) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare fp128 @llvm.nearbyint.f128(fp128 %a)
%tmp = call fp128 @llvm.nearbyint.f128(fp128 %a)
ret fp128 %tmp
min(a: float128, b: float128) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare fp128 @llvm.minnum.f128(fp128 %a, fp128 %b)
%tmp = call fp128 @llvm.minnum.f128(fp128 %a, fp128 %b)
ret fp128 %tmp
max(a: float128, b: float128) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare fp128 @llvm.maxnum.f128(fp128 %a, fp128 %b)
%tmp = call fp128 @llvm.maxnum.f128(fp128 %a, fp128 %b)
ret fp128 %tmp
copysign(a: float128, b: float128) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare fp128 @llvm.copysign.f128(fp128 %a, fp128 %b)
%tmp = call fp128 @llvm.copysign.f128(fp128 %a, fp128 %b)
ret fp128 %tmp
fma(a: float128, b: float128, c: float128) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare fp128 @llvm.fma.f128(fp128 %a, fp128 %b, fp128 %c)
%tmp = call fp128 @llvm.fma.f128(fp128 %a, fp128 %b, fp128 %c)
ret fp128 %tmp