[Test()] // NUnit.Framework.TestAttribute public void Constructing() { List <Interval <int> > intervals_int = new List <Interval <int> >() { new Interval <int>(-3), new Interval <int>(-3, 6), new Interval <int>(0, 3, false, false), new Interval <int>(0, 3, false, true), new Interval <int>(0, 3, true, false), new Interval <int>(0, 3, true, true), new Interval <int>(11, 11, true, true), }; foreach (Interval <int> i in intervals_int) { Console.WriteLine($"interval = {i}"); } List <Interval <double> > intervals_double = new List <Interval <double> >() { new Interval <double>(-10.1, 3.3), new Interval <double>(-10.1, 3.3, false, false), new Interval <double>(-10.1, 3.3, false, true), new Interval <double>(-10.1, 3.3, true, false), new Interval <double>(-10.1, 3.3, true, true), }; foreach (Interval <double> i in intervals_double) { Console.WriteLine($"interval = {i}"); } bool contains = false; interval_datetime_11 = new Interval <DateTime>("[20171011, 2018-01-10]"); contains = interval_datetime_11.Contains(new DateTime(2018, 01, 10)); Assert.AreEqual(contains, true); contains = interval_datetime_11.Contains(new DateTime(2017, 10, 11)); Assert.AreEqual(contains, true); interval_datetime_11 = new Interval <DateTime>("[20171011, 2018-01-10)"); contains = interval_datetime_11.Contains(new DateTime(2018, 01, 10)); Assert.AreEqual(contains, false); contains = interval_datetime_11.Contains(new DateTime(2017, 10, 11)); Assert.AreEqual(contains, true); interval_datetime_11 = new Interval <DateTime>("(20171011, 2018-01-10]"); contains = interval_datetime_11.Contains(new DateTime(2018, 01, 10)); Assert.AreEqual(contains, true); contains = interval_datetime_11.Contains(new DateTime(2017, 10, 11)); Assert.AreEqual(contains, false); interval_datetime_11 = new Interval <DateTime>("(20171011, 2018-01-10)"); contains = interval_datetime_11.Contains(new DateTime(2018, 01, 10)); Assert.AreEqual(contains, false); contains = interval_datetime_11.Contains(new DateTime(2017, 10, 11)); Assert.AreEqual(contains, false); return; }
public static bool Overlaps(this Interval self, Interval other) { return(self.Contains(other.Start) || self.Contains(other.End) || other.Contains(self.Start) || other.Contains(self.End)); }
public void Contains_Infinite() { var interval = new Interval(null, null); Assert.IsTrue(interval.Contains(Instant.MaxValue)); Assert.IsTrue(interval.Contains(Instant.MinValue)); }
public void FullInterval() { Interval full = new Interval(int.MinValue, int.MinValue); Assert.IsFalse(full.IsEmpty); Assert.IsTrue(full.Contains(int.MinValue)); Assert.IsTrue(full.Contains(0)); Assert.IsTrue(full.Contains(int.MaxValue)); }
public void TestContains() { var interval = new Interval(0, 5); Assert.That(interval.Contains(3), Is.True); Assert.That(interval.Contains(0), Is.True); Assert.That(interval.Contains(5), Is.True); Assert.That(interval.Contains(-1), Is.False); }
public void Contains() { Interval interval = new Interval(0, 1, IntervalEndpoint.Closed, IntervalEndpoint.Open); Assert.IsFalse(interval.Contains(-1)); Assert.IsTrue(interval.Contains(0)); Assert.IsTrue(interval.Contains(0.5)); Assert.IsFalse(interval.Contains(1)); Assert.IsFalse(interval.Contains(2)); }
public void OneToThree() { Interval i = new Interval(1, 3); Assert.IsFalse(i.IsEmpty); Assert.IsFalse(i.Contains(0)); Assert.IsTrue(i.Contains(1)); Assert.IsTrue(i.Contains(2)); Assert.IsFalse(i.Contains(3)); }
public void ContainsInstant() { var start = new DateTime(2016, 07, 06); var duration = TimeSpan.FromHours(1); var interval = new Interval(start, duration); Assert.IsFalse(interval.Contains(start.AddHours(-0.5))); Assert.IsTrue(interval.Contains(start.AddHours(0.5))); Assert.IsFalse(interval.Contains(start.AddHours(1.5))); }
public void Contains() { IInterval<int> interval = new Interval<int>(5, 10); Assert.IsTrue(interval.Contains(5)); Assert.IsTrue(interval.Contains(7)); Assert.IsTrue(interval.Contains(10)); Assert.IsFalse(interval.Contains(4)); Assert.IsFalse(interval.Contains(11)); }
public void Can_CheckContainment() { var i = new Interval(0.455, 4.134); const double n1 = 0.0; const double n2 = 5.0; const double n3 = 2.33; Assert.False(i.Contains(n1)); Assert.False(i.Contains(n2)); Assert.True(i.Contains(n3)); }
public void Contains() { IInterval <int> interval = new Interval <int>(5, 10); Assert.IsTrue(interval.Contains(5)); Assert.IsTrue(interval.Contains(7)); Assert.IsTrue(interval.Contains(10)); Assert.IsFalse(interval.Contains(4)); Assert.IsFalse(interval.Contains(11)); }
public void ContainsInterval() { var start = new DateTime(2016, 07, 06); var duration = TimeSpan.FromHours(1); var interval = new Interval(start, duration); Assert.IsTrue(interval.Contains(new Interval(start.AddSeconds(1), TimeSpan.FromSeconds(1)))); Assert.IsFalse(interval.Contains(new Interval(start.AddSeconds(-1), TimeSpan.FromSeconds(2)))); Assert.IsFalse(interval.Contains(new Interval(start.AddSeconds(-2), TimeSpan.FromSeconds(1)))); Assert.IsFalse(interval.Contains(new Interval(start + duration + TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(1)))); }
public void ContainsValue() { var epsilon = 1E-12; Interval x; x = new Interval(); Assert.IsTrue(x.Contains(0)); Assert.IsFalse(x.Contains(0 + 2 * epsilon)); x = new Interval(-1, 1, epsilon); Assert.IsTrue(x.Contains(0)); Assert.IsTrue(x.Contains(-1 - epsilon / 2)); Assert.IsFalse(x.Contains(3)); Assert.IsFalse(x.Contains(1 + 2 * epsilon)); }
public void ContainsValue() { var epsilon = 1E-12; Interval x; x = new Interval(); Assert.IsTrue(x.Contains(0)); Assert.IsFalse(x.Contains(0 + 2 * epsilon)); x = new Interval(-1, 1, epsilon); Assert.IsTrue(x.Contains(0)); Assert.IsTrue(x.Contains(-1 - epsilon / 2)); Assert.IsFalse(x.Contains(3)); Assert.IsFalse(x.Contains(1 + 2 * epsilon)); }
/// <summary> /// Returns a new time series which is a view of a subset of the current series. /// <para> /// The new series has begin and end indexes which correspond to the bounds of the sub-set into the full series.<br/> /// The tick of the series are shared between the original time series and the returned one (i.e. no copy). /// </para> /// </summary> /// <param name="beginIndex"> the begin index (inclusive) of the time series </param> /// <param name="duration"> the duration of the time series </param> /// <returns> a constrained <seealso cref="TimeSeries"/> which is a sub-set of the current series </returns> public virtual TimeSeries Subseries(int beginIndex, Period duration) { // Calculating the sub-series interval var tickEndTime = GetTick(beginIndex).EndTime; var beginInterval = Instant.FromDateTimeUtc(tickEndTime.InUtc().ToDateTimeUtc()); var endInterval = Instant.FromDateTimeUtc(tickEndTime.Plus(duration).InUtc().ToDateTimeUtc()); var subseriesInterval = new Interval(beginInterval, endInterval); // Checking ticks belonging to the sub-series (starting at the provided index) var subseriesNbTicks = 0; for (var i = beginIndex; i <= _endIndex; i++) { // For each tick... var tickTime = Instant.FromDateTimeUtc(GetTick(i).EndTime.InUtc().ToDateTimeUtc()); if (!subseriesInterval.Contains(tickTime)) { // Tick out of the interval break; } // Tick in the interval // --> Incrementing the number of ticks in the subseries subseriesNbTicks++; } return(Subseries(beginIndex, beginIndex + subseriesNbTicks - 1)); }
/// <summary> /// Populate another polycurve with the portions of this one which lie within /// the specified subDomain /// </summary> /// <param name="subDomain"></param> /// <param name="result"></param> private void PopulateWithSubCurves(Interval subDomain, PolyCurve result) { double segCount = SegmentCount; double segStart = 0; foreach (Curve subCrv in SubCurves) { double subSC = subCrv.SegmentCount; double segEnd = segStart + subSC; Interval crvDom = new Interval(segStart / segCount, segEnd / segCount); if (subDomain.Contains(crvDom)) { result.Add(subCrv.Duplicate()); } else if (subDomain.Overlaps(crvDom)) { Curve subSubCrv = subCrv.Extract(crvDom.ParameterOf(subDomain.Overlap(crvDom))); if (subSubCrv != null) { result.Add(subSubCrv); } } segStart = segEnd; } }
public void Contains_EmptyInterval_EndOfTime() { var instant = Instant.MaxValue; var interval = new Interval(instant, instant); Assert.IsTrue(interval.Contains(instant)); }
private static void Contains <T>(bool expect, T l, T r, T value, bool closed) where T : IComparable <T> { var interval = new Interval <T>(l, r); Assert.AreEqual(expect, interval.Contains(value, closed)); }
protected ComparerResult CompareDecimals(Interval interval, decimal actual) { if (interval.Contains(actual)) return ComparerResult.Equality; return new ComparerResult(interval.ToString()); }
public void AddRange(char lo, char hi) { Interval i = new Interval(lo, hi); if (ignore) { if (upper_case_characters.Intersects(i)) { Interval i2; if (i.low < upper_case_characters.low) { i2 = new Interval(upper_case_characters.low + 32, i.high + 32); i.high = upper_case_characters.low - 1; } else { i2 = new Interval(i.low + 32, upper_case_characters.high + 32); i.low = upper_case_characters.high + 1; } intervals.Add(i2); } else if (upper_case_characters.Contains(i)) { i.high += 32; i.low += 32; } } intervals.Add(i); }
public void Contains_EmptyInterval() { var instant = NodaConstants.UnixEpoch; var interval = new Interval(instant, instant); Assert.IsFalse(interval.Contains(instant)); }
// Complete the arrayManipulation function below. static long arrayManipulation(int n, int m, int[][] queries) { // approach: array with 'n' items will not be created, instead only some processing over the 'm' queries will be made // rational: O(m^2) is potentially faster than O(n*m) // more on "https://github.com/franciscoraphael/HackerRank/blob/master/ArrayManipulation_approach_Om2.cs" long max = 0; ListNode processedIntervalsHead = new ListNode(new Interval(1, n, 0)); for (int i = 0; i < m; i++) { Interval processing = new Interval(queries[i][0], queries[i][1], queries[i][2]); for (ListNode processedNode = processedIntervalsHead; processedNode != null; processedNode = processedNode.Next) { Interval processed = processedNode.Value; if (processing.End < processed.Begin) { break; } if (processing.Begin > processed.End) { continue; } Interval intersection = processing.Intersection(processed); // intersection already have as its value the sum of each given Interval if (intersection == null) { continue; } max = GetMaxBetween(max, intersection.Value); if (processing.Contains(processed)) // means that 'intersection' and 'processed' have the same positions range { processedNode.Value = intersection; } else { List <Interval> resultantIntervals = processed.Except(processing); int positionToInsert = (intersection.Begin < resultantIntervals[0].Begin) ? 0 : 1; resultantIntervals.Insert(positionToInsert, intersection); processedNode.Value = resultantIntervals[0]; processedNode.Next = new ListNode(resultantIntervals[1], processedNode.Next); processedNode = processedNode.Next; if (resultantIntervals.Count > 2) { processedNode.Next = new ListNode(resultantIntervals[2], processedNode.Next); processedNode = processedNode.Next; } } } } return(max); }
private bool Overlaps(Interval interval, Interval resInterval) { if (interval.Contains(resInterval.Start)) return true; if (interval.Contains(resInterval.End)) return true; if (resInterval.Contains(interval.Start)) return true; if (resInterval.Contains(interval.End)) return true; return false; }
/// <summary> /// brings the first leaf which interval was hit and the delegate is happy with the object /// </summary> /// <param name="point"></param> /// <param name="hitTestFordoubleDelegate"></param> /// <returns></returns> public IntervalNode <TData> FirstHitNode(double point, Func <double, TData, HitTestBehavior> hitTestFordoubleDelegate) { if (interval.Contains(point)) { if (IsLeaf) { if (hitTestFordoubleDelegate != null) { return(hitTestFordoubleDelegate(point, UserData) == HitTestBehavior.Stop ? this : null); } return(this); } return(Left.FirstHitNode(point, hitTestFordoubleDelegate) ?? Right.FirstHitNode(point, hitTestFordoubleDelegate)); } return(null); }
public void Contains() { Instant start = Instant.FromUtc(2019, 1, 1, 15, 25, 48); Instant end = Instant.FromUtc(2019, 1, 1, 16, 25, 48); Interval interval = new Interval(start, end); Assert.True(Snippet.For(interval.Contains(Instant.FromUtc(2019, 1, 1, 15, 50, 50)))); }
public void Contains_EmptyInterval_MaxValue() { var instant = Instant.MaxValue; var interval = new Interval(instant, instant); // This would have been true under Noda Time 1.x Assert.IsFalse(interval.Contains(instant)); }
public static void Step3() { Interval i = new Interval(); i.a = 41; i.b = 43; Console.WriteLine(i.Contains(50)); }
public void Contains_TwoIntervals() { var interval1 = new Interval(1, 10); var interval2 = new Interval(5, 6); var observedResult = interval1.Contains(interval2); Assert.True(observedResult); }
public void TestContains() { var int1 = new Interval(3, 6); var int2 = new Interval(4, 5); Assert.That(int1.Contains(int2), Is.True); int2 = new Interval(6, 7); Assert.That(int1.Contains(int2), Is.False); int2 = new Interval(7, 8); Assert.That(int1.Contains(int2), Is.False); int2 = new Interval(5, 6.1); Assert.That(int1.Contains(int2), Is.False); int2 = new Interval(2, 3); Assert.That(int1.Contains(int2), Is.False); int2 = new Interval(1.9, 4); Assert.That(int1.Contains(int2), Is.False); int2 = new Interval(1, 2); Assert.That(int1.Contains(int2), Is.False); }
public void TestEmptyInterval() { var empty = new Interval(); var a = new Interval(-1, 3); Contract.Assert(empty.DisjointFrom(empty)); Contract.Assert(!empty.OverlapsWith(empty)); Contract.Assert(!empty.Contains(empty)); }
public IObservable <IFile> RecordingsBetween(Interval interval) { var inside = fileSystem.GetAllFiles() .SelectMany(async file => new { Interval = await file.GetInterval(), File = file }) .Where(x => x.Interval != null && interval.Contains(x.Interval.Value)) .Select(x => x.File); return(inside); }
public void Contains(string candidateText, bool expectedResult) { var start = Instant.FromUtc(2000, 1, 1, 0, 0); var end = Instant.FromUtc(2020, 1, 1, 0, 0); var interval = new Interval(start, end); var candidate = InstantPattern.ExtendedIsoPattern.Parse(candidateText).Value; Assert.AreEqual(expectedResult, interval.Contains(candidate)); }
protected ComparerResult CompareDecimals(Interval interval, decimal actual) { if (interval.Contains(actual)) { return(ComparerResult.Equality); } return(new ComparerResult(interval.ToString())); }
public void TestEmptyWithOtherInterval() { var empty = new Interval(); var other = new Interval(-1, 3); Contract.Assert(other.DisjointFrom(empty)); Contract.Assert(!other.OverlapsWith(empty)); Contract.Assert(other.Contains(empty)); Contract.Assert(!empty.Contains(other)); }
public void TestContainment() { var a = new Interval(0, 3); var b = new Interval(-1, 3, endInclusive: true); Contract.Assert(a.OverlapsWith(b)); Contract.Assert(!a.DisjointFrom(b)); Contract.Assert(!a.Contains(b)); Contract.Assert(b.Contains(a)); }
public void ContainsTest_Bound_ExclusiveOnUpperExclusive() { int lowerBound = 2; BoundType lowerBoundType = BoundType.Inclusive; int upperBound = 5; BoundType upperBoundType = BoundType.Exclusive; Interval<int> target = new Interval<int>(lowerBound, lowerBoundType, upperBound, upperBoundType); IBound<int> bound = new Bound<int>(5, BoundType.Exclusive); bool expected = true; bool actual; actual = target.Contains(bound); Assert.AreEqual(expected, actual); }
public void AtLeast() { var list = new int[] { 1, 2, 3 }; Assert.True(list.AtLeast(2)); Assert.True(list.AtLeast(3)); Assert.False(list.AtLeast(4)); Assert.True(list.AtLeast(2, i => i < 3)); Assert.False(list.AtLeast(3, i => i < 3)); // Should work for infinite sequences as well Assert.True(1.Inc().AtLeast(2)); var interval = new Interval<int>(3, 7); Assert.True(1.Inc().AtLeast(2, i => interval.Contains(i))); }
/// <summary> /// Liefert alle Intersections im Bogenlängenintervall intervall /// </summary> /// <param name="interval">Bogenlängeintervall in dem die Intersections liegen sollen</param> /// <returns>Eine Liste von Intersections, die im Bogenlängenintervall intervall liegen</returns> public List<SpecificIntersection> GetIntersectionsWithinArcLength(Interval<double> interval) { List<SpecificIntersection> toReturn = new List<SpecificIntersection>(); foreach (Intersection i in this.intersections) { if (this == i._aConnection) { if (interval.Contains(i.aArcPosition)) { toReturn.Add(new SpecificIntersection(this, i)); } } else { if (interval.Contains(i.bArcPosition)) { toReturn.Add(new SpecificIntersection(this, i)); } } } return toReturn; }
/// <summary> /// Returns all intersections within the given interval. Returned List is guaranteed to be sorted in ascending order. /// </summary> /// <param name="interval">Arc length interval to search for.</param> /// <returns>A list of all intersections within the given interval, guaranteed to be sorted in ascending order.</returns> public List<SpecificIntersection> GetSortedIntersectionsWithinArcLength(Interval<double> interval) { // possibly redundant to the version above, but I don't want to trust the iterator. List<SpecificIntersection> toReturn = new List<SpecificIntersection>(); LinkedListNode<Intersection> lln = intersections.First; while (lln != null) { if (interval.Contains(lln.Value.GetMyArcPosition(this))) { toReturn.Add(new SpecificIntersection(this, lln.Value)); } lln = lln.Next; } return toReturn; }
public void Contains_EmptyInterval_MaxValue() { var instant = Instant.MaxValue; var interval = new Interval(instant, instant); // This would have been true under Noda Time 1.x Assert.IsFalse(interval.Contains(instant)); }
public void Contains(string candidateText, bool expectedResult) { var start = Instant.FromUtc(2000, 1, 1, 0, 0); var end = Instant.FromUtc(2020, 1, 1, 0, 0); var interval = new Interval(start, end); var candidate = InstantPattern.ExtendedIsoPattern.Parse(candidateText).Value; Assert.AreEqual(expectedResult, interval.Contains(candidate)); }
public void Contains_Infinite() { var interval = new Interval(null, null); Assert.IsTrue(interval.Contains(Instant.MaxValue)); Assert.IsTrue(interval.Contains(Instant.MinValue)); }
/// <summary> /// Liefert alle Intersections im Zeitintervall interval /// </summary> /// <param name="interval">Intervall in dem nach Intersections gesucht werden soll</param> /// <returns>Eine Liste von Intersections die im Zeitintervall interval auf dieser Linie vorkommen</returns> public List<Intersection> GetIntersectionsWithinTime(Interval<double> interval) { List<Intersection> toReturn = new List<Intersection>(); foreach (Intersection i in this.intersections) { if (this == i._aConnection) { if (interval.Contains(i._aTime)) { toReturn.Add(i); } } else { if (interval.Contains(i._bTime)) { toReturn.Add(i); } } } return toReturn; }
public void IntervalContainment(int s1, int e1, int s2, int e2, bool expected) { Interval<int> a = new Interval<int>(s1, e1); Interval<int> b = new Interval<int>(s2, e2); if (expected) { Assert.True(a.Contains(b)); Assert.False(b.Contains(a)); } else Assert.False(a.Contains(b)); }
private void CheckContains(Interval interval1, Interval interval2, bool expextedResult) { Assert.AreEqual(interval1.Contains(interval2), expextedResult); }
public void Contains_EmptyInterval() { var instant = NodaConstants.UnixEpoch; var interval = new Interval(instant, instant); Assert.IsFalse(interval.Contains(instant)); }
public void IntervalContainment(int s1, int e1, int v, bool expected) { Interval<int> a = new Interval<int>(s1, e1); if (expected) Assert.True(a.Contains(v)); else Assert.False(a.Contains(v)); }
public void ContainsTest_Key_TooLow() { int lowerBound = 2; BoundType lowerBoundType = BoundType.Inclusive; int upperBound = 5; BoundType upperBoundType = BoundType.Inclusive; Interval<int> target = new Interval<int>(lowerBound, lowerBoundType, upperBound, upperBoundType); int key = 1; bool expected = false; bool actual; actual = target.Contains(key); Assert.AreEqual(expected, actual); }