diff --git a/CHANGELOG.md b/CHANGELOG.md index 8eb9277..ca113fa 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -69,6 +69,10 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0. - Better VC-4 support for IcdConsole - JSON refactoring for simpler deserialization +## [8.6.0] - 2019-06-14 +### Changed + - Overhaul of RangeAttribute remap methods to better avoid overflows + ## [8.5.0] - 2019-06-06 ### Added - Adding features to IcdEnvironment for tracking program initialization state diff --git a/ICD.Common.Utils.Tests/Attributes/RangeAttributeTest.cs b/ICD.Common.Utils.Tests/Attributes/RangeAttributeTest.cs new file mode 100644 index 0000000..b702d58 --- /dev/null +++ b/ICD.Common.Utils.Tests/Attributes/RangeAttributeTest.cs @@ -0,0 +1,86 @@ +using System; +using NUnit.Framework; +using RangeAttribute = ICD.Common.Utils.Attributes.RangeAttribute; + +namespace ICD.Common.Utils.Tests.Attributes +{ + [TestFixture] + public sealed class RangeAttributeTest : AbstractIcdAttributeTest + { + #region Properties + + [TestCase(1)] + [TestCase(1.0f)] + [TestCase(1.0)] + public void MinTest(object min) + { + Assert.AreEqual(min, new RangeAttribute(min, min).Min); + } + + [TestCase(1)] + [TestCase(1.0f)] + [TestCase(1.0)] + public void MaxTest(object max) + { + Assert.AreEqual(max, new RangeAttribute(max, max).Max); + } + + #endregion + + #region Methods + + [TestCase((double)0, (double)0)] + [TestCase((double)1, (double)1)] + [TestCase(ushort.MaxValue, double.MaxValue)] + [TestCase(short.MinValue, double.MinValue)] + public void RemapToDoubleTest(object value, double expected) + { + Assert.AreEqual(expected, RangeAttribute.RemapToDouble(value)); + } + + [TestCase((double)0, typeof(ushort), (ushort)32767)] + [TestCase(double.MinValue, typeof(ushort), ushort.MinValue)] + [TestCase(double.MaxValue, typeof(ushort), ushort.MaxValue)] + public void RemapFromDoubleTest(double value, Type type, object expected) + { + Assert.AreEqual(expected, RangeAttribute.RemapFromDouble(value, type)); + } + + [TestCase(short.MinValue, typeof(ushort), ushort.MinValue)] + [TestCase(short.MaxValue, typeof(ushort), short.MaxValue)] + public static void Clamp(object value, Type type, object expected) + { + Assert.AreEqual(expected, RangeAttribute.Clamp(value, type)); + } + + [TestCase(double.MinValue, typeof(ushort), ushort.MinValue)] + [TestCase(double.MaxValue, typeof(ushort), ushort.MaxValue)] + public void Clamp(double value, Type type, double expected) + { + Assert.AreEqual(expected, RangeAttribute.Clamp(value, type)); + } + + [TestCase(short.MinValue, typeof(ushort), ushort.MinValue)] + [TestCase(short.MaxValue, typeof(ushort), ushort.MaxValue)] + public void RemapTest(object value, Type type, object expected) + { + Assert.AreEqual(expected, RangeAttribute.Remap(value, type)); + } + + [TestCase(0, 100, ushort.MaxValue, typeof(ushort), ushort.MaxValue)] + [TestCase(0, 100, ushort.MaxValue, typeof(short), short.MaxValue)] + public void ClampMinMaxThenRemapTest(object min, object max, object value, Type type, object expected) + { + Assert.AreEqual(expected, new RangeAttribute(min, max).ClampMinMaxThenRemap(value, type)); + } + + [TestCase(0, 100, ushort.MaxValue, 100)] + [TestCase(0, 100, ushort.MinValue, 0)] + public void RemapMinMaxTest(object min, object max, object value, object expected) + { + Assert.AreEqual(expected, new RangeAttribute(min, max).RemapMinMax(value)); + } + + #endregion + } +} diff --git a/ICD.Common.Utils.Tests/MathUtilsTest.cs b/ICD.Common.Utils.Tests/MathUtilsTest.cs index 52c1edd..ebf3280 100644 --- a/ICD.Common.Utils.Tests/MathUtilsTest.cs +++ b/ICD.Common.Utils.Tests/MathUtilsTest.cs @@ -27,6 +27,10 @@ namespace ICD.Common.Utils.Tests [Test, UsedImplicitly] public void MapRangeTest() { + Assert.AreEqual(5, MathUtils.MapRange(-100, 100, 0, 10, 0)); + Assert.AreEqual(7, MathUtils.MapRange(-100, 100, 0, 10, 50)); + Assert.AreEqual(10, MathUtils.MapRange(-100, 100, 0, 10, 100)); + Assert.AreEqual(0, MathUtils.MapRange(0, 100, 0, 10, 0)); Assert.AreEqual(5, MathUtils.MapRange(0, 100, 0, 10, 50)); Assert.AreEqual(10, MathUtils.MapRange(0, 100, 0, 10, 100)); @@ -36,7 +40,7 @@ namespace ICD.Common.Utils.Tests Assert.AreEqual(100, MathUtils.MapRange(0, 10, 0, 100, 10)); } - [Test, UsedImplicitly] + [Test, UsedImplicitly] public void GetRangesTest() { IEnumerable values = new [] { 1, 3, 5, 6, 7, 8, 9, 10, 12 }; diff --git a/ICD.Common.Utils/Attributes/RangeAttribute.cs b/ICD.Common.Utils/Attributes/RangeAttribute.cs index 1574f9e..db53ce9 100644 --- a/ICD.Common.Utils/Attributes/RangeAttribute.cs +++ b/ICD.Common.Utils/Attributes/RangeAttribute.cs @@ -1,4 +1,7 @@ using System; +using System.Collections.Generic; +using System.Globalization; +using ICD.Common.Utils.Extensions; namespace ICD.Common.Utils.Attributes { @@ -8,295 +11,509 @@ namespace ICD.Common.Utils.Attributes [AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter | - AttributeTargets.ReturnValue, - AllowMultiple = false, - Inherited = true)] + AttributeTargets.ReturnValue)] public sealed class RangeAttribute : AbstractIcdAttribute { + /// + /// Remaps from the source numeric min/max to double min/max. + /// + private static readonly Dictionary> s_Clamp = + new Dictionary> + { + // Duh + {typeof(double), o => o}, + + // Signed + {typeof(short), o => o < short.MinValue ? short.MinValue : o > short.MaxValue ? short.MaxValue : o}, + {typeof(int), o => o < int.MinValue ? int.MinValue : o > int.MaxValue ? int.MaxValue : o}, + {typeof(long), o => o < long.MinValue ? long.MinValue : o > long.MaxValue ? long.MaxValue : o}, + {typeof(float),o => o < float.MinValue ? float.MinValue : o > float.MaxValue ? float.MaxValue : o}, + {typeof(decimal), o => o < (double)decimal.MinValue ? (double)decimal.MinValue : o > (double)decimal.MaxValue ? (double)decimal.MaxValue : o}, + + // Unsigned + {typeof(ushort), o => o < ushort.MinValue ? ushort.MinValue : o > ushort.MaxValue ? ushort.MaxValue : o}, + {typeof(uint), o => o < uint.MinValue ? uint.MinValue : o > uint.MaxValue ? uint.MaxValue : o}, + {typeof(ulong), o => o < ulong.MinValue ? ulong.MinValue : o > ulong.MaxValue ? ulong.MaxValue : o}, + {typeof(byte), o => o < byte.MinValue ? byte.MinValue : o > byte.MaxValue ? byte.MaxValue : o} + }; + + /// + /// Remaps from the source numeric min/max to double min/max. + /// + private static readonly Dictionary> s_RemapToDouble = + new Dictionary> + { + // Duh + { typeof(double), o => (double)o}, + + // Signed - Clamping prevents an overflow due to loss of precision + { typeof(short), o => MathUtils.Clamp(Convert.ToDouble(o) / short.MaxValue, -1, 1) * double.MaxValue}, + { typeof(int), o => MathUtils.Clamp(Convert.ToDouble(o) / int.MaxValue, -1, 1) * double.MaxValue}, + { typeof(long), o => MathUtils.Clamp(Convert.ToDouble(o) / long.MaxValue, -1, 1) * double.MaxValue}, + { typeof(float), o => MathUtils.Clamp(Convert.ToDouble(o) / float.MaxValue, -1, 1) * double.MaxValue}, + { typeof(decimal), o => MathUtils.Clamp(Convert.ToDouble(o) / (double)decimal.MaxValue, -1, 1) * double.MaxValue}, + + // Unsigned + { typeof(ushort), o => MathUtils.Clamp((Convert.ToDouble(o) / ushort.MaxValue - 0.5) * 2, -1, 1) * double.MaxValue}, + { typeof(uint), o => MathUtils.Clamp((Convert.ToDouble(o) / uint.MaxValue - 0.5) * 2, -1, 1) * double.MaxValue}, + { typeof(ulong), o => MathUtils.Clamp((Convert.ToDouble(o) / ulong.MaxValue - 0.5) * 2, -1, 1) * double.MaxValue}, + { typeof(byte), o => MathUtils.Clamp((Convert.ToDouble(o) / byte.MaxValue - 0.5) * 2, -1, 1) * double.MaxValue} + }; + + /// + /// Remaps from the double min/max to target numeric min/max. + /// + private static readonly Dictionary> s_RemapFromDouble = + new Dictionary> + { + // Duh + {typeof(double), v => v}, + + // Signed + {typeof(short), v => (short)(v / double.MaxValue * short.MaxValue)}, + {typeof(int), v => (int)(v / double.MaxValue * int.MaxValue)}, + {typeof(long), v => (long)(v / double.MaxValue * long.MaxValue)}, + {typeof(float), v => (float)(v / double.MaxValue * float.MaxValue)}, + {typeof(decimal), v => (decimal)(v / double.MaxValue) * decimal.MaxValue}, + + // Unsigned + {typeof(ushort), v => (ushort)((v / double.MaxValue + 1) / 2 * ushort.MaxValue)}, + {typeof(uint), v => (uint)((v / double.MaxValue + 1) / 2 * uint.MaxValue)}, + {typeof(ulong), v => (ulong)((v / double.MaxValue + 1) / 2 * ulong.MaxValue)}, + {typeof(byte), v => (byte)((v / double.MaxValue + 1) / 2 * byte.MaxValue)} + }; + + /// + /// Gets the min value of a given numeric type as a double. + /// + private static readonly Dictionary s_MinAsDouble = + new Dictionary + { + // Duh + {typeof(double), double.MinValue}, + + // Signed + {typeof(short), Convert.ToDouble(short.MinValue)}, + {typeof(int), Convert.ToDouble(int.MinValue)}, + {typeof(long), Convert.ToDouble(long.MinValue)}, + {typeof(float), Convert.ToDouble(float.MinValue)}, + {typeof(decimal), Convert.ToDouble(decimal.MinValue)}, + + // Unsigned + {typeof(ushort), Convert.ToDouble(ushort.MinValue)}, + {typeof(uint), Convert.ToDouble(uint.MinValue)}, + {typeof(ulong), Convert.ToDouble(ulong.MinValue)}, + {typeof(byte), Convert.ToDouble(byte.MinValue)} + }; + + /// + /// Gets the min value of a given numeric type as a double. + /// + private static readonly Dictionary s_MaxAsDouble = + new Dictionary + { + // Duh + {typeof(double), double.MaxValue}, + + // Signed + {typeof(short), Convert.ToDouble(short.MaxValue)}, + {typeof(int), Convert.ToDouble(int.MaxValue)}, + {typeof(long), Convert.ToDouble(long.MaxValue)}, + {typeof(float), Convert.ToDouble(float.MaxValue)}, + {typeof(decimal), Convert.ToDouble(decimal.MaxValue)}, + + // Unsigned + {typeof(ushort), Convert.ToDouble(ushort.MaxValue)}, + {typeof(uint), Convert.ToDouble(uint.MaxValue)}, + {typeof(ulong), Convert.ToDouble(ulong.MaxValue)}, + {typeof(byte), Convert.ToDouble(byte.MaxValue)} + }; + + private readonly object m_Min; + private readonly object m_Max; + #region Properties - public object Min { get; private set; } - public object Max { get; private set; } + /// + /// Gets the min value for this range. + /// + public object Min { get { return m_Min; } } + + /// + /// Gets the max value for this range. + /// + public object Max { get { return m_Max; } } #endregion #region Constructors + /// + /// Constructor. + /// + /// + /// public RangeAttribute(ushort min, ushort max) + : this((object)min, (object)max) { - Min = min; - Max = max; } + /// + /// Constructor. + /// + /// + /// public RangeAttribute(short min, short max) + : this((object)min, (object)max) { - Min = min; - Max = max; } + /// + /// Constructor. + /// + /// + /// public RangeAttribute(uint min, uint max) + : this((object)min, (object)max) { - Min = min; - Max = max; } + /// + /// Constructor. + /// + /// + /// public RangeAttribute(int min, int max) + : this((object)min, (object)max) { - Min = min; - Max = max; } + /// + /// Constructor. + /// + /// + /// public RangeAttribute(ulong min, ulong max) + : this((object)min, (object)max) { - Min = min; - Max = max; } + /// + /// Constructor. + /// + /// + /// public RangeAttribute(long min, long max) + : this((object)min, (object)max) { - Min = min; - Max = max; } + /// + /// Constructor. + /// + /// + /// public RangeAttribute(float min, float max) + : this((object)min, (object)max) { - Min = min; - Max = max; } + /// + /// Constructor. + /// + /// + /// public RangeAttribute(double min, double max) + : this((object)min, (object)max) { - Min = min; - Max = max; } + /// + /// Constructor. + /// + /// + /// public RangeAttribute(byte min, byte max) + : this((object)min, (object)max) { - Min = min; - Max = max; } + /// + /// Constructor. + /// + /// + /// public RangeAttribute(sbyte min, sbyte max) + : this((object)min, (object)max) { - Min = min; - Max = max; } + /// + /// Constructor. + /// + /// + /// public RangeAttribute(decimal min, decimal max) + : this((object)min, (object)max) { - Min = min; - Max = max; + } + + /// + /// Constructor. + /// + /// + /// + public RangeAttribute(object min, object max) + { + if (min == null) + throw new ArgumentNullException("min"); + + if (max == null) + throw new ArgumentNullException("max"); + + if (min.GetType() != max.GetType()) + throw new ArgumentException("Min and Max types do not match"); + + if (!min.GetType().IsNumeric()) + throw new ArgumentException("Given types are not numeric"); + + m_Min = min; + m_Max = max; } #endregion #region Methods - public T GetMin() + /// + /// Remaps the given numeric value from its min/max range into double min/max range. + /// + /// + /// + public static double RemapToDouble(object value) { - return (T)Convert.ChangeType(Min, typeof(T), null); + if (value == null) + throw new ArgumentNullException("value"); + + Func remap; + if (!s_RemapToDouble.TryGetValue(value.GetType(), out remap)) + throw new NotSupportedException("Value type is not supported."); + + return remap(value); } - public T GetMax() + /// + /// Remaps the given double value from its min/max range into the target type min/max range. + /// + /// + /// + /// + public static object RemapFromDouble(double value, Type type) { - return (T)Convert.ChangeType(Max, typeof(T), null); + if (type == null) + throw new ArgumentNullException("type"); + + Func remap; + if (!s_RemapFromDouble.TryGetValue(type, out remap)) + throw new NotSupportedException("Value type is not supported."); + + return remap(value); } - public bool IsInRange(object value) + /// + /// Clamps the given numeric value into the valid ranges of the target numeric type. + /// + /// + /// + /// + public static object Clamp(object value, Type type) { - if (value is ushort) - { - if (!(Min is ushort)) - throw new ArgumentException("the type of value does not match the type of min / max"); + if (value == null) + throw new ArgumentNullException("value"); - var castVal = (ushort)value; - return (castVal >= GetMin() && castVal <= GetMax()); - } + if (type == null) + throw new ArgumentNullException("type"); - if (value is short) - { - if (!(Min is short)) - throw new ArgumentException("the type of value does not match the type of min / max"); + if (!type.IsNumeric()) + throw new ArgumentException("Target type is not numeric"); - var castVal = (short)value; - return (castVal >= GetMin() && castVal <= GetMax()); - } + if (!value.GetType().IsNumeric()) + throw new ArgumentException("Source value is not numeric"); - if (value is uint) - { - if (!(Min is uint)) - throw new ArgumentException("the type of value does not match the type of min / max"); + double doubleValue = Convert.ToDouble(value); + double clamped = Clamp(doubleValue, type); - var castVal = (uint)value; - return (castVal >= GetMin() && castVal <= GetMax()); - } - - if (value is int) - { - if (!(Min is int)) - throw new ArgumentException("the type of value does not match the type of min / max"); - - var castVal = (int)value; - return (castVal >= GetMin() && castVal <= GetMax()); - } - - if (value is ulong) - { - if (!(Min is ulong)) - throw new ArgumentException("the type of value does not match the type of min / max"); - - var castVal = (ulong)value; - return (castVal >= GetMin() && castVal <= GetMax()); - } - - if (value is long) - { - if (!(Min is long)) - throw new ArgumentException("the type of value does not match the type of min / max"); - - var castVal = (long)value; - return (castVal >= GetMin() && castVal <= GetMax()); - } - - if (value is float) - { - if (!(Min is float)) - throw new ArgumentException("the type of value does not match the type of min / max"); - - var castVal = (float)value; - return (castVal >= GetMin() && castVal <= GetMax()); - } - - if (value is double) - { - if (!(Min is double)) - throw new ArgumentException("the type of value does not match the type of min / max"); - - var castVal = (double)value; - return (castVal >= GetMin() && castVal <= GetMax()); - } - - if (value is decimal) - { - if (!(Min is decimal)) - throw new ArgumentException("the type of value does not match the type of min / max"); - - var castVal = (decimal)value; - return (castVal >= GetMin() && castVal <= GetMax()); - } - - if (value is byte) - { - if (!(Min is byte)) - throw new ArgumentException("the type of value does not match the type of min / max"); - - var castVal = (byte)value; - return (castVal >= GetMin() && castVal <= GetMax()); - } - - if (value is sbyte) - { - if (!(Min is sbyte)) - throw new ArgumentException("the type of value does not match the type of min / max"); - - var castVal = (sbyte)value; - return (castVal >= GetMin() && castVal <= GetMax()); - } - - throw new ArgumentException("the type of value is not a numeric type."); + return Convert.ChangeType(clamped, value.GetType(), CultureInfo.InvariantCulture); } - #region Range -> UShort - - public ushort RemapRangeToUshort(double value) + /// + /// Clamps the given double value into the valid ranges of the target numeric type. + /// + /// + /// + /// + public static double Clamp(double value, Type type) { - return (ushort)MathUtils.MapRange(GetMin(), GetMax(), ushort.MinValue, ushort.MaxValue, value); + if (type == null) + throw new ArgumentNullException("type"); + + Func clamp; + if (!s_Clamp.TryGetValue(type, out clamp)) + throw new NotSupportedException("Value type is not supported."); + + return clamp(value); } - public ushort RemapRangeToUshort(float value) + /// + /// Remaps the numeric value into the min-max range of the target numeric type. + /// + /// + /// + /// + public static object Remap(object value, Type type) { - return (ushort)MathUtils.MapRange(GetMin(), GetMax(), ushort.MinValue, ushort.MaxValue, value); + if (value == null) + throw new ArgumentNullException("value"); + + if (type == null) + throw new ArgumentNullException("type"); + + if (!type.IsNumeric()) + throw new ArgumentException("Target type is not numeric"); + + if (!value.GetType().IsNumeric()) + throw new ArgumentException("Source value is not numeric"); + + double intermediate = RemapToDouble(value); + return RemapFromDouble(intermediate, type); } - public ushort RemapRangeToUshort(int value) + /// + /// Clamps the given numeric value to the defined min/max then remaps to the target numeric type. + /// + /// + /// + /// + public object ClampMinMaxThenRemap(object value, Type type) { - return (ushort)MathUtils.MapRange(GetMin(), GetMax(), ushort.MinValue, ushort.MaxValue, value); + if (value == null) + throw new ArgumentNullException("value"); + + if (type == null) + throw new ArgumentNullException("type"); + + if (!type.IsNumeric()) + throw new ArgumentException("Target type is not numeric"); + + if (!value.GetType().IsNumeric()) + throw new ArgumentException("Source value is not numeric"); + + double min = Convert.ToDouble(Min); + double max = Convert.ToDouble(Max); + double doubleValue = Convert.ToDouble(value); + + double clamped = MathUtils.Clamp(doubleValue, min, max); + object remapped = RemapMinMax(clamped, type); + + return Convert.ChangeType(remapped, value.GetType(), CultureInfo.InvariantCulture); } - public ushort RemapRangeToUshort(ushort value) + /// + /// Remaps the given numeric value to the defined min/max. + /// + /// + /// + public object RemapMinMax(object value) { - return MathUtils.MapRange(GetMin(), GetMax(), ushort.MinValue, ushort.MaxValue, value); + if (value == null) + throw new ArgumentNullException("value"); + + if (!value.GetType().IsNumeric()) + throw new ArgumentException("Source value is not numeric"); + + double sourceMin = GetMinAsDouble(value.GetType()); + double sourceMax = GetMaxAsDouble(value.GetType()); + + double targetMin = Convert.ToDouble(Min); + double targetMax = Convert.ToDouble(Max); + + double doubleValue = Convert.ToDouble(value); + + double remapped = MathUtils.MapRange(sourceMin, sourceMax, targetMin, targetMax, doubleValue); + + return Convert.ChangeType(remapped, value.GetType(), CultureInfo.InvariantCulture); + } + + private object RemapMinMax(object value, Type type) + { + if (value == null) + throw new ArgumentNullException("value"); + + if (type == null) + throw new ArgumentNullException("type"); + + if (!type.IsNumeric()) + throw new ArgumentException("Target type is not numeric"); + + if (!value.GetType().IsNumeric()) + throw new ArgumentException("Source value is not numeric"); + + double sourceMin = Convert.ToDouble(Min); + double sourceMax = Convert.ToDouble(Max); + + double targetMin = GetMinAsDouble(type); + double targetMax = GetMaxAsDouble(type); + + double doubleValue = Convert.ToDouble(value); + + double remapped = MathUtils.MapRange(sourceMin, sourceMax, targetMin, targetMax, doubleValue); + + return Convert.ChangeType(remapped, type, CultureInfo.InvariantCulture); } #endregion - #region UShort -> Range + #region Private Methods - public object RemapUshortToRange(ushort value) + /// + /// Gets the min value for the given numeric type as a double. + /// + /// + /// + private static double GetMinAsDouble(Type type) { - if (Min is ushort) - { - return MathUtils.MapRange(ushort.MinValue, ushort.MaxValue, GetMin(), GetMax(), value); - } + if (type == null) + throw new ArgumentNullException("type"); - if (Min is short) - { - var castVal = (short)value; - return (short)MathUtils.MapRange(ushort.MinValue, ushort.MaxValue, GetMin(), GetMax(), castVal); - } + if (!type.IsNumeric()) + throw new ArgumentException("Target type is not numeric"); - if (Min is uint) - { - var castVal = (uint)value; - return (uint)MathUtils.MapRange(ushort.MinValue, ushort.MaxValue, GetMin(), GetMax(), castVal); - } + double min; + if (!s_MinAsDouble.TryGetValue(type, out min)) + throw new NotSupportedException("Type is not supported."); - if (Min is int) - { - var castVal = (int)value; - return MathUtils.MapRange(ushort.MinValue, ushort.MaxValue, GetMin(), GetMax(), castVal); - } - - if (Min is ulong) - { - var castVal = (ulong)value; - return MathUtils.MapRange(ushort.MinValue, ushort.MaxValue, GetMin(), GetMax(), castVal); - } - - if (Min is long) - { - var castVal = (long)value; - return MathUtils.MapRange(ushort.MinValue, ushort.MaxValue, GetMin(), GetMax(), castVal); - } - - if (Min is float) - { - var castVal = (float)value; - return MathUtils.MapRange(ushort.MinValue, ushort.MaxValue, GetMin(), GetMax(), castVal); - } - - if (Min is double) - { - var castVal = (double)value; - return MathUtils.MapRange(ushort.MinValue, ushort.MaxValue, GetMin(), GetMax(), castVal); - } - - if (Min is decimal) - { - var castVal = (decimal)value; - return MathUtils.MapRange(ushort.MinValue, ushort.MaxValue, GetMin(), GetMax(), castVal); - } - - if (Min is byte) - { - var castVal = (byte)value; - return (byte)MathUtils.MapRange(ushort.MinValue, ushort.MaxValue, GetMin(), GetMax(), castVal); - } - - throw new NotSupportedException("Value type of range attribute is not supported."); + return min; } - #endregion + /// + /// Gets the max value for the given numeric type as a double. + /// + /// + /// + private static double GetMaxAsDouble(Type type) + { + if (type == null) + throw new ArgumentNullException("type"); + + if (!type.IsNumeric()) + throw new ArgumentException("Target type is not numeric"); + + double max; + if (!s_MaxAsDouble.TryGetValue(type, out max)) + throw new NotSupportedException("Type is not supported."); + + return max; + } #endregion } diff --git a/ICD.Common.Utils/MathUtils.cs b/ICD.Common.Utils/MathUtils.cs index e4427ac..832ccba 100644 --- a/ICD.Common.Utils/MathUtils.cs +++ b/ICD.Common.Utils/MathUtils.cs @@ -138,42 +138,6 @@ namespace ICD.Common.Utils return (ushort)MapRange((double)inputStart, inputEnd, outputStart, outputEnd, value); } - /// - /// Returns the value after the input range has been mapped to a new range - /// - /// Input start. - /// Input end. - /// Output start. - /// Output end. - /// Value. - /// The newly mapped value - public static ulong MapRange(ulong inputStart, ulong inputEnd, ulong outputStart, ulong outputEnd, ulong value) - { - if (inputStart.Equals(inputEnd)) - throw new DivideByZeroException(); - - ulong slope = (outputEnd - outputStart) / (inputEnd - inputStart); - return outputStart + slope * (value - inputStart); - } - - /// - /// Returns the value after the input range has been mapped to a new range - /// - /// Input start. - /// Input end. - /// Output start. - /// Output end. - /// Value. - /// The newly mapped value - public static long MapRange(long inputStart, long inputEnd, long outputStart, long outputEnd, long value) - { - if (inputStart.Equals(inputEnd)) - throw new DivideByZeroException(); - - long slope = (outputEnd - outputStart) / (inputEnd - inputStart); - return outputStart + slope * (value - inputStart); - } - /// /// Maps the date in the given range to the float range 0.0f to 1.0f. /// 0.5f - The date is half way between the end points.