Merge pull request #38 from rauls5382/mean

Fix mean computation during graph creation

internal/driver/driver.go

 
 func reportOptions(p *profile.Profile, vars variables) (*report.Options, error) {
 	si, mean := vars["sample_index"].value, vars["mean"].boolValue()
-	value, sample, err := sampleFormat(p, si, mean)
+	value, meanDiv, sample, err := sampleFormat(p, si, mean)
 	if err != nil {
 		return nil, err
 	}
 		NodeFraction: vars["nodefraction"].floatValue(),
 		EdgeFraction: vars["edgefraction"].floatValue(),
 
-		SampleValue: value,
-		SampleType:  stype,
-		SampleUnit:  sample.Unit,
+		SampleValue:       value,
+		SampleMeanDivisor: meanDiv,
+		SampleType:        stype,
+		SampleUnit:        sample.Unit,
 
 		OutputUnit: vars["unit"].value,
 
 
 // sampleFormat returns a function to extract values out of a profile.Sample,
 // and the type/units of those values.
-func sampleFormat(p *profile.Profile, sampleIndex string, mean bool) (sampleValueFunc, *profile.ValueType, error) {
+func sampleFormat(p *profile.Profile, sampleIndex string, mean bool) (value, meanDiv sampleValueFunc, v *profile.ValueType, err error) {
 	if len(p.SampleType) == 0 {
-		return nil, nil, fmt.Errorf("profile has no samples")
+		return nil, nil, nil, fmt.Errorf("profile has no samples")
 	}
 	index, err := locateSampleIndex(p, sampleIndex)
 	if err != nil {
-		return nil, nil, err
+		return nil, nil, nil, err
 	}
+	value = valueExtractor(index)
 	if mean {
-		return meanExtractor(index), p.SampleType[index], nil
+		meanDiv = valueExtractor(0)
 	}
-	return valueExtractor(index), p.SampleType[index], nil
+	v = p.SampleType[index]
+	return
 }
 
 func valueExtractor(ix int) sampleValueFunc {
 		return v[ix]
 	}
 }
-
-func meanExtractor(ix int) sampleValueFunc {
-	return func(v []int64) int64 {
-		if v[0] == 0 {
-			return 0
-		}
-		return v[ix] / v[0]
-	}
-}

internal/graph/dotgraph.go

 	nodeIDMap := make(map[*Node]int)
 	hasNodelets := make(map[*Node]bool)
 
-	maxFlat := float64(abs64(g.Nodes[0].Flat))
+	maxFlat := float64(abs64(g.Nodes[0].FlatValue()))
 	for i, n := range g.Nodes {
 		nodeIDMap[n] = i + 1
-		if float64(abs64(n.Flat)) > maxFlat {
-			maxFlat = float64(abs64(n.Flat))
+		if float64(abs64(n.FlatValue())) > maxFlat {
+			maxFlat = float64(abs64(n.FlatValue()))
 		}
 	}
 
 
 // addNode generates a graph node in DOT format.
 func (b *builder) addNode(node *Node, nodeID int, maxFlat float64) {
-	flat, cum := node.Flat, node.Cum
+	flat, cum := node.FlatValue(), node.CumValue()
 	attrs := b.attributes.Nodes[node]
 
 	// Populate label for node.
 	// Create DOT attribute for node.
 	attr := fmt.Sprintf(`label="%s" fontsize=%d shape=%s tooltip="%s (%s)" color="%s" fillcolor="%s"`,
 		label, fontSize, shape, node.Info.PrintableName(), cumValue,
-		dotColor(float64(node.Cum)/float64(abs64(b.config.Total)), false),
-		dotColor(float64(node.Cum)/float64(abs64(b.config.Total)), true))
+		dotColor(float64(node.CumValue())/float64(abs64(b.config.Total)), false),
+		dotColor(float64(node.CumValue())/float64(abs64(b.config.Total)), true))
 
 	// Add on extra attributes if provided.
 	if attrs != nil {
 		ts = ts[:maxNodelets]
 	}
 	for i, t := range ts {
-		w := t.Cum
+		w := t.CumValue()
 		if flatTags {
-			w = t.Flat
+			w = t.FlatValue()
 		}
 		if w == 0 {
 			continue
 	// Collapse numeric labels into maxNumNodelets buckets, of the form:
 	// 1MB..2MB, 3MB..5MB, ...
 	for j, t := range collapsedTags(nts, maxNumNodelets, flatTags) {
-		w, attr := t.Cum, ` style="dotted"`
-		if flatTags || t.Flat == t.Cum {
-			w, attr = t.Flat, ""
+		w, attr := t.CumValue(), ` style="dotted"`
+		if flatTags || t.FlatValue() == t.CumValue() {
+			w, attr = t.FlatValue(), ""
 		}
 		if w != 0 {
 			weight := b.config.FormatValue(w)
 	if edge.Inline {
 		inline = `\n (inline)`
 	}
-	w := b.config.FormatValue(edge.Weight)
+	w := b.config.FormatValue(edge.WeightValue())
 	attr := fmt.Sprintf(`label=" %s%s"`, w, inline)
 	if b.config.Total != 0 {
 		// Note: edge.weight > b.config.Total is possible for profile diffs.
-		if weight := 1 + int(min64(abs64(edge.Weight*100/b.config.Total), 100)); weight > 1 {
+		if weight := 1 + int(min64(abs64(edge.WeightValue()*100/b.config.Total), 100)); weight > 1 {
 			attr = fmt.Sprintf(`%s weight=%d`, attr, weight)
 		}
-		if width := 1 + int(min64(abs64(edge.Weight*5/b.config.Total), 5)); width > 1 {
+		if width := 1 + int(min64(abs64(edge.WeightValue()*5/b.config.Total), 5)); width > 1 {
 			attr = fmt.Sprintf(`%s penwidth=%d`, attr, width)
 		}
 		attr = fmt.Sprintf(`%s color="%s"`, attr,
-			dotColor(float64(edge.Weight)/float64(abs64(b.config.Total)), false))
+			dotColor(float64(edge.WeightValue())/float64(abs64(b.config.Total)), false))
 	}
 	arrow := "->"
 	if edge.Residual {
 func tagGroupLabel(g []*Tag) (label string, flat, cum int64) {
 	if len(g) == 1 {
 		t := g[0]
-		return measurement.Label(t.Value, t.Unit), t.Flat, t.Cum
+		return measurement.Label(t.Value, t.Unit), t.FlatValue(), t.CumValue()
 	}
 	min := g[0]
 	max := g[0]
-	f := min.Flat
-	c := min.Cum
+	df, f := min.FlatDiv, min.Flat
+	dc, c := min.CumDiv, min.Cum
 	for _, t := range g[1:] {
 		if v, _ := measurement.Scale(t.Value, t.Unit, min.Unit); int64(v) < min.Value {
 			min = t
 			max = t
 		}
 		f += t.Flat
+		df += t.FlatDiv
 		c += t.Cum
+		dc += t.CumDiv
+	}
+	if df != 0 {
+		f = f / df
+	}
+	if dc != 0 {
+		c = c / dc
 	}
 	return measurement.Label(min.Value, min.Unit) + ".." + measurement.Label(max.Value, max.Unit), f, c
 }

internal/graph/dotgraph_test.go

 }
 
 func TestTagCollapse(t *testing.T) {
+
+	makeTag := func(name, unit string, value, flat, cum int64) *Tag {
+		return &Tag{name, unit, value, flat, 0, cum, 0}
+	}
+
 	tagSource := []*Tag{
-		{"12mb", "mb", 12, 100, 100},
-		{"1kb", "kb", 1, 1, 1},
-		{"1mb", "mb", 1, 1000, 1000},
-		{"2048mb", "mb", 2048, 1000, 1000},
-		{"1b", "b", 1, 100, 100},
-		{"2b", "b", 2, 100, 100},
-		{"7b", "b", 7, 100, 100},
+		makeTag("12mb", "mb", 12, 100, 100),
+		makeTag("1kb", "kb", 1, 1, 1),
+		makeTag("1mb", "mb", 1, 1000, 1000),
+		makeTag("2048mb", "mb", 2048, 1000, 1000),
+		makeTag("1b", "b", 1, 100, 100),
+		makeTag("2b", "b", 2, 100, 100),
+		makeTag("7b", "b", 7, 100, 100),
 	}
 
 	tagWant := [][]*Tag{
 		[]*Tag{
-			{"1B..2GB", "", 0, 2401, 2401},
+			makeTag("1B..2GB", "", 0, 2401, 2401),
 		},
 		[]*Tag{
-			{"2GB", "", 0, 1000, 1000},
-			{"1B..12MB", "", 0, 1401, 1401},
+			makeTag("2GB", "", 0, 1000, 1000),
+			makeTag("1B..12MB", "", 0, 1401, 1401),
 		},
 		[]*Tag{
-			{"2GB", "", 0, 1000, 1000},
-			{"12MB", "", 0, 100, 100},
-			{"1B..1MB", "", 0, 1301, 1301},
+			makeTag("2GB", "", 0, 1000, 1000),
+			makeTag("12MB", "", 0, 100, 100),
+			makeTag("1B..1MB", "", 0, 1301, 1301),
 		},
 		[]*Tag{
-			{"2GB", "", 0, 1000, 1000},
-			{"1MB", "", 0, 1000, 1000},
-			{"2B..1kB", "", 0, 201, 201},
-			{"1B", "", 0, 100, 100},
-			{"12MB", "", 0, 100, 100},
+			makeTag("2GB", "", 0, 1000, 1000),
+			makeTag("1MB", "", 0, 1000, 1000),
+			makeTag("2B..1kB", "", 0, 201, 201),
+			makeTag("1B", "", 0, 100, 100),
+			makeTag("12MB", "", 0, 100, 100),
 		},
 	}
 

internal/graph/graph.go

 
 // Options encodes the options for constructing a graph
 type Options struct {
-	SampleValue func(s []int64) int64      // Function to compute the value of a sample
-	FormatTag   func(int64, string) string // Function to format a sample tag value into a string
-	ObjNames    bool                       // Always preserve obj filename
-	OrigFnNames bool                       // Preserve original (eg mangled) function names
+	SampleValue       func(s []int64) int64      // Function to compute the value of a sample
+	SampleMeanDivisor func(s []int64) int64      // Function to compute the divisor for mean graphs, or nil
+	FormatTag         func(int64, string) string // Function to format a sample tag value into a string
+	ObjNames          bool                       // Always preserve obj filename
+	OrigFnNames       bool                       // Preserve original (eg mangled) function names
 
 	CallTree     bool // Build a tree instead of a graph
 	DropNegative bool // Drop nodes with overall negative values
 
 	// Values associated to this node. Flat is exclusive to this node,
 	// Cum includes all descendents.
-	Flat, Cum int64
+	Flat, FlatDiv, Cum, CumDiv int64
 
 	// In and out Contains the nodes immediately reaching or reached by
 	// this node.
 	NumericTags map[string]TagMap
 }
 
+// FlatValue returns the exclusive value for this node, computing the
+// mean if a divisor is available.
+func (n *Node) FlatValue() int64 {
+	if n.FlatDiv == 0 {
+		return n.Flat
+	}
+	return n.Flat / n.FlatDiv
+}
+
+// CumValue returns the inclusive value for this node, computing the
+// mean if a divisor is available.
+func (n *Node) CumValue() int64 {
+	if n.CumDiv == 0 {
+		return n.Cum
+	}
+	return n.Cum / n.CumDiv
+}
+
 // AddToEdge increases the weight of an edge between two nodes. If
 // there isn't such an edge one is created.
-func (n *Node) AddToEdge(to *Node, w int64, residual, inline bool) {
+func (n *Node) AddToEdge(to *Node, v int64, residual, inline bool) {
+	n.AddToEdgeDiv(to, 0, v, residual, inline)
+}
+
+// AddToEdgeDiv increases the weight of an edge between two nodes. If
+// there isn't such an edge one is created.
+func (n *Node) AddToEdgeDiv(to *Node, dv, v int64, residual, inline bool) {
 	if n.Out[to] != to.In[n] {
 		panic(fmt.Errorf("asymmetric edges %v %v", *n, *to))
 	}
 
 	if e := n.Out[to]; e != nil {
-		e.Weight += w
+		e.WeightDiv += dv
+		e.Weight += v
 		if residual {
 			e.Residual = true
 		}
 		return
 	}
 
-	info := &Edge{Src: n, Dest: to, Weight: w, Residual: residual, Inline: inline}
+	info := &Edge{Src: n, Dest: to, WeightDiv: dv, Weight: v, Residual: residual, Inline: inline}
 	n.Out[to] = info
 	to.In[n] = info
 }
 type Edge struct {
 	Src, Dest *Node
 	// The summary weight of the edge
-	Weight int64
+	Weight, WeightDiv int64
+
 	// residual edges connect nodes that were connected through a
 	// separate node, which has been removed from the report.
 	Residual bool
 	Inline bool
 }
 
+func (e *Edge) WeightValue() int64 {
+	if e.WeightDiv == 0 {
+		return e.Weight
+	}
+	return e.Weight / e.WeightDiv
+}
+
 // Tag represent sample annotations
 type Tag struct {
-	Name  string
-	Unit  string // Describe the value, "" for non-numeric tags
-	Value int64
-	Flat  int64
-	Cum   int64
+	Name          string
+	Unit          string // Describe the value, "" for non-numeric tags
+	Value         int64
+	Flat, FlatDiv int64
+	Cum, CumDiv   int64
+}
+
+// FlatValue returns the exclusive value for this tag, computing the
+// mean if a divisor is available.
+func (t *Tag) FlatValue() int64 {
+	if t.FlatDiv == 0 {
+		return t.Flat
+	}
+	return t.Flat / t.FlatDiv
+}
+
+// CumValue returns the inclusive value for this tag, computing the
+// mean if a divisor is available.
+func (t *Tag) CumValue() int64 {
+	if t.CumDiv == 0 {
+		return t.Cum
+	}
+	return t.Cum / t.CumDiv
 }
 
 // TagMap is a collection of tags, classified by their name.
 func newGraph(prof *profile.Profile, o *Options) (*Graph, map[uint64]Nodes) {
 	nodes, locationMap := CreateNodes(prof, o)
 	for _, sample := range prof.Sample {
-		weight := o.SampleValue(sample.Value)
-		if weight == 0 {
+		var w, dw int64
+		w = o.SampleValue(sample.Value)
+		if o.SampleMeanDivisor != nil {
+			dw = o.SampleMeanDivisor(sample.Value)
+		}
+		if dw == 0 && w == 0 {
 			continue
 		}
 		seenNode := make(map[*Node]bool, len(sample.Location))
 				// Add cum weight to all nodes in stack, avoiding double counting.
 				if _, ok := seenNode[n]; !ok {
 					seenNode[n] = true
-					n.addSample(weight, labels, sample.NumLabel, o.FormatTag, false)
+					n.addSample(dw, w, labels, sample.NumLabel, o.FormatTag, false)
 				}
 				// Update edge weights for all edges in stack, avoiding double counting.
 				if _, ok := seenEdge[nodePair{n, parent}]; !ok && parent != nil && n != parent {
 					seenEdge[nodePair{n, parent}] = true
-					parent.AddToEdge(n, weight, residual, ni != len(locNodes)-1)
+					parent.AddToEdgeDiv(n, dw, w, residual, ni != len(locNodes)-1)
 				}
 				parent = n
 				residual = false
 		}
 		if parent != nil && !residual {
 			// Add flat weight to leaf node.
-			parent.addSample(weight, labels, sample.NumLabel, o.FormatTag, true)
+			parent.addSample(dw, w, labels, sample.NumLabel, o.FormatTag, true)
 		}
 	}
 
 func newTree(prof *profile.Profile, o *Options) (g *Graph) {
 	parentNodeMap := make(map[*Node]NodeMap, len(prof.Sample))
 	for _, sample := range prof.Sample {
-		weight := o.SampleValue(sample.Value)
-		if weight == 0 {
+		var w, dw int64
+		w = o.SampleValue(sample.Value)
+		if o.SampleMeanDivisor != nil {
+			dw = o.SampleMeanDivisor(sample.Value)
+		}
+		if dw == 0 && w == 0 {
 			continue
 		}
 		var parent *Node
 				if n == nil {
 					continue
 				}
-				n.addSample(weight, labels, sample.NumLabel, o.FormatTag, false)
+				n.addSample(dw, w, labels, sample.NumLabel, o.FormatTag, false)
 				if parent != nil {
-					parent.AddToEdge(n, weight, false, lidx != len(lines)-1)
+					parent.AddToEdgeDiv(n, dw, w, false, lidx != len(lines)-1)
 				}
 				parent = n
 			}
 		}
 		if parent != nil {
-			parent.addSample(weight, labels, sample.NumLabel, o.FormatTag, true)
+			parent.addSample(dw, w, labels, sample.NumLabel, o.FormatTag, true)
 		}
 	}
 
 	return
 }
 
-func (n *Node) addSample(value int64, labels string, numLabel map[string][]int64, format func(int64, string) string, flat bool) {
+func (n *Node) addSample(dw, w int64, labels string, numLabel map[string][]int64, format func(int64, string) string, flat bool) {
 	// Update sample value
 	if flat {
-		n.Flat += value
+		n.FlatDiv += dw
+		n.Flat += w
 	} else {
-		n.Cum += value
+		n.CumDiv += dw
+		n.Cum += w
 	}
 
 	// Add string tags
 	if labels != "" {
 		t := n.LabelTags.findOrAddTag(labels, "", 0)
 		if flat {
-			t.Flat += value
+			t.FlatDiv += dw
+			t.Flat += w
 		} else {
-			t.Cum += value
+			t.CumDiv += dw
+			t.Cum += w
 		}
 	}
 
 		for _, v := range nvals {
 			t := numericTags.findOrAddTag(format(v, key), key, v)
 			if flat {
-				t.Flat += value
+				t.FlatDiv += dw
+				t.Flat += w
 			} else {
-				t.Cum += value
+				t.CumDiv += dw
+				t.Cum += w
 			}
 		}
 	}

internal/report/report.go

 	var minValue int64
 
 	for _, n := range g.Nodes {
-		nodeMin := abs64(n.Flat)
+		nodeMin := abs64(n.FlatValue())
 		if nodeMin == 0 {
-			nodeMin = abs64(n.Cum)
+			nodeMin = abs64(n.CumValue())
 		}
 		if nodeMin > 0 && (minValue == 0 || nodeMin < minValue) {
 			minValue = nodeMin
 	}
 
 	gopt := &graph.Options{
-		SampleValue:  o.SampleValue,
-		FormatTag:    formatTag,
-		CallTree:     o.CallTree && (o.OutputFormat == Dot || o.OutputFormat == Callgrind),
-		DropNegative: o.DropNegative,
-		KeptNodes:    nodes,
+		SampleValue:       o.SampleValue,
+		SampleMeanDivisor: o.SampleMeanDivisor,
+		FormatTag:         formatTag,
+		CallTree:          o.CallTree && (o.OutputFormat == Dot || o.OutputFormat == Callgrind),
+		DropNegative:      o.DropNegative,
+		KeptNodes:         nodes,
 	}
 
 	// Only keep binary names for disassembly-based reports, otherwise
 	}
 	var flatSum int64
 	for i, n := range g.Nodes {
-		name, flat, cum := n.Info.PrintableName(), n.Flat, n.Cum
+		name, flat, cum := n.Info.PrintableName(), n.FlatValue(), n.CumValue()
 
 		flatSum += flat
 		f := &profile.Function{
 			percentage(cumSum, rpt.total))
 
 		for _, n := range ns {
-			fmt.Fprintf(w, "%10s %10s %10x: %s\n", valueOrDot(n.Flat, rpt), valueOrDot(n.Cum, rpt), n.Info.Address, n.Info.Name)
+			fmt.Fprintf(w, "%10s %10s %10x: %s\n", valueOrDot(n.FlatValue(), rpt), valueOrDot(n.CumValue(), rpt), n.Info.Address, n.Info.Name)
 		}
 	}
 	return nil
 		// Sum all the samples until the next instruction (to account
 		// for samples attributed to the middle of an instruction).
 		for next := insns[ix+1].Addr; s < len(samples) && samples[s].Info.Address-base < next; s++ {
+			n.FlatDiv += samples[s].FlatDiv
 			n.Flat += samples[s].Flat
+			n.CumDiv += samples[s].CumDiv
 			n.Cum += samples[s].Cum
 			if samples[s].Info.File != "" {
 				n.Info.File = trimPath(samples[s].Info.File)
 		fmt.Fprintf(w, "%s: Total %d\n", key, total)
 		for _, t := range graph.SortTags(tags, true) {
 			if total > 0 {
-				fmt.Fprintf(w, "  %8d (%s): %s\n", t.Flat,
-					percentage(t.Flat, total), t.Name)
+				fmt.Fprintf(w, "  %8d (%s): %s\n", t.FlatValue(),
+					percentage(t.FlatValue(), total), t.Name)
 			} else {
-				fmt.Fprintf(w, "  %8d: %s\n", t.Flat, t.Name)
+				fmt.Fprintf(w, "  %8d: %s\n", t.FlatValue(), t.Name)
 			}
 		}
 		fmt.Fprintln(w)
 
 	var flatSum int64
 	for _, n := range g.Nodes {
-		name, flat, cum := n.Info.PrintableName(), n.Flat, n.Cum
+		name, flat, cum := n.Info.PrintableName(), n.FlatValue(), n.CumValue()
 
 		var inline, noinline bool
 		for _, e := range n.In {
 		}
 		sort.Strings(labels)
 		fmt.Fprint(w, strings.Join(labels, ""))
+		var d, v int64
+		v = o.SampleValue(sample.Value)
+		if o.SampleMeanDivisor != nil {
+			d = o.SampleMeanDivisor(sample.Value)
+		}
 		// Print call stack.
+		if d != 0 {
+			v = v / d
+		}
 		fmt.Fprintf(w, "%10s   %s\n",
-			rpt.formatValue(o.SampleValue(sample.Value)),
-			stack[0].Info.PrintableName())
-
+			rpt.formatValue(v), stack[0].Info.PrintableName())
 		for _, s := range stack[1:] {
 			fmt.Fprintf(w, "%10s   %s\n", "", s.Info.PrintableName())
 		}
 		}
 
 		addr := callgrindAddress(prevInfo, n.Info.Address)
-		sv, _ := measurement.Scale(n.Flat, o.SampleUnit, o.OutputUnit)
+		sv, _ := measurement.Scale(n.FlatValue(), o.SampleUnit, o.OutputUnit)
 		fmt.Fprintf(w, "%s %d %d\n", addr, n.Info.Lineno, int64(sv))
 
 		// Print outgoing edges.
 
 	rx := rpt.options.Symbol
 	for _, n := range g.Nodes {
-		name, flat, cum := n.Info.PrintableName(), n.Flat, n.Cum
+		name, flat, cum := n.Info.PrintableName(), n.FlatValue(), n.CumValue()
 
 		// Skip any entries that do not match the regexp (for the "peek" command).
 		if rx != nil && !rx.MatchString(name) {
 
 	var flatSum int64
 	for _, n := range g.Nodes {
-		flatSum = flatSum + n.Flat
+		flatSum = flatSum + n.FlatValue()
 	}
 
 	label = append(label, fmt.Sprintf("Showing nodes accounting for %s, %s of %s total", rpt.formatValue(flatSum), strings.TrimSpace(percentage(flatSum, rpt.total)), rpt.formatValue(rpt.total)))
 	NodeFraction float64
 	EdgeFraction float64
 
-	SampleValue func(s []int64) int64
-	SampleType  string
-	SampleUnit  string // Unit for the sample data from the profile.
+	SampleValue       func(s []int64) int64
+	SampleMeanDivisor func(s []int64) int64
+	SampleType        string
+	SampleUnit        string // Unit for the sample data from the profile.
 
 	OutputUnit string // Units for data formatting in report.
 
 		}
 		return measurement.ScaledLabel(v, o.SampleUnit, o.OutputUnit)
 	}
-	return &Report{prof, computeTotal(prof, o.SampleValue, !o.PositivePercentages),
+	return &Report{prof, computeTotal(prof, o.SampleValue, o.SampleMeanDivisor, !o.PositivePercentages),
 		o, format}
 }
 
 // absolute values to provide a meaningful percentage for both
 // negative and positive values. Otherwise only use positive values,
 // which is useful when comparing profiles from different jobs.
-func computeTotal(prof *profile.Profile, value func(v []int64) int64, includeNegative bool) int64 {
-	var ret int64
+func computeTotal(prof *profile.Profile, value, meanDiv func(v []int64) int64, includeNegative bool) int64 {
+	var div, ret int64
 	for _, sample := range prof.Sample {
-		if v := value(sample.Value); v > 0 {
+		var d, v int64
+		v = value(sample.Value)
+		if meanDiv != nil {
+			d = meanDiv(sample.Value)
+		}
+		if v >= 0 {
 			ret += v
+			div += d
 		} else if includeNegative {
 			ret -= v
+			div += d
 		}
 	}
+	if div != 0 {
+		return ret / div
+	}
 	return ret
 }