Index: Core/Common/src/Core.Common.Base/Data/RoundedDouble.cs
===================================================================
diff -u -rf8eeb4e21d9e282d998f3f218593bfb0fec681b7 -r22f847897e3a8dcefbb04b51dd1fc346448cd62d
--- Core/Common/src/Core.Common.Base/Data/RoundedDouble.cs	(.../RoundedDouble.cs)	(revision f8eeb4e21d9e282d998f3f218593bfb0fec681b7)
+++ Core/Common/src/Core.Common.Base/Data/RoundedDouble.cs	(.../RoundedDouble.cs)	(revision 22f847897e3a8dcefbb04b51dd1fc346448cd62d)
@@ -9,7 +9,7 @@
     /// This class represents a <see cref="double"/> that is being rounded to a certain
     /// number of places.
     /// </summary>
-    public sealed class RoundedDouble : IEquatable<RoundedDouble>
+    public sealed class RoundedDouble : IEquatable<RoundedDouble>, IEquatable<Double>
     {
         private double value;
 
@@ -55,6 +55,21 @@
             }
         }
 
+        public static bool operator ==(RoundedDouble left, RoundedDouble right)
+        {
+            return Equals(left, right);
+        }
+
+        public static bool operator !=(RoundedDouble left, RoundedDouble right)
+        {
+            return !Equals(left, right);
+        }
+
+        public static implicit operator double(RoundedDouble d)
+        {
+            return d.Value;
+        }
+
         public override bool Equals(object obj)
         {
             if (ReferenceEquals(null, obj))
@@ -90,6 +105,11 @@
             return Value.ToString(GetFormat(), CultureInfo.CurrentCulture);
         }
 
+        public bool Equals(double other)
+        {
+            return Value.Equals(other);
+        }
+
         public bool Equals(RoundedDouble other)
         {
             if (ReferenceEquals(null, other))
@@ -103,16 +123,6 @@
             return Value.Equals(other.Value);
         }
 
-        public static bool operator ==(RoundedDouble left, RoundedDouble right)
-        {
-            return Equals(left, right);
-        }
-
-        public static bool operator !=(RoundedDouble left, RoundedDouble right)
-        {
-            return !Equals(left, right);
-        }
-
         private static bool IsSpecialDoubleValue(double value)
         {
             return double.IsNaN(value) ||
Index: Core/Common/test/Core.Common.Base.Test/Data/RoundedDoubleTest.cs
===================================================================
diff -u -rf8eeb4e21d9e282d998f3f218593bfb0fec681b7 -r22f847897e3a8dcefbb04b51dd1fc346448cd62d
--- Core/Common/test/Core.Common.Base.Test/Data/RoundedDoubleTest.cs	(.../RoundedDoubleTest.cs)	(revision f8eeb4e21d9e282d998f3f218593bfb0fec681b7)
+++ Core/Common/test/Core.Common.Base.Test/Data/RoundedDoubleTest.cs	(.../RoundedDoubleTest.cs)	(revision 22f847897e3a8dcefbb04b51dd1fc346448cd62d)
@@ -21,6 +21,7 @@
 
             // Assert
             Assert.IsInstanceOf<IEquatable<RoundedDouble>>(roundedDouble);
+            Assert.IsInstanceOf<IEquatable<double>>(roundedDouble);
             Assert.AreEqual(numberOfDecimalPlaces, roundedDouble.NumberOfDecimalPlaces);
             Assert.AreEqual(0.0, roundedDouble.Value);
         }
@@ -379,6 +380,190 @@
             Assert.IsFalse(isNotEqual2);
         }
 
+        [Test]
+        [TestCase(987654321.0, 5)]
+        [TestCase(-9876543.1200, 2)]
+        public void Equals_RoundedDoubleEqualToDouble_ReturnTrue(
+            double value, int numberOfDecimalPlaces)
+        {
+            // Setup
+            var roundedDouble = new RoundedDouble(numberOfDecimalPlaces)
+            {
+                Value = value
+            };
 
+            // Call
+            var isEqual1 = roundedDouble.Equals(value);
+            var isEqual2 = value.Equals(roundedDouble);
+
+            // Assert
+            Assert.IsTrue(isEqual1);
+            Assert.IsTrue(isEqual2);
+        }
+
+        [Test]
+        [TestCase(987654321.1, 0)]
+        [TestCase(-9876543.1234, 2)]
+        public void Equals_RoundedDoubleNotEqualToDouble_ReturnFalse(
+            double value, int numberOfDecimalPlaces)
+        {
+            // Setup
+            var roundedDouble = new RoundedDouble(numberOfDecimalPlaces)
+            {
+                Value = value
+            };
+
+            // Call
+            var isEqual1 = roundedDouble.Equals(value);
+            var isEqual2 = value.Equals(roundedDouble);
+
+            // Assert
+            Assert.IsFalse(isEqual1);
+            Assert.IsFalse(isEqual2);
+        }
+
+        [Test]
+        public void Equals_RoundedDoubleTotallyDifferentFromDouble_ReturnFalse()
+        {
+            // Setup
+            var roundedDouble = new RoundedDouble(2)
+            {
+                Value = 1.23
+            };
+            double otherValue = 4.56;
+
+            // Call
+            var isEqual1 = roundedDouble.Equals(otherValue);
+            var isEqual2 = otherValue.Equals(roundedDouble);
+
+            // Assert
+            Assert.IsFalse(isEqual1);
+            Assert.IsFalse(isEqual2);
+        }
+
+        [Test]
+        public void GetHashCode_RoundedDoubleEqualToDouble_ReturnSameHashCode()
+        {
+            // Setup
+            double otherValue = 4.56;
+            var roundedDouble = new RoundedDouble(2)
+            {
+                Value = otherValue
+            };
+
+            // Precondition:
+            Assert.IsTrue(otherValue.Equals(roundedDouble));
+            
+            // Call
+            var hash1 = roundedDouble.GetHashCode();
+            var hash2 = otherValue.GetHashCode();
+
+            // Assert
+            Assert.AreEqual(hash1, hash2);
+        }
+
+        [Test]
+        public void DoubleEqualityOperator_DoubleIsEqualToRoundedDouble_ReturnTrue()
+        {
+            // Setup
+            double value = 1.234;
+            var roundedDouble = new RoundedDouble(4)
+            {
+                Value = value
+            };
+
+            // Precondition
+            Assert.IsTrue(roundedDouble.Equals(value));
+
+            // Call
+            var isEqual1 = value == roundedDouble;
+            var isEqual2 = roundedDouble == value;
+
+            // Assert
+            Assert.IsTrue(isEqual1);
+            Assert.IsTrue(isEqual2);
+        }
+
+        [Test]
+        public void DoubleEqualityOperator_DoubleIsNotEqualToRoundedDouble_ReturnFalse()
+        {
+            // Setup
+            double value = 1.234;
+            var roundedDouble = new RoundedDouble(4)
+            {
+                Value = 3.21543
+            };
+
+            // Precondition
+            Assert.IsFalse(roundedDouble.Equals(value));
+
+            // Call
+            var isEqual1 = value == roundedDouble;
+            var isEqual2 = roundedDouble == value;
+
+            // Assert
+            Assert.IsFalse(isEqual1);
+            Assert.IsFalse(isEqual2);
+        }
+
+        [Test]
+        public void DoubleInequalityOperator_DoubleIsEqualToRoundedDouble_ReturnFalse()
+        {
+            // Setup
+            double value = 1.234;
+            var roundedDouble = new RoundedDouble(4)
+            {
+                Value = value
+            };
+
+            // Precondition
+            Assert.IsTrue(roundedDouble.Equals(value));
+
+            // Call
+            var isEqual1 = value != roundedDouble;
+            var isEqual2 = roundedDouble != value;
+
+            // Assert
+            Assert.IsFalse(isEqual1);
+            Assert.IsFalse(isEqual2);
+        }
+
+        [Test]
+        public void DoubleInequalityOperator_DoubleIsNotEqualToRoundedDouble_ReturnTrue()
+        {
+            // Setup
+            double value = 1.234;
+            var roundedDouble = new RoundedDouble(4)
+            {
+                Value = 3.21543
+            };
+
+            // Precondition
+            Assert.IsFalse(roundedDouble.Equals(value));
+
+            // Call
+            var isEqual1 = value != roundedDouble;
+            var isEqual2 = roundedDouble != value;
+
+            // Assert
+            Assert.IsTrue(isEqual1);
+            Assert.IsTrue(isEqual2);
+        }
+
+        [Test]
+        public void ImplicitConversion_FromRoundedDoubleToDouble_ConvertedValueIsEqual()
+        {
+            // Setup
+            var roundedDouble = new RoundedDouble(4)
+            {
+                Value = 3.2154
+            };
+            
+            // Call
+            double convertedValue = roundedDouble;
+
+            // Assert
+            Assert.AreEqual(roundedDouble.Value, convertedValue);
+        }
     }
 }
\ No newline at end of file