static string ExpandRange(SingleRange range) { char first = range._first; char last = range._last; return(String.Concat(Enumerable.Range(first, last - first + 1).Select(i => (char)i))); }
private static SingleRange GetEquallyDividedSubRange(SingleRange singleRange, int numSubRanges, int mySubRangeIndex) { var rangeSize = singleRange.RangeSize(); uint portion = (uint)(rangeSize / numSubRanges); uint remainder = (uint)(rangeSize - portion * numSubRanges); uint start = singleRange.Begin; for (int i = 0; i < numSubRanges; i++) { // (Begin, End] uint end = (unchecked (start + portion)); // I want it to overflow on purpose. It will do the right thing. if (remainder > 0) { end++; remainder--; } if (i == mySubRangeIndex) { return(new SingleRange(start, end)); } start = end; // nextStart } throw new ArgumentException(nameof(mySubRangeIndex)); }
public void Range_MinGreaterThanMax() { // Act & Assert Assert.Throws(typeof(ArgumentException), // ReSharper disable once ObjectCreationAsStatement () => SingleRange.Range(20, 10)); }
public static SingleRange Intersect(SingleRange a, SingleRange b) { BoundValue <T> newLower = a.lower < b.lower ? b.lower : a.lower; BoundValue <T> newUpper = a.upper < b.upper ? a.upper : b.upper; return(new SingleRange(newLower, newUpper)); }
public void Range_MinEqualToMax() { // Act var range = SingleRange.Range(10, 10); // Assert AssertChunks(range, 10, 10); }
public void Range_MinLowerThanMax() { // Act var range = SingleRange.Range(10, 20); // Assert AssertChunks(range, 10, 20); }
/// <summary> /// Extension method that allows for <see cref="NonIntegralRangeBase{TIntegralType}.Constrain"/> /// to be called on a <see cref="Single"/> subject with the range and exclusivity passed as a /// parameter, rather than on the <see cref="NonIntegralRangeBase{TIntegralType}"/> object /// with a <see cref="Single"/> parameter. /// </summary> /// <param name="this"> /// The subject <see cref="Single"/> value in which to check against the <paramref name="range"/> /// parameter to constrain a value within a range with an implicit inclusive comparison mode. /// </param> /// <param name="range"> /// An instance of the type <see cref="SingleRange"/>, describing a range of numeric values in /// which the <paramref name="this"/> subject is to be compared against. /// </param> /// <exception cref="ArgumentNullException"> /// Thrown when the specified <paramref name="range"/> is <see langword="null"/>. /// </exception> /// <returns> /// A <see cref="Single"/> value that is the <paramref name="this"/> subject value adjusted to /// force the range of possible values to be within the provided <paramref cref="range"/> /// parameter, using <see cref="EndpointExclusivity.Inclusive"/> as the comparison mode. /// </returns> public static Single Constrain( this Single @this, [NotNull] SingleRange range) { range.IsNotNull(nameof(range)); return(range .Constrain( @this)); }
/// <summary> /// Extension method that allows for <see cref="NonIntegralRangeBase{TIntegralType}.IsNotWithin"/> /// to be called on a <see cref="Single"/> subject with the range and exclusivity passed as a /// parameter, rather than on the <see cref="NonIntegralRangeBase{TIntegralType}"/> object /// with a <see cref="Single"/> parameter. /// </summary> /// <param name="this"> /// The subject <see cref="Single"/> value in which to check against the <paramref name="range"/> /// parameter to determine whether it is within the range, taking into account the exclusivity. /// </param> /// <param name="range"> /// An instance of the type <see cref="SingleRange"/>, describing a range of numeric values in /// which the <paramref name="this"/> subject is to be compared against. /// </param> /// <param name="exclusivity"> /// A value indicating whether to perform the upper and lower bounds comparisons including /// the range's Minimum and Maximum bounds, or to exclude them. This parameter is optional, /// and the default value is <see cref="EndpointExclusivity.Inclusive"/>. /// </param> /// <exception cref="ArgumentNullException"> /// Thrown when the specified <paramref name="range"/> is <see langword="null"/>. /// </exception> /// <returns> /// A <see cref="Single"/> value indicating whether or not the <paramref name="this"/> subject /// is within the provided <paramref cref="range"/> parameter, taking into account the /// <see cref="EndpointExclusivity"/> mode via the <paramref name="exclusivity"/> parameter. /// This comparison is the logical inverse of the <see cref="IsNotWithin"/> extension method. /// </returns> public static bool IsNotWithin( this Single @this, [NotNull] SingleRange range, EndpointExclusivity exclusivity = EndpointExclusivity.Inclusive) { range.IsNotNull(nameof(range)); return(range .IsNotWithin( @this, exclusivity)); }
public void AddChunk_Error() { // Arrange var range = SingleRange.Range(10, 20); // Assume AssertChunks(range, 10, 20); // Act & Assert Assert.Throws(typeof(ArgumentException), // ReSharper disable once ObjectCreationAsStatement () => range.Range(20, 10)); }
public void AddChunk_ImmediatelyBeforeMin1() { var range = SingleRange.Range(10, 20); // Assume AssertChunks(range, 10, 20); // Act range.Range(_Before10, _Before10); // Assert AssertChunks(range, _Before10, 20); }
public void AddChunk_AfterMaxInfinity() { // Arrange var range = SingleRange.Range(10, 20); // Assume AssertChunks(range, 10, 20); // Act range.Range(30, SingleRange.MaxValue); // Assert AssertChunks(range, 10, 20, 30, SingleRange.MaxValue); }
public void AddChunk_AfterMax() { // Arrange var range = SingleRange.Range(10, 20); // Assume AssertChunks(range, 10, 20); // Act range.Range(30, 40); // Assert AssertChunks(range, 10, 20, 30, 40); }
public void AddChunk_MaxImmediatelyAfterMax() { // Arrange var range = SingleRange.Range(10, 20); // Assume AssertChunks(range, 10, 20); // Act range.Range(15, _After20); // Assert AssertChunks(range, 10, _After20); }
public void AddChunk_ContainingMax() { // Arrange var range = SingleRange.Range(10, 20); // Assume AssertChunks(range, 10, 20); // Act range.Range(12, 25); // Assert AssertChunks(range, 10, 25); }
public void AddChunk_BetweenMinMax() { // Arrange var range = SingleRange.Range(10, 20); // Assume AssertChunks(range, 10, 20); // Act range.Range(12, 14); // Assert AssertChunks(range, 10, 20); }
public void AddChunk_MinImmediatelyBeforeMin() { // Arrange var range = SingleRange.Range(10, 20); // Assume AssertChunks(range, 10, 20); // Act range.Range(_Before10, 15); // Assert AssertChunks(range, _Before10, 20); }
public void AddChunk_BeforeMin() { // Arrange var range = SingleRange.Range(10, 20); // Assume AssertChunks(range, 10, 20); // Act range.Range(5, 8); // Assert AssertChunks(range, 5, 8, 10, 20); }
public void AddChunk_InfinityBeforeMin() { // Arrange var range = SingleRange.Range(10, 20); // Assume AssertChunks(range, 10, 20); // Act range.Range(SingleRange.MinValue, 8); // Assert AssertChunks(range, SingleRange.MinValue, 8, 10, 20); }
public void AddChunk_ContainingMin() { // Arrange var range = SingleRange.Range(10, 20); // Assume AssertChunks(range, 10, 20); // Act range.Range(5, 14); // Assert AssertChunks(range, 5, 20); }
/// <summary> /// Extension method that performs a transformation on the <see cref="Single"/> subject using /// linear mapping to re-map from the provided initial range <paramref name="startRange"/> /// to the target range <paramref name="endRange"/>. /// </summary> /// <param name="this"> /// The subject <see cref="Single"/> to perform the linear map range re-mapping upon. /// </param> /// <param name="startRange"> /// An instance of the type <see cref="SingleRange"/>, describing a range of numeric values in /// which the linear re-mapping uses as the initial range of the subject. /// </param> /// <param name="endRange"> /// An instance of the type <see cref="SingleRange"/>, describing a range of numeric values in /// which the linear re-mapping uses as the target range of the return value. /// </param> /// <exception cref="ArgumentNullException"> /// Thrown when either the <paramref name="startRange"/> or the <paramref name="endRange"/> /// parameters are equal to <see langword="null"/>. /// </exception> /// <returns> /// A <see cref="Single"/> value that has been linearly mapped to the <paramref name="startRange"/> /// parameter and re-mapped to the <paramref name="endRange"/> parameter. /// </returns> public static Single LinearMap( this Single @this, [NotNull] SingleRange startRange, [NotNull] SingleRange endRange) { startRange.IsNotNull(nameof(startRange)); endRange.IsNotNull(nameof(endRange)); return(( (@this - startRange.Minimum) * (endRange.Maximum - endRange.Minimum) / (startRange.Maximum - startRange.Minimum) + endRange.Minimum) .To <Single>()); }
public void AddChunk2_ContainingMinMax1_ImmediatelyBeforeMin2() { // Arrange var range = SingleRange.Range(10, 20); range.Range(30, 40); // Assume AssertChunks(range, 10, 20, 30, 40); // Act range.Range(5, _Before30); // Assert AssertChunks(range, 5, 40); }
public void AddChunkThatCompleteBoth() { // Arrange var range = SingleRange.Range(1, SingleRange.MaxValue); range.Range(SingleRange.MinValue, -1); // Assume AssertChunks(range, SingleRange.MinValue, -1, 1, SingleRange.MaxValue); // Act range.Range(BitConverterHelper.Next(-1F), BitConverterHelper.Previous(1F)); // Assert AssertChunks(range, SingleRange.MinValue, SingleRange.MaxValue); }
public void AddChunk2_ImmediatelyAfterMax2_Infinity() { // Arrange var range = SingleRange.Range(10, 20); range.Range(30, 40); // Assume AssertChunks(range, 10, 20, 30, 40); // Act range.Range(_After40, SingleRange.MaxValue); // Assert AssertChunks(range, 10, 20, 30, SingleRange.MaxValue); }
public void AddChunk2_BetweenMinMax2_Infinity() { // Arrange var range = SingleRange.Range(10, 20); range.Range(30, 40); // Assume AssertChunks(range, 10, 20, 30, 40); // Act range.Range(34, SingleRange.MaxValue); // Assert AssertChunks(range, 10, 20, 30, SingleRange.MaxValue); }
public void AddChunk2_BetweenMinMax2_AfterMax2() { // Arrange var range = SingleRange.Range(10, 20); range.Range(30, 40); // Assume AssertChunks(range, 10, 20, 30, 40); // Act range.Range(34, 46); // Assert AssertChunks(range, 10, 20, 30, 46); }
public void AddChunk2_ImmediatelyBeforeMin1() { // Arrange var range = SingleRange.Range(10, 20); range.Range(30, 40); // Assume AssertChunks(range, 10, 20, 30, 40); // Act range.Range(5, _Before10); // Assert AssertChunks(range, 5, 20, 30, 40); }
public void AddChunk2_AfterMax1_ImmediatelyBeforeMin2() { // Arrange var range = SingleRange.Range(10, 20); range.Range(30, 40); // Assume AssertChunks(range, 10, 20, 30, 40); // Act range.Range(23, _Before30); // Assert AssertChunks(range, 10, 20, 23, 40); }
public void AddChunk2_ImmediatelyAfterMax1_AfterMax2() { // Arrange var range = SingleRange.Range(10, 20); range.Range(30, 40); // Assume AssertChunks(range, 10, 20, 30, 40); // Act range.Range(_After20, 45); // Assert AssertChunks(range, 10, 45); }
public void AddChunk2_ContainingMax1_ContainingMinMax2() { // Arrange var range = SingleRange.Range(10, 20); range.Range(30, 40); // Assume AssertChunks(range, 10, 20, 30, 40); // Act range.Range(15, 42); // Assert AssertChunks(range, 10, 42); }
public void AddChunk2_ContainingMinMax1_Infinity() { // Arrange var range = SingleRange.Range(10, 20); range.Range(30, 40); // Assume AssertChunks(range, 10, 20, 30, 40); // Act range.Range(5, SingleRange.MaxValue); // Assert AssertChunks(range, 5, SingleRange.MaxValue); }