vieter-v
/
v
2
0
Fork 0
Code Issues Pull Requests Releases Activity

bitfield: rename functions, getsize => get_size, etc.

pull/4770/head
Don Alfons Nisnoni 2020-05-07 16:21:14 +08:00 committed by GitHub
parent 0f8ed84333
commit 0a930f9862
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
2 changed files with 86 additions and 86 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

76
vlib/bitfield/bitfield.v
View File

@ -42,7 +42,7 @@ pub fn from_str(input string) BitField {
mut output := new(input.len) mut output := new(input.len)
for i in 0..input.len { for i in 0..input.len {
if input[i] != `0` { if input[i] != `0` {
output.setbit(i) output.set_bit(i)
} }
} }
return output return output
@ -53,7 +53,7 @@ pub fn from_str(input string) BitField {
pub fn (input BitField) str() string { pub fn (input BitField) str() string {
mut output := '' mut output := ''
for i in 0..input.size { for i in 0..input.size {
if input.getbit(i) == 1 { if input.get_bit(i) == 1 {
output = output + '1' output = output + '1'
} }
else { else {
@ -79,105 +79,105 @@ pub fn del(instance *BitField) {
} }
*/ */
// getbit returns the value (0 or 1) of bit number 'bit_nr' (count from 0). // get_bit returns the value (0 or 1) of bit number 'bit_nr' (count from 0).
pub fn (instance BitField) getbit(bitnr int) int { pub fn (instance BitField) get_bit(bitnr int) int {
if bitnr >= instance.size { if bitnr >= instance.size {
return 0 return 0
} }
return (instance.field[bitslot(bitnr)] >> (bitnr % SLOT_SIZE)) & u32(1) return (instance.field[bitslot(bitnr)] >> (bitnr % SLOT_SIZE)) & u32(1)
} }
// setbit sets bit number 'bit_nr' to 1 (count from 0). // set_bit sets bit number 'bit_nr' to 1 (count from 0).
pub fn (instance mut BitField) setbit(bitnr int) { pub fn (instance mut BitField) set_bit(bitnr int) {
if bitnr >= instance.size { if bitnr >= instance.size {
return return
} }
instance.field[bitslot(bitnr)] |= bitmask(bitnr) instance.field[bitslot(bitnr)] |= bitmask(bitnr)
} }
// clearbit clears (sets to zero) bit number 'bit_nr' (count from 0). // clear_bit clears (sets to zero) bit number 'bit_nr' (count from 0).
pub fn (instance mut BitField) clearbit(bitnr int) { pub fn (instance mut BitField) clear_bit(bitnr int) {
if bitnr >= instance.size { if bitnr >= instance.size {
return return
} }
instance.field[bitslot(bitnr)] &= ~bitmask(bitnr) instance.field[bitslot(bitnr)] &= ~bitmask(bitnr)
} }
// setall sets all bits in the array to 1. // set_all sets all bits in the array to 1.
pub fn (instance mut BitField) setall() { pub fn (instance mut BitField) set_all() {
for i in 0..bitnslots(instance.size) { for i in 0..bitnslots(instance.size) {
instance.field[i] = u32(-1) instance.field[i] = u32(-1)
} }
instance.cleartail() instance.clear_tail()
} }
// clearall clears (sets to zero) all bits in the array. // clear_all clears (sets to zero) all bits in the array.
pub fn (instance mut BitField) clearall() { pub fn (instance mut BitField) clear_all() {
for i in 0..bitnslots(instance.size) { for i in 0..bitnslots(instance.size) {
instance.field[i] = u32(0) instance.field[i] = u32(0)
} }
} }
// togglebit changes the value (from 0 to 1 or from 1 to 0) of bit // toggle_bit changes the value (from 0 to 1 or from 1 to 0) of bit
// number 'bit_nr'. // number 'bit_nr'.
pub fn (instance mut BitField) togglebit(bitnr int) { pub fn (instance mut BitField) toggle_bit(bitnr int) {
if bitnr >= instance.size { if bitnr >= instance.size {
return return
} }
instance.field[bitslot(bitnr)] ^= bitmask(bitnr) instance.field[bitslot(bitnr)] ^= bitmask(bitnr)
} }
// bfand performs logical AND operation on every pair of bits from 'input1' and // bf_and performs logical AND operation on every pair of bits from 'input1' and
// 'input2' and returns the result as a new array. If inputs differ in size, // 'input2' and returns the result as a new array. If inputs differ in size,
// the tail of the longer one is ignored. // the tail of the longer one is ignored.
pub fn bfand(input1 BitField, input2 BitField) BitField { pub fn bf_and(input1 BitField, input2 BitField) BitField {
size := min(input1.size, input2.size) size := min(input1.size, input2.size)
bitnslots := bitnslots(size) bitnslots := bitnslots(size)
mut output := new(size) mut output := new(size)
for i in 0..bitnslots { for i in 0..bitnslots {
output.field[i] = input1.field[i] & input2.field[i] output.field[i] = input1.field[i] & input2.field[i]
} }
output.cleartail() output.clear_tail()
return output return output
} }
// bfnot toggles all bits in a bit array and returns the result as a new array. // bf_not toggles all bits in a bit array and returns the result as a new array.
pub fn bfnot(input BitField) BitField { pub fn bf_not(input BitField) BitField {
size := input.size size := input.size
bitnslots := bitnslots(size) bitnslots := bitnslots(size)
mut output := new(size) mut output := new(size)
for i in 0..bitnslots { for i in 0..bitnslots {
output.field[i] = ~input.field[i] output.field[i] = ~input.field[i]
} }
output.cleartail() output.clear_tail()
return output return output
} }
// bfor performs logical OR operation on every pair of bits from 'input1' and // bf_or performs logical OR operation on every pair of bits from 'input1' and
// 'input2' and returns the result as a new array. If inputs differ in size, // 'input2' and returns the result as a new array. If inputs differ in size,
// the tail of the longer one is ignored. // the tail of the longer one is ignored.
pub fn bfor(input1 BitField, input2 BitField) BitField { pub fn bf_or(input1 BitField, input2 BitField) BitField {
size := min(input1.size, input2.size) size := min(input1.size, input2.size)
bitnslots := bitnslots(size) bitnslots := bitnslots(size)
mut output := new(size) mut output := new(size)
for i in 0..bitnslots { for i in 0..bitnslots {
output.field[i] = input1.field[i] | input2.field[i] output.field[i] = input1.field[i] | input2.field[i]
} }
output.cleartail() output.clear_tail()
return output return output
} }
// bfxor perform logical XOR operation on every pair of bits from 'input1' and // bf_xor perform logical XOR operation on every pair of bits from 'input1' and
// 'input2' and returns the result as a new array. If inputs differ in size, // 'input2' and returns the result as a new array. If inputs differ in size,
// the tail of the longer one is ignored. // the tail of the longer one is ignored.
pub fn bfxor(input1 BitField, input2 BitField) BitField { pub fn bf_xor(input1 BitField, input2 BitField) BitField {
size := min(input1.size, input2.size) size := min(input1.size, input2.size)
bitnslots := bitnslots(size) bitnslots := bitnslots(size)
mut output := new(size) mut output := new(size)
for i in 0..bitnslots { for i in 0..bitnslots {
output.field[i] = input1.field[i] ^ input2.field[i] output.field[i] = input1.field[i] ^ input2.field[i]
} }
output.cleartail() output.clear_tail()
return output return output
} }
@ -226,8 +226,8 @@ pub fn join(input1 BitField, input2 BitField) BitField {
return output return output
} }
// getsize returns the number of bits the array can hold. // get_size returns the number of bits the array can hold.
pub fn (instance BitField) getsize() int { pub fn (instance BitField) get_size() int {
return instance.size return instance.size
} }
@ -251,8 +251,8 @@ pub fn (instance BitField) cmp(input BitField) bool {
return true return true
} }
// popcount returns the number of set bits (ones) in the array. // pop_count returns the number of set bits (ones) in the array.
pub fn (instance BitField) popcount() int { pub fn (instance BitField) pop_count() int {
size := instance.size size := instance.size
bitnslots := bitnslots(size) bitnslots := bitnslots(size)
tail := size % SLOT_SIZE tail := size % SLOT_SIZE
@ -273,9 +273,9 @@ pub fn (instance BitField) popcount() int {
} }
// hamming computes the Hamming distance between two bit arrays. // hamming computes the Hamming distance between two bit arrays.
pub fn hamming (input1 BitField, input2 BitField) int { pub fn hamming(input1 BitField, input2 BitField) int {
input_xored := bfxor(input1, input2) input_xored := bf_xor(input1, input2)
return input_xored.popcount() return input_xored.pop_count()
} }
// pos checks if the array contains a sub-array 'needle' and returns its // pos checks if the array contains a sub-array 'needle' and returns its
@ -376,14 +376,14 @@ pub fn (instance BitField) reverse() BitField {
for i:= 0; i < (bitnslots - 1); i++ { for i:= 0; i < (bitnslots - 1); i++ {
for j in 0..SLOT_SIZE { for j in 0..SLOT_SIZE {
if u32(instance.field[i] >> u32(j)) & u32(1) == u32(1) { if u32(instance.field[i] >> u32(j)) & u32(1) == u32(1) {
output.setbit(size - i * SLOT_SIZE - j - 1) output.set_bit(size - i * SLOT_SIZE - j - 1)
} }
} }
} }
bits_in_last_input_slot := (size - 1) % SLOT_SIZE + 1 bits_in_last_input_slot := (size - 1) % SLOT_SIZE + 1
for j in 0..bits_in_last_input_slot { for j in 0..bits_in_last_input_slot {
if u32(instance.field[bitnslots - 1] >> u32(j)) & u32(1) == u32(1) { if u32(instance.field[bitnslots - 1] >> u32(j)) & u32(1) == u32(1) {
output.setbit(bits_in_last_input_slot - j - 1) output.set_bit(bits_in_last_input_slot - j - 1)
} }
} }
return output return output
@ -401,7 +401,7 @@ pub fn (instance mut BitField) resize(new_size int) {
instance.field = field.clone() instance.field = field.clone()
instance.size = new_size instance.size = new_size
if new_size < old_size && new_size % SLOT_SIZE != 0 { if new_size < old_size && new_size % SLOT_SIZE != 0 {
instance.cleartail() instance.clear_tail()
} }
} }
@ -433,7 +433,7 @@ pub fn (instance BitField) rotate(offset int) BitField {
// Internal functions // Internal functions
fn (instance mut BitField) cleartail() { fn (instance mut BitField) clear_tail() {
tail := instance.size % SLOT_SIZE tail := instance.size % SLOT_SIZE
if tail != 0 { if tail != 0 {
// create a mask for the tail // create a mask for the tail

96
vlib/bitfield/bitfield_test.v
View File

@ -5,17 +5,17 @@ import time
fn test_bf_new_size() { fn test_bf_new_size() {
instance := bitfield.new(75) instance := bitfield.new(75)
assert instance.getsize() == 75 assert instance.get_size() == 75
} }
fn test_bf_set_clear_toggle_get() { fn test_bf_set_clear_toggle_get() {
mut instance := bitfield.new(75) mut instance := bitfield.new(75)
instance.setbit(47) instance.set_bit(47)
assert instance.getbit(47) == 1 assert instance.get_bit(47) == 1
instance.clearbit(47) instance.clear_bit(47)
assert instance.getbit(47) == 0 assert instance.get_bit(47) == 0
instance.togglebit(47) instance.toggle_bit(47)
assert instance.getbit(47) == 1 assert instance.get_bit(47) == 1
} }
fn test_bf_and_not_or_xor() { fn test_bf_and_not_or_xor() {
@ -26,21 +26,21 @@ fn test_bf_and_not_or_xor() {
mut i := 0 mut i := 0
for i < len { for i < len {
if rand.next(2) == 1 { if rand.next(2) == 1 {
input1.setbit(i) input1.set_bit(i)
} }
if rand.next(2) == 1{ if rand.next(2) == 1{
input2.setbit(i) input2.set_bit(i)
} }
i++ i++
} }
output1 := bitfield.bfxor(input1, input2) output1 := bitfield.bf_xor(input1, input2)
bfand := bitfield.bfand(input1, input2) bf_and := bitfield.bf_and(input1, input2)
bfor := bitfield.bfor(input1, input2) bf_or := bitfield.bf_or(input1, input2)
bfnot := bitfield.bfnot(bfand) bf_not := bitfield.bf_not(bf_and)
output2 := bitfield.bfand(bfor, bfnot) output2 := bitfield.bf_and(bf_or, bf_not)
mut result := 1 mut result := 1
for i < len { for i < len {
if output1.getbit(i) != output2.getbit(i) {result = 0} if output1.get_bit(i) != output2.get_bit(i) {result = 0}
} }
assert result == 1 assert result == 1
} }
@ -51,11 +51,11 @@ fn test_clone_cmp() {
mut input := bitfield.new(len) mut input := bitfield.new(len)
for i in 0..len { for i in 0..len {
if rand.next(2) == 1 { if rand.next(2) == 1 {
input.setbit(i) input.set_bit(i)
} }
} }
output := input.clone() output := input.clone()
assert output.getsize() == len assert output.get_size() == len
assert input.cmp(output) == true assert input.cmp(output) == true
} }
@ -65,14 +65,14 @@ fn test_slice_join() {
mut input := bitfield.new(len) mut input := bitfield.new(len)
for i in 0..len { for i in 0..len {
if rand.next(2) == 1 { if rand.next(2) == 1 {
input.setbit(i) input.set_bit(i)
} }
} }
mut result := 1 mut result := 1
for point := 1; point < (len - 1); point++ { for point := 1; point < (len - 1); point++ {
// divide a bitfield into two subfields // divide a bitfield into two subfields
chunk1 := input.slice(0, point) chunk1 := input.slice(0, point)
chunk2 := input.slice(point, input.getsize()) chunk2 := input.slice(point, input.get_size())
// concatenate them back into one and compare to the original // concatenate them back into one and compare to the original
output := bitfield.join(chunk1, chunk2) output := bitfield.join(chunk1, chunk2)
if !input.cmp(output) { if !input.cmp(output) {
@ -82,18 +82,18 @@ fn test_slice_join() {
assert result == 1 assert result == 1
} }
fn test_popcount() { fn test_pop_count() {
rand.seed(time.now().unix) rand.seed(time.now().unix)
len := 80 len := 80
mut count0 := 0 mut count0 := 0
mut input := bitfield.new(len) mut input := bitfield.new(len)
for i in 0..len { for i in 0..len {
if rand.next(2) == 1 { if rand.next(2) == 1 {
input.setbit(i) input.set_bit(i)
count0++ count0++
} }
} }
count1 := input.popcount() count1 := input.pop_count()
assert count0 == count1 assert count0 == count1
} }
@ -106,16 +106,16 @@ fn test_hamming() {
for i in 0..len { for i in 0..len {
match rand.next(4) { match rand.next(4) {
0, 1 { 0, 1 {
input1.setbit(i) input1.set_bit(i)
count++ count++
} }
2 { 2 {
input2.setbit(i) input2.set_bit(i)
count++ count++
} }
3 { 3 {
input1.setbit(i) input1.set_bit(i)
input2.setbit(i) input2.set_bit(i)
} }
else { else {
@ -130,7 +130,7 @@ fn test_bf_from_bytes() {
output := bitfield.from_bytes(input) output := bitfield.from_bytes(input)
mut result := 1 mut result := 1
for i in 0..input.len * 8 { for i in 0..input.len * 8 {
if (input[i / 8] >> (i % 8)) & 1 != output.getbit(i) { if (input[i / 8] >> (i % 8)) & 1 != output.get_bit(i) {
result = 0 result = 0
} }
} }
@ -152,7 +152,7 @@ fn test_bf_from_str() {
output := bitfield.from_str(input) output := bitfield.from_str(input)
mut result := 1 mut result := 1
for i in 0..len { for i in 0..len {
if input[i] != output.getbit(i) + 48 { if input[i] != output.get_bit(i) + 48 {
result = 0 result = 0
} }
} }
@ -165,12 +165,12 @@ fn test_bf_bf2str() {
mut input := bitfield.new(len) mut input := bitfield.new(len)
for i in 0..len { for i in 0..len {
if rand.next(2) == 1 { if rand.next(2) == 1 {
input.setbit(i) input.set_bit(i)
} }
} }
mut check := '' mut check := ''
for i in 0..len { for i in 0..len {
if input.getbit(i) == 1 { if input.get_bit(i) == 1 {
check = check + '1' check = check + '1'
} }
else { else {
@ -187,33 +187,33 @@ fn test_bf_bf2str() {
assert result == 1 assert result == 1
} }
fn test_bf_setall() { fn test_bf_set_all() {
rand.seed(time.now().unix) rand.seed(time.now().unix)
len := 80 len := 80
mut input := bitfield.new(len) mut input := bitfield.new(len)
input.setall() input.set_all()
mut result := 1 mut result := 1
for i in 0..len { for i in 0..len {
if input.getbit(i) != 1 { if input.get_bit(i) != 1 {
result = 0 result = 0
} }
} }
assert result == 1 assert result == 1
} }
fn test_bf_clearall() { fn test_bf_clear_all() {
rand.seed(time.now().unix) rand.seed(time.now().unix)
len := 80 len := 80
mut input := bitfield.new(len) mut input := bitfield.new(len)
for i in 0..len { for i in 0..len {
if rand.next(2) == 1 { if rand.next(2) == 1 {
input.setbit(i) input.set_bit(i)
} }
} }
input.clearall() input.clear_all()
mut result := 1 mut result := 1
for i in 0..len { for i in 0..len {
if input.getbit(i) != 0 { if input.get_bit(i) != 0 {
result = 0 result = 0
} }
} }
@ -226,14 +226,14 @@ fn test_bf_reverse() {
mut input := bitfield.new(len) mut input := bitfield.new(len)
for i in 0..len { for i in 0..len {
if rand.next(2) == 1 { if rand.next(2) == 1 {
input.setbit(i) input.set_bit(i)
} }
} }
check := input.clone() check := input.clone()
output := input.reverse() output := input.reverse()
mut result := 1 mut result := 1
for i in 0..len { for i in 0..len {
if output.getbit(i) != check.getbit(len - i - 1) { if output.get_bit(i) != check.get_bit(len - i - 1) {
result = 0 result = 0
} }
} }
@ -246,9 +246,9 @@ fn test_bf_resize() {
mut input := bitfield.new(rand.next(len) + 1) mut input := bitfield.new(rand.next(len) + 1)
for _ in 0..100 { for _ in 0..100 {
input.resize(rand.next(len) + 1) input.resize(rand.next(len) + 1)
input.setbit(input.getsize() - 1) input.set_bit(input.get_size() - 1)
} }
assert input.getbit(input.getsize() - 1) == 1 assert input.get_bit(input.get_size() - 1) == 1
} }
fn test_bf_pos() { fn test_bf_pos() {
@ -270,13 +270,13 @@ fn test_bf_pos() {
// fill the needle with random values // fill the needle with random values
for k in 0..i { for k in 0..i {
if rand.next(2) == 1 { if rand.next(2) == 1 {
needle.setbit(k) needle.set_bit(k)
} }
} }
// make sure the needle contains at least one set bit, selected randomly // make sure the needle contains at least one set bit, selected randomly
r := rand.next(i) r := rand.next(i)
needle.setbit(r) needle.set_bit(r)
// create the haystack, make sure it contains the needle // create the haystack, make sure it contains the needle
mut haystack := needle.clone() mut haystack := needle.clone()
@ -311,10 +311,10 @@ fn test_bf_rotate() {
for i := 1; i < 80 && result == 1; i++ { for i := 1; i < 80 && result == 1; i++ {
mut chunk1 := bitfield.new(i) mut chunk1 := bitfield.new(i)
chunk2 := bitfield.new(len - i) chunk2 := bitfield.new(len - i)
chunk1.setall() chunk1.set_all()
input := bitfield.join(chunk1, chunk2) input := bitfield.join(chunk1, chunk2)
output := input.rotate(i) output := input.rotate(i)
if output.getbit(len - i - 1) != 0 || output.getbit(len - i) != 1 { if output.get_bit(len - i - 1) != 0 || output.get_bit(len - i) != 1 {
result = 0 result = 0
} }
} }
@ -327,7 +327,7 @@ fn test_bf_printing(){
mut input := bitfield.new(len) mut input := bitfield.new(len)
for i in 0..len { for i in 0..len {
if rand.next(2) == 0 { if rand.next(2) == 0 {
input.setbit(i) input.set_bit(i)
} }
} }
// the following should convert the bitfield input into a string automatically // the following should convert the bitfield input into a string automatically