mirror/v
1
0
Fork 0
mirror of https://github.com/vlang/v.git synced 2023-08-10 21:13:21 +03:00
Code Issues Projects Releases Wiki Activity

all: vfmt (new const rule)

Browse Source
This commit is contained in:
Alexander Medvednikov
2021-01-24 10:54:27 +01:00
parent 12ff1c2702
commit 29d6e40f29
13 changed files with 114 additions and 107 deletions
Download Patch File Download Diff File Expand all files Collapse all files

58
vlib/math/bits/bits.v
View File

@ -63,7 +63,7 @@ pub fn trailing_zeros_16(x u16) int {
return 16
}
// see comment in trailing_zeros_64
return int(de_bruijn32tab[u32(x & -x) * de_bruijn32 >> (32 - 5)])
return int(bits.de_bruijn32tab[u32(x & -x) * bits.de_bruijn32 >> (32 - 5)])
}
// trailing_zeros_32 returns the number of trailing zero bits in x; the result is 32 for x == 0.
@ -72,7 +72,7 @@ pub fn trailing_zeros_32(x u32) int {
return 32
}
// see comment in trailing_zeros_64
return int(de_bruijn32tab[(x & -x) * de_bruijn32 >> (32 - 5)])
return int(bits.de_bruijn32tab[(x & -x) * bits.de_bruijn32 >> (32 - 5)])
}
// trailing_zeros_64 returns the number of trailing zero bits in x; the result is 64 for x == 0.
@ -91,7 +91,7 @@ pub fn trailing_zeros_64(x u64) int {
// find by how many bits it was shifted by looking at which six bit
// substring ended up at the top of the word.
// (Knuth, volume 4, section 7.3.1)
return int(de_bruijn64tab[(x & -x) * de_bruijn64 >> (64 - 6)])
return int(bits.de_bruijn64tab[(x & -x) * bits.de_bruijn64 >> (64 - 6)])
}
// --- OnesCount ---
@ -132,9 +132,9 @@ pub fn ones_count_64(x u64) int {
// Per "Hacker's Delight", the first line can be simplified
// more, but it saves at best one instruction, so we leave
// it alone for clarity.
mut y := (x >> u64(1) & (m0 & max_u64)) + (x & (m0 & max_u64))
y = (y >> u64(2) & (m1 & max_u64)) + (y & (m1 & max_u64))
y = ((y >> 4) + y) & (m2 & max_u64)
mut y := (x >> u64(1) & (bits.m0 & bits.max_u64)) + (x & (bits.m0 & bits.max_u64))
y = (y >> u64(2) & (bits.m1 & bits.max_u64)) + (y & (bits.m1 & bits.max_u64))
y = ((y >> 4) + y) & (bits.m2 & bits.max_u64)
y += y >> 8
y += y >> 16
y += y >> 32
@ -202,18 +202,18 @@ pub fn reverse_16(x u16) u16 {
// reverse_32 returns the value of x with its bits in reversed order.
[inline]
pub fn reverse_32(x u32) u32 {
mut y := ((x >> u32(1) & (m0 & max_u32)) | ((x & (m0 & max_u32)) << 1))
y = ((y >> u32(2) & (m1 & max_u32)) | ((y & (m1 & max_u32)) << u32(2)))
y = ((y >> u32(4) & (m2 & max_u32)) | ((y & (m2 & max_u32)) << u32(4)))
mut y := ((x >> u32(1) & (bits.m0 & bits.max_u32)) | ((x & (bits.m0 & bits.max_u32)) << 1))
y = ((y >> u32(2) & (bits.m1 & bits.max_u32)) | ((y & (bits.m1 & bits.max_u32)) << u32(2)))
y = ((y >> u32(4) & (bits.m2 & bits.max_u32)) | ((y & (bits.m2 & bits.max_u32)) << u32(4)))
return reverse_bytes_32(u32(y))
}
// reverse_64 returns the value of x with its bits in reversed order.
[inline]
pub fn reverse_64(x u64) u64 {
mut y := ((x >> u64(1) & (m0 & max_u64)) | ((x & (m0 & max_u64)) << 1))
y = ((y >> u64(2) & (m1 & max_u64)) | ((y & (m1 & max_u64)) << 2))
y = ((y >> u64(4) & (m2 & max_u64)) | ((y & (m2 & max_u64)) << 4))
mut y := ((x >> u64(1) & (bits.m0 & bits.max_u64)) | ((x & (bits.m0 & bits.max_u64)) << 1))
y = ((y >> u64(2) & (bits.m1 & bits.max_u64)) | ((y & (bits.m1 & bits.max_u64)) << 2))
y = ((y >> u64(4) & (bits.m2 & bits.max_u64)) | ((y & (bits.m2 & bits.max_u64)) << 4))
return reverse_bytes_64(y)
}
@ -231,7 +231,7 @@ pub fn reverse_bytes_16(x u16) u16 {
// This function's execution time does not depend on the inputs.
[inline]
pub fn reverse_bytes_32(x u32) u32 {
y := ((x >> u32(8) & (m3 & max_u32)) | ((x & (m3 & max_u32)) << u32(8)))
y := ((x >> u32(8) & (bits.m3 & bits.max_u32)) | ((x & (bits.m3 & bits.max_u32)) << u32(8)))
return u32((y >> 16) | (y << 16))
}
@ -240,8 +240,8 @@ pub fn reverse_bytes_32(x u32) u32 {
// This function's execution time does not depend on the inputs.
[inline]
pub fn reverse_bytes_64(x u64) u64 {
mut y := ((x >> u64(8) & (m3 & max_u64)) | ((x & (m3 & max_u64)) << u64(8)))
y = ((y >> u64(16) & (m4 & max_u64)) | ((y & (m4 & max_u64)) << u64(16)))
mut y := ((x >> u64(8) & (bits.m3 & bits.max_u64)) | ((x & (bits.m3 & bits.max_u64)) << u64(8)))
y = ((y >> u64(16) & (bits.m4 & bits.max_u64)) | ((y & (bits.m4 & bits.max_u64)) << u64(16)))
return (y >> 32) | (y << 32)
}
@ -385,13 +385,13 @@ pub fn mul_32(x u32, y u32) (u32, u32) {
//
// This function's execution time does not depend on the inputs.
pub fn mul_64(x u64, y u64) (u64, u64) {
x0 := x & mask32
x0 := x & bits.mask32
x1 := x >> 32
y0 := y & mask32
y0 := y & bits.mask32
y1 := y >> 32
w0 := x0 * y0
t := x1 * y0 + (w0 >> 32)
mut w1 := t & mask32
mut w1 := t & bits.mask32
w2 := t >> 32
w1 += x0 * y1
hi := x1 * y1 + w2 + (w1 >> 32)
@ -406,7 +406,7 @@ pub fn mul_64(x u64, y u64) (u64, u64) {
// div_32 panics for y == 0 (division by zero) or y <= hi (quotient overflow).
pub fn div_32(hi u32, lo u32, y u32) (u32, u32) {
if y != 0 && y <= hi {
panic(overflow_error)
panic(bits.overflow_error)
}
z := (u64(hi) << 32) | u64(lo)
quo := u32(z / u64(y))
@ -421,39 +421,39 @@ pub fn div_32(hi u32, lo u32, y u32) (u32, u32) {
pub fn div_64(hi u64, lo u64, y1 u64) (u64, u64) {
mut y := y1
if y == 0 {
panic(overflow_error)
panic(bits.overflow_error)
}
if y <= hi {
panic(overflow_error)
panic(bits.overflow_error)
}
s := u32(leading_zeros_64(y))
y <<= s
yn1 := y >> 32
yn0 := y & mask32
yn0 := y & bits.mask32
un32 := (hi << s) | (lo >> (64 - s))
un10 := lo << s
un1 := un10 >> 32
un0 := un10 & mask32
un0 := un10 & bits.mask32
mut q1 := un32 / yn1
mut rhat := un32 - q1 * yn1
for q1 >= two32 || q1 * yn0 > two32 * rhat + un1 {
for q1 >= bits.two32 || q1 * yn0 > bits.two32 * rhat + un1 {
q1--
rhat += yn1
if rhat >= two32 {
if rhat >= bits.two32 {
break
}
}
un21 := un32 * two32 + un1 - q1 * y
un21 := un32 * bits.two32 + un1 - q1 * y
mut q0 := un21 / yn1
rhat = un21 - q0 * yn1
for q0 >= two32 || q0 * yn0 > two32 * rhat + un0 {
for q0 >= bits.two32 || q0 * yn0 > bits.two32 * rhat + un0 {
q0--
rhat += yn1
if rhat >= two32 {
if rhat >= bits.two32 {
break
}
}
return q1 * two32 + q0, (un21 * two32 + un0 - q0 * y) >> s
return q1 * bits.two32 + q0, (un21 * bits.two32 + un0 - q0 * y) >> s
}
// rem_32 returns the remainder of (hi, lo) divided by y. Rem32 panics