public bool IsNextTo(IntInterval newInterval) { bool newIsLefter = newInterval.Last + 1 < First; bool newIsRighter = newInterval.First > Last + 1; return(!(newIsLefter || newIsRighter)); }
protected BoundsRelation ParseBoundsRelation(IntInterval bounds) { var result = new BoundsRelation(); if (arrows.Count == 0 || bounds.IsEmpty) { result.ReplaceIndex = 0; return(result); } int i = 0; int count = arrows.Count; IntIntervalRelation relation; // Skip 'Less*' while (LookAhead(i, bounds) == IntIntervalRelation.Less) { ++i; } // 'OverlapFirst?' if (LookAhead(i, bounds) == IntIntervalRelation.OverlapFirst) { result.FirstOverlapIndex = i++; } result.ReplaceIndex = i; while (true) { relation = LookAhead(i, bounds); switch (relation) { case IntIntervalRelation.Undefined: case IntIntervalRelation.Greater: return(result); // 'OverlapLast?' case IntIntervalRelation.OverlapLast: result.LastOverlapIndex = i; ++i; return(result); case IntIntervalRelation.Equal: case IntIntervalRelation.Contains: result.ContainsIndex = i; return(result); case IntIntervalRelation.Contained: result.ContainedIndexes.Add(i); ++i; continue; default: Debug.Fail("Internal error"); break; } } }
public IntIntervalRelation RelationTo(IntInterval other) { if (this < other) { return(IntIntervalRelation.Less); } else if (other < this) { return(IntIntervalRelation.Greater); } else if (this == other) { return(IntIntervalRelation.Equal); } else if (this.Contains(other)) { return(IntIntervalRelation.Contains); } else if (other.Contains(this)) { return(IntIntervalRelation.Contained); } else if (this.Contains(other.First)) { return(IntIntervalRelation.OverlapFirst); } else if (other.Contains(this.First)) { return(IntIntervalRelation.OverlapLast); } else { throw new InvalidOperationException("Internal error"); } }
public IEnumerable <IntArrow <TAttr> > Enumerate(IntInterval bounds) { if (arrows.Count == 0 || bounds.IsEmpty) { yield break; } int i = 0; int count = arrows.Count; while (i != count && bounds.First > arrows[i].Key.Last) { ++i; } while (i != count && bounds.Contains(arrows[i].Key)) { yield return(arrows[i]); ++i; } if (i != count) { var intersection = arrows[i].Key * bounds; if (!intersection.IsEmpty) { yield return(new IntArrow <TAttr>(intersection, arrows[i].Value)); } } }
public Decision Build( IIntMap <int> outcomeArrows, IntInterval possibleBounds, IIntFrequency frequency) { defaultAction = outcomeArrows.DefaultValue; this.actionIdToDecision[defaultAction] = new ActionDecision(defaultAction); Decision result; if (TryBuildElementaryTree(outcomeArrows, out result)) { return(result); } // TODO: Alternatively to averaging probability, each test can // be split if probability varies significantly within test range DecisionTest[] tests = outcomeArrows .EnumerateCoverage(possibleBounds) .Select( a => new DecisionTest(a.Key, a.Value, frequency.Average(a.Key)) ) .ToArray(); result = GenTree(new ArraySlice <DecisionTest>(tests)); return(result); }
public override void Remove(Int value) { if (bounds.Contains(value)) { int i = FindInterval(value); if (i >= 0) { var interval = intervals[i]; if (interval.First == interval.Last) { intervals.RemoveAt(i); } else if (interval.First == value) { intervals[i] = new IntInterval(value + 1, interval.Last); } else if (interval.Last == value) { intervals[i] = new IntInterval(interval.First, value - 1); } else { intervals[i] = new IntInterval(value + 1, interval.Last); intervals.Insert(i, new IntInterval(interval.First, value - 1)); } bounds = bounds - value; } } }
public void TestBalanced() { var frequency = new MutableIntFrequency(); frequency.DefaultValue = 0.0000001; frequency.Set(new IntArrow<double>(1, 520.0)); frequency.Set(new IntArrow<double>(2, 49, 3.0)); frequency.Set(new IntArrow<double>(50, 236.0)); frequency.Set(new IntArrow<double>(51, 100, 2.0)); const int DefaultValue = -1; var elementToAction = new MutableIntMap<int>(); elementToAction.DefaultValue = DefaultValue; elementToAction.Set(new IntArrow<int>(1, 1)); elementToAction.Set(new IntArrow<int>(2, 49, 2)); elementToAction.Set(new IntArrow<int>(50, 3)); elementToAction.Set(new IntArrow<int>(51, 100, 4)); var target = new DecisionTreeBuilder(platformInfo); var bounds = new IntInterval(int.MinValue, int.MaxValue); var node = target.Build(elementToAction, bounds, frequency); PrintProgram(node, target.DefaultActionDecision); Assert.AreEqual(-1, node.Decide(int.MinValue) ); Assert.AreEqual(-1, node.Decide(0) ); Assert.AreEqual(1, node.Decide(1) ); Assert.AreEqual(2, node.Decide(2) ); Assert.AreEqual(2, node.Decide(49) ); Assert.AreEqual(3, node.Decide(50) ); Assert.AreEqual(4, node.Decide(51) ); Assert.AreEqual(4, node.Decide(100) ); Assert.AreEqual(-1, node.Decide(200) ); Assert.AreEqual(-1, node.Decide(bounds.Last) ); }
public Decision Build( IIntMap<int> outcomeArrows, IntInterval possibleBounds, IIntFrequency frequency) { defaultAction = outcomeArrows.DefaultValue; this.actionIdToDecision[defaultAction] = new ActionDecision(defaultAction); Decision result; if (TryBuildElementaryTree(outcomeArrows, out result)) { return result; } // TODO: Alternatively to averaging probability, each test can // be split if probability varies significantly within test range DecisionTest[] tests = outcomeArrows .EnumerateCoverage(possibleBounds) .Select( a => new DecisionTest(a.Key, a.Value, frequency.Average(a.Key)) ) .ToArray(); result = GenTree(new ArraySlice<DecisionTest>(tests)); return result; }
public EmitSyntax Build(EmitSyntax emit) { int rows = table.RowCount; int columns = table.ColumnCount; Ref<Labels> END = emit.Labels.Generate().GetRef(); Ref<Labels>[] labels = new Ref<Labels>[rows]; for (int i = 0; i != rows; ++i) { labels[i] = emit.Labels.Generate().GetRef(); } emit .Do(LdRow) .Switch(labels) .Ldc_I4(-1) .Br(END) ; var columnRange = new IntInterval(0, columns - 1); var columnFrequency = new UniformIntFrequency(columnRange); for (int i = 0; i != rows; ++i) { var switchEmitter = SwitchGenerator.Sparse(table.GetRow(i), columnRange, columnFrequency); emit.Label(labels[i].Def); switchEmitter.Build(emit, LdCol, SwitchGenerator.LdValueAction(END)); } return emit .Label(END.Def); }
/// <summary> /// Intersection /// </summary> /// <param name="x"></param> /// <param name="y"></param> /// <returns></returns> public static IntInterval operator *(IntInterval x, IntInterval y) { var result = new IntInterval( (x.First > y.First) ? x.First : y.First, (x.Last < y.Last) ? x.Last : y.Last); return(result); }
public IntInterval Union(IntInterval other) { var result = new IntInterval( Math.Min(First, other.First), Math.Max(Last, other.Last)); return(result); }
public static SwitchGenerator Sparse( IIntMap<int> arrows, IntInterval possibleBounds, IIntFrequency frequency = null) { var result = new SparseSwitchGenerator(arrows, possibleBounds, frequency); return result; }
public override void RemoveAll(IntSet other) { var complemented = (IntervalIntSetBase)other.Complement(this); this.intervals = complemented.intervals; this.bounds = complemented.bounds; this.hash = complemented.hash; }
public static SwitchGenerator Sparse( IntArrow<int>[] intervalToValue, int defaultValue, IntInterval possibleBounds, IIntFrequency frequency = null) { var result = new SparseSwitchGenerator(intervalToValue, defaultValue, possibleBounds, frequency); return result; }
private IntIntervalRelation LookAhead(int i, IntInterval bounds) { if (i == arrows.Count) { return(IntIntervalRelation.Undefined); } return(arrows[i].Key.RelationTo(bounds)); }
public IEnumerable <IntArrow <TAttr> > EnumerateCoverage(IntInterval bounds) { var relation = ParseBoundsRelation(bounds); if (relation.ContainsIndex >= 0) { yield return(new IntArrow <TAttr>(bounds, arrows[relation.ContainsIndex].Value)); yield break; } int prevIndex = bounds.First; if (relation.FirstOverlapIndex >= 0) { var arrow = arrows[relation.FirstOverlapIndex]; var intersection = arrow.Key * bounds; yield return(new IntArrow <TAttr>(intersection, arrow.Value)); prevIndex = intersection.Last + 1; } foreach (int i in relation.ContainedIndexes) { var arrow = arrows[i]; if (prevIndex < arrow.Key.First) { yield return(new IntArrow <TAttr>(prevIndex, arrow.Key.First - 1, DefaultValue)); } yield return(arrow); prevIndex = arrow.Key.Last + 1; } if (relation.LastOverlapIndex >= 0) { var arrow = arrows[relation.LastOverlapIndex]; if (prevIndex < arrow.Key.First) { yield return(new IntArrow <TAttr>(prevIndex, arrow.Key.First - 1, DefaultValue)); } var intersection = arrow.Key * bounds; yield return(new IntArrow <TAttr>(intersection, arrow.Value)); } else { if (prevIndex <= bounds.Last) { yield return(new IntArrow <TAttr>(prevIndex, bounds.Last, DefaultValue)); } } }
public IntInterval After(IntInterval bounds) { if (bounds.Last < First) { return(this); } // Maybe empty return(new IntInterval(bounds.Last + 1, Last)); }
protected void UpdateHashAndBounds() { bounds = new IntInterval(setType.MaxValue, setType.MinValue); foreach (var interval in intervals) { bounds = bounds.Union(interval); } UpdateHash(); }
public override void Add(IntInterval interval) { int first = interval.First; int last = interval.Last; while (first <= last) { Add(first++); } }
public double Average(IntInterval interval) { var intersection = arrow * interval; if (intersection.IsEmpty) { return 0; } return intersection.Key.LongSize / (double)arrow.Key.LongSize / interval.LongSize; }
public SparseSwitchGenerator( IntArrow<int>[] intArrows, int defaultValue, IntInterval possibleBounds, IIntFrequency frequency = null) : this(new MutableIntMap<int>(intArrows, defaultValue), possibleBounds, frequency) { }
public IntInterval Before(IntInterval bounds) { if (Last < bounds.First) { return(this); } // Maybe empty return(new IntInterval(First, bounds.First - 1)); }
public SparseSwitchGenerator( IIntMap<int> intMap, IntInterval possibleBounds, IIntFrequency frequency) { this.strategy = new InlineFirstDTStrategy(this); this.intMap = intMap; this.possibleBounds = possibleBounds; this.frequency = frequency ?? new UniformIntFrequency(possibleBounds); }
public double Sum(IntInterval interval) { var intersection = arrow * interval; if (intersection.IsEmpty) { return 0; } double result = intersection.Key.LongSize / (double)arrow.Key.LongSize / interval.LongSize; return result; }
public double Average(IntInterval interval) { var intersection = arrow * interval; if (intersection.IsEmpty) { return(0); } return(intersection.Key.LongSize / (double)arrow.Key.LongSize / interval.LongSize); }
public double Sum(IntInterval interval) { var intersection = arrow * interval; if (intersection.IsEmpty) { return(0); } double result = intersection.Key.LongSize / (double)arrow.Key.LongSize / interval.LongSize; return(result); }
public void TestElementaryChecks() { const int DefaultValue = -100; var elementToAction = new MutableIntMap<int>(); elementToAction.DefaultValue = DefaultValue; var bounds = new IntInterval(0, 9); var frequency = new UniformIntFrequency(bounds); elementToAction.Set(new IntArrow<int>(2, 100)); elementToAction.Set(new IntArrow<int>(5, 200)); var target = new DecisionTreeBuilder(platformInfo); var node = target.Build(elementToAction, bounds, frequency); PrintProgram(node, target.DefaultActionDecision); }
public void Clear(IntInterval bounds) { var relation = ParseBoundsRelation(bounds); if (relation.ContainsIndex >= 0) { var before = arrows[relation.ContainsIndex].Before(bounds); var after = arrows[relation.ContainsIndex].After(bounds); if (!before.Key.IsEmpty) { arrows[relation.ContainsIndex] = before; } if (!after.Key.IsEmpty) { if (before.IsEmpty) { arrows[relation.ContainsIndex] = after; } else { arrows.Insert(relation.ContainsIndex + 1, after); } } return; } if (relation.FirstOverlapIndex >= 0) { arrows[relation.FirstOverlapIndex] = arrows[relation.FirstOverlapIndex].Before(bounds); } if (relation.LastOverlapIndex >= 0) { arrows[relation.LastOverlapIndex] = arrows[relation.LastOverlapIndex].After(bounds); } int shift = 0; foreach (int containedIndex in relation.ContainedIndexes) { arrows.RemoveAt(containedIndex + shift); --shift; } }
public IEnumerable<IntArrow<double>> EnumerateCoverage(IntInterval bounds) { var before = arrow.Before(bounds); if (!before.IsEmpty) { yield return before; } var intersection = arrow * bounds; if (!intersection.IsEmpty) { yield return intersection; } var after = arrow.After(bounds); if (!after.IsEmpty) { yield return after; } }
public override Int PopAny() { if (intervals.Count == 0) { throw new InvalidOperationException("Unable to pop element from the empty set"); } int index = intervals.Count - 1; var interval = intervals[index]; if (interval.First == interval.Last) { intervals.RemoveAt(index); return(interval.First); } Int result = interval.Last; intervals[index] = new IntInterval(interval.First, interval.Last - 1); return(result); }
// TODO: Performance in set differences private void Remove(IntInterval otherInterval) { // TODO: BOUNDS update at the end if (bounds.Intersects(otherInterval)) { bounds = IntInterval.Empty; bool notDone = false; for (int i = 0; i != intervals.Count && notDone; ++i) { var interval = intervals[i]; var rel = interval.RelationTo(otherInterval); switch (rel) { case IntIntervalRelation.Contained: intervals.RemoveAt(i); continue; case IntIntervalRelation.Contains: intervals[i] = interval.Before(otherInterval); intervals.Insert(i + 1, interval.After(otherInterval)); return; case IntIntervalRelation.OverlapFirst: intervals[i] = interval.Before(otherInterval); ++i; continue; case IntIntervalRelation.OverlapLast: intervals[i] = interval.After(otherInterval); return; default: ++i; continue; } } } }
public IEnumerable <IntArrow <double> > EnumerateCoverage(IntInterval bounds) { var before = arrow.Before(bounds); if (!before.IsEmpty) { yield return(before); } var intersection = arrow * bounds; if (!intersection.IsEmpty) { yield return(intersection); } var after = arrow.After(bounds); if (!after.IsEmpty) { yield return(after); } }
public IntInterval After(IntInterval bounds) { if (bounds.Last < First) { return this; } // Maybe empty return new IntInterval(bounds.Last + 1, Last); }
public bool Disjoined(IntInterval other) { return(this < other || other < this); }
public SparseSwitchGenerator(IIntMap<int> intMap, IntInterval possibleBounds) : this(intMap, possibleBounds, null) { }
public void TestSameActionUnification() { var frequency = new UniformIntFrequency(new IntInterval(-100, 100)); const int DefaultValue = -100; var elementToAction = new MutableIntMap<int>(); elementToAction.DefaultValue = DefaultValue; elementToAction.Set(new IntArrow<int>(1, 1)); elementToAction.Set(new IntArrow<int>(3, 49, 1)); elementToAction.Set(new IntArrow<int>(51, 1)); elementToAction.Set(new IntArrow<int>(54, 100, 1)); var target = new DecisionTreeBuilder(platformInfo); var bounds = new IntInterval(0, 1000); var node = target.Build(elementToAction, bounds, frequency); PrintProgram(node); }
public void Set(IntArrow <TAttr> newArrow) { #if false if (newArrow.Value.Equals(DefaultValue)) { Clear(newArrow.Key); return; } #endif IntInterval bounds = newArrow.Key; var relation = ParseBoundsRelation(bounds); if (relation.ContainsIndex >= 0) { int i = relation.ContainsIndex; var oldArrow = arrows[i]; if (oldArrow.Value.Equals(newArrow.Value)) { return; } var before = oldArrow.Before(bounds); if (!before.IsEmpty) { arrows.Insert(i, before); ++i; } arrows[i] = newArrow; ++i; var after = oldArrow.After(bounds); if (!after.IsEmpty) { arrows.Insert(i, after); } return; } if (relation.FirstOverlapIndex >= 0) { int i = relation.FirstOverlapIndex; arrows[i] = arrows[i].Before(bounds); } int shift = 0; Debug.Assert(relation.ReplaceIndex >= 0); arrows.Insert(relation.ReplaceIndex, newArrow); ++shift; foreach (int containedIndex in relation.ContainedIndexes) { arrows.RemoveAt(containedIndex + shift); --shift; } if (relation.LastOverlapIndex >= 0) { arrows[relation.LastOverlapIndex + shift] = arrows[relation.LastOverlapIndex + shift].After(bounds); } }
public bool IsNextTo(IntInterval newInterval) { bool newIsLefter = newInterval.Last + 1 < First; bool newIsRighter = newInterval.First > Last + 1; return !(newIsLefter || newIsRighter); }
public bool Disjoined(IntInterval other) { return this < other || other < this; }
public IEnumerable<IntArrow<double>> EnumerateCoverage(IntInterval bounds) { return data.EnumerateCoverage(bounds); }
public double Sum(IntInterval interval) { return data.Sum(interval); }
public void BuildBody( EmitSyntax emit, LanguageData data, Ref<Args> tokenId, Ref<Args> oldValue, Ref<Args> newValue, Ref<Args> ctx, Ref<Args> lookbackStart) { var mergers = data.Grammar.Mergers; if (mergers.Count == 0) { emit .Ldarg(oldValue) .Ret(); return; } var contextResolverCode = new ContextCode( emit, il => il.Ldarg(ctx), il => il.Ldarg(lookbackStart), data, data.Grammar.GlobalContextProvider, data.LocalParseContexts); IActionCode code = new MergeCode(emit, contextResolverCode) { LoadOldValue = il => il.Ldarg(oldValue), LoadNewValue = il => il.Ldarg(newValue), }; var tokenToRuleIndex = new MutableIntMap<int>( mergers.Select( merger => new IntArrow<int>(merger.Symbol.Index, merger.Index))); tokenToRuleIndex.DefaultValue = -1; var ids = mergers.Select(m => m.Symbol.Index); IntInterval possibleBounds = new IntInterval(ids.Min(), ids.Max()); var switchGenerator = SwitchGenerator.Sparse(tokenToRuleIndex, possibleBounds); switchGenerator.Build( emit, il => il.Ldarg(tokenId), (il, value) => { if (value < 0) { emit .Ldarg(newValue) .Ret(); } else { var merger = mergers[value]; var binding = merger.Joint.The<CilMerger>(); code = code .Do(binding.Context.Load) .Do(binding.ActionBuilder) .Emit(il2 => il2.Ret()) ; } }); emit .Ret(); }
public bool Intersects(IntInterval other) { return(!(this < other || other < this)); }
public IntInterval Before(IntInterval bounds) { if (Last < bounds.First) { return this; } // Maybe empty return new IntInterval(First, bounds.First - 1); }
public bool Contains(IntInterval other) { return other.First >= First && other.Last <= Last; }
public IntInterval Union(IntInterval other) { var result = new IntInterval( Math.Min(First, other.First), Math.Max(Last, other.Last)); return result; }
public bool Intersects(IntInterval other) { return !(this < other || other < this); }
public void WhenBoundsAreInsideSingleArrowEnumerateCoverage() { var target = new MutableIntMap<double>(); target.DefaultValue = D; target.Set(new IntArrow<double>(0, 5, X)); target.Set(new IntArrow<double>(9, 9, Y)); target.Set(new IntArrow<double>(11, 14, Z)); target.Set(new IntArrow<double>(20, 25, Y)); var bounds = new IntInterval(21, 24); var expected = new[] { new IntArrow<double>(21, 24, Y), }; var got = target.EnumerateCoverage(bounds).ToArray(); Assert.AreEqual(expected, got); }
public IntIntervalRelation RelationTo(IntInterval other) { if (this < other) { return IntIntervalRelation.Less; } else if (other < this) { return IntIntervalRelation.Greater; } else if (this == other) { return IntIntervalRelation.Equal; } else if (this.Contains(other)) { return IntIntervalRelation.Contains; } else if (other.Contains(this)) { return IntIntervalRelation.Contained; } else if (this.Contains(other.First)) { return IntIntervalRelation.OverlapFirst; } else if (other.Contains(this.First)) { return IntIntervalRelation.OverlapLast; } else { throw new InvalidOperationException("Internal error"); } }
public UniformIntFrequency(IntInterval bounds) { double elementProbability = bounds.IsEmpty ? 0 : (1.0 / bounds.LongSize); this.arrow = new IntArrow<double>(bounds, elementProbability); }
public void WhenBoundsCoverMultipleArrowsEnumerateCoverage() { var target = new MutableIntMap<double>(); target.DefaultValue = D; target.Set(new IntArrow<double>(0, 5, X)); target.Set(new IntArrow<double>(9, 9, Y)); target.Set(new IntArrow<double>(11, 14, Z)); target.Set(new IntArrow<double>(20, 25, Y)); var bounds = new IntInterval(3, 22); var expected = new[] { new IntArrow<double>(3, 5, X), new IntArrow<double>(6, 8, D), new IntArrow<double>(9, 9, Y), new IntArrow<double>(10, 10, D), new IntArrow<double>(11, 14, Z), new IntArrow<double>(15, 19, D), new IntArrow<double>(20, 22, Y), }; var got = target.EnumerateCoverage(bounds).ToArray(); Assert.AreEqual(expected, got); }
public IEnumerable <IntArrow <double> > EnumerateCoverage(IntInterval bounds) { return(data.EnumerateCoverage(bounds)); }
public abstract void Add(IntInterval interval);
public override IntSet Intersect(IntSet other0) { IntervalIntSetBase other = (IntervalIntSetBase)other0; if (bounds.Intersects(other.bounds)) { var result = new IntervalIntSet(setType); var otherIntervals = other.intervals; int myCount = intervals.Count; int theirCount = otherIntervals.Count; int i = 0, j = 0; while (i != myCount && j != theirCount) { IntInterval mine = intervals[i]; IntInterval theirs = otherIntervals[j]; switch (mine.RelationTo(theirs)) { case IntIntervalRelation.Less: { ++i; break; } case IntIntervalRelation.Greater: { ++j; break; } case IntIntervalRelation.Equal: case IntIntervalRelation.Contains: { result.Add(theirs); ++j; break; } case IntIntervalRelation.Contained: { result.Add(mine); ++i; break; } case IntIntervalRelation.OverlapFirst: { result.Add(mine * theirs); ++i; break; } case IntIntervalRelation.OverlapLast: { result.Add(mine * theirs); ++j; break; } default: throw new InvalidOperationException("Internal error"); } } result.UpdateHash(); return(result); } return(setType.Empty); }
public void set_from_intervals_array_contains_only_element_in_these_ranges(IntInterval[] intervals) { var target = IntSet.Ranges(intervals); foreach (var interval in intervals) { Assert.IsTrue(target.Contains(interval.First)); Assert.IsTrue(target.Contains(interval.Last)); int middle = (int)(((long)interval.First + interval.Last) / 2); Assert.IsTrue(target.Contains(middle)); } foreach (int value in ExceptValues(intervals)) { Assert.IsFalse(target.Contains(value)); } }
private IEnumerable<int> ExceptValues(IntInterval[] intervals) { foreach (var value in Values) { if (!intervals.Any(r => value >= r.First && value <= r.Last)) { yield return value; } } }
public bool Contains(IntInterval other) { return(other.First >= First && other.Last <= Last); }
/// <summary> /// Intersection /// </summary> /// <param name="x"></param> /// <param name="y"></param> /// <returns></returns> public static IntInterval operator *(IntInterval x, IntInterval y) { var result = new IntInterval( (x.First > y.First) ? x.First : y.First, (x.Last < y.Last) ? x.Last : y.Last); return result; }
public override void Add(IntInterval newInterval) { if (newInterval.First > newInterval.Last) { return; } bool changed = false; var oldBounds = bounds; bounds = bounds.Union(newInterval); if (oldBounds.IsNextTo(newInterval)) { bool done = false; for (int i = 0; i != intervals.Count; ++i) { IntInterval interval = intervals[i]; if (interval == newInterval) { // already in set done = true; break; } if (interval.IsNextTo(newInterval)) { changed = !interval.Contains(newInterval); var bigger = interval.Union(newInterval); intervals[i] = bigger; for (int j = i + 1; j != intervals.Count;) { interval = intervals[j]; if (bigger.IsNextTo(interval)) { bigger = bigger.Union(interval); intervals[i] = bigger; intervals.RemoveAt(j); } else { ++j; } } done = true; break; } if (newInterval < interval) { intervals.Insert(i, newInterval); done = true; changed = true; break; } } if (!done) { intervals.Insert(0, newInterval); changed = true; } } else if (newInterval < oldBounds) { intervals.Insert(0, newInterval); changed = true; } else { intervals.Add(newInterval); changed = true; } if (changed) { UpdateHash(); } }
public double Sum(IntInterval interval) { return(data.Sum(interval)); }