From e73c928dad2f13145251d8587bb1a8a781a9567a Mon Sep 17 00:00:00 2001 From: Daniel Gil Date: Thu, 5 Jul 2018 09:04:38 +0200 Subject: [PATCH] renamed pkg from interval to intervals --- README.md | 4 +- add.go | 2 +- demo_test.go | 1180 +++++++++++++++++++++++----------------------- example/main.go | 14 +- example/out2.png | Bin 0 -> 40740 bytes find.go | 2 +- find_test.go | 34 +- gaps.go | 2 +- gaps_test.go | 6 +- get.go | 2 +- inclusives.go | 2 +- interval.go | 2 +- intervals.go | 8 +- merge.go | 2 +- merge_test.go | 6 +- overlap.go | 2 +- overlap_test.go | 6 +- plot.go | 2 +- report.go | 2 +- report_test.go | 20 +- sort.go | 2 +- utils.go | 2 +- 22 files changed, 651 insertions(+), 651 deletions(-) create mode 100644 example/out2.png diff --git a/README.md b/README.md index e58736a..8e89d87 100644 --- a/README.md +++ b/README.md @@ -46,7 +46,7 @@ API documentation is available on [godoc.org][doc]. To use this package the first thing we have to do is create an instance: ```go -intvls := interval.NewIntervals(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) +intvls := intervals.New(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) ``` where `minLow` and `maxHigh` are integers that defines the accepted integer space to work with, anything else outside will be rejected. The booleans `lowInclusive` and `highInclusive` indicates if the values of a range (low, high) are inclusive or not. The booleans `selfAdjustMinLow`and `selfAdjustMaxHigh` indicates that we do not need to specify the minLow or maxHigh in the constructor, but those values will be self adjusted automatically taking the lower and greatest value respectively of all intervals added. @@ -63,7 +63,7 @@ Once initialized, we can proced to add new intervals. We can add intervals by passing an `Interval` object: ```go -intvl := &interval.Interval{Low: ageFrom, High: ageTo, Object: myObject} +intvl := &intervals.Interval{Low: ageFrom, High: ageTo, Object: myObject} err := intvls.AddInterval(intvl) if err != nil { fmt.Printf("invalid interval discarded: %v\n", err) diff --git a/add.go b/add.go index 969078b..ff22be5 100644 --- a/add.go +++ b/add.go @@ -1,4 +1,4 @@ -package interval +package intervals import "math" diff --git a/demo_test.go b/demo_test.go index 1473fcf..ad0aa0a 100644 --- a/demo_test.go +++ b/demo_test.go @@ -1,4 +1,4 @@ -package interval_test +package intervals_test import ( "fmt" @@ -8,11 +8,11 @@ import ( ) type demo struct { - Intervals interval.Intervals - ExpectedGaps []interval.Interval - ExpectedOverlaps []interval.Interval - ExpectedMerges []interval.Interval - ExpectedFindMatches []interval.Interval + Intervals intervals.Intervals + ExpectedGaps []intervals.Interval + ExpectedOverlaps []intervals.Interval + ExpectedMerges []intervals.Interval + ExpectedFindMatches []intervals.Interval ValueToFind int } @@ -29,17 +29,17 @@ func buildIntervalsDemo001() demo { highInclusive := true selfAdjustMinLow := false selfAdjustMaxHigh := false - itvls := interval.NewIntervals(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) + itvls := intervals.New(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) // calculate expected gaps - gaps := []interval.Interval{} - gaps = append(gaps, interval.Interval{Low: minLow, High: maxHigh}) + gaps := []intervals.Interval{} + gaps = append(gaps, intervals.Interval{Low: minLow, High: maxHigh}) // calculate expected overlaps - overlaps := []interval.Interval{} + overlaps := []intervals.Interval{} // calculate expected merges - merges := []interval.Interval{} + merges := []intervals.Interval{} return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps, ExpectedMerges: merges} } @@ -53,23 +53,23 @@ func buildIntervalsDemo002() demo { highInclusive := true selfAdjustMinLow := false selfAdjustMaxHigh := false - itvls := interval.NewIntervals(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) + itvls := intervals.New(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) // add intervals - if err := itvls.AddInterval(&interval.Interval{Low: minLow, High: 4}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: minLow, High: 4}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } // calculate expected gaps - gaps := []interval.Interval{} - gaps = append(gaps, interval.Interval{Low: 5, High: maxHigh}) + gaps := []intervals.Interval{} + gaps = append(gaps, intervals.Interval{Low: 5, High: maxHigh}) // calculate expected overlaps - overlaps := []interval.Interval{} + overlaps := []intervals.Interval{} // calculate expected merges - merges := []interval.Interval{} - merges = append(merges, interval.Interval{Low: minLow, High: 4}) + merges := []intervals.Interval{} + merges = append(merges, intervals.Interval{Low: minLow, High: 4}) return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps, ExpectedMerges: merges} } @@ -83,23 +83,23 @@ func buildIntervalsDemo003() demo { highInclusive := true selfAdjustMinLow := false selfAdjustMaxHigh := false - itvls := interval.NewIntervals(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) + itvls := intervals.New(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) // add intervals - if err := itvls.AddInterval(&interval.Interval{Low: 8, High: maxHigh}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 8, High: maxHigh}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } // calculate expected gaps - gaps := []interval.Interval{} - gaps = append(gaps, interval.Interval{Low: minLow, High: 7}) + gaps := []intervals.Interval{} + gaps = append(gaps, intervals.Interval{Low: minLow, High: 7}) // calculate expected overlaps - overlaps := []interval.Interval{} + overlaps := []intervals.Interval{} // calculate expected merges - merges := []interval.Interval{} - merges = append(merges, interval.Interval{Low: 8, High: maxHigh}) + merges := []intervals.Interval{} + merges = append(merges, intervals.Interval{Low: 8, High: maxHigh}) return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps, ExpectedMerges: merges} } @@ -113,24 +113,24 @@ func buildIntervalsDemo004() demo { highInclusive := true selfAdjustMinLow := false selfAdjustMaxHigh := false - itvls := interval.NewIntervals(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) + itvls := intervals.New(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) // add intervals - if err := itvls.AddInterval(&interval.Interval{Low: 5, High: 8}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 5, High: 8}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } // calculate expected gaps - gaps := []interval.Interval{} - gaps = append(gaps, interval.Interval{Low: minLow, High: 4}) - gaps = append(gaps, interval.Interval{Low: 9, High: maxHigh}) + gaps := []intervals.Interval{} + gaps = append(gaps, intervals.Interval{Low: minLow, High: 4}) + gaps = append(gaps, intervals.Interval{Low: 9, High: maxHigh}) // calculate expected overlaps - overlaps := []interval.Interval{} + overlaps := []intervals.Interval{} // calculate expected merges - merges := []interval.Interval{} - merges = append(merges, interval.Interval{Low: 5, High: 8}) + merges := []intervals.Interval{} + merges = append(merges, intervals.Interval{Low: 5, High: 8}) return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps, ExpectedMerges: merges} } @@ -144,28 +144,28 @@ func buildIntervalsDemo005() demo { highInclusive := true selfAdjustMinLow := false selfAdjustMaxHigh := false - itvls := interval.NewIntervals(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) + itvls := intervals.New(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) // add intervals - if err := itvls.AddInterval(&interval.Interval{Low: 2, High: 8}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 2, High: 8}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - if err := itvls.AddInterval(&interval.Interval{Low: 4, High: 6}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 4, High: 6}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } // calculate expected gaps - gaps := []interval.Interval{} - gaps = append(gaps, interval.Interval{Low: minLow, High: 1}) - gaps = append(gaps, interval.Interval{Low: 9, High: maxHigh}) + gaps := []intervals.Interval{} + gaps = append(gaps, intervals.Interval{Low: minLow, High: 1}) + gaps = append(gaps, intervals.Interval{Low: 9, High: maxHigh}) // calculate expected overlaps - overlaps := []interval.Interval{} - overlaps = append(overlaps, interval.Interval{Low: 4, High: 6}) + overlaps := []intervals.Interval{} + overlaps = append(overlaps, intervals.Interval{Low: 4, High: 6}) // calculate expected merges - merges := []interval.Interval{} - merges = append(merges, interval.Interval{Low: 2, High: 8}) + merges := []intervals.Interval{} + merges = append(merges, intervals.Interval{Low: 2, High: 8}) return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps, ExpectedMerges: merges} } @@ -179,29 +179,29 @@ func buildIntervalsDemo006() demo { highInclusive := true selfAdjustMinLow := false selfAdjustMaxHigh := false - itvls := interval.NewIntervals(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) + itvls := intervals.New(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) // add intervals - if err := itvls.AddInterval(&interval.Interval{Low: 2, High: 4}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 2, High: 4}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - if err := itvls.AddInterval(&interval.Interval{Low: 6, High: 8}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 6, High: 8}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } // calculate expected gaps - gaps := []interval.Interval{} - gaps = append(gaps, interval.Interval{Low: minLow, High: 1}) - gaps = append(gaps, interval.Interval{Low: 5, High: 5}) - gaps = append(gaps, interval.Interval{Low: 9, High: maxHigh}) + gaps := []intervals.Interval{} + gaps = append(gaps, intervals.Interval{Low: minLow, High: 1}) + gaps = append(gaps, intervals.Interval{Low: 5, High: 5}) + gaps = append(gaps, intervals.Interval{Low: 9, High: maxHigh}) // calculate expected overlaps - overlaps := []interval.Interval{} + overlaps := []intervals.Interval{} // calculate expected merges - merges := []interval.Interval{} - merges = append(merges, interval.Interval{Low: 2, High: 4}) - merges = append(merges, interval.Interval{Low: 6, High: 8}) + merges := []intervals.Interval{} + merges = append(merges, intervals.Interval{Low: 2, High: 4}) + merges = append(merges, intervals.Interval{Low: 6, High: 8}) return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps, ExpectedMerges: merges} } @@ -215,27 +215,27 @@ func buildIntervalsDemo007() demo { highInclusive := true selfAdjustMinLow := false selfAdjustMaxHigh := false - itvls := interval.NewIntervals(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) + itvls := intervals.New(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) // add intervals - if err := itvls.AddInterval(&interval.Interval{Low: 2, High: 3}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 2, High: 3}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - if err := itvls.AddInterval(&interval.Interval{Low: 4, High: 6}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 4, High: 6}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } // calculate expected gaps - gaps := []interval.Interval{} - gaps = append(gaps, interval.Interval{Low: minLow, High: 1}) - gaps = append(gaps, interval.Interval{Low: 7, High: maxHigh}) + gaps := []intervals.Interval{} + gaps = append(gaps, intervals.Interval{Low: minLow, High: 1}) + gaps = append(gaps, intervals.Interval{Low: 7, High: maxHigh}) // calculate expected overlaps - overlaps := []interval.Interval{} + overlaps := []intervals.Interval{} // calculate expected merges - merges := []interval.Interval{} - merges = append(merges, interval.Interval{Low: 2, High: 6}) + merges := []intervals.Interval{} + merges = append(merges, intervals.Interval{Low: 2, High: 6}) return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps, ExpectedMerges: merges} } @@ -249,28 +249,28 @@ func buildIntervalsDemo008() demo { highInclusive := true selfAdjustMinLow := false selfAdjustMaxHigh := false - itvls := interval.NewIntervals(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) + itvls := intervals.New(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) // add intervals - if err := itvls.AddInterval(&interval.Interval{Low: 2, High: 6}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 2, High: 6}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - if err := itvls.AddInterval(&interval.Interval{Low: 6, High: 7}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 6, High: 7}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } // calculate expected gaps - gaps := []interval.Interval{} - gaps = append(gaps, interval.Interval{Low: minLow, High: 1}) - gaps = append(gaps, interval.Interval{Low: 8, High: maxHigh}) + gaps := []intervals.Interval{} + gaps = append(gaps, intervals.Interval{Low: minLow, High: 1}) + gaps = append(gaps, intervals.Interval{Low: 8, High: maxHigh}) // calculate expected overlaps - overlaps := []interval.Interval{} - overlaps = append(overlaps, interval.Interval{Low: 6, High: 6}) + overlaps := []intervals.Interval{} + overlaps = append(overlaps, intervals.Interval{Low: 6, High: 6}) // calculate expected merges - merges := []interval.Interval{} - merges = append(merges, interval.Interval{Low: 2, High: 7}) + merges := []intervals.Interval{} + merges = append(merges, intervals.Interval{Low: 2, High: 7}) return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps, ExpectedMerges: merges} } @@ -284,28 +284,28 @@ func buildIntervalsDemo009() demo { highInclusive := true selfAdjustMinLow := false selfAdjustMaxHigh := false - itvls := interval.NewIntervals(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) + itvls := intervals.New(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) // add intervals - if err := itvls.AddInterval(&interval.Interval{Low: 2, High: 6}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 2, High: 6}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - if err := itvls.AddInterval(&interval.Interval{Low: 4, High: 8}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 4, High: 8}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } // calculate expected gaps - gaps := []interval.Interval{} - gaps = append(gaps, interval.Interval{Low: minLow, High: 1}) - gaps = append(gaps, interval.Interval{Low: 9, High: maxHigh}) + gaps := []intervals.Interval{} + gaps = append(gaps, intervals.Interval{Low: minLow, High: 1}) + gaps = append(gaps, intervals.Interval{Low: 9, High: maxHigh}) // calculate expected overlaps - overlaps := []interval.Interval{} - overlaps = append(overlaps, interval.Interval{Low: 4, High: 6}) + overlaps := []intervals.Interval{} + overlaps = append(overlaps, intervals.Interval{Low: 4, High: 6}) // calculate expected merges - merges := []interval.Interval{} - merges = append(merges, interval.Interval{Low: 2, High: 8}) + merges := []intervals.Interval{} + merges = append(merges, intervals.Interval{Low: 2, High: 8}) return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps, ExpectedMerges: merges} } @@ -319,32 +319,32 @@ func buildIntervalsDemo010() demo { highInclusive := true selfAdjustMinLow := false selfAdjustMaxHigh := false - itvls := interval.NewIntervals(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) + itvls := intervals.New(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) // add intervals - if err := itvls.AddInterval(&interval.Interval{Low: minLow, High: 2}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: minLow, High: 2}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - if err := itvls.AddInterval(&interval.Interval{Low: 4, High: 4}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 4, High: 4}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - if err := itvls.AddInterval(&interval.Interval{Low: 8, High: maxHigh}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 8, High: maxHigh}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } // calculate expected gaps - gaps := []interval.Interval{} - gaps = append(gaps, interval.Interval{Low: 3, High: 3}) - gaps = append(gaps, interval.Interval{Low: 5, High: 7}) + gaps := []intervals.Interval{} + gaps = append(gaps, intervals.Interval{Low: 3, High: 3}) + gaps = append(gaps, intervals.Interval{Low: 5, High: 7}) // calculate expected overlaps - overlaps := []interval.Interval{} + overlaps := []intervals.Interval{} // calculate expected merges - merges := []interval.Interval{} - merges = append(merges, interval.Interval{Low: minLow, High: 2}) - merges = append(merges, interval.Interval{Low: 4, High: 4}) - merges = append(merges, interval.Interval{Low: 8, High: maxHigh}) + merges := []intervals.Interval{} + merges = append(merges, intervals.Interval{Low: minLow, High: 2}) + merges = append(merges, intervals.Interval{Low: 4, High: 4}) + merges = append(merges, intervals.Interval{Low: 8, High: maxHigh}) return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps, ExpectedMerges: merges} } @@ -358,32 +358,32 @@ func buildIntervalsDemo011() demo { highInclusive := true selfAdjustMinLow := false selfAdjustMaxHigh := false - itvls := interval.NewIntervals(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) + itvls := intervals.New(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) // add intervals - if err := itvls.AddInterval(&interval.Interval{Low: 2, High: 4}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 2, High: 4}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - if err := itvls.AddInterval(&interval.Interval{Low: 3, High: 6}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 3, High: 6}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - if err := itvls.AddInterval(&interval.Interval{Low: 5, High: 7}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 5, High: 7}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } // calculate expected gaps - gaps := []interval.Interval{} - gaps = append(gaps, interval.Interval{Low: minLow, High: 1}) - gaps = append(gaps, interval.Interval{Low: 8, High: maxHigh}) + gaps := []intervals.Interval{} + gaps = append(gaps, intervals.Interval{Low: minLow, High: 1}) + gaps = append(gaps, intervals.Interval{Low: 8, High: maxHigh}) // calculate expected overlaps - overlaps := []interval.Interval{} - overlaps = append(overlaps, interval.Interval{Low: 3, High: 4}) - overlaps = append(overlaps, interval.Interval{Low: 5, High: 6}) + overlaps := []intervals.Interval{} + overlaps = append(overlaps, intervals.Interval{Low: 3, High: 4}) + overlaps = append(overlaps, intervals.Interval{Low: 5, High: 6}) // calculate expected merges - merges := []interval.Interval{} - merges = append(merges, interval.Interval{Low: 2, High: 7}) + merges := []intervals.Interval{} + merges = append(merges, intervals.Interval{Low: 2, High: 7}) return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps, ExpectedMerges: merges} } @@ -397,61 +397,61 @@ func buildIntervalsDemo012() demo { highInclusive := true selfAdjustMinLow := false selfAdjustMaxHigh := false - itvls := interval.NewIntervals(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) + itvls := intervals.New(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) // add intervals - if err := itvls.AddInterval(&interval.Interval{Low: 5, High: 7}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 5, High: 7}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - if err := itvls.AddInterval(&interval.Interval{Low: 2, High: 4}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 2, High: 4}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - if err := itvls.AddInterval(&interval.Interval{Low: 35, High: 35}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 35, High: 35}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - if err := itvls.AddInterval(&interval.Interval{Low: 3, High: 6}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 3, High: 6}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - if err := itvls.AddInterval(&interval.Interval{Low: 18, High: 20}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 18, High: 20}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - if err := itvls.AddInterval(&interval.Interval{Low: 20, High: 30}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 20, High: 30}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - if err := itvls.AddInterval(&interval.Interval{Low: 25, High: 28}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 25, High: 28}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - if err := itvls.AddInterval(&interval.Interval{Low: minLow, High: 1}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: minLow, High: 1}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - if err := itvls.AddInterval(&interval.Interval{Low: 30, High: 32}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 30, High: 32}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - if err := itvls.AddInterval(&interval.Interval{Low: 10, High: 12}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 10, High: 12}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } // calculate expected gaps - gaps := []interval.Interval{} - gaps = append(gaps, interval.Interval{Low: 8, High: 9}) - gaps = append(gaps, interval.Interval{Low: 13, High: 17}) - gaps = append(gaps, interval.Interval{Low: 33, High: 34}) - gaps = append(gaps, interval.Interval{Low: 36, High: maxHigh}) + gaps := []intervals.Interval{} + gaps = append(gaps, intervals.Interval{Low: 8, High: 9}) + gaps = append(gaps, intervals.Interval{Low: 13, High: 17}) + gaps = append(gaps, intervals.Interval{Low: 33, High: 34}) + gaps = append(gaps, intervals.Interval{Low: 36, High: maxHigh}) // calculate expected overlaps - overlaps := []interval.Interval{} - overlaps = append(overlaps, interval.Interval{Low: 3, High: 4}) - overlaps = append(overlaps, interval.Interval{Low: 5, High: 6}) - overlaps = append(overlaps, interval.Interval{Low: 20, High: 20}) - overlaps = append(overlaps, interval.Interval{Low: 25, High: 28}) - overlaps = append(overlaps, interval.Interval{Low: 30, High: 30}) + overlaps := []intervals.Interval{} + overlaps = append(overlaps, intervals.Interval{Low: 3, High: 4}) + overlaps = append(overlaps, intervals.Interval{Low: 5, High: 6}) + overlaps = append(overlaps, intervals.Interval{Low: 20, High: 20}) + overlaps = append(overlaps, intervals.Interval{Low: 25, High: 28}) + overlaps = append(overlaps, intervals.Interval{Low: 30, High: 30}) // calculate expected merges - merges := []interval.Interval{} - merges = append(merges, interval.Interval{Low: minLow, High: 7}) - merges = append(merges, interval.Interval{Low: 10, High: 12}) - merges = append(merges, interval.Interval{Low: 18, High: 32}) - merges = append(merges, interval.Interval{Low: 35, High: 35}) + merges := []intervals.Interval{} + merges = append(merges, intervals.Interval{Low: minLow, High: 7}) + merges = append(merges, intervals.Interval{Low: 10, High: 12}) + merges = append(merges, intervals.Interval{Low: 18, High: 32}) + merges = append(merges, intervals.Interval{Low: 35, High: 35}) return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps, ExpectedMerges: merges} } @@ -465,60 +465,60 @@ func buildIntervalsDemo013() demo { highInclusive := true selfAdjustMinLow := false selfAdjustMaxHigh := true - itvls := interval.NewIntervals(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) + itvls := intervals.New(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) // add intervals - if err := itvls.AddInterval(&interval.Interval{Low: 5, High: 7}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 5, High: 7}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - if err := itvls.AddInterval(&interval.Interval{Low: 2, High: 4}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 2, High: 4}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - if err := itvls.AddInterval(&interval.Interval{Low: 35, High: 35}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 35, High: 35}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - if err := itvls.AddInterval(&interval.Interval{Low: 3, High: 6}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 3, High: 6}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - if err := itvls.AddInterval(&interval.Interval{Low: 18, High: 20}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 18, High: 20}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - if err := itvls.AddInterval(&interval.Interval{Low: 20, High: 30}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 20, High: 30}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - if err := itvls.AddInterval(&interval.Interval{Low: 25, High: 28}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 25, High: 28}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - if err := itvls.AddInterval(&interval.Interval{Low: minLow, High: 1}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: minLow, High: 1}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - if err := itvls.AddInterval(&interval.Interval{Low: 30, High: 32}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 30, High: 32}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - if err := itvls.AddInterval(&interval.Interval{Low: 10, High: 12}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 10, High: 12}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } // calculate expected gaps - gaps := []interval.Interval{} - gaps = append(gaps, interval.Interval{Low: 8, High: 9}) - gaps = append(gaps, interval.Interval{Low: 13, High: 17}) - gaps = append(gaps, interval.Interval{Low: 33, High: 34}) + gaps := []intervals.Interval{} + gaps = append(gaps, intervals.Interval{Low: 8, High: 9}) + gaps = append(gaps, intervals.Interval{Low: 13, High: 17}) + gaps = append(gaps, intervals.Interval{Low: 33, High: 34}) // calculate expected overlaps - overlaps := []interval.Interval{} - overlaps = append(overlaps, interval.Interval{Low: 3, High: 4}) - overlaps = append(overlaps, interval.Interval{Low: 5, High: 6}) - overlaps = append(overlaps, interval.Interval{Low: 20, High: 20}) - overlaps = append(overlaps, interval.Interval{Low: 25, High: 28}) - overlaps = append(overlaps, interval.Interval{Low: 30, High: 30}) + overlaps := []intervals.Interval{} + overlaps = append(overlaps, intervals.Interval{Low: 3, High: 4}) + overlaps = append(overlaps, intervals.Interval{Low: 5, High: 6}) + overlaps = append(overlaps, intervals.Interval{Low: 20, High: 20}) + overlaps = append(overlaps, intervals.Interval{Low: 25, High: 28}) + overlaps = append(overlaps, intervals.Interval{Low: 30, High: 30}) // calculate expected merges - merges := []interval.Interval{} - merges = append(merges, interval.Interval{Low: minLow, High: 7}) - merges = append(merges, interval.Interval{Low: 10, High: 12}) - merges = append(merges, interval.Interval{Low: 18, High: 32}) - merges = append(merges, interval.Interval{Low: 35, High: 35}) + merges := []intervals.Interval{} + merges = append(merges, intervals.Interval{Low: minLow, High: 7}) + merges = append(merges, intervals.Interval{Low: 10, High: 12}) + merges = append(merges, intervals.Interval{Low: 18, High: 32}) + merges = append(merges, intervals.Interval{Low: 35, High: 35}) return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps, ExpectedMerges: merges} } @@ -532,57 +532,57 @@ func buildIntervalsDemo014() demo { highInclusive := true selfAdjustMinLow := true selfAdjustMaxHigh := true - itvls := interval.NewIntervals(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) + itvls := intervals.New(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) // add intervals - if err := itvls.AddInterval(&interval.Interval{Low: 5, High: 7}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 5, High: 7}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - if err := itvls.AddInterval(&interval.Interval{Low: 2, High: 4}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 2, High: 4}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - if err := itvls.AddInterval(&interval.Interval{Low: 35, High: 35}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 35, High: 35}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - if err := itvls.AddInterval(&interval.Interval{Low: 3, High: 6}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 3, High: 6}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - if err := itvls.AddInterval(&interval.Interval{Low: 18, High: 20}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 18, High: 20}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - if err := itvls.AddInterval(&interval.Interval{Low: 20, High: 30}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 20, High: 30}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - if err := itvls.AddInterval(&interval.Interval{Low: 25, High: 28}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 25, High: 28}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - if err := itvls.AddInterval(&interval.Interval{Low: 30, High: 32}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 30, High: 32}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - if err := itvls.AddInterval(&interval.Interval{Low: 10, High: 12}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 10, High: 12}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } // calculate expected gaps - gaps := []interval.Interval{} - gaps = append(gaps, interval.Interval{Low: 8, High: 9}) - gaps = append(gaps, interval.Interval{Low: 13, High: 17}) - gaps = append(gaps, interval.Interval{Low: 33, High: 34}) + gaps := []intervals.Interval{} + gaps = append(gaps, intervals.Interval{Low: 8, High: 9}) + gaps = append(gaps, intervals.Interval{Low: 13, High: 17}) + gaps = append(gaps, intervals.Interval{Low: 33, High: 34}) // calculate expected overlaps - overlaps := []interval.Interval{} - overlaps = append(overlaps, interval.Interval{Low: 3, High: 4}) - overlaps = append(overlaps, interval.Interval{Low: 5, High: 6}) - overlaps = append(overlaps, interval.Interval{Low: 20, High: 20}) - overlaps = append(overlaps, interval.Interval{Low: 25, High: 28}) - overlaps = append(overlaps, interval.Interval{Low: 30, High: 30}) + overlaps := []intervals.Interval{} + overlaps = append(overlaps, intervals.Interval{Low: 3, High: 4}) + overlaps = append(overlaps, intervals.Interval{Low: 5, High: 6}) + overlaps = append(overlaps, intervals.Interval{Low: 20, High: 20}) + overlaps = append(overlaps, intervals.Interval{Low: 25, High: 28}) + overlaps = append(overlaps, intervals.Interval{Low: 30, High: 30}) // calculate expected merges - merges := []interval.Interval{} - merges = append(merges, interval.Interval{Low: 2, High: 7}) - merges = append(merges, interval.Interval{Low: 10, High: 12}) - merges = append(merges, interval.Interval{Low: 18, High: 32}) - merges = append(merges, interval.Interval{Low: 35, High: 35}) + merges := []intervals.Interval{} + merges = append(merges, intervals.Interval{Low: 2, High: 7}) + merges = append(merges, intervals.Interval{Low: 10, High: 12}) + merges = append(merges, intervals.Interval{Low: 18, High: 32}) + merges = append(merges, intervals.Interval{Low: 35, High: 35}) return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps, ExpectedMerges: merges} } @@ -596,58 +596,58 @@ func buildIntervalsDemo015() demo { highInclusive := true selfAdjustMinLow := true selfAdjustMaxHigh := false - itvls := interval.NewIntervals(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) + itvls := intervals.New(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) // add intervals - if err := itvls.AddInterval(&interval.Interval{Low: 5, High: 7}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 5, High: 7}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - if err := itvls.AddInterval(&interval.Interval{Low: 2, High: 4}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 2, High: 4}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - if err := itvls.AddInterval(&interval.Interval{Low: 35, High: 35}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 35, High: 35}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - if err := itvls.AddInterval(&interval.Interval{Low: 3, High: 6}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 3, High: 6}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - if err := itvls.AddInterval(&interval.Interval{Low: 18, High: 20}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 18, High: 20}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - if err := itvls.AddInterval(&interval.Interval{Low: 20, High: 30}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 20, High: 30}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - if err := itvls.AddInterval(&interval.Interval{Low: 25, High: 28}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 25, High: 28}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - if err := itvls.AddInterval(&interval.Interval{Low: 30, High: 32}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 30, High: 32}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - if err := itvls.AddInterval(&interval.Interval{Low: 10, High: 12}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 10, High: 12}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } // calculate expected gaps - gaps := []interval.Interval{} - gaps = append(gaps, interval.Interval{Low: 8, High: 9}) - gaps = append(gaps, interval.Interval{Low: 13, High: 17}) - gaps = append(gaps, interval.Interval{Low: 33, High: 34}) - gaps = append(gaps, interval.Interval{Low: 36, High: maxHigh}) + gaps := []intervals.Interval{} + gaps = append(gaps, intervals.Interval{Low: 8, High: 9}) + gaps = append(gaps, intervals.Interval{Low: 13, High: 17}) + gaps = append(gaps, intervals.Interval{Low: 33, High: 34}) + gaps = append(gaps, intervals.Interval{Low: 36, High: maxHigh}) // calculate expected overlaps - overlaps := []interval.Interval{} - overlaps = append(overlaps, interval.Interval{Low: 3, High: 4}) - overlaps = append(overlaps, interval.Interval{Low: 5, High: 6}) - overlaps = append(overlaps, interval.Interval{Low: 20, High: 20}) - overlaps = append(overlaps, interval.Interval{Low: 25, High: 28}) - overlaps = append(overlaps, interval.Interval{Low: 30, High: 30}) + overlaps := []intervals.Interval{} + overlaps = append(overlaps, intervals.Interval{Low: 3, High: 4}) + overlaps = append(overlaps, intervals.Interval{Low: 5, High: 6}) + overlaps = append(overlaps, intervals.Interval{Low: 20, High: 20}) + overlaps = append(overlaps, intervals.Interval{Low: 25, High: 28}) + overlaps = append(overlaps, intervals.Interval{Low: 30, High: 30}) // calculate expected merges - merges := []interval.Interval{} - merges = append(merges, interval.Interval{Low: 2, High: 7}) - merges = append(merges, interval.Interval{Low: 10, High: 12}) - merges = append(merges, interval.Interval{Low: 18, High: 32}) - merges = append(merges, interval.Interval{Low: 35, High: 35}) + merges := []intervals.Interval{} + merges = append(merges, intervals.Interval{Low: 2, High: 7}) + merges = append(merges, intervals.Interval{Low: 10, High: 12}) + merges = append(merges, intervals.Interval{Low: 18, High: 32}) + merges = append(merges, intervals.Interval{Low: 35, High: 35}) return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps, ExpectedMerges: merges} } @@ -665,17 +665,17 @@ func buildIntervalsDemo101() demo { highInclusive := false selfAdjustMinLow := false selfAdjustMaxHigh := false - itvls := interval.NewIntervals(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) + itvls := intervals.New(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) // calculate expected gaps - gaps := []interval.Interval{} - gaps = append(gaps, interval.Interval{Low: minLow, High: maxHigh}) + gaps := []intervals.Interval{} + gaps = append(gaps, intervals.Interval{Low: minLow, High: maxHigh}) // calculate expected overlaps - overlaps := []interval.Interval{} + overlaps := []intervals.Interval{} // calculate expected merges - merges := []interval.Interval{} + merges := []intervals.Interval{} return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps, ExpectedMerges: merges} } @@ -689,24 +689,24 @@ func buildIntervalsDemo102() demo { highInclusive := false selfAdjustMinLow := false selfAdjustMaxHigh := false - itvls := interval.NewIntervals(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) + itvls := intervals.New(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) // add intervals - if err := itvls.AddInterval(&interval.Interval{Low: minLow, High: 4}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: minLow, High: 4}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } // calculate expected gaps - gaps := []interval.Interval{} - gaps = append(gaps, interval.Interval{Low: minLow, High: minLow}) - gaps = append(gaps, interval.Interval{Low: 4, High: maxHigh}) + gaps := []intervals.Interval{} + gaps = append(gaps, intervals.Interval{Low: minLow, High: minLow}) + gaps = append(gaps, intervals.Interval{Low: 4, High: maxHigh}) // calculate expected overlaps - overlaps := []interval.Interval{} + overlaps := []intervals.Interval{} // calculate expected merges - merges := []interval.Interval{} - merges = append(merges, interval.Interval{Low: 1, High: 3}) + merges := []intervals.Interval{} + merges = append(merges, intervals.Interval{Low: 1, High: 3}) return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps, ExpectedMerges: merges} } @@ -720,24 +720,24 @@ func buildIntervalsDemo103() demo { highInclusive := false selfAdjustMinLow := false selfAdjustMaxHigh := false - itvls := interval.NewIntervals(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) + itvls := intervals.New(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) // add intervals - if err := itvls.AddInterval(&interval.Interval{Low: 8, High: maxHigh}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 8, High: maxHigh}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } // calculate expected gaps - gaps := []interval.Interval{} - gaps = append(gaps, interval.Interval{Low: minLow, High: 8}) - gaps = append(gaps, interval.Interval{Low: maxHigh, High: maxHigh}) + gaps := []intervals.Interval{} + gaps = append(gaps, intervals.Interval{Low: minLow, High: 8}) + gaps = append(gaps, intervals.Interval{Low: maxHigh, High: maxHigh}) // calculate expected overlaps - overlaps := []interval.Interval{} + overlaps := []intervals.Interval{} // calculate expected merges - merges := []interval.Interval{} - merges = append(merges, interval.Interval{Low: 9, High: 9}) + merges := []intervals.Interval{} + merges = append(merges, intervals.Interval{Low: 9, High: 9}) return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps, ExpectedMerges: merges} } @@ -751,24 +751,24 @@ func buildIntervalsDemo104() demo { highInclusive := false selfAdjustMinLow := false selfAdjustMaxHigh := false - itvls := interval.NewIntervals(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) + itvls := intervals.New(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) // add intervals - if err := itvls.AddInterval(&interval.Interval{Low: 5, High: 8}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 5, High: 8}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } // calculate expected gaps - gaps := []interval.Interval{} - gaps = append(gaps, interval.Interval{Low: minLow, High: 5}) - gaps = append(gaps, interval.Interval{Low: 8, High: maxHigh}) + gaps := []intervals.Interval{} + gaps = append(gaps, intervals.Interval{Low: minLow, High: 5}) + gaps = append(gaps, intervals.Interval{Low: 8, High: maxHigh}) // calculate expected overlaps - overlaps := []interval.Interval{} + overlaps := []intervals.Interval{} // calculate expected merges - merges := []interval.Interval{} - merges = append(merges, interval.Interval{Low: 6, High: 7}) + merges := []intervals.Interval{} + merges = append(merges, intervals.Interval{Low: 6, High: 7}) return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps, ExpectedMerges: merges} } @@ -782,28 +782,28 @@ func buildIntervalsDemo105() demo { highInclusive := false selfAdjustMinLow := false selfAdjustMaxHigh := false - itvls := interval.NewIntervals(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) + itvls := intervals.New(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) // add intervals - if err := itvls.AddInterval(&interval.Interval{Low: 2, High: 8}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 2, High: 8}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - if err := itvls.AddInterval(&interval.Interval{Low: 4, High: 6}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 4, High: 6}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } // calculate expected gaps - gaps := []interval.Interval{} - gaps = append(gaps, interval.Interval{Low: minLow, High: 2}) - gaps = append(gaps, interval.Interval{Low: 8, High: maxHigh}) + gaps := []intervals.Interval{} + gaps = append(gaps, intervals.Interval{Low: minLow, High: 2}) + gaps = append(gaps, intervals.Interval{Low: 8, High: maxHigh}) // calculate expected overlaps - overlaps := []interval.Interval{} - overlaps = append(overlaps, interval.Interval{Low: 5, High: 5}) + overlaps := []intervals.Interval{} + overlaps = append(overlaps, intervals.Interval{Low: 5, High: 5}) // calculate expected merges - merges := []interval.Interval{} - merges = append(merges, interval.Interval{Low: 3, High: 7}) + merges := []intervals.Interval{} + merges = append(merges, intervals.Interval{Low: 3, High: 7}) return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps, ExpectedMerges: merges} } @@ -817,29 +817,29 @@ func buildIntervalsDemo106() demo { highInclusive := false selfAdjustMinLow := false selfAdjustMaxHigh := false - itvls := interval.NewIntervals(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) + itvls := intervals.New(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) // add intervals - if err := itvls.AddInterval(&interval.Interval{Low: 2, High: 4}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 2, High: 4}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - if err := itvls.AddInterval(&interval.Interval{Low: 6, High: 8}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 6, High: 8}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } // calculate expected gaps - gaps := []interval.Interval{} - gaps = append(gaps, interval.Interval{Low: minLow, High: 2}) - gaps = append(gaps, interval.Interval{Low: 4, High: 6}) - gaps = append(gaps, interval.Interval{Low: 8, High: maxHigh}) + gaps := []intervals.Interval{} + gaps = append(gaps, intervals.Interval{Low: minLow, High: 2}) + gaps = append(gaps, intervals.Interval{Low: 4, High: 6}) + gaps = append(gaps, intervals.Interval{Low: 8, High: maxHigh}) // calculate expected overlaps - overlaps := []interval.Interval{} + overlaps := []intervals.Interval{} // calculate expected merges - merges := []interval.Interval{} - merges = append(merges, interval.Interval{Low: 3, High: 3}) - merges = append(merges, interval.Interval{Low: 7, High: 7}) + merges := []intervals.Interval{} + merges = append(merges, intervals.Interval{Low: 3, High: 3}) + merges = append(merges, intervals.Interval{Low: 7, High: 7}) return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps, ExpectedMerges: merges} } @@ -853,29 +853,29 @@ func buildIntervalsDemo107() demo { highInclusive := false selfAdjustMinLow := false selfAdjustMaxHigh := false - itvls := interval.NewIntervals(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) + itvls := intervals.New(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) // add intervals - if err := itvls.AddInterval(&interval.Interval{Low: 2, High: 4}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 2, High: 4}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - if err := itvls.AddInterval(&interval.Interval{Low: 4, High: 6}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 4, High: 6}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } // calculate expected gaps - gaps := []interval.Interval{} - gaps = append(gaps, interval.Interval{Low: minLow, High: 2}) - gaps = append(gaps, interval.Interval{Low: 4, High: 4}) - gaps = append(gaps, interval.Interval{Low: 6, High: maxHigh}) + gaps := []intervals.Interval{} + gaps = append(gaps, intervals.Interval{Low: minLow, High: 2}) + gaps = append(gaps, intervals.Interval{Low: 4, High: 4}) + gaps = append(gaps, intervals.Interval{Low: 6, High: maxHigh}) // calculate expected overlaps - overlaps := []interval.Interval{} + overlaps := []intervals.Interval{} // calculate expected merges - merges := []interval.Interval{} - merges = append(merges, interval.Interval{Low: 3, High: 3}) - merges = append(merges, interval.Interval{Low: 5, High: 5}) + merges := []intervals.Interval{} + merges = append(merges, intervals.Interval{Low: 3, High: 3}) + merges = append(merges, intervals.Interval{Low: 5, High: 5}) return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps, ExpectedMerges: merges} } @@ -889,27 +889,27 @@ func buildIntervalsDemo108() demo { highInclusive := false selfAdjustMinLow := false selfAdjustMaxHigh := false - itvls := interval.NewIntervals(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) + itvls := intervals.New(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) // add intervals - if err := itvls.AddInterval(&interval.Interval{Low: 2, High: 6}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 2, High: 6}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - if err := itvls.AddInterval(&interval.Interval{Low: 6, High: 7}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 6, High: 7}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } // calculate expected gaps - gaps := []interval.Interval{} - gaps = append(gaps, interval.Interval{Low: minLow, High: 2}) - gaps = append(gaps, interval.Interval{Low: 6, High: maxHigh}) + gaps := []intervals.Interval{} + gaps = append(gaps, intervals.Interval{Low: minLow, High: 2}) + gaps = append(gaps, intervals.Interval{Low: 6, High: maxHigh}) // calculate expected overlaps - overlaps := []interval.Interval{} + overlaps := []intervals.Interval{} // calculate expected merges - merges := []interval.Interval{} - merges = append(merges, interval.Interval{Low: 3, High: 5}) + merges := []intervals.Interval{} + merges = append(merges, intervals.Interval{Low: 3, High: 5}) return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps, ExpectedMerges: merges} } @@ -923,28 +923,28 @@ func buildIntervalsDemo109() demo { highInclusive := false selfAdjustMinLow := false selfAdjustMaxHigh := false - itvls := interval.NewIntervals(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) + itvls := intervals.New(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) // add intervals - if err := itvls.AddInterval(&interval.Interval{Low: 2, High: 6}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 2, High: 6}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - if err := itvls.AddInterval(&interval.Interval{Low: 4, High: 8}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 4, High: 8}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } // calculate expected gaps - gaps := []interval.Interval{} - gaps = append(gaps, interval.Interval{Low: minLow, High: 2}) - gaps = append(gaps, interval.Interval{Low: 8, High: maxHigh}) + gaps := []intervals.Interval{} + gaps = append(gaps, intervals.Interval{Low: minLow, High: 2}) + gaps = append(gaps, intervals.Interval{Low: 8, High: maxHigh}) // calculate expected overlaps - overlaps := []interval.Interval{} - overlaps = append(overlaps, interval.Interval{Low: 5, High: 5}) + overlaps := []intervals.Interval{} + overlaps = append(overlaps, intervals.Interval{Low: 5, High: 5}) // calculate expected merges - merges := []interval.Interval{} - merges = append(merges, interval.Interval{Low: 3, High: 7}) + merges := []intervals.Interval{} + merges = append(merges, intervals.Interval{Low: 3, High: 7}) return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps, ExpectedMerges: merges} } @@ -958,32 +958,32 @@ func buildIntervalsDemo110() demo { highInclusive := false selfAdjustMinLow := false selfAdjustMaxHigh := false - itvls := interval.NewIntervals(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) + itvls := intervals.New(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) // add intervals - if err := itvls.AddInterval(&interval.Interval{Low: minLow, High: 2}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: minLow, High: 2}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - if err := itvls.AddInterval(&interval.Interval{Low: 4, High: 4}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 4, High: 4}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - if err := itvls.AddInterval(&interval.Interval{Low: 8, High: maxHigh}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 8, High: maxHigh}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } // calculate expected gaps - gaps := []interval.Interval{} - gaps = append(gaps, interval.Interval{Low: minLow, High: minLow}) - gaps = append(gaps, interval.Interval{Low: 2, High: 8}) - gaps = append(gaps, interval.Interval{Low: maxHigh, High: maxHigh}) + gaps := []intervals.Interval{} + gaps = append(gaps, intervals.Interval{Low: minLow, High: minLow}) + gaps = append(gaps, intervals.Interval{Low: 2, High: 8}) + gaps = append(gaps, intervals.Interval{Low: maxHigh, High: maxHigh}) // calculate expected overlaps - overlaps := []interval.Interval{} + overlaps := []intervals.Interval{} // calculate expected merges - merges := []interval.Interval{} - merges = append(merges, interval.Interval{Low: 1, High: 1}) - merges = append(merges, interval.Interval{Low: 9, High: 9}) + merges := []intervals.Interval{} + merges = append(merges, intervals.Interval{Low: 1, High: 1}) + merges = append(merges, intervals.Interval{Low: 9, High: 9}) return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps, ExpectedMerges: merges} } @@ -997,30 +997,30 @@ func buildIntervalsDemo111() demo { highInclusive := false selfAdjustMinLow := false selfAdjustMaxHigh := false - itvls := interval.NewIntervals(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) + itvls := intervals.New(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) // add intervals - if err := itvls.AddInterval(&interval.Interval{Low: 2, High: 4}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 2, High: 4}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - if err := itvls.AddInterval(&interval.Interval{Low: 3, High: 6}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 3, High: 6}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - if err := itvls.AddInterval(&interval.Interval{Low: 5, High: 7}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 5, High: 7}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } // calculate expected gaps - gaps := []interval.Interval{} - gaps = append(gaps, interval.Interval{Low: minLow, High: 2}) - gaps = append(gaps, interval.Interval{Low: 7, High: maxHigh}) + gaps := []intervals.Interval{} + gaps = append(gaps, intervals.Interval{Low: minLow, High: 2}) + gaps = append(gaps, intervals.Interval{Low: 7, High: maxHigh}) // calculate expected overlaps - overlaps := []interval.Interval{} + overlaps := []intervals.Interval{} // calculate expected merges - merges := []interval.Interval{} - merges = append(merges, interval.Interval{Low: 3, High: 6}) + merges := []intervals.Interval{} + merges = append(merges, intervals.Interval{Low: 3, High: 6}) return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps, ExpectedMerges: merges} } @@ -1034,60 +1034,60 @@ func buildIntervalsDemo112() demo { highInclusive := false selfAdjustMinLow := false selfAdjustMaxHigh := false - itvls := interval.NewIntervals(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) + itvls := intervals.New(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) // add intervals - if err := itvls.AddInterval(&interval.Interval{Low: 5, High: 7}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 5, High: 7}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - if err := itvls.AddInterval(&interval.Interval{Low: 2, High: 4}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 2, High: 4}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - if err := itvls.AddInterval(&interval.Interval{Low: 35, High: 35}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 35, High: 35}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - if err := itvls.AddInterval(&interval.Interval{Low: 3, High: 6}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 3, High: 6}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - if err := itvls.AddInterval(&interval.Interval{Low: 18, High: 20}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 18, High: 20}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - if err := itvls.AddInterval(&interval.Interval{Low: 20, High: 30}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 20, High: 30}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - if err := itvls.AddInterval(&interval.Interval{Low: 25, High: 28}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 25, High: 28}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - if err := itvls.AddInterval(&interval.Interval{Low: minLow, High: 1}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: minLow, High: 1}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - if err := itvls.AddInterval(&interval.Interval{Low: 30, High: 32}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 30, High: 32}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - if err := itvls.AddInterval(&interval.Interval{Low: 10, High: 12}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 10, High: 12}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } // calculate expected gaps - gaps := []interval.Interval{} - gaps = append(gaps, interval.Interval{Low: minLow, High: 2}) - gaps = append(gaps, interval.Interval{Low: 7, High: 10}) - gaps = append(gaps, interval.Interval{Low: 12, High: 18}) - gaps = append(gaps, interval.Interval{Low: 20, High: 20}) - gaps = append(gaps, interval.Interval{Low: 30, High: 30}) - gaps = append(gaps, interval.Interval{Low: 32, High: maxHigh}) + gaps := []intervals.Interval{} + gaps = append(gaps, intervals.Interval{Low: minLow, High: 2}) + gaps = append(gaps, intervals.Interval{Low: 7, High: 10}) + gaps = append(gaps, intervals.Interval{Low: 12, High: 18}) + gaps = append(gaps, intervals.Interval{Low: 20, High: 20}) + gaps = append(gaps, intervals.Interval{Low: 30, High: 30}) + gaps = append(gaps, intervals.Interval{Low: 32, High: maxHigh}) // calculate expected overlaps - overlaps := []interval.Interval{} - overlaps = append(overlaps, interval.Interval{Low: 26, High: 27}) + overlaps := []intervals.Interval{} + overlaps = append(overlaps, intervals.Interval{Low: 26, High: 27}) // calculate expected merges - merges := []interval.Interval{} - merges = append(merges, interval.Interval{Low: 3, High: 6}) - merges = append(merges, interval.Interval{Low: 11, High: 11}) - merges = append(merges, interval.Interval{Low: 19, High: 19}) - merges = append(merges, interval.Interval{Low: 21, High: 29}) - merges = append(merges, interval.Interval{Low: 31, High: 31}) + merges := []intervals.Interval{} + merges = append(merges, intervals.Interval{Low: 3, High: 6}) + merges = append(merges, intervals.Interval{Low: 11, High: 11}) + merges = append(merges, intervals.Interval{Low: 19, High: 19}) + merges = append(merges, intervals.Interval{Low: 21, High: 29}) + merges = append(merges, intervals.Interval{Low: 31, High: 31}) return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps, ExpectedMerges: merges} } @@ -1105,17 +1105,17 @@ func buildIntervalsDemo201() demo { highInclusive := false selfAdjustMinLow := false selfAdjustMaxHigh := false - itvls := interval.NewIntervals(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) + itvls := intervals.New(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) // calculate expected gaps - gaps := []interval.Interval{} - gaps = append(gaps, interval.Interval{Low: minLow, High: maxHigh}) + gaps := []intervals.Interval{} + gaps = append(gaps, intervals.Interval{Low: minLow, High: maxHigh}) // calculate expected overlaps - overlaps := []interval.Interval{} + overlaps := []intervals.Interval{} // calculate expected merges - merges := []interval.Interval{} + merges := []intervals.Interval{} return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps, ExpectedMerges: merges} } @@ -1129,23 +1129,23 @@ func buildIntervalsDemo202() demo { highInclusive := false selfAdjustMinLow := false selfAdjustMaxHigh := false - itvls := interval.NewIntervals(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) + itvls := intervals.New(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) // add intervals - if err := itvls.AddInterval(&interval.Interval{Low: minLow, High: 4}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: minLow, High: 4}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } // calculate expected gaps - gaps := []interval.Interval{} - gaps = append(gaps, interval.Interval{Low: 4, High: maxHigh}) + gaps := []intervals.Interval{} + gaps = append(gaps, intervals.Interval{Low: 4, High: maxHigh}) // calculate expected overlaps - overlaps := []interval.Interval{} + overlaps := []intervals.Interval{} // calculate expected merges - merges := []interval.Interval{} - merges = append(merges, interval.Interval{Low: minLow, High: 3}) + merges := []intervals.Interval{} + merges = append(merges, intervals.Interval{Low: minLow, High: 3}) return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps, ExpectedMerges: merges} } @@ -1159,24 +1159,24 @@ func buildIntervalsDemo203() demo { highInclusive := false selfAdjustMinLow := false selfAdjustMaxHigh := false - itvls := interval.NewIntervals(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) + itvls := intervals.New(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) // add intervals - if err := itvls.AddInterval(&interval.Interval{Low: 8, High: maxHigh}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 8, High: maxHigh}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } // calculate expected gaps - gaps := []interval.Interval{} - gaps = append(gaps, interval.Interval{Low: minLow, High: 7}) - gaps = append(gaps, interval.Interval{Low: maxHigh, High: maxHigh}) + gaps := []intervals.Interval{} + gaps = append(gaps, intervals.Interval{Low: minLow, High: 7}) + gaps = append(gaps, intervals.Interval{Low: maxHigh, High: maxHigh}) // calculate expected overlaps - overlaps := []interval.Interval{} + overlaps := []intervals.Interval{} // calculate expected merges - merges := []interval.Interval{} - merges = append(merges, interval.Interval{Low: 8, High: maxHigh - 1}) + merges := []intervals.Interval{} + merges = append(merges, intervals.Interval{Low: 8, High: maxHigh - 1}) return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps, ExpectedMerges: merges} } @@ -1190,24 +1190,24 @@ func buildIntervalsDemo204() demo { highInclusive := false selfAdjustMinLow := false selfAdjustMaxHigh := false - itvls := interval.NewIntervals(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) + itvls := intervals.New(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) // add intervals - if err := itvls.AddInterval(&interval.Interval{Low: 5, High: 8}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 5, High: 8}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } // calculate expected gaps - gaps := []interval.Interval{} - gaps = append(gaps, interval.Interval{Low: minLow, High: 4}) - gaps = append(gaps, interval.Interval{Low: 8, High: maxHigh}) + gaps := []intervals.Interval{} + gaps = append(gaps, intervals.Interval{Low: minLow, High: 4}) + gaps = append(gaps, intervals.Interval{Low: 8, High: maxHigh}) // calculate expected overlaps - overlaps := []interval.Interval{} + overlaps := []intervals.Interval{} // calculate expected merges - merges := []interval.Interval{} - merges = append(merges, interval.Interval{Low: 5, High: 7}) + merges := []intervals.Interval{} + merges = append(merges, intervals.Interval{Low: 5, High: 7}) return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps, ExpectedMerges: merges} } @@ -1221,28 +1221,28 @@ func buildIntervalsDemo205() demo { highInclusive := false selfAdjustMinLow := false selfAdjustMaxHigh := false - itvls := interval.NewIntervals(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) + itvls := intervals.New(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) // add intervals - if err := itvls.AddInterval(&interval.Interval{Low: 2, High: 8}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 2, High: 8}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - if err := itvls.AddInterval(&interval.Interval{Low: 4, High: 6}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 4, High: 6}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } // calculate expected gaps - gaps := []interval.Interval{} - gaps = append(gaps, interval.Interval{Low: minLow, High: 1}) - gaps = append(gaps, interval.Interval{Low: 8, High: maxHigh}) + gaps := []intervals.Interval{} + gaps = append(gaps, intervals.Interval{Low: minLow, High: 1}) + gaps = append(gaps, intervals.Interval{Low: 8, High: maxHigh}) // calculate expected overlaps - overlaps := []interval.Interval{} - overlaps = append(overlaps, interval.Interval{Low: 4, High: 5}) + overlaps := []intervals.Interval{} + overlaps = append(overlaps, intervals.Interval{Low: 4, High: 5}) // calculate expected merges - merges := []interval.Interval{} - merges = append(merges, interval.Interval{Low: 2, High: 7}) + merges := []intervals.Interval{} + merges = append(merges, intervals.Interval{Low: 2, High: 7}) return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps, ExpectedMerges: merges} } @@ -1256,29 +1256,29 @@ func buildIntervalsDemo206() demo { highInclusive := false selfAdjustMinLow := false selfAdjustMaxHigh := false - itvls := interval.NewIntervals(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) + itvls := intervals.New(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) // add intervals - if err := itvls.AddInterval(&interval.Interval{Low: 2, High: 4}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 2, High: 4}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - if err := itvls.AddInterval(&interval.Interval{Low: 6, High: 8}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 6, High: 8}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } // calculate expected gaps - gaps := []interval.Interval{} - gaps = append(gaps, interval.Interval{Low: minLow, High: 1}) - gaps = append(gaps, interval.Interval{Low: 4, High: 5}) - gaps = append(gaps, interval.Interval{Low: 8, High: maxHigh}) + gaps := []intervals.Interval{} + gaps = append(gaps, intervals.Interval{Low: minLow, High: 1}) + gaps = append(gaps, intervals.Interval{Low: 4, High: 5}) + gaps = append(gaps, intervals.Interval{Low: 8, High: maxHigh}) // calculate expected overlaps - overlaps := []interval.Interval{} + overlaps := []intervals.Interval{} // calculate expected merges - merges := []interval.Interval{} - merges = append(merges, interval.Interval{Low: 2, High: 3}) - merges = append(merges, interval.Interval{Low: 6, High: 7}) + merges := []intervals.Interval{} + merges = append(merges, intervals.Interval{Low: 2, High: 3}) + merges = append(merges, intervals.Interval{Low: 6, High: 7}) return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps, ExpectedMerges: merges} } @@ -1292,27 +1292,27 @@ func buildIntervalsDemo207() demo { highInclusive := false selfAdjustMinLow := false selfAdjustMaxHigh := false - itvls := interval.NewIntervals(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) + itvls := intervals.New(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) // add intervals - if err := itvls.AddInterval(&interval.Interval{Low: 2, High: 4}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 2, High: 4}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - if err := itvls.AddInterval(&interval.Interval{Low: 4, High: 6}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 4, High: 6}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } // calculate expected gaps - gaps := []interval.Interval{} - gaps = append(gaps, interval.Interval{Low: minLow, High: 1}) - gaps = append(gaps, interval.Interval{Low: 6, High: maxHigh}) + gaps := []intervals.Interval{} + gaps = append(gaps, intervals.Interval{Low: minLow, High: 1}) + gaps = append(gaps, intervals.Interval{Low: 6, High: maxHigh}) // calculate expected overlaps - overlaps := []interval.Interval{} + overlaps := []intervals.Interval{} // calculate expected merges - merges := []interval.Interval{} - merges = append(merges, interval.Interval{Low: 2, High: 5}) + merges := []intervals.Interval{} + merges = append(merges, intervals.Interval{Low: 2, High: 5}) return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps, ExpectedMerges: merges} } @@ -1326,27 +1326,27 @@ func buildIntervalsDemo208() demo { highInclusive := false selfAdjustMinLow := false selfAdjustMaxHigh := false - itvls := interval.NewIntervals(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) + itvls := intervals.New(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) // add intervals - if err := itvls.AddInterval(&interval.Interval{Low: 2, High: 6}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 2, High: 6}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - if err := itvls.AddInterval(&interval.Interval{Low: 6, High: 7}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 6, High: 7}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } // calculate expected gaps - gaps := []interval.Interval{} - gaps = append(gaps, interval.Interval{Low: minLow, High: 1}) - gaps = append(gaps, interval.Interval{Low: 7, High: maxHigh}) + gaps := []intervals.Interval{} + gaps = append(gaps, intervals.Interval{Low: minLow, High: 1}) + gaps = append(gaps, intervals.Interval{Low: 7, High: maxHigh}) // calculate expected overlaps - overlaps := []interval.Interval{} + overlaps := []intervals.Interval{} // calculate expected merges - merges := []interval.Interval{} - merges = append(merges, interval.Interval{Low: 2, High: 6}) + merges := []intervals.Interval{} + merges = append(merges, intervals.Interval{Low: 2, High: 6}) return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps, ExpectedMerges: merges} } @@ -1360,28 +1360,28 @@ func buildIntervalsDemo209() demo { highInclusive := false selfAdjustMinLow := false selfAdjustMaxHigh := false - itvls := interval.NewIntervals(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) + itvls := intervals.New(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) // add intervals - if err := itvls.AddInterval(&interval.Interval{Low: 2, High: 6}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 2, High: 6}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - if err := itvls.AddInterval(&interval.Interval{Low: 4, High: 8}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 4, High: 8}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } // calculate expected gaps - gaps := []interval.Interval{} - gaps = append(gaps, interval.Interval{Low: minLow, High: 1}) - gaps = append(gaps, interval.Interval{Low: 8, High: maxHigh}) + gaps := []intervals.Interval{} + gaps = append(gaps, intervals.Interval{Low: minLow, High: 1}) + gaps = append(gaps, intervals.Interval{Low: 8, High: maxHigh}) // calculate expected overlaps - overlaps := []interval.Interval{} - overlaps = append(overlaps, interval.Interval{Low: 4, High: 5}) + overlaps := []intervals.Interval{} + overlaps = append(overlaps, intervals.Interval{Low: 4, High: 5}) // calculate expected merges - merges := []interval.Interval{} - merges = append(merges, interval.Interval{Low: 2, High: 7}) + merges := []intervals.Interval{} + merges = append(merges, intervals.Interval{Low: 2, High: 7}) return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps, ExpectedMerges: merges} } @@ -1395,31 +1395,31 @@ func buildIntervalsDemo210() demo { highInclusive := false selfAdjustMinLow := false selfAdjustMaxHigh := false - itvls := interval.NewIntervals(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) + itvls := intervals.New(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) // add intervals - if err := itvls.AddInterval(&interval.Interval{Low: minLow, High: 2}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: minLow, High: 2}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - if err := itvls.AddInterval(&interval.Interval{Low: 4, High: 4}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 4, High: 4}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - if err := itvls.AddInterval(&interval.Interval{Low: 8, High: maxHigh}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 8, High: maxHigh}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } // calculate expected gaps - gaps := []interval.Interval{} - gaps = append(gaps, interval.Interval{Low: 2, High: 7}) - gaps = append(gaps, interval.Interval{Low: maxHigh, High: maxHigh}) + gaps := []intervals.Interval{} + gaps = append(gaps, intervals.Interval{Low: 2, High: 7}) + gaps = append(gaps, intervals.Interval{Low: maxHigh, High: maxHigh}) // calculate expected overlaps - overlaps := []interval.Interval{} + overlaps := []intervals.Interval{} // calculate expected merges - merges := []interval.Interval{} - merges = append(merges, interval.Interval{Low: minLow, High: 1}) - merges = append(merges, interval.Interval{Low: 8, High: 9}) + merges := []intervals.Interval{} + merges = append(merges, intervals.Interval{Low: minLow, High: 1}) + merges = append(merges, intervals.Interval{Low: 8, High: 9}) return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps, ExpectedMerges: merges} } @@ -1433,32 +1433,32 @@ func buildIntervalsDemo211() demo { highInclusive := false selfAdjustMinLow := false selfAdjustMaxHigh := false - itvls := interval.NewIntervals(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) + itvls := intervals.New(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) // add intervals - if err := itvls.AddInterval(&interval.Interval{Low: 2, High: 4}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 2, High: 4}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - if err := itvls.AddInterval(&interval.Interval{Low: 3, High: 6}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 3, High: 6}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - if err := itvls.AddInterval(&interval.Interval{Low: 5, High: 7}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 5, High: 7}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } // calculate expected gaps - gaps := []interval.Interval{} - gaps = append(gaps, interval.Interval{Low: minLow, High: 1}) - gaps = append(gaps, interval.Interval{Low: 7, High: maxHigh}) + gaps := []intervals.Interval{} + gaps = append(gaps, intervals.Interval{Low: minLow, High: 1}) + gaps = append(gaps, intervals.Interval{Low: 7, High: maxHigh}) // calculate expected overlaps - overlaps := []interval.Interval{} - overlaps = append(overlaps, interval.Interval{Low: 3, High: 3}) - overlaps = append(overlaps, interval.Interval{Low: 5, High: 5}) + overlaps := []intervals.Interval{} + overlaps = append(overlaps, intervals.Interval{Low: 3, High: 3}) + overlaps = append(overlaps, intervals.Interval{Low: 5, High: 5}) // calculate expected merges - merges := []interval.Interval{} - merges = append(merges, interval.Interval{Low: 2, High: 6}) + merges := []intervals.Interval{} + merges = append(merges, intervals.Interval{Low: 2, High: 6}) return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps, ExpectedMerges: merges} } @@ -1472,59 +1472,59 @@ func buildIntervalsDemo212() demo { highInclusive := false selfAdjustMinLow := false selfAdjustMaxHigh := false - itvls := interval.NewIntervals(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) + itvls := intervals.New(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) // add intervals - if err := itvls.AddInterval(&interval.Interval{Low: 5, High: 7}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 5, High: 7}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - if err := itvls.AddInterval(&interval.Interval{Low: 2, High: 4}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 2, High: 4}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - if err := itvls.AddInterval(&interval.Interval{Low: 35, High: 35}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 35, High: 35}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - if err := itvls.AddInterval(&interval.Interval{Low: 3, High: 6}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 3, High: 6}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - if err := itvls.AddInterval(&interval.Interval{Low: 18, High: 20}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 18, High: 20}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - if err := itvls.AddInterval(&interval.Interval{Low: 20, High: 30}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 20, High: 30}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - if err := itvls.AddInterval(&interval.Interval{Low: 25, High: 28}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 25, High: 28}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - if err := itvls.AddInterval(&interval.Interval{Low: minLow, High: 1}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: minLow, High: 1}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - if err := itvls.AddInterval(&interval.Interval{Low: 30, High: 32}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 30, High: 32}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - if err := itvls.AddInterval(&interval.Interval{Low: 10, High: 12}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 10, High: 12}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } // calculate expected gaps - gaps := []interval.Interval{} - gaps = append(gaps, interval.Interval{Low: 1, High: 1}) - gaps = append(gaps, interval.Interval{Low: 7, High: 9}) - gaps = append(gaps, interval.Interval{Low: 12, High: 17}) - gaps = append(gaps, interval.Interval{Low: 32, High: maxHigh}) + gaps := []intervals.Interval{} + gaps = append(gaps, intervals.Interval{Low: 1, High: 1}) + gaps = append(gaps, intervals.Interval{Low: 7, High: 9}) + gaps = append(gaps, intervals.Interval{Low: 12, High: 17}) + gaps = append(gaps, intervals.Interval{Low: 32, High: maxHigh}) // calculate expected overlaps - overlaps := []interval.Interval{} - overlaps = append(overlaps, interval.Interval{Low: 3, High: 3}) - overlaps = append(overlaps, interval.Interval{Low: 5, High: 5}) - overlaps = append(overlaps, interval.Interval{Low: 25, High: 27}) + overlaps := []intervals.Interval{} + overlaps = append(overlaps, intervals.Interval{Low: 3, High: 3}) + overlaps = append(overlaps, intervals.Interval{Low: 5, High: 5}) + overlaps = append(overlaps, intervals.Interval{Low: 25, High: 27}) // calculate expected merges - merges := []interval.Interval{} - merges = append(merges, interval.Interval{Low: minLow, High: minLow}) - merges = append(merges, interval.Interval{Low: 2, High: 6}) - merges = append(merges, interval.Interval{Low: 10, High: 11}) - merges = append(merges, interval.Interval{Low: 18, High: 31}) + merges := []intervals.Interval{} + merges = append(merges, intervals.Interval{Low: minLow, High: minLow}) + merges = append(merges, intervals.Interval{Low: 2, High: 6}) + merges = append(merges, intervals.Interval{Low: 10, High: 11}) + merges = append(merges, intervals.Interval{Low: 18, High: 31}) return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps, ExpectedMerges: merges} } @@ -1542,17 +1542,17 @@ func buildIntervalsDemo301() demo { highInclusive := true selfAdjustMinLow := false selfAdjustMaxHigh := false - itvls := interval.NewIntervals(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) + itvls := intervals.New(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) // calculate expected gaps - gaps := []interval.Interval{} - gaps = append(gaps, interval.Interval{Low: minLow, High: maxHigh}) + gaps := []intervals.Interval{} + gaps = append(gaps, intervals.Interval{Low: minLow, High: maxHigh}) // calculate expected overlaps - overlaps := []interval.Interval{} + overlaps := []intervals.Interval{} // calculate expected merges - merges := []interval.Interval{} + merges := []intervals.Interval{} return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps, ExpectedMerges: merges} } @@ -1566,24 +1566,24 @@ func buildIntervalsDemo302() demo { highInclusive := true selfAdjustMinLow := false selfAdjustMaxHigh := false - itvls := interval.NewIntervals(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) + itvls := intervals.New(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) // add intervals - if err := itvls.AddInterval(&interval.Interval{Low: minLow, High: 4}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: minLow, High: 4}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } // calculate expected gaps - gaps := []interval.Interval{} - gaps = append(gaps, interval.Interval{Low: minLow, High: minLow}) - gaps = append(gaps, interval.Interval{Low: 5, High: maxHigh}) + gaps := []intervals.Interval{} + gaps = append(gaps, intervals.Interval{Low: minLow, High: minLow}) + gaps = append(gaps, intervals.Interval{Low: 5, High: maxHigh}) // calculate expected overlaps - overlaps := []interval.Interval{} + overlaps := []intervals.Interval{} // calculate expected merges - merges := []interval.Interval{} - merges = append(merges, interval.Interval{Low: 1, High: 4}) + merges := []intervals.Interval{} + merges = append(merges, intervals.Interval{Low: 1, High: 4}) return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps, ExpectedMerges: merges} } @@ -1597,23 +1597,23 @@ func buildIntervalsDemo303() demo { highInclusive := true selfAdjustMinLow := false selfAdjustMaxHigh := false - itvls := interval.NewIntervals(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) + itvls := intervals.New(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) // add intervals - if err := itvls.AddInterval(&interval.Interval{Low: 8, High: maxHigh}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 8, High: maxHigh}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } // calculate expected gaps - gaps := []interval.Interval{} - gaps = append(gaps, interval.Interval{Low: minLow, High: 8}) + gaps := []intervals.Interval{} + gaps = append(gaps, intervals.Interval{Low: minLow, High: 8}) // calculate expected overlaps - overlaps := []interval.Interval{} + overlaps := []intervals.Interval{} // calculate expected merges - merges := []interval.Interval{} - merges = append(merges, interval.Interval{Low: 9, High: maxHigh}) + merges := []intervals.Interval{} + merges = append(merges, intervals.Interval{Low: 9, High: maxHigh}) return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps, ExpectedMerges: merges} } @@ -1627,24 +1627,24 @@ func buildIntervalsDemo304() demo { highInclusive := true selfAdjustMinLow := false selfAdjustMaxHigh := false - itvls := interval.NewIntervals(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) + itvls := intervals.New(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) // add intervals - if err := itvls.AddInterval(&interval.Interval{Low: 5, High: 8}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 5, High: 8}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } // calculate expected gaps - gaps := []interval.Interval{} - gaps = append(gaps, interval.Interval{Low: minLow, High: 5}) - gaps = append(gaps, interval.Interval{Low: 9, High: maxHigh}) + gaps := []intervals.Interval{} + gaps = append(gaps, intervals.Interval{Low: minLow, High: 5}) + gaps = append(gaps, intervals.Interval{Low: 9, High: maxHigh}) // calculate expected overlaps - overlaps := []interval.Interval{} + overlaps := []intervals.Interval{} // calculate expected merges - merges := []interval.Interval{} - merges = append(merges, interval.Interval{Low: 6, High: 8}) + merges := []intervals.Interval{} + merges = append(merges, intervals.Interval{Low: 6, High: 8}) return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps, ExpectedMerges: merges} } @@ -1658,28 +1658,28 @@ func buildIntervalsDemo305() demo { highInclusive := true selfAdjustMinLow := false selfAdjustMaxHigh := false - itvls := interval.NewIntervals(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) + itvls := intervals.New(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) // add intervals - if err := itvls.AddInterval(&interval.Interval{Low: 2, High: 8}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 2, High: 8}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - if err := itvls.AddInterval(&interval.Interval{Low: 4, High: 6}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 4, High: 6}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } // calculate expected gaps - gaps := []interval.Interval{} - gaps = append(gaps, interval.Interval{Low: minLow, High: 2}) - gaps = append(gaps, interval.Interval{Low: 9, High: maxHigh}) + gaps := []intervals.Interval{} + gaps = append(gaps, intervals.Interval{Low: minLow, High: 2}) + gaps = append(gaps, intervals.Interval{Low: 9, High: maxHigh}) // calculate expected overlaps - overlaps := []interval.Interval{} - overlaps = append(overlaps, interval.Interval{Low: 5, High: 6}) + overlaps := []intervals.Interval{} + overlaps = append(overlaps, intervals.Interval{Low: 5, High: 6}) // calculate expected merges - merges := []interval.Interval{} - merges = append(merges, interval.Interval{Low: 3, High: 8}) + merges := []intervals.Interval{} + merges = append(merges, intervals.Interval{Low: 3, High: 8}) return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps, ExpectedMerges: merges} } @@ -1693,29 +1693,29 @@ func buildIntervalsDemo306() demo { highInclusive := true selfAdjustMinLow := false selfAdjustMaxHigh := false - itvls := interval.NewIntervals(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) + itvls := intervals.New(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) // add intervals - if err := itvls.AddInterval(&interval.Interval{Low: 2, High: 4}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 2, High: 4}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - if err := itvls.AddInterval(&interval.Interval{Low: 6, High: 8}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 6, High: 8}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } // calculate expected gaps - gaps := []interval.Interval{} - gaps = append(gaps, interval.Interval{Low: minLow, High: 2}) - gaps = append(gaps, interval.Interval{Low: 5, High: 6}) - gaps = append(gaps, interval.Interval{Low: 9, High: maxHigh}) + gaps := []intervals.Interval{} + gaps = append(gaps, intervals.Interval{Low: minLow, High: 2}) + gaps = append(gaps, intervals.Interval{Low: 5, High: 6}) + gaps = append(gaps, intervals.Interval{Low: 9, High: maxHigh}) // calculate expected overlaps - overlaps := []interval.Interval{} + overlaps := []intervals.Interval{} // calculate expected merges - merges := []interval.Interval{} - merges = append(merges, interval.Interval{Low: 3, High: 4}) - merges = append(merges, interval.Interval{Low: 7, High: 8}) + merges := []intervals.Interval{} + merges = append(merges, intervals.Interval{Low: 3, High: 4}) + merges = append(merges, intervals.Interval{Low: 7, High: 8}) return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps, ExpectedMerges: merges} } @@ -1729,27 +1729,27 @@ func buildIntervalsDemo307() demo { highInclusive := true selfAdjustMinLow := false selfAdjustMaxHigh := false - itvls := interval.NewIntervals(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) + itvls := intervals.New(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) // add intervals - if err := itvls.AddInterval(&interval.Interval{Low: 2, High: 4}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 2, High: 4}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - if err := itvls.AddInterval(&interval.Interval{Low: 4, High: 6}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 4, High: 6}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } // calculate expected gaps - gaps := []interval.Interval{} - gaps = append(gaps, interval.Interval{Low: minLow, High: 2}) - gaps = append(gaps, interval.Interval{Low: 7, High: maxHigh}) + gaps := []intervals.Interval{} + gaps = append(gaps, intervals.Interval{Low: minLow, High: 2}) + gaps = append(gaps, intervals.Interval{Low: 7, High: maxHigh}) // calculate expected overlaps - overlaps := []interval.Interval{} + overlaps := []intervals.Interval{} // calculate expected merges - merges := []interval.Interval{} - merges = append(merges, interval.Interval{Low: 3, High: 6}) + merges := []intervals.Interval{} + merges = append(merges, intervals.Interval{Low: 3, High: 6}) return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps, ExpectedMerges: merges} } @@ -1763,27 +1763,27 @@ func buildIntervalsDemo308() demo { highInclusive := true selfAdjustMinLow := false selfAdjustMaxHigh := false - itvls := interval.NewIntervals(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) + itvls := intervals.New(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) // add intervals - if err := itvls.AddInterval(&interval.Interval{Low: 2, High: 6}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 2, High: 6}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - if err := itvls.AddInterval(&interval.Interval{Low: 6, High: 7}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 6, High: 7}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } // calculate expected gaps - gaps := []interval.Interval{} - gaps = append(gaps, interval.Interval{Low: minLow, High: 2}) - gaps = append(gaps, interval.Interval{Low: 8, High: maxHigh}) + gaps := []intervals.Interval{} + gaps = append(gaps, intervals.Interval{Low: minLow, High: 2}) + gaps = append(gaps, intervals.Interval{Low: 8, High: maxHigh}) // calculate expected overlaps - overlaps := []interval.Interval{} + overlaps := []intervals.Interval{} // calculate expected merges - merges := []interval.Interval{} - merges = append(merges, interval.Interval{Low: 3, High: 7}) + merges := []intervals.Interval{} + merges = append(merges, intervals.Interval{Low: 3, High: 7}) return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps, ExpectedMerges: merges} } @@ -1797,28 +1797,28 @@ func buildIntervalsDemo309() demo { highInclusive := true selfAdjustMinLow := false selfAdjustMaxHigh := false - itvls := interval.NewIntervals(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) + itvls := intervals.New(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) // add intervals - if err := itvls.AddInterval(&interval.Interval{Low: 2, High: 6}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 2, High: 6}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - if err := itvls.AddInterval(&interval.Interval{Low: 4, High: 8}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 4, High: 8}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } // calculate expected gaps - gaps := []interval.Interval{} - gaps = append(gaps, interval.Interval{Low: minLow, High: 2}) - gaps = append(gaps, interval.Interval{Low: 9, High: maxHigh}) + gaps := []intervals.Interval{} + gaps = append(gaps, intervals.Interval{Low: minLow, High: 2}) + gaps = append(gaps, intervals.Interval{Low: 9, High: maxHigh}) // calculate expected overlaps - overlaps := []interval.Interval{} - overlaps = append(overlaps, interval.Interval{Low: 5, High: 6}) + overlaps := []intervals.Interval{} + overlaps = append(overlaps, intervals.Interval{Low: 5, High: 6}) // calculate expected merges - merges := []interval.Interval{} - merges = append(merges, interval.Interval{Low: 3, High: 8}) + merges := []intervals.Interval{} + merges = append(merges, intervals.Interval{Low: 3, High: 8}) return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps, ExpectedMerges: merges} } @@ -1832,31 +1832,31 @@ func buildIntervalsDemo310() demo { highInclusive := true selfAdjustMinLow := false selfAdjustMaxHigh := false - itvls := interval.NewIntervals(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) + itvls := intervals.New(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) // add intervals - if err := itvls.AddInterval(&interval.Interval{Low: minLow, High: 2}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: minLow, High: 2}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - if err := itvls.AddInterval(&interval.Interval{Low: 4, High: 4}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 4, High: 4}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - if err := itvls.AddInterval(&interval.Interval{Low: 8, High: maxHigh}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 8, High: maxHigh}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } // calculate expected gaps - gaps := []interval.Interval{} - gaps = append(gaps, interval.Interval{Low: minLow, High: minLow}) - gaps = append(gaps, interval.Interval{Low: 3, High: 8}) + gaps := []intervals.Interval{} + gaps = append(gaps, intervals.Interval{Low: minLow, High: minLow}) + gaps = append(gaps, intervals.Interval{Low: 3, High: 8}) // calculate expected overlaps - overlaps := []interval.Interval{} + overlaps := []intervals.Interval{} // calculate expected merges - merges := []interval.Interval{} - merges = append(merges, interval.Interval{Low: 1, High: 2}) - merges = append(merges, interval.Interval{Low: 9, High: maxHigh}) + merges := []intervals.Interval{} + merges = append(merges, intervals.Interval{Low: 1, High: 2}) + merges = append(merges, intervals.Interval{Low: 9, High: maxHigh}) return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps, ExpectedMerges: merges} } @@ -1870,32 +1870,32 @@ func buildIntervalsDemo311() demo { highInclusive := true selfAdjustMinLow := false selfAdjustMaxHigh := false - itvls := interval.NewIntervals(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) + itvls := intervals.New(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) // add intervals - if err := itvls.AddInterval(&interval.Interval{Low: 2, High: 4}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 2, High: 4}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - if err := itvls.AddInterval(&interval.Interval{Low: 3, High: 6}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 3, High: 6}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - if err := itvls.AddInterval(&interval.Interval{Low: 5, High: 7}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 5, High: 7}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } // calculate expected gaps - gaps := []interval.Interval{} - gaps = append(gaps, interval.Interval{Low: minLow, High: 2}) - gaps = append(gaps, interval.Interval{Low: 8, High: maxHigh}) + gaps := []intervals.Interval{} + gaps = append(gaps, intervals.Interval{Low: minLow, High: 2}) + gaps = append(gaps, intervals.Interval{Low: 8, High: maxHigh}) // calculate expected overlaps - overlaps := []interval.Interval{} - overlaps = append(overlaps, interval.Interval{Low: 4, High: 4}) - overlaps = append(overlaps, interval.Interval{Low: 6, High: 6}) + overlaps := []intervals.Interval{} + overlaps = append(overlaps, intervals.Interval{Low: 4, High: 4}) + overlaps = append(overlaps, intervals.Interval{Low: 6, High: 6}) // calculate expected merges - merges := []interval.Interval{} - merges = append(merges, interval.Interval{Low: 3, High: 7}) + merges := []intervals.Interval{} + merges = append(merges, intervals.Interval{Low: 3, High: 7}) return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps, ExpectedMerges: merges} } @@ -1909,60 +1909,60 @@ func buildIntervalsDemo312() demo { highInclusive := true selfAdjustMinLow := false selfAdjustMaxHigh := false - itvls := interval.NewIntervals(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) + itvls := intervals.New(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) // add intervals - if err := itvls.AddInterval(&interval.Interval{Low: 5, High: 7}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 5, High: 7}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - if err := itvls.AddInterval(&interval.Interval{Low: 2, High: 4}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 2, High: 4}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - if err := itvls.AddInterval(&interval.Interval{Low: 35, High: 35}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 35, High: 35}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - if err := itvls.AddInterval(&interval.Interval{Low: 3, High: 6}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 3, High: 6}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - if err := itvls.AddInterval(&interval.Interval{Low: 18, High: 20}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 18, High: 20}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - if err := itvls.AddInterval(&interval.Interval{Low: 20, High: 30}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 20, High: 30}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - if err := itvls.AddInterval(&interval.Interval{Low: 25, High: 28}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 25, High: 28}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - if err := itvls.AddInterval(&interval.Interval{Low: minLow, High: 1}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: minLow, High: 1}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - if err := itvls.AddInterval(&interval.Interval{Low: 30, High: 32}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 30, High: 32}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - if err := itvls.AddInterval(&interval.Interval{Low: 10, High: 12}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 10, High: 12}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } // calculate expected gaps - gaps := []interval.Interval{} - gaps = append(gaps, interval.Interval{Low: minLow, High: minLow}) - gaps = append(gaps, interval.Interval{Low: 2, High: 2}) - gaps = append(gaps, interval.Interval{Low: 8, High: 10}) - gaps = append(gaps, interval.Interval{Low: 13, High: 18}) - gaps = append(gaps, interval.Interval{Low: 33, High: maxHigh}) + gaps := []intervals.Interval{} + gaps = append(gaps, intervals.Interval{Low: minLow, High: minLow}) + gaps = append(gaps, intervals.Interval{Low: 2, High: 2}) + gaps = append(gaps, intervals.Interval{Low: 8, High: 10}) + gaps = append(gaps, intervals.Interval{Low: 13, High: 18}) + gaps = append(gaps, intervals.Interval{Low: 33, High: maxHigh}) // calculate expected overlaps - overlaps := []interval.Interval{} - overlaps = append(overlaps, interval.Interval{Low: 4, High: 4}) - overlaps = append(overlaps, interval.Interval{Low: 6, High: 6}) - overlaps = append(overlaps, interval.Interval{Low: 26, High: 28}) + overlaps := []intervals.Interval{} + overlaps = append(overlaps, intervals.Interval{Low: 4, High: 4}) + overlaps = append(overlaps, intervals.Interval{Low: 6, High: 6}) + overlaps = append(overlaps, intervals.Interval{Low: 26, High: 28}) // calculate expected merges - merges := []interval.Interval{} - merges = append(merges, interval.Interval{Low: 1, High: 1}) - merges = append(merges, interval.Interval{Low: 3, High: 7}) - merges = append(merges, interval.Interval{Low: 11, High: 12}) - merges = append(merges, interval.Interval{Low: 19, High: 32}) + merges := []intervals.Interval{} + merges = append(merges, intervals.Interval{Low: 1, High: 1}) + merges = append(merges, intervals.Interval{Low: 3, High: 7}) + merges = append(merges, intervals.Interval{Low: 11, High: 12}) + merges = append(merges, intervals.Interval{Low: 19, High: 32}) return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps, ExpectedMerges: merges} } diff --git a/example/main.go b/example/main.go index 0f5356d..a1aedb0 100644 --- a/example/main.go +++ b/example/main.go @@ -20,9 +20,9 @@ func main() { if err != nil { log.Fatalf("could not read %s: %v", filename, err) } - intervals := initIntervals(xys) - ip := interval.NewPlot(intervals.IsLowInclusive(), intervals.IsHighInclusive()) - err = ip.PlotData("out.png", intervals, true, true, true, true) + intvls := initIntervals(xys) + ip := intervals.NewPlot(intvls.IsLowInclusive(), intvls.IsHighInclusive()) + err = ip.PlotData("out.png", intvls, true, true, true, true) if err != nil { log.Fatalf("could not plot data: %v", err) } @@ -59,7 +59,7 @@ func readData(path string) ([]xy, error) { return xys, nil } -func initIntervals(xys []xy) interval.Intervals { +func initIntervals(xys []xy) intervals.Intervals { // initialize Intervals minLow := MinX maxHigh := MaxX @@ -67,13 +67,13 @@ func initIntervals(xys []xy) interval.Intervals { highInclusive := true selfAdjustMinLow := false selfAdjustMaxHigh := true - intervals := interval.NewIntervals(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) + intvls := intervals.New(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) for _, xy := range xys { - err := intervals.AddInterval(&interval.Interval{Low: xy.x, High: xy.y}) + err := intvls.AddInterval(&intervals.Interval{Low: xy.x, High: xy.y}) if err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } } - return intervals + return intvls } diff --git a/example/out2.png b/example/out2.png new file mode 100644 index 0000000000000000000000000000000000000000..7f4dbe9be28bfaa9fe83d8d5c083eb84eaf5296a GIT binary patch literal 40740 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 literal 0 HcmV?d00001 diff --git a/find.go b/find.go index c7092f1..df2d986 100644 --- a/find.go +++ b/find.go @@ -1,4 +1,4 @@ -package interval +package intervals import "fmt" diff --git a/find_test.go b/find_test.go index 1c7bd9f..0bc9d9a 100644 --- a/find_test.go +++ b/find_test.go @@ -1,4 +1,4 @@ -package interval_test +package intervals_test import ( "fmt" @@ -7,7 +7,7 @@ import ( "github.com/centraldereservas/intervals" ) -func initIntervalsForDemo001() interval.Intervals { +func initIntervalsForDemo001() intervals.Intervals { // initialize Intervals minLow := 0 maxHigh := 100 @@ -15,28 +15,28 @@ func initIntervalsForDemo001() interval.Intervals { highInclusive := true selfAdjustMinLow := false selfAdjustMaxHigh := true - itvls := interval.NewIntervals(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) + itvls := intervals.New(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) // add new intervals - if err := itvls.AddInterval(&interval.Interval{Low: 5, High: 7}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 5, High: 7}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - if err := itvls.AddInterval(&interval.Interval{Low: 2, High: 4}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 2, High: 4}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - if err := itvls.AddInterval(&interval.Interval{Low: 3, High: 6}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 3, High: 6}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - if err := itvls.AddInterval(&interval.Interval{Low: 18, High: 20}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 18, High: 20}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - if err := itvls.AddInterval(&interval.Interval{Low: 20, High: 30}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 20, High: 30}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - if err := itvls.AddInterval(&interval.Interval{Low: 25, High: 28}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 25, High: 28}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - if err := itvls.AddInterval(&interval.Interval{Low: 30, High: 32}); err != nil { + if err := itvls.AddInterval(&intervals.Interval{Low: 30, High: 32}); err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } return itvls @@ -45,17 +45,17 @@ func initIntervalsForDemo001() interval.Intervals { // matches for value=2 func buildFindDemo001() demo { itvls := initIntervalsForDemo001() - matches := []interval.Interval{} - matches = append(matches, interval.Interval{Low: 2, High: 4}) + matches := []intervals.Interval{} + matches = append(matches, intervals.Interval{Low: 2, High: 4}) return demo{Intervals: itvls, ExpectedFindMatches: matches, ValueToFind: 2} } // matches for value=4 func buildFindDemo002() demo { itvls := initIntervalsForDemo001() - matches := []interval.Interval{} - matches = append(matches, interval.Interval{Low: 2, High: 4}) - matches = append(matches, interval.Interval{Low: 3, High: 6}) + matches := []intervals.Interval{} + matches = append(matches, intervals.Interval{Low: 2, High: 4}) + matches = append(matches, intervals.Interval{Low: 3, High: 6}) return demo{Intervals: itvls, ExpectedFindMatches: matches, ValueToFind: 4} } @@ -66,8 +66,8 @@ func TestFindIntervalsForValue(t *testing.T) { tt := []struct { name string valueToFind int - intvls interval.Intervals - expectedMatches []interval.Interval + intvls intervals.Intervals + expectedMatches []intervals.Interval }{ {name: "demo001", valueToFind: demo001.ValueToFind, intvls: demo001.Intervals, expectedMatches: demo001.ExpectedFindMatches}, {name: "demo002", valueToFind: demo002.ValueToFind, intvls: demo002.Intervals, expectedMatches: demo002.ExpectedFindMatches}, diff --git a/gaps.go b/gaps.go index 9d877d9..b480a0e 100644 --- a/gaps.go +++ b/gaps.go @@ -1,4 +1,4 @@ -package interval +package intervals import "fmt" diff --git a/gaps_test.go b/gaps_test.go index 2e66ac5..a1b151c 100644 --- a/gaps_test.go +++ b/gaps_test.go @@ -1,4 +1,4 @@ -package interval_test +package intervals_test import ( "testing" @@ -67,8 +67,8 @@ func TestGaps(t *testing.T) { demo312 := buildIntervalsDemo312() tt := []struct { name string - intvls interval.Intervals - expectedGaps []interval.Interval + intvls intervals.Intervals + expectedGaps []intervals.Interval }{ {name: "demo001", intvls: demo001.Intervals, expectedGaps: demo001.ExpectedGaps}, {name: "demo002", intvls: demo002.Intervals, expectedGaps: demo002.ExpectedGaps}, diff --git a/get.go b/get.go index 28f8f20..65f50a9 100644 --- a/get.go +++ b/get.go @@ -1,4 +1,4 @@ -package interval +package intervals func (intvls *intervals) GetIntervals() []*Interval { // sort intervals (if necessary) diff --git a/inclusives.go b/inclusives.go index 958690e..ccb3ed5 100644 --- a/inclusives.go +++ b/inclusives.go @@ -1,4 +1,4 @@ -package interval +package intervals import "fmt" diff --git a/interval.go b/interval.go index 778c008..bbc04b3 100644 --- a/interval.go +++ b/interval.go @@ -1,4 +1,4 @@ -package interval +package intervals import "fmt" diff --git a/intervals.go b/intervals.go index ce15d8d..2e4f67a 100644 --- a/intervals.go +++ b/intervals.go @@ -1,4 +1,4 @@ -package interval +package intervals import ( "math" @@ -77,11 +77,11 @@ func (itvls *intervals) String() string { // NewIntervalsDefault is a constructor that returns an instance of the Intervals interface with default values func NewIntervalsDefault() Intervals { - return NewIntervals(defaultMinLow, defaultMaxHigh, defaultLowInclusive, defaultHighInclusive, defaultSelfAdjustMinLow, defaultSelfAdjustMaxHigh) + return New(defaultMinLow, defaultMaxHigh, defaultLowInclusive, defaultHighInclusive, defaultSelfAdjustMinLow, defaultSelfAdjustMaxHigh) } -// NewIntervals is a constructor that returns an instance of the Intervals interface -func NewIntervals(minLow, maxHigh int, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh bool) Intervals { +// New is a constructor that returns an instance of the Intervals interface +func New(minLow, maxHigh int, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh bool) Intervals { return &intervals{ MinLow: minLow, MaxHigh: maxHigh, diff --git a/merge.go b/merge.go index b3b50c5..4a48219 100644 --- a/merge.go +++ b/merge.go @@ -1,4 +1,4 @@ -package interval +package intervals import "fmt" diff --git a/merge_test.go b/merge_test.go index 494bc15..5ab62ad 100644 --- a/merge_test.go +++ b/merge_test.go @@ -1,4 +1,4 @@ -package interval_test +package intervals_test import ( "testing" @@ -67,8 +67,8 @@ func TestMerge(t *testing.T) { demo312 := buildIntervalsDemo312() tt := []struct { name string - intvls interval.Intervals - expectedMerges []interval.Interval + intvls intervals.Intervals + expectedMerges []intervals.Interval }{ {name: "demo001", intvls: demo001.Intervals, expectedMerges: demo001.ExpectedMerges}, {name: "demo002", intvls: demo002.Intervals, expectedMerges: demo002.ExpectedMerges}, diff --git a/overlap.go b/overlap.go index 9376bc1..0c21285 100644 --- a/overlap.go +++ b/overlap.go @@ -1,4 +1,4 @@ -package interval +package intervals import ( "fmt" diff --git a/overlap_test.go b/overlap_test.go index 7e84425..4208f95 100644 --- a/overlap_test.go +++ b/overlap_test.go @@ -1,4 +1,4 @@ -package interval_test +package intervals_test import ( "testing" @@ -67,8 +67,8 @@ func TestOverlapped(t *testing.T) { demo312 := buildIntervalsDemo312() tt := []struct { name string - intvls interval.Intervals - expectedOverlaps []interval.Interval + intvls intervals.Intervals + expectedOverlaps []intervals.Interval }{ {name: "demo001", intvls: demo001.Intervals, expectedOverlaps: demo001.ExpectedOverlaps}, {name: "demo002", intvls: demo002.Intervals, expectedOverlaps: demo002.ExpectedOverlaps}, diff --git a/plot.go b/plot.go index d584abb..b56f122 100644 --- a/plot.go +++ b/plot.go @@ -1,4 +1,4 @@ -package interval +package intervals import ( "fmt" diff --git a/report.go b/report.go index 011d183..de6272c 100644 --- a/report.go +++ b/report.go @@ -1,4 +1,4 @@ -package interval +package intervals import "fmt" diff --git a/report_test.go b/report_test.go index 794cac0..c86414e 100644 --- a/report_test.go +++ b/report_test.go @@ -1,4 +1,4 @@ -package interval_test +package intervals_test import ( "fmt" @@ -14,41 +14,41 @@ func TestReport(t *testing.T) { highInclusive := true selfAdjustMinLow := false selfAdjustMaxHigh := true - itvls := interval.NewIntervals(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) + itvls := intervals.New(minLow, maxHigh, lowInclusive, highInclusive, selfAdjustMinLow, selfAdjustMaxHigh) var err error - err = itvls.AddInterval(&interval.Interval{Low: 5, High: 7}) + err = itvls.AddInterval(&intervals.Interval{Low: 5, High: 7}) if err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - err = itvls.AddInterval(&interval.Interval{Low: 2, High: 4}) + err = itvls.AddInterval(&intervals.Interval{Low: 2, High: 4}) if err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - err = itvls.AddInterval(&interval.Interval{Low: 3, High: 6}) + err = itvls.AddInterval(&intervals.Interval{Low: 3, High: 6}) if err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - err = itvls.AddInterval(&interval.Interval{Low: 18, High: 20}) + err = itvls.AddInterval(&intervals.Interval{Low: 18, High: 20}) if err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - err = itvls.AddInterval(&interval.Interval{Low: 20, High: 30}) + err = itvls.AddInterval(&intervals.Interval{Low: 20, High: 30}) if err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - err = itvls.AddInterval(&interval.Interval{Low: 25, High: 28}) + err = itvls.AddInterval(&intervals.Interval{Low: 25, High: 28}) if err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } - err = itvls.AddInterval(&interval.Interval{Low: 30, High: 32}) + err = itvls.AddInterval(&intervals.Interval{Low: 30, High: 32}) if err != nil { fmt.Printf("invalid interval discarded: %v\n", err) } tt := []struct { name string - itvls interval.Intervals + itvls intervals.Intervals }{ {name: "normal case", itvls: itvls}, } diff --git a/sort.go b/sort.go index 0f68038..8007124 100644 --- a/sort.go +++ b/sort.go @@ -1,4 +1,4 @@ -package interval +package intervals import "sort" diff --git a/utils.go b/utils.go index fbad269..3874653 100644 --- a/utils.go +++ b/utils.go @@ -1,4 +1,4 @@ -package interval +package intervals func min(a, b int) int { if a < b {