Extending an array of array

Author: iwdgo

src/arrayinit/README.md

@@ -5,9 +5,12 @@ Initializing an array can be:
 - with a known length and make
 - using append
 
+Comparison is unfair but sheds some light on the cost.
+The most efficient is obviously static. 
+Append is extending the array and x5 the make().
+
 The method may depend on your app requirement and/or practical constraints.
 
-The most efficient is obviously static. It appears that append is costly.
 
 `src>go test -bench=. ./arrayinit` 
 

src/arrayinit/arrayinit.go

@@ -1,17 +1,21 @@
 package arrayinit
 
-// Luckily, it is only 10 items...
+// Array is known
 func InitArrayStatic() []int {
 	a := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
 	return a
 }
+
+// Array is made and filled
 func InitArrayMake() []int {
 	a := make([]int, 10)
 	for i := 1; i <= 10; i++ {
 		a[i-1] = i
 	}
 	return a
 }
+
+// Var is created and values appended
 func InitArrayAppend() []int {
 	a := make([]int, 0)
 	for i := 1; i <= 10; i++ {

src/arrayofarray/README.md

@@ -0,0 +1,34 @@
+# Appending elements to an array of array
+
+Adding a element to an array is done using append.
+The array is defined as:
+- [][]int which is always the underlying type
+- []t
+- tt where a method is used
+
+Go is strong typed and object oriented.
+Using a method is the most efficient even if difference can be small.
+
+`src>go test -bench=. ./arrayofarray`
+
+**Results**
+
+```
+go version go1.12beta1 windows/amd64
+```
+add one cell (inc == 1)
+```
+BenchmarkUpdateArray-4          10000000               231 ns/op
+BenchmarkUpdateArrayType-4      20000000               154 ns/op
+BenchmarkUpdateArrayMethod-4    20000000               119 ns/op
+```
+
+add 10 cells (inc == 10)
+```
+BenchmarkUpdateArray-4           1000000              1872 ns/op
+BenchmarkUpdateArrayType-4       1000000              1220 ns/op
+BenchmarkUpdateArrayMethod-4     1000000              1116 ns/op
+PASS
+```
+ 
+ 

src/arrayofarray/arrayofarray.go

@@ -0,0 +1,66 @@
+package arrayofarray
+
+type (
+	t  []int
+	tt []t
+)
+
+const (
+	size = 5
+)
+
+var a = []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
+
+// [][]int
+func initArray() [][]int {
+	ab := make([][]int, size)
+	for i, _ := range ab {
+		ab[i] = a[i:]
+	}
+	return ab
+}
+func updateArray(ab [][]int, inc int) [][]int {
+	for k, _ := range ab {
+		for i := 0; i < inc; i++ {
+			// b = append(b, i): no update
+			// ab[k] = append(b, i): last update
+			ab[k] = append(ab[k], i)
+		}
+	}
+	return ab
+}
+
+// []t
+func initArrayType() []t {
+	ab := make([]t, size)
+	for i, _ := range ab {
+		ab[i] = a[i:]
+	}
+	return ab
+}
+func updateArrayType(ab []t, inc int) []t {
+	for k, _ := range ab {
+		for i := 0; i < inc; i++ {
+			ab[k] = append(ab[k], i)
+		}
+	}
+	return ab
+}
+
+// tt
+func initArrayTyped() tt {
+	ab := make([]t, size)
+	for i, _ := range ab {
+		ab[i] = a[i:]
+	}
+	return ab
+}
+func (ab *tt) updateArrayMethod(inc int) {
+	abt := *ab
+	for k, _ := range abt {
+		for i := 0; i < inc; i++ {
+			abt[k] = append(abt[k], i)
+		}
+	}
+	*ab = abt
+}

src/arrayofarray/arrayofarray_test.go

@@ -0,0 +1,108 @@
+package arrayofarray
+
+import (
+	"testing"
+)
+
+const (
+	inc  = 1
+	want = 10 * size
+)
+
+// [][]int
+func llen(ab [][]int) (l int) {
+	for _, a := range ab {
+		l += len(a)
+	}
+	return
+}
+func TestInitArray(t *testing.T) {
+	want := want - size*(size-1)/2
+	if got := initArray(); llen(got) != want {
+		t.Fatalf("want %d, got %d\n %v", want, llen(got), got)
+	}
+}
+func TestUpdateArray(t *testing.T) {
+	want := want - size*(size-1)/2 + inc*size
+	if got := updateArray(initArray(), inc); llen(got) != want {
+		t.Fatalf("want %d, got %d\n %v", want, llen(got), got)
+	} else {
+		for _, a := range got {
+			if gotv := a[len(a)-inc]; gotv != 0 {
+				t.Fatalf("want 0, got %d in %v", gotv, a)
+			}
+		}
+	}
+
+}
+
+// []t
+func llent(ab []t) (l int) {
+	for _, a := range ab {
+		l += len(a)
+	}
+
+	return
+}
+func TestUpdateArrayType(t *testing.T) {
+	want := want - size*(size-1)/2 + inc*size
+	if got := updateArrayType(initArrayType(), inc); llent(got) != want {
+		t.Fatalf("want %d, got %d\n %v", want, llent(got), got)
+	} else {
+		for _, a := range got {
+			if gotv := a[len(a)-inc]; gotv != 0 {
+				t.Fatalf("want 0, got %d in %v", gotv, a)
+			}
+		}
+	}
+}
+
+// tt
+func (ab tt) llen() (l int) {
+	for _, a := range ab {
+		l += len(a)
+	}
+	return
+}
+func TestInitArrayType(t *testing.T) {
+	want := want - size*(size-1)/2
+	if got := initArrayTyped(); got.llen() != want {
+		t.Fatalf("want %d, got %d\n %v", want, got.llen(), got)
+	}
+}
+func TestUpdateArrayMethod(t *testing.T) {
+	var tb tt
+	tb = initArrayType()
+	want := want - size*(size-1)/2 + inc*size
+	tb.updateArrayMethod(inc)
+	if ll := tb.llen(); ll != want {
+		t.Fatalf("want %d, got %d\n %v", want, ll, tb)
+	} else {
+		for _, a := range tb {
+			if gotv := a[len(a)-inc]; gotv != 0 {
+				t.Fatalf("want 0, got %d in %v", gotv, a)
+			}
+		}
+	}
+}
+
+// w/o the for loop, no benchmarking occurs because of optimization
+func BenchmarkUpdateArray(b *testing.B) {
+	tb := initArray()
+	for n := 0; n < b.N; n++ {
+		updateArray(tb, inc)
+	}
+}
+func BenchmarkUpdateArrayType(b *testing.B) {
+	tb := initArrayType()
+	for n := 0; n < b.N; n++ {
+		updateArrayType(tb, inc)
+	}
+}
+func BenchmarkUpdateArrayMethod(b *testing.B) {
+	var tb tt
+	tb = initArrayType()
+	for n := 0; n < b.N; n++ {
+		tb.updateArrayMethod(inc)
+	}
+}

src/arraysstruct/README.md

@@ -9,8 +9,8 @@ You need to maintain related data using an ordinary string key:
 
 **Results**
 
-Arrays are slightly the faster.
-An array of struct has a similar performance with the advantage of stronger typing.
+Arrays are slightly faster.
+Performance of an array of struct is similar with the advantage of stronger typing.
 The map is 30% more expensive.
 
 ```