Bits representation of a byte added

Comments refactoring.

Author: iwdgo

README.md

@@ -10,16 +10,18 @@ To distinguish bad habits, benchmarking against the compiler performance is ofte
 - Don't bother to use anything but the len() to get the [size of an array](./src/lenarray/README.md)
 - Don't duplicate code to handle the [first item of a list](./src/firstitem/README.md)
 - Don't try to [keep a single exit](./src/singleexit/README.md)
-- Always use [shadowing inside a for loop](./src/isvalid/README.md) even for a boolean
-- Don't bother about [irrelevant cases](./src/switch/README.md) in a switch 
-- Use [bit masking](./src/bitorif/README.md) instead of a second if 
+- Always use [shadowing inside a for loop](./src/isvalid/README.md) even for a boolean.
+- Don't bother about [irrelevant cases](./src/switch/README.md) in a switch.
+- Use [bit masking](./src/bitorif/README.md) instead of a second if.
+- Get the [bits representation of a byte](./src/bytetobits/README.md) using bits package is simple and efficient.
 
 ***Math***
 - math.Log2() is the most efficient to check that 2 is the [sole divisor](./src/switch/README.md). 
 
 ***Arrays***
 - [Array of struct](./src/arraysstruct/README.md) is as efficient as multiple arrays.
 - [Array initialization](./src/arrayinit/README.md) using append is costly.
+- Using a method is marginally more efficient to [add an element to an array](./src/arrayofarray/README.md).
 
 ***Templates***
 - Use [implicit parsing for forms](src/formparse/README.md)
@@ -28,7 +30,7 @@ To distinguish bad habits, benchmarking against the compiler performance is ofte
 ***Buffers***
 - No difference when [writing to file](src/tofile/README.md) 
 - [Returning a buffer](src/returnbuffer/README.md) as a string is marginally more expensive.
-- Package io is much more efficient than fmt which offers many more possibilities:
+- Package `io` is much more efficient than `fmt` which offers many more possibilities:
     - [write a simple string](src/writestring/README.md).
     - [write a buffer to a buffer](src/writebuffer/README.md).
 - When handling every byte of a buffer, [use ReadByte](src/readbyte/README.md).

src/bytetobits/README.md

@@ -0,0 +1,27 @@
+# Get bit representation of a byte
+
+When based on strings, `%b` directive of the `fmt` package provides a bit display.
+But it requires to range on chars which is prohibitive compared to other methods.
+
+Rotating the bits each time introduces some penalty.
+
+The simplest code is using the `bits` package and is marginally more efficient.
+
+`src>go test -bench=. ./bytetobits`
+
+**Results**
+
+```
+go version go1.13 windows/amd64
+
+pkg: github.com/iWdGo/GoCompilerEfficiency/src/bytetobits
+BenchmarkRangeToBits-4           2522445               472 ns/op
+BenchmarkBits-4                 11327166               101 ns/op
+BenchmarkAndToBits-4            13191872                93.4 ns/op
+BenchmarkBitsToBits-4           12252073                90.8 ns/op
+PASS
+```
+
+ 
+ 
+ 

src/bytetobits/bitstobytes.go

@@ -0,0 +1,72 @@
+package main
+
+import (
+	"fmt"
+	"math/bits"
+)
+
+// fmt package and %b directive.
+// strings.SplitN has no use as []string is returned.
+func rangeToBits(data []byte) (st []int) {
+	st = make([]int, len(data)*8) // Performance x 2 as no append occurs
+	for i, d := range data {
+		// Sprintf is overkill as you get 48 (0) and 49 (1)
+		for j, c := range fmt.Sprintf("%08b", d) {
+			if c == 48 { // "0"
+				st[i*8+j] = 0
+			} else {
+				st[i*8+j] = 1
+			}
+		}
+	}
+	return
+}
+
+// Isolating each bit in one rotation.
+func forToBits(bs []byte) []int {
+	r := make([]int, len(bs)*8)
+	for i, b := range bs {
+		for j := 0; j < 8; j++ {
+			r[i*8+j] = int(b >> uint(7-j) & 0x01)
+		}
+	}
+	return r
+}
+
+// Using and operation to isolate the bit and no rotation.
+func andToBits(data []byte) (st []int) {
+	st = make([]int, len(data)*8) // Performance x 2 as no append occurs.
+	var j uint
+	exp := 0
+	for i, d := range data {
+		exp = 0
+		j = 256 // 2 with exponent 8 to get leftmost bit first.
+		for exp < 8 {
+			j /= 2
+			if b := uint(d) & j; b == j {
+				st[i*8+exp] = 1
+			} else {
+				st[i*8+exp] = 0
+			}
+			exp += 1
+		}
+	}
+	return
+}
+
+// Using the bits package and a rotation.
+func bitsToBits(data []byte) (st []int) {
+	st = make([]int, len(data)*8) // Performance x 2 as no append occurs.
+	for i, d := range data {
+		for j := 0; j < 8; j++ {
+			if bits.LeadingZeros8(d) == 0 {
+				// No leading 0 means that it is a 1
+				st[i*8+j] = 1
+			} else {
+				st[i*8+j] = 0
+			}
+			d = d << 1
+		}
+	}
+	return
+}

src/bytetobits/bitstobytes_test.go

@@ -0,0 +1,65 @@
+package main
+
+import "testing"
+
+var (
+	data = []byte{3, 255}
+	res  = []int{0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}
+)
+
+func arrayCompare(a1, a2 []int) bool {
+	for i, a := range a1 {
+		if a != a2[i] {
+			return false
+		}
+	}
+	return true
+}
+
+func TestBits(t *testing.T) {
+	if d := forToBits(data); !arrayCompare(d, res) {
+		t.Errorf("got %v, want %v", d, res)
+	}
+}
+
+func TestRangeToBits(t *testing.T) {
+	if d := rangeToBits(data); !arrayCompare(d, res) {
+		t.Errorf("got %v, want %v", d, res)
+	}
+}
+
+func TestRangeAndToBits(t *testing.T) {
+	if d := andToBits(data); !arrayCompare(d, res) {
+		t.Errorf("got %v, want %v", d, res)
+	}
+}
+
+func TestRangeBitsToBits(t *testing.T) {
+	if d := bitsToBits(data); !arrayCompare(d, res) {
+		t.Errorf("got %v, want %v", d, res)
+	}
+}
+
+func BenchmarkBits(b *testing.B) {
+	for n := 0; n < b.N; n++ {
+		forToBits(data)
+	}
+}
+
+func BenchmarkRangeToBits(b *testing.B) {
+	for n := 0; n < b.N; n++ {
+		rangeToBits(data)
+	}
+}
+
+func BenchmarkAndToBits(b *testing.B) {
+	for n := 0; n < b.N; n++ {
+		andToBits(data)
+	}
+}
+
+func BenchmarkBitsToBits(b *testing.B) {
+	for n := 0; n < b.N; n++ {
+		bitsToBits(data)
+	}
+}

src/writebuffer/README.md

@@ -1,8 +1,6 @@
 # Elementary write of a buffer to a buffer
 
 The target is of type *buffer.Bytes and the `buffer` is simply written to it.
-An elementary case is considered. Any formatting or processing makes this benchmark irrelevant.
-This module is using methods writing a `buffer` without conversion.
  - `fmt.Fprint`
  - `Write()` method of buffer package with a conversion to `bytes`
  - `WriteTo()` method of buffer package

src/writestring/README.md

@@ -18,7 +18,7 @@ go version go1.12.6 windows/amd64
 pkg: github.com/iWdGo/GoCompilerEfficiency/src/writestring
 BenchmarkFmtWriteString-4        1000000              1885 ns/op
 BenchmarkIoWriteString-4         2000000               694 ns/op
-BenchmarkBufferWriteTo-4         3000000               447 ns/op
+BenchmarkBufferWriteString-4     3000000               447 ns/op
 PASS
 ```
 

src/writestring/writestring_test.go

@@ -41,7 +41,7 @@ func BenchmarkIoWriteString(b *testing.B) {
 	}
 }
 
-func BenchmarkBufferWriteTo(b *testing.B) {
+func BenchmarkBufferWriteString(b *testing.B) {
 	for n := 0; n < b.N; n++ {
 		i := bufferWriteString(s).Len()
 		if i != len(s)*len(s) {