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

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

Browse Source
This commit is contained in:
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)
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

96
vlib/bitfield/bitfield_test.v
View File

@ -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