From 0a930f9862a48d774d0bd5cac610e1b611558508 Mon Sep 17 00:00:00 2001 From: Don Alfons Nisnoni Date: Thu, 7 May 2020 16:21:14 +0800 Subject: [PATCH] bitfield: rename functions, getsize => get_size, etc. --- vlib/bitfield/bitfield.v | 76 +++++++++++++-------------- vlib/bitfield/bitfield_test.v | 96 +++++++++++++++++------------------ 2 files changed, 86 insertions(+), 86 deletions(-) diff --git a/vlib/bitfield/bitfield.v b/vlib/bitfield/bitfield.v index 9e4d135692..e9632f366d 100644 --- a/vlib/bitfield/bitfield.v +++ b/vlib/bitfield/bitfield.v @@ -42,7 +42,7 @@ pub fn from_str(input string) BitField { mut output := new(input.len) for i in 0..input.len { if input[i] != `0` { - output.setbit(i) + output.set_bit(i) } } return output @@ -53,7 +53,7 @@ pub fn from_str(input string) BitField { pub fn (input BitField) str() string { mut output := '' for i in 0..input.size { - if input.getbit(i) == 1 { + if input.get_bit(i) == 1 { output = output + '1' } 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). -pub fn (instance BitField) getbit(bitnr int) int { +// get_bit returns the value (0 or 1) of bit number 'bit_nr' (count from 0). +pub fn (instance BitField) get_bit(bitnr int) int { if bitnr >= instance.size { return 0 } return (instance.field[bitslot(bitnr)] >> (bitnr % SLOT_SIZE)) & u32(1) } -// setbit sets bit number 'bit_nr' to 1 (count from 0). -pub fn (instance mut BitField) setbit(bitnr int) { +// set_bit sets bit number 'bit_nr' to 1 (count from 0). +pub fn (instance mut BitField) set_bit(bitnr int) { if bitnr >= instance.size { return } instance.field[bitslot(bitnr)] |= bitmask(bitnr) } -// clearbit clears (sets to zero) bit number 'bit_nr' (count from 0). -pub fn (instance mut BitField) clearbit(bitnr int) { +// clear_bit clears (sets to zero) bit number 'bit_nr' (count from 0). +pub fn (instance mut BitField) clear_bit(bitnr int) { if bitnr >= instance.size { return } instance.field[bitslot(bitnr)] &= ~bitmask(bitnr) } -// setall sets all bits in the array to 1. -pub fn (instance mut BitField) setall() { +// set_all sets all bits in the array to 1. +pub fn (instance mut BitField) set_all() { for i in 0..bitnslots(instance.size) { instance.field[i] = u32(-1) } - instance.cleartail() + instance.clear_tail() } -// clearall clears (sets to zero) all bits in the array. -pub fn (instance mut BitField) clearall() { +// clear_all clears (sets to zero) all bits in the array. +pub fn (instance mut BitField) clear_all() { for i in 0..bitnslots(instance.size) { 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'. -pub fn (instance mut BitField) togglebit(bitnr int) { +pub fn (instance mut BitField) toggle_bit(bitnr int) { if bitnr >= instance.size { return } 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, // 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) bitnslots := bitnslots(size) mut output := new(size) for i in 0..bitnslots { output.field[i] = input1.field[i] & input2.field[i] } - output.cleartail() + output.clear_tail() return output } -// bfnot toggles all bits in a bit array and returns the result as a new array. -pub fn bfnot(input BitField) BitField { +// bf_not toggles all bits in a bit array and returns the result as a new array. +pub fn bf_not(input BitField) BitField { size := input.size bitnslots := bitnslots(size) mut output := new(size) for i in 0..bitnslots { output.field[i] = ~input.field[i] } - output.cleartail() + output.clear_tail() 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, // 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) bitnslots := bitnslots(size) mut output := new(size) for i in 0..bitnslots { output.field[i] = input1.field[i] | input2.field[i] } - output.cleartail() + output.clear_tail() 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, // 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) bitnslots := bitnslots(size) mut output := new(size) for i in 0..bitnslots { output.field[i] = input1.field[i] ^ input2.field[i] } - output.cleartail() + output.clear_tail() return output } @@ -226,8 +226,8 @@ pub fn join(input1 BitField, input2 BitField) BitField { return output } -// getsize returns the number of bits the array can hold. -pub fn (instance BitField) getsize() int { +// get_size returns the number of bits the array can hold. +pub fn (instance BitField) get_size() int { return instance.size } @@ -251,8 +251,8 @@ pub fn (instance BitField) cmp(input BitField) bool { return true } -// popcount returns the number of set bits (ones) in the array. -pub fn (instance BitField) popcount() int { +// pop_count returns the number of set bits (ones) in the array. +pub fn (instance BitField) pop_count() int { size := instance.size bitnslots := bitnslots(size) tail := size % SLOT_SIZE @@ -273,9 +273,9 @@ pub fn (instance BitField) popcount() int { } // hamming computes the Hamming distance between two bit arrays. -pub fn hamming (input1 BitField, input2 BitField) int { - input_xored := bfxor(input1, input2) - return input_xored.popcount() +pub fn hamming(input1 BitField, input2 BitField) int { + input_xored := bf_xor(input1, input2) + return input_xored.pop_count() } // 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 j in 0..SLOT_SIZE { 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 for j in 0..bits_in_last_input_slot { 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 @@ -401,7 +401,7 @@ pub fn (instance mut BitField) resize(new_size int) { instance.field = field.clone() instance.size = new_size 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 -fn (instance mut BitField) cleartail() { +fn (instance mut BitField) clear_tail() { tail := instance.size % SLOT_SIZE if tail != 0 { // create a mask for the tail diff --git a/vlib/bitfield/bitfield_test.v b/vlib/bitfield/bitfield_test.v index f4deef8af6..71c679418a 100644 --- a/vlib/bitfield/bitfield_test.v +++ b/vlib/bitfield/bitfield_test.v @@ -5,17 +5,17 @@ import time fn test_bf_new_size() { instance := bitfield.new(75) - assert instance.getsize() == 75 + assert instance.get_size() == 75 } fn test_bf_set_clear_toggle_get() { mut instance := bitfield.new(75) - instance.setbit(47) - assert instance.getbit(47) == 1 - instance.clearbit(47) - assert instance.getbit(47) == 0 - instance.togglebit(47) - assert instance.getbit(47) == 1 + instance.set_bit(47) + assert instance.get_bit(47) == 1 + instance.clear_bit(47) + assert instance.get_bit(47) == 0 + instance.toggle_bit(47) + assert instance.get_bit(47) == 1 } fn test_bf_and_not_or_xor() { @@ -26,21 +26,21 @@ fn test_bf_and_not_or_xor() { mut i := 0 for i < len { if rand.next(2) == 1 { - input1.setbit(i) + input1.set_bit(i) } if rand.next(2) == 1{ - input2.setbit(i) + input2.set_bit(i) } i++ } - output1 := bitfield.bfxor(input1, input2) - bfand := bitfield.bfand(input1, input2) - bfor := bitfield.bfor(input1, input2) - bfnot := bitfield.bfnot(bfand) - output2 := bitfield.bfand(bfor, bfnot) + output1 := bitfield.bf_xor(input1, input2) + bf_and := bitfield.bf_and(input1, input2) + bf_or := bitfield.bf_or(input1, input2) + bf_not := bitfield.bf_not(bf_and) + output2 := bitfield.bf_and(bf_or, bf_not) mut result := 1 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 } @@ -51,11 +51,11 @@ fn test_clone_cmp() { mut input := bitfield.new(len) for i in 0..len { if rand.next(2) == 1 { - input.setbit(i) + input.set_bit(i) } } output := input.clone() - assert output.getsize() == len + assert output.get_size() == len assert input.cmp(output) == true } @@ -65,14 +65,14 @@ fn test_slice_join() { mut input := bitfield.new(len) for i in 0..len { if rand.next(2) == 1 { - input.setbit(i) + input.set_bit(i) } } mut result := 1 for point := 1; point < (len - 1); point++ { // divide a bitfield into two subfields 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 output := bitfield.join(chunk1, chunk2) if !input.cmp(output) { @@ -82,18 +82,18 @@ fn test_slice_join() { assert result == 1 } -fn test_popcount() { +fn test_pop_count() { rand.seed(time.now().unix) len := 80 mut count0 := 0 mut input := bitfield.new(len) for i in 0..len { if rand.next(2) == 1 { - input.setbit(i) + input.set_bit(i) count0++ } } - count1 := input.popcount() + count1 := input.pop_count() assert count0 == count1 } @@ -106,16 +106,16 @@ fn test_hamming() { for i in 0..len { match rand.next(4) { 0, 1 { - input1.setbit(i) + input1.set_bit(i) count++ } 2 { - input2.setbit(i) + input2.set_bit(i) count++ } 3 { - input1.setbit(i) - input2.setbit(i) + input1.set_bit(i) + input2.set_bit(i) } else { @@ -130,7 +130,7 @@ fn test_bf_from_bytes() { output := bitfield.from_bytes(input) mut result := 1 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 } } @@ -152,7 +152,7 @@ fn test_bf_from_str() { output := bitfield.from_str(input) mut result := 1 for i in 0..len { - if input[i] != output.getbit(i) + 48 { + if input[i] != output.get_bit(i) + 48 { result = 0 } } @@ -165,12 +165,12 @@ fn test_bf_bf2str() { mut input := bitfield.new(len) for i in 0..len { if rand.next(2) == 1 { - input.setbit(i) + input.set_bit(i) } } mut check := '' for i in 0..len { - if input.getbit(i) == 1 { + if input.get_bit(i) == 1 { check = check + '1' } else { @@ -187,33 +187,33 @@ fn test_bf_bf2str() { assert result == 1 } -fn test_bf_setall() { - rand.seed(time.now().unix) +fn test_bf_set_all() { + rand.seed(time.now().unix) len := 80 mut input := bitfield.new(len) - input.setall() + input.set_all() mut result := 1 for i in 0..len { - if input.getbit(i) != 1 { + if input.get_bit(i) != 1 { result = 0 } } assert result == 1 } -fn test_bf_clearall() { - rand.seed(time.now().unix) +fn test_bf_clear_all() { + rand.seed(time.now().unix) len := 80 mut input := bitfield.new(len) for i in 0..len { if rand.next(2) == 1 { - input.setbit(i) + input.set_bit(i) } } - input.clearall() + input.clear_all() mut result := 1 for i in 0..len { - if input.getbit(i) != 0 { + if input.get_bit(i) != 0 { result = 0 } } @@ -226,14 +226,14 @@ fn test_bf_reverse() { mut input := bitfield.new(len) for i in 0..len { if rand.next(2) == 1 { - input.setbit(i) + input.set_bit(i) } } check := input.clone() output := input.reverse() mut result := 1 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 } } @@ -246,9 +246,9 @@ fn test_bf_resize() { mut input := bitfield.new(rand.next(len) + 1) for _ in 0..100 { 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() { @@ -270,13 +270,13 @@ fn test_bf_pos() { // fill the needle with random values for k in 0..i { if rand.next(2) == 1 { - needle.setbit(k) + needle.set_bit(k) } } // make sure the needle contains at least one set bit, selected randomly r := rand.next(i) - needle.setbit(r) + needle.set_bit(r) // create the haystack, make sure it contains the needle mut haystack := needle.clone() @@ -311,10 +311,10 @@ fn test_bf_rotate() { for i := 1; i < 80 && result == 1; i++ { mut chunk1 := bitfield.new(i) chunk2 := bitfield.new(len - i) - chunk1.setall() + chunk1.set_all() input := bitfield.join(chunk1, chunk2) 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 } } @@ -327,7 +327,7 @@ fn test_bf_printing(){ mut input := bitfield.new(len) for i in 0..len { if rand.next(2) == 0 { - input.setbit(i) + input.set_bit(i) } } // the following should convert the bitfield input into a string automatically