private static void Clamp <T>(T expectL, T expectR, T l, T r, T targetL, T targetR) { var expect = new Interval <T>(expectL, expectR); Interval <T> i = new Interval <T>(l, r), target = new Interval <T>(targetL, targetR); Assert.AreEqual(expect, i.Clamp(target)); }
public object Coerce(object context, object value) { if (value == null) { return(null); } // Initialize functions to access the panel. if (_getMaxima == null) { Type type = context.GetType(); // Allow accessing properties. MethodInfo getMaxima = type.GetProperty("Maxima" + _axisName).GetGetMethod(); _getMaxima = DelegateHelper.CreateOpenInstanceDelegate <Func <object, object> >(getMaxima, DelegateHelper.CreateOptions.Downcasting); MethodInfo getMinimumSize = type.GetProperty("MinimumSize" + _axisName).GetGetMethod(); _getMinimumSize = DelegateHelper.CreateOpenInstanceDelegate <Func <object, object> >(getMinimumSize, DelegateHelper.CreateOptions.Downcasting); MethodInfo getMaximumSize = type.GetProperty("MaximumSize" + _axisName).GetGetMethod(); _getMaximumSize = DelegateHelper.CreateOpenInstanceDelegate <Func <object, object> >(getMaximumSize, DelegateHelper.CreateOptions.Downcasting); // Allow accessing protected conversion functions. MethodInfo convertToInternalInterval = type.GetMethod(_convertToInternalIntervalMethod, Reflection.ReflectionHelper.InstanceMembers); _convertToInternalInterval = DelegateHelper.CreateOpenInstanceDelegate <Func <object, object, Interval <double> > >(convertToInternalInterval, DelegateHelper.CreateOptions.Downcasting); MethodInfo convertToInterval = type.GetMethod(_convertToIntervalMethod, Reflection.ReflectionHelper.InstanceMembers); _convertToInterval = DelegateHelper.CreateOpenInstanceDelegate <Func <object, Interval <double>, object> >(convertToInterval, DelegateHelper.CreateOptions.Downcasting); MethodInfo convertToInternalSize = type.GetMethod(_convertToInternalSizeMethod, Reflection.ReflectionHelper.InstanceMembers); _convertToInternalSize = DelegateHelper.CreateOpenInstanceDelegate <Func <object, object, double> >(convertToInternalSize, DelegateHelper.CreateOptions.Downcasting); } // Limit size of the desired interval. Interval <double> setInterval = _convertToInternalInterval(context, value); object min = _getMinimumSize(context); double minimumSize = _convertToInternalSize(context, min); double tooSmallRatio = minimumSize / setInterval.Size; if (tooSmallRatio > 1) { setInterval = setInterval.Scale(tooSmallRatio); } object max = _getMaximumSize(context); double maximumSize = _convertToInternalSize(context, max); double tooBigRatio = maximumSize / setInterval.Size; if (tooBigRatio < 1) { setInterval = setInterval.Scale(tooBigRatio); } // Limit how far the time line goes. Interval <double> limitInterval = _convertToInternalInterval(context, _getMaxima(context)); Interval <double> limited = setInterval.Clamp(limitInterval); return(_convertToInterval(context, limited)); }
static void ClampIntervalTestHelper <T, TSize>( T startA, bool startAIncluded, TSize additionA, bool endAIncluded, T startB, bool startBIncluded, TSize additionB, bool endBIncluded, Interval <T, TSize> clamped) where T : IComparable <T> where TSize : IComparable <TSize> { // Fully included intervals. Interval <T, TSize> intervalA = NewInterval(startA, additionA, startAIncluded, endAIncluded); Interval <T, TSize> intervalB = NewInterval(startB, additionB, startBIncluded, endBIncluded); IInterval <T, TSize> result = intervalA.Clamp(intervalB); Assert.Equal(clamped, result); }
static void ClampValueTestHelper <T, TSize>(T start, TSize addition, T actual, T clamped) where T : IComparable <T> where TSize : IComparable <TSize> { T end = AddSize(start, addition); // Fully included interval. var interval = new Interval <T, TSize>(start, end); Assert.Equal(clamped, interval.Clamp(actual)); // Reversed intervals. var reversed = new Interval <T, TSize>(end, start); Assert.Equal(clamped, reversed.Clamp(actual)); // Excluded borders. // TODO: For now it does not matter whether start or end is included. Do we want to take this into account? var excludedInterval = new Interval <T, TSize>(start, false, end, false); Assert.Equal(clamped, excludedInterval.Clamp(actual)); }