M array/polyarray.go

array/polyarray.go

@@ -70,16 +70,11 @@ func NewPolyArray(nums []int32) *PolyArray {
 		N: int32(len(nums)),
 	}
 
-	rank := uint64(0)
-
-	for {
-		if len(nums) > segmentSize {
-			rank = pa.addSeg(nums[:segmentSize], rank)
-			nums = nums[segmentSize:]
-		} else {
-			pa.addSeg(nums, rank)
-			break
-		}
+	for ; len(nums) > segmentSize; nums = nums[segmentSize:] {
+		pa.addSeg(nums[:segmentSize])
+	}
+	if len(nums) > 0 {
+		pa.addSeg(nums)
 	}
 
 	// Add another empty word to avoid panic for residual of width = 0.
@@ -172,7 +167,7 @@ func (m *PolyArray) Stat() map[string]int32 {
 		"mem_total": int32(totalmem),
 		"mem_elts":  int32(memWords),
 		"bits/elt":  int32(totalmem * 8 / n),
-		"polys/seg": int32(polyCnt / nseg),
+		"polys/seg": int32((polyCnt * 1000) / (nseg*1000 + 1)),
 	}
 
 	return st
@@ -188,7 +183,24 @@ func unpackConfig(config float64) (int64, int64) {
 	return offset, residualWidth
 }
 
-func (m *PolyArray) addSeg(nums []int32, rank uint64) uint64 {
+func (m *PolyArray) addSeg(nums []int32) {
+
+	bm, polys, words := newSeg(nums, int64(len(m.Residuals)*64))
+
+	var r uint64
+	if len(m.Bitmap) > 0 {
+		l := len(m.Bitmap)
+		r = m.Bitmap[l-1] + uint64(bits.OnesCount64(m.Bitmap[l-2]))
+	} else {
+		r = 0
+	}
+
+	m.Bitmap = append(m.Bitmap, bm, r)
+	m.Polynomials = append(m.Polynomials, polys...)
+	m.Residuals = append(m.Residuals, words...)
+}
+
+func newSeg(nums []int32, start int64) (uint64, []float64, []uint64) {
 
 	n := int32(len(nums))
 	xs := make([]float64, n)
@@ -210,12 +222,7 @@ func (m *PolyArray) addSeg(nums []int32, rank uint64) uint64 {
 	// Using a bitmap to describe which spans a polynomial spans
 	segPolyBitmap := uint64(0)
 
-	// Where the residual of the first elt of this segment is in m.Residuals
-	segStart := int64(len(m.Residuals) * 64)
-
-	// Where a residual is in m.Residuals, relatvie to the 0-th bit in
-	// m.Residuals .
-	resI := segStart
+	resI := int64(0)
 
 	for _, sp := range spans {
 
@@ -229,16 +236,16 @@ func (m *PolyArray) addSeg(nums []int32, rank uint64) uint64 {
 			resI -= resI % int64(width)
 		}
 
-		if resI >= int64(1)<<35 {
-			panic(fmt.Sprintf("wordStart is too large:%d, should < 2^35", resI))
+		if resI+start >= int64(1)<<35 {
+			panic(fmt.Sprintf("wordStart is too large:%d, should < 2^35", resI+start))
 		}
 
 		polys = append(polys, sp.poly...)
 
 		// We want eltIndex = stBySeg + i * residualWidth
 		// min of stBySeg is -segWidth * residualWidth = -1024 * 16;
 		// Add this value to make it a positive number.
-		offset := resI - int64(sp.s)*int64(width)
+		offset := resI + start - int64(sp.s)*int64(width)
 		config := packConfig(offset+maxNegOffset, int64(width))
 		polys = append(polys, config)
 
@@ -251,23 +258,16 @@ func (m *PolyArray) addSeg(nums []int32, rank uint64) uint64 {
 				panic(fmt.Sprintf("d=%d must smaller than %d and > 0", d, margin))
 			}
 
-			wordI := (resI - segStart) >> 6
+			wordI := resI >> 6
 			words[wordI] |= uint64(d) << uint(resI&63)
 
 			resI += int64(width)
 		}
 	}
 
-	nWords := (resI - segStart + 63) >> 6
-
-	m.Bitmap = append(m.Bitmap,
-		segPolyBitmap, rank,
-	)
-
-	m.Polynomials = append(m.Polynomials, polys...)
-	m.Residuals = append(m.Residuals, words[:nWords]...)
+	nWords := (resI + 63) >> 6
 
-	return rank + uint64(bits.OnesCount64(segPolyBitmap))
+	return segPolyBitmap, polys, words[:nWords]
 }
 
 func initFittings(xs, ys []float64, polysize int32) []*polyfit.Fitting {

array/polyarray_test.go

@@ -194,7 +194,7 @@ func TestDense_Stat(t *testing.T) {
 		"elt_width": 3,
 		"mem_elts":  160,
 		"mem_total": st["mem_total"], // do not compare this
-		"polys/seg": 5,
+		"polys/seg": 4,
 		"bits/elt":  10,
 	}