- Sort Score
- Result 10 results
- Languages All
Results 1 - 10 of 27 for Div64F (2.29 sec)
-
src/cmd/compile/internal/ssa/_gen/genericOps.go
{name: "Div16", argLength: 2, aux: "Bool"}, {name: "Div16u", argLength: 2}, {name: "Div32", argLength: 2, aux: "Bool"}, {name: "Div32u", argLength: 2}, {name: "Div64", argLength: 2, aux: "Bool"}, {name: "Div64u", argLength: 2}, {name: "Div128u", argLength: 3}, // arg0:arg1 / arg2 (128-bit divided by 64-bit), returns (q, r) // For Mod16, Mod32 and Mod64, AuxInt non-zero means that the divisor has been proved to be not -1.
Registered: Wed Jun 12 16:32:35 UTC 2024 - Last Modified: Thu May 23 15:49:20 UTC 2024 - 42.6K bytes - Viewed (0) -
src/cmd/compile/internal/ssa/_gen/generic.rules
(Div32F (Const32F [c]) (Const32F [d])) && c/d == c/d => (Const32F [c/d]) (Div64F (Const64F [c]) (Const64F [d])) && c/d == c/d => (Const64F [c/d]) (Select0 (Div128u (Const64 [0]) lo y)) => (Div64u lo y) (Select1 (Div128u (Const64 [0]) lo y)) => (Mod64u lo y) (Not (ConstBool [c])) => (ConstBool [!c]) (Floor (Const64F [c])) => (Const64F [math.Floor(c)]) (Ceil (Const64F [c])) => (Const64F [math.Ceil(c)])
Registered: Wed Jun 12 16:32:35 UTC 2024 - Last Modified: Thu May 16 22:21:05 UTC 2024 - 135.3K bytes - Viewed (0) -
src/cmd/compile/internal/ssa/_gen/S390X.rules
(Mul64 ...) => (MULLD ...) (Mul(32|16|8) ...) => (MULLW ...) (Mul32F ...) => (FMULS ...) (Mul64F ...) => (FMUL ...) (Mul64uhilo ...) => (MLGR ...) (Div32F ...) => (FDIVS ...) (Div64F ...) => (FDIV ...) (Div64 x y) => (DIVD x y) (Div64u ...) => (DIVDU ...) // DIVW/DIVWU has a 64-bit dividend and a 32-bit divisor, // so a sign/zero extension of the dividend is required. (Div32 x y) => (DIVW (MOVWreg x) y)
Registered: Wed Jun 12 16:32:35 UTC 2024 - Last Modified: Thu Oct 12 18:09:26 UTC 2023 - 74.3K bytes - Viewed (0) -
src/cmd/compile/internal/ssa/_gen/ARM64.rules
(Select1 (Mul64uhilo x y)) => (MUL x y) (Div64 [false] x y) => (DIV x y) (Div32 [false] x y) => (DIVW x y) (Div16 [false] x y) => (DIVW (SignExt16to32 x) (SignExt16to32 y)) (Div16u x y) => (UDIVW (ZeroExt16to32 x) (ZeroExt16to32 y)) (Div8 x y) => (DIVW (SignExt8to32 x) (SignExt8to32 y)) (Div8u x y) => (UDIVW (ZeroExt8to32 x) (ZeroExt8to32 y)) (Div64u ...) => (UDIV ...) (Div32u ...) => (UDIVW ...)
Registered: Wed Jun 12 16:32:35 UTC 2024 - Last Modified: Thu May 23 15:49:20 UTC 2024 - 113.1K bytes - Viewed (0) -
src/math/bits/bits_test.go
{_M64, _M64, _M64 - 1, 1, 42}, } { testMul("Mul64", Mul64, a.x, a.y, a.hi, a.lo) testMul("Mul64 symmetric", Mul64, a.y, a.x, a.hi, a.lo) testDiv("Div64", Div64, a.hi, a.lo+a.r, a.y, a.x, a.r) testDiv("Div64 symmetric", Div64, a.hi, a.lo+a.r, a.x, a.y, a.r) // The above code can't test intrinsic implementation, because the passed function is not called directly.
Registered: Wed Jun 12 16:32:35 UTC 2024 - Last Modified: Wed Apr 22 20:11:06 UTC 2020 - 32.5K bytes - Viewed (0) -
src/testing/testing_windows.go
if queryPerformanceFrequency == 0 { queryPerformanceFrequency = windows.QueryPerformanceFrequency() } hi, lo := bits.Mul64(uint64(delta), uint64(time.Second)/uint64(time.Nanosecond)) quo, _ := bits.Div64(hi, lo, uint64(queryPerformanceFrequency)) return time.Duration(quo) } var queryPerformanceFrequency int64 // highPrecisionTimeSince returns duration since a.
Registered: Wed Jun 12 16:32:35 UTC 2024 - Last Modified: Fri Apr 26 22:55:25 UTC 2024 - 1.9K bytes - Viewed (0) -
src/math/bits/bits.go
quo, rem = uint32(z/uint64(y)), uint32(z%uint64(y)) return } // Div64 returns the quotient and remainder of (hi, lo) divided by y: // quo = (hi, lo)/y, rem = (hi, lo)%y with the dividend bits' upper // half in parameter hi and the lower half in parameter lo. // Div64 panics for y == 0 (division by zero) or y <= hi (quotient overflow). func Div64(hi, lo, y uint64) (quo, rem uint64) { if y == 0 { panic(divideError) }
Registered: Wed Jun 12 16:32:35 UTC 2024 - Last Modified: Thu Oct 19 11:59:09 UTC 2023 - 17.9K bytes - Viewed (0) -
src/math/bits/example_math_test.go
// Divide them together. quo, rem := bits.Div64(n1[0], n1[1], n2[1]) nsum := []uint64{quo, rem} fmt.Printf("[%v %v] / %v = %v\n", n1[0], n1[1], n2[1], nsum) // First number is 2<<64 + 9223372036854775808 n1 = []uint64{2, 0x8000000000000000} // Second number is 0<<64 + 9223372036854775808 n2 = []uint64{0, 0x8000000000000000} // Divide them together. quo, rem = bits.Div64(n1[0], n1[1], n2[1]) nsum = []uint64{quo, rem}
Registered: Wed Jun 12 16:32:35 UTC 2024 - Last Modified: Thu Nov 11 21:27:05 UTC 2021 - 6.3K bytes - Viewed (0) -
src/cmd/compile/internal/ssa/_gen/Wasm.rules
(Mul(64|32|16|8) ...) => (I64Mul ...) (Mul(64|32)F ...) => (F(64|32)Mul ...) (Div64 [false] x y) => (I64DivS x y) (Div32 [false] x y) => (I64DivS (SignExt32to64 x) (SignExt32to64 y)) (Div16 [false] x y) => (I64DivS (SignExt16to64 x) (SignExt16to64 y)) (Div8 x y) => (I64DivS (SignExt8to64 x) (SignExt8to64 y)) (Div64u ...) => (I64DivU ...) (Div32u x y) => (I64DivU (ZeroExt32to64 x) (ZeroExt32to64 y))
Registered: Wed Jun 12 16:32:35 UTC 2024 - Last Modified: Fri Feb 17 03:56:57 UTC 2023 - 16.9K bytes - Viewed (0) -
test/codegen/mathbits.go
Registered: Wed Jun 12 16:32:35 UTC 2024 - Last Modified: Thu May 23 18:51:17 UTC 2024 - 19.6K bytes - Viewed (0)