Index: Ringtoets/Piping/src/Ringtoets.Piping.Forms/PropertyClasses/PipingSemiProbabilisticOutputProperties.cs
===================================================================
diff -u -r37e31f1893a9cfe14e9f05779eb6a0e12f6d7b6b -rcfefec5a1180c70370d17ae82a7629e0d2ac24b7
--- Ringtoets/Piping/src/Ringtoets.Piping.Forms/PropertyClasses/PipingSemiProbabilisticOutputProperties.cs	(.../PipingSemiProbabilisticOutputProperties.cs)	(revision 37e31f1893a9cfe14e9f05779eb6a0e12f6d7b6b)
+++ Ringtoets/Piping/src/Ringtoets.Piping.Forms/PropertyClasses/PipingSemiProbabilisticOutputProperties.cs	(.../PipingSemiProbabilisticOutputProperties.cs)	(revision cfefec5a1180c70370d17ae82a7629e0d2ac24b7)
@@ -1,3 +1,4 @@
+using Core.Common.Base.Data;
 using Core.Common.Gui.PropertyBag;
 using Core.Common.Utils.Attributes;
 using Ringtoets.Piping.Data;
@@ -10,7 +11,7 @@
         [ResourcesCategory(typeof(Resources), "PipingSemiProbabilisticOutput_Categories_Uplift")]
         [ResourcesDisplayName(typeof(Resources), "PipingSemiProbabilisticOutput_UpliftFactorOfSafety_DisplayName")]
         [ResourcesDescription(typeof(Resources), "PipingSemiProbabilisticOutput_UpliftFactorOfSafety_Description")]
-        public double UpliftFactorOfSafety
+        public RoundedDouble UpliftFactorOfSafety
         {
             get
             {
@@ -21,7 +22,7 @@
         [ResourcesCategory(typeof(Resources), "PipingSemiProbabilisticOutput_Categories_Uplift")]
         [ResourcesDisplayName(typeof(Resources), "PipingSemiProbabilisticOutput_UpliftReliability_DisplayName")]
         [ResourcesDescription(typeof(Resources), "PipingSemiProbabilisticOutput_UpliftReliability_Description")]
-        public double UpliftReliability
+        public RoundedDouble UpliftReliability
         {
             get
             {
@@ -32,7 +33,7 @@
         [ResourcesCategory(typeof(Resources), "PipingSemiProbabilisticOutput_Categories_Uplift")]
         [ResourcesDisplayName(typeof(Resources), "PipingSemiProbabilisticOutput_UpliftProbability_DisplayName")]
         [ResourcesDescription(typeof(Resources), "PipingSemiProbabilisticOutput_UpliftProbability_Description")]
-        public double UpliftProbability
+        public RoundedDouble UpliftProbability
         {
             get
             {
@@ -43,7 +44,7 @@
         [ResourcesCategory(typeof(Resources), "PipingSemiProbabilisticOutput_Categories_Heave")]
         [ResourcesDisplayName(typeof(Resources), "PipingSemiProbabilisticOutput_HeaveFactorOfSafety_DisplayName")]
         [ResourcesDescription(typeof(Resources), "PipingSemiProbabilisticOutput_HeaveFactorOfSafety_Description")]
-        public double HeaveFactorOfSafety
+        public RoundedDouble HeaveFactorOfSafety
         {
             get
             {
@@ -54,7 +55,7 @@
         [ResourcesCategory(typeof(Resources), "PipingSemiProbabilisticOutput_Categories_Heave")]
         [ResourcesDisplayName(typeof(Resources), "PipingSemiProbabilisticOutput_HeaveReliability_DisplayName")]
         [ResourcesDescription(typeof(Resources), "PipingSemiProbabilisticOutput_HeaveReliability_Description")]
-        public double HeaveReliability
+        public RoundedDouble HeaveReliability
         {
             get
             {
@@ -65,7 +66,7 @@
         [ResourcesCategory(typeof(Resources), "PipingSemiProbabilisticOutput_Categories_Heave")]
         [ResourcesDisplayName(typeof(Resources), "PipingSemiProbabilisticOutput_HeaveProbability_DisplayName")]
         [ResourcesDescription(typeof(Resources), "PipingSemiProbabilisticOutput_HeaveProbability_Description")]
-        public double HeaveProbability
+        public RoundedDouble HeaveProbability
         {
             get
             {
@@ -76,7 +77,7 @@
         [ResourcesCategory(typeof(Resources), "PipingSemiProbabilisticOutput_Categories_Sellmeijer")]
         [ResourcesDisplayName(typeof(Resources), "PipingSemiProbabilisticOutput_SellmeijerFactorOfSafety_DisplayName")]
         [ResourcesDescription(typeof(Resources), "PipingSemiProbabilisticOutput_SellmeijerFactorOfSafety_Description")]
-        public double SellmeijerFactorOfSafety
+        public RoundedDouble SellmeijerFactorOfSafety
         {
             get
             {
@@ -87,7 +88,7 @@
         [ResourcesCategory(typeof(Resources), "PipingSemiProbabilisticOutput_Categories_Sellmeijer")]
         [ResourcesDisplayName(typeof(Resources), "PipingSemiProbabilisticOutput_SellmeijerReliability_DisplayName")]
         [ResourcesDescription(typeof(Resources), "PipingSemiProbabilisticOutput_SellmeijerReliability_Description")]
-        public double SellmeijerReliability
+        public RoundedDouble SellmeijerReliability
         {
             get
             {
@@ -98,7 +99,7 @@
         [ResourcesCategory(typeof(Resources), "PipingSemiProbabilisticOutput_Categories_Sellmeijer")]
         [ResourcesDisplayName(typeof(Resources), "PipingSemiProbabilisticOutput_SellmeijerProbability_DisplayName")]
         [ResourcesDescription(typeof(Resources), "PipingSemiProbabilisticOutput_SellmeijerProbability_Description")]
-        public double SellmeijerProbability
+        public RoundedDouble SellmeijerProbability
         {
             get
             {
@@ -109,7 +110,7 @@
         [ResourcesCategory(typeof(Resources), "PipingSemiProbabilisticOutput_Categories_Piping")]
         [ResourcesDisplayName(typeof(Resources), "PipingSemiProbabilisticOutput_RequiredProbability_DisplayName")]
         [ResourcesDescription(typeof(Resources), "PipingSemiProbabilisticOutput_RequiredProbability_Description")]
-        public double RequiredProbability
+        public RoundedDouble RequiredProbability
         {
             get
             {
@@ -120,7 +121,7 @@
         [ResourcesCategory(typeof(Resources), "PipingSemiProbabilisticOutput_Categories_Piping")]
         [ResourcesDisplayName(typeof(Resources), "PipingSemiProbabilisticOutput_RequiredReliability_DisplayName")]
         [ResourcesDescription(typeof(Resources), "PipingSemiProbabilisticOutput_RequiredReliability_Description")]
-        public double RequiredReliability
+        public RoundedDouble RequiredReliability
         {
             get
             {
@@ -131,7 +132,7 @@
         [ResourcesCategory(typeof(Resources), "PipingSemiProbabilisticOutput_Categories_Piping")]
         [ResourcesDisplayName(typeof(Resources), "PipingSemiProbabilisticOutput_PipingProbability_DisplayName")]
         [ResourcesDescription(typeof(Resources), "PipingSemiProbabilisticOutput_PipingProbability_Description")]
-        public double PipingProbability
+        public RoundedDouble PipingProbability
         {
             get
             {
@@ -142,7 +143,7 @@
         [ResourcesCategory(typeof(Resources), "PipingSemiProbabilisticOutput_Categories_Piping")]
         [ResourcesDisplayName(typeof(Resources), "PipingSemiProbabilisticOutput_PipingReliability_DisplayName")]
         [ResourcesDescription(typeof(Resources), "PipingSemiProbabilisticOutput_PipingReliability_Description")]
-        public double PipingReliability
+        public RoundedDouble PipingReliability
         {
             get
             {
@@ -153,7 +154,7 @@
         [ResourcesCategory(typeof(Resources), "PipingSemiProbabilisticOutput_Categories_Piping")]
         [ResourcesDisplayName(typeof(Resources), "PipingSemiProbabilisticOutput_PipingFactorOfSafety_DisplayName")]
         [ResourcesDescription(typeof(Resources), "PipingSemiProbabilisticOutput_PipingFactorOfSafety_Description")]
-        public double PipingFactorOfSafety
+        public RoundedDouble PipingFactorOfSafety
         {
             get
             {
Index: Ringtoets/Piping/src/Ringtoets.Piping.Service/PipingSemiProbabilisticCalculationService.cs
===================================================================
diff -u -r37e31f1893a9cfe14e9f05779eb6a0e12f6d7b6b -rcfefec5a1180c70370d17ae82a7629e0d2ac24b7
--- Ringtoets/Piping/src/Ringtoets.Piping.Service/PipingSemiProbabilisticCalculationService.cs	(.../PipingSemiProbabilisticCalculationService.cs)	(revision 37e31f1893a9cfe14e9f05779eb6a0e12f6d7b6b)
+++ Ringtoets/Piping/src/Ringtoets.Piping.Service/PipingSemiProbabilisticCalculationService.cs	(.../PipingSemiProbabilisticCalculationService.cs)	(revision cfefec5a1180c70370d17ae82a7629e0d2ac24b7)
@@ -48,7 +48,7 @@
         /// <param name="constantB">The constant b.</param>
         /// <param name="assessmentSectionLength">The length of the assessment section.</param>
         /// <param name="contribution">The contribution of piping to the total failure.</param>
-        public PipingSemiProbabilisticCalculationService(double upliftFactorOfSafety, double heaveFactorOfSafety, double sellmeijerFactorOfSafety, int returnPeriod, double constantA, double constantB, double assessmentSectionLength, double contribution)
+        private PipingSemiProbabilisticCalculationService(double upliftFactorOfSafety, double heaveFactorOfSafety, double sellmeijerFactorOfSafety, int returnPeriod, double constantA, double constantB, double assessmentSectionLength, double contribution)
         {
             this.heaveFactorOfSafety = heaveFactorOfSafety;
             this.upliftFactorOfSafety = upliftFactorOfSafety;
@@ -65,13 +65,13 @@
         /// </summary>
         /// <param name="calculation">The calculation which is used as input for the semi-probabilistic assessment. If the semi-
         /// probabilistic calculation is successful, <see cref="PipingCalculation.SemiProbabilisticOutput"/> is set.</param>
-        /// <exception cref="ArgumentNullException">Thrown when calculation has no output from a piping calculation.</exception>
+        /// <exception cref="ArgumentException">Thrown when calculation has no output from a piping calculation.</exception>
         public static void Calculate(PipingCalculation calculation)
         {
             ValidateOutputOnCalculation(calculation);
 
             SemiProbabilisticPipingInput semiProbabilisticParameters = calculation.SemiProbabilisticParameters;
-            var pipingOutput = calculation.Output;
+            PipingOutput pipingOutput = calculation.Output;
 
             var calculator = new PipingSemiProbabilisticCalculationService(
                 pipingOutput.UpliftFactorOfSafety,
@@ -81,7 +81,8 @@
                 semiProbabilisticParameters.A,
                 semiProbabilisticParameters.B,
                 semiProbabilisticParameters.SectionLength,
-                semiProbabilisticParameters.Contribution / 100);
+                semiProbabilisticParameters.Contribution/100);
+
             calculator.Calculate();
 
             calculation.SemiProbabilisticOutput = new PipingSemiProbabilisticOutput(
@@ -102,90 +103,66 @@
                 );
         }
 
+        /// <summary>
+        /// Performs the full semi-probabilistic calculation while setting intermediate results.
+        /// </summary>
         private void Calculate()
         {
-            FailureProbabilityUplift();
-            FailureProbabilityHeave();
-            FailureProbabilitySellmeijer();
-            BetaCrossPiping();
-            BetaCrossRequired();
-            FactorOfSafety();
+            CalculatePipingReliability();
+
+            CalculateRequiredReliability();
+
+            pipingFactorOfSafety = requiredReliability/pipingReliability;
         }
 
         /// <summary>
-        /// Returns the failure probability of the uplift sub mechanism.
+        /// Calculates the required reliability based on the norm and length of the assessment section and the contribution of piping.
         /// </summary>
-        /// <returns>A value represening failure probability.</returns>
-        public double FailureProbabilityUplift()
+        private void CalculateRequiredReliability()
         {
-            upliftReliability = SubMechanismReliability(upliftFactorOfSafety, upliftFactors);
-            upliftProbability = ReliabilityToProbability(upliftReliability);
-            return upliftProbability;
+            requiredProbability = RequiredProbability();
+            requiredReliability = ProbabilityToReliability(requiredProbability);
         }
 
         /// <summary>
-        /// Returns the failure probability of the heave sub mechanism.
+        /// Calculates the reliability of piping based on the factors of safety from the sub-mechanisms.
         /// </summary>
-        /// <returns>A value represening failure probability.</returns>
-        public double FailureProbabilityHeave()
+        private void CalculatePipingReliability()
         {
+            upliftReliability = SubMechanismReliability(upliftFactorOfSafety, upliftFactors);
+            upliftProbability = ReliabilityToProbability(upliftReliability);
+
             heaveReliability = SubMechanismReliability(heaveFactorOfSafety, heaveFactors);
             heaveProbability = ReliabilityToProbability(heaveReliability);
-            return heaveProbability;
-        }
 
-        /// <summary>
-        /// Returns the failure probability of the Sellmeijer sub mechanism.
-        /// </summary>
-        /// <returns>A value represening failure probability.</returns>
-        public double FailureProbabilitySellmeijer()
-        {
             sellmeijerReliability = SubMechanismReliability(sellmeijerFactorOfSafety, sellmeijerFactors);
             sellmeijerProbability = ReliabilityToProbability(sellmeijerReliability);
-            return sellmeijerProbability;
-        }
 
-        /// <summary>
-        /// Returns the reliability index of the piping failure mechanism.
-        /// </summary>
-        /// <returns>A value representing the reliability.</returns>
-        public double BetaCrossPiping()
-        {
-            pipingProbability = Math.Min(Math.Min(heaveProbability, upliftProbability), sellmeijerProbability);
+            pipingProbability = PipingProbability(upliftProbability, heaveProbability, sellmeijerProbability);
             pipingReliability = ProbabilityToReliability(pipingProbability);
-            return pipingReliability;
         }
 
         /// <summary>
-        /// Returns the required reliability of the piping failure mechanism for the complete assessment section.
+        /// Calculates the probability of occurrence of the piping failure mechanism.
         /// </summary>
-        /// <returns>A value representing the required reliability.</returns>
-        public double BetaCrossRequired()
+        /// <param name="probabilityOfHeave">The calculated probability of the heave sub-mechanism.</param>
+        /// <param name="probabilityOfUplift">The calculated probability of the uplift sub-mechanism.</param>
+        /// <param name="probabilityOfSellmeijer">The calculated probability of the Sellmeijer sub-mechanism.</param>
+        /// <returns>A value representing the probability of occurrence of piping.</returns>
+        private static double PipingProbability(double probabilityOfHeave, double probabilityOfUplift, double probabilityOfSellmeijer)
         {
-            requiredProbability = (contribution/returnPeriod)/(1 + (constantA*assessmentSectionLength)/constantB);
-            requiredReliability = ProbabilityToReliability(requiredProbability);
-            return requiredReliability;
+            return Math.Min(Math.Min(probabilityOfHeave, probabilityOfUplift), probabilityOfSellmeijer);
         }
 
         /// <summary>
-        /// Returns the safety factor of piping based on the factor of safety of
-        /// the sub mechanisms.
+        /// Calculates the required probability of the piping failure mechanism for the complete assessment section.
         /// </summary>
-        /// <returns>A factor of safety value.</returns>
-        public double FactorOfSafety()
+        /// <returns>A value representing the required probability.</returns>
+        private double RequiredProbability()
         {
-            pipingFactorOfSafety = requiredReliability/pipingReliability;
-            return pipingFactorOfSafety;
+            return (contribution/returnPeriod)/(1 + (constantA*assessmentSectionLength)/constantB);
         }
 
-        private static void ValidateOutputOnCalculation(PipingCalculation calculation)
-        {
-            if (!calculation.HasOutput)
-            {
-                throw new ArgumentNullException("calculation", "Cannot perform a semi-probabilistic calculation without output form the piping kernel.");
-            }
-        }
-
         private double SubMechanismReliability(double factorOfSafety, SubCalculationFactors factors)
         {
             var norm = (1.0/returnPeriod);
@@ -194,12 +171,20 @@
             return (1/factors.A)*(Math.Log(factorOfSafety/factors.B) + (factors.C*bNorm));
         }
 
-        private double ReliabilityToProbability(double reliability)
+        private static void ValidateOutputOnCalculation(PipingCalculation calculation)
         {
+            if (!calculation.HasOutput)
+            {
+                throw new ArgumentException("Cannot perform a semi-probabilistic calculation without output form the piping kernel.");
+            }
+        }
+
+        private static double ReliabilityToProbability(double reliability)
+        {
             return Normal.CDF(0, 1, -reliability);
         }
 
-        private double ProbabilityToReliability(double probability)
+        private static double ProbabilityToReliability(double probability)
         {
             return Normal.InvCDF(0, 1, 1 - probability);
         }
Index: Ringtoets/Piping/test/Ringtoets.Piping.Data.Test/PipingSemiProbabilisticOutputTest.cs
===================================================================
diff -u -r37e31f1893a9cfe14e9f05779eb6a0e12f6d7b6b -rcfefec5a1180c70370d17ae82a7629e0d2ac24b7
--- Ringtoets/Piping/test/Ringtoets.Piping.Data.Test/PipingSemiProbabilisticOutputTest.cs	(.../PipingSemiProbabilisticOutputTest.cs)	(revision 37e31f1893a9cfe14e9f05779eb6a0e12f6d7b6b)
+++ Ringtoets/Piping/test/Ringtoets.Piping.Data.Test/PipingSemiProbabilisticOutputTest.cs	(.../PipingSemiProbabilisticOutputTest.cs)	(revision cfefec5a1180c70370d17ae82a7629e0d2ac24b7)
@@ -1,4 +1,5 @@
 using System;
+using Core.Common.Base.Data;
 using NUnit.Framework;
 
 namespace Ringtoets.Piping.Data.Test
@@ -43,20 +44,26 @@
                 pipingFactorOfSafety);
 
             // Assert
-            Assert.AreEqual(upliftFactorOfSafety, output.UpliftFactorOfSafety);
-            Assert.AreEqual(upliftReliability, output.UpliftReliability);
-            Assert.AreEqual(upliftProbability, output.UpliftProbability);
-            Assert.AreEqual(heaveFactorOfSafety, output.HeaveFactorOfSafety);
-            Assert.AreEqual(heaveReliability, output.HeaveReliability);
-            Assert.AreEqual(heaveProbability, output.HeaveProbability);
-            Assert.AreEqual(sellmeijerFactorOfSafety, output.SellmeijerFactorOfSafety);
-            Assert.AreEqual(sellmeijerReliability, output.SellmeijerReliability);
-            Assert.AreEqual(sellmeijerProbability, output.SellmeijerProbability);
-            Assert.AreEqual(requiredProbability, output.RequiredProbability);
-            Assert.AreEqual(requiredReliability, output.RequiredReliability);
-            Assert.AreEqual(pipingProbability, output.PipingProbability);
-            Assert.AreEqual(pipingReliability, output.PipingReliability);
-            Assert.AreEqual(pipingFactorOfSafety, output.PipingFactorOfSafety);
-        } 
+            Assert.AreEqual(upliftFactorOfSafety, output.UpliftFactorOfSafety, GetAccuracy(output.UpliftFactorOfSafety));
+            Assert.AreEqual(upliftReliability, output.UpliftReliability, GetAccuracy(output.UpliftReliability));
+            Assert.AreEqual(upliftProbability, output.UpliftProbability, GetAccuracy(output.UpliftProbability));
+            Assert.AreEqual(heaveFactorOfSafety, output.HeaveFactorOfSafety, GetAccuracy(output.HeaveFactorOfSafety));
+            Assert.AreEqual(heaveReliability, output.HeaveReliability, GetAccuracy(output.HeaveReliability));
+            Assert.AreEqual(heaveProbability, output.HeaveProbability, GetAccuracy(output.HeaveProbability));
+            Assert.AreEqual(sellmeijerFactorOfSafety, output.SellmeijerFactorOfSafety, GetAccuracy(output.SellmeijerFactorOfSafety));
+            Assert.AreEqual(sellmeijerReliability, output.SellmeijerReliability, GetAccuracy(output.SellmeijerReliability));
+            Assert.AreEqual(sellmeijerProbability, output.SellmeijerProbability, GetAccuracy(output.SellmeijerProbability));
+            Assert.AreEqual(requiredProbability, output.RequiredProbability, GetAccuracy(output.RequiredProbability));
+            Assert.AreEqual(requiredReliability, output.RequiredReliability, GetAccuracy(output.RequiredReliability));
+            Assert.AreEqual(pipingProbability, output.PipingProbability, GetAccuracy(output.PipingProbability));
+            Assert.AreEqual(pipingReliability, output.PipingReliability, GetAccuracy(output.PipingReliability));
+            Assert.AreEqual(pipingFactorOfSafety, output.PipingFactorOfSafety, GetAccuracy(output.PipingFactorOfSafety));
+        }
+
+
+        private static double GetAccuracy(RoundedDouble d)
+        {
+            return Math.Pow(10.0, -d.NumberOfDecimalPlaces);
+        }
     }
 }
\ No newline at end of file
Index: Ringtoets/Piping/test/Ringtoets.Piping.Forms.Test/PropertyClasses/PipingSemiProbabilisticOutputPropertiesTest.cs
===================================================================
diff -u -r37e31f1893a9cfe14e9f05779eb6a0e12f6d7b6b -rcfefec5a1180c70370d17ae82a7629e0d2ac24b7
--- Ringtoets/Piping/test/Ringtoets.Piping.Forms.Test/PropertyClasses/PipingSemiProbabilisticOutputPropertiesTest.cs	(.../PipingSemiProbabilisticOutputPropertiesTest.cs)	(revision 37e31f1893a9cfe14e9f05779eb6a0e12f6d7b6b)
+++ Ringtoets/Piping/test/Ringtoets.Piping.Forms.Test/PropertyClasses/PipingSemiProbabilisticOutputPropertiesTest.cs	(.../PipingSemiProbabilisticOutputPropertiesTest.cs)	(revision cfefec5a1180c70370d17ae82a7629e0d2ac24b7)
@@ -1,4 +1,5 @@
 using System;
+using Core.Common.Base.Data;
 using Core.Common.Gui.PropertyBag;
 using NUnit.Framework;
 using Ringtoets.Piping.Data;
@@ -63,20 +64,26 @@
             };
 
             // Call & Assert
-            Assert.AreEqual(upliftFactorOfSafety, properties.UpliftFactorOfSafety);
-            Assert.AreEqual(upliftReliability, properties.UpliftReliability);
-            Assert.AreEqual(upliftProbability, properties.UpliftProbability);
-            Assert.AreEqual(heaveFactorOfSafety, properties.HeaveFactorOfSafety);
-            Assert.AreEqual(heaveReliability, properties.HeaveReliability);
-            Assert.AreEqual(heaveProbability, properties.HeaveProbability);
-            Assert.AreEqual(sellmeijerFactorOfSafety, properties.SellmeijerFactorOfSafety);
-            Assert.AreEqual(sellmeijerReliability, properties.SellmeijerReliability);
-            Assert.AreEqual(sellmeijerProbability, properties.SellmeijerProbability);
-            Assert.AreEqual(requiredProbability, properties.RequiredProbability);
-            Assert.AreEqual(requiredReliability, properties.RequiredReliability);
-            Assert.AreEqual(pipingProbability, properties.PipingProbability);
-            Assert.AreEqual(pipingReliability, properties.PipingReliability);
-            Assert.AreEqual(pipingFactorOfSafety, properties.PipingFactorOfSafety);
+            Assert.AreEqual(upliftFactorOfSafety, properties.UpliftFactorOfSafety, GetAccuracy(properties.UpliftFactorOfSafety));
+            Assert.AreEqual(upliftReliability, properties.UpliftReliability, GetAccuracy(properties.UpliftReliability));
+            Assert.AreEqual(upliftProbability, properties.UpliftProbability, GetAccuracy(properties.UpliftProbability));
+            Assert.AreEqual(heaveFactorOfSafety, properties.HeaveFactorOfSafety, GetAccuracy(properties.HeaveFactorOfSafety));
+            Assert.AreEqual(heaveReliability, properties.HeaveReliability, GetAccuracy(properties.HeaveReliability));
+            Assert.AreEqual(heaveProbability, properties.HeaveProbability, GetAccuracy(properties.HeaveProbability));
+            Assert.AreEqual(sellmeijerFactorOfSafety, properties.SellmeijerFactorOfSafety, GetAccuracy(properties.SellmeijerFactorOfSafety));
+            Assert.AreEqual(sellmeijerReliability, properties.SellmeijerReliability, GetAccuracy(properties.SellmeijerReliability));
+            Assert.AreEqual(sellmeijerProbability, properties.SellmeijerProbability, GetAccuracy(properties.SellmeijerProbability));
+            Assert.AreEqual(requiredProbability, properties.RequiredProbability, GetAccuracy(properties.RequiredProbability));
+            Assert.AreEqual(requiredReliability, properties.RequiredReliability, GetAccuracy(properties.RequiredReliability));
+            Assert.AreEqual(pipingProbability, properties.PipingProbability, GetAccuracy(properties.PipingProbability));
+            Assert.AreEqual(pipingReliability, properties.PipingReliability, GetAccuracy(properties.PipingReliability));
+            Assert.AreEqual(pipingFactorOfSafety, properties.PipingFactorOfSafety, GetAccuracy(properties.PipingFactorOfSafety));
         }
+
+
+        private static double GetAccuracy(RoundedDouble d)
+        {
+            return Math.Pow(10.0, -d.NumberOfDecimalPlaces);
+        }
     }
 }
\ No newline at end of file
Index: Ringtoets/Piping/test/Ringtoets.Piping.Service.Test/PipingSemiProbabilisticCalculationServiceTest.cs
===================================================================
diff -u -r37e31f1893a9cfe14e9f05779eb6a0e12f6d7b6b -rcfefec5a1180c70370d17ae82a7629e0d2ac24b7
--- Ringtoets/Piping/test/Ringtoets.Piping.Service.Test/PipingSemiProbabilisticCalculationServiceTest.cs	(.../PipingSemiProbabilisticCalculationServiceTest.cs)	(revision 37e31f1893a9cfe14e9f05779eb6a0e12f6d7b6b)
+++ Ringtoets/Piping/test/Ringtoets.Piping.Service.Test/PipingSemiProbabilisticCalculationServiceTest.cs	(.../PipingSemiProbabilisticCalculationServiceTest.cs)	(revision cfefec5a1180c70370d17ae82a7629e0d2ac24b7)
@@ -1,4 +1,5 @@
 using System;
+using Core.Common.Base.Data;
 using Core.Common.TestUtil;
 using NUnit.Framework;
 using Ringtoets.Piping.Data;
@@ -27,10 +28,10 @@
             PipingSemiProbabilisticCalculationService.Calculate(calculation);
 
             // Call
-            double result = calculation.SemiProbabilisticOutput.UpliftProbability;
+            RoundedDouble result = calculation.SemiProbabilisticOutput.UpliftProbability;
 
             // Assert
-            Assert.AreEqual(expectedResult, result, 1e-8);
+            Assert.AreEqual(expectedResult, result, GetAccuracy(result));
         }
 
         [Test]
@@ -52,10 +53,10 @@
             PipingSemiProbabilisticCalculationService.Calculate(calculation);
 
             // Call
-            double result = calculation.SemiProbabilisticOutput.HeaveProbability;
+            RoundedDouble result = calculation.SemiProbabilisticOutput.HeaveProbability;
 
             // Assert
-            Assert.AreEqual(expectedResult, result, 1e-8);
+            Assert.AreEqual(expectedResult, result, GetAccuracy(result));
         }
 
         [Test]
@@ -77,10 +78,10 @@
             PipingSemiProbabilisticCalculationService.Calculate(calculation);
 
             // Call
-            double result = calculation.SemiProbabilisticOutput.SellmeijerProbability;
+            RoundedDouble result = calculation.SemiProbabilisticOutput.SellmeijerProbability;
 
             // Assert
-            Assert.AreEqual(expectedResult, result, 1e-8);
+            Assert.AreEqual(expectedResult, result, GetAccuracy(result));
         }
 
         [Test]
@@ -104,10 +105,10 @@
             PipingSemiProbabilisticCalculationService.Calculate(calculation);
 
             // Call
-            double result = calculation.SemiProbabilisticOutput.PipingReliability;
+            RoundedDouble result = calculation.SemiProbabilisticOutput.PipingReliability;
 
             // Assert
-            Assert.AreEqual(expectedResult, result, 1e-8);
+            Assert.AreEqual(expectedResult, result, GetAccuracy(result));
         }
 
         [Test]
@@ -130,10 +131,10 @@
             PipingSemiProbabilisticCalculationService.Calculate(calculation);
 
             // Call
-            double result = calculation.SemiProbabilisticOutput.RequiredReliability;
+            RoundedDouble result = calculation.SemiProbabilisticOutput.RequiredReliability;
 
             // Assert
-            Assert.AreEqual(expectedResult, result, 1e-8);
+            Assert.AreEqual(expectedResult, result, GetAccuracy(result));
         }
 
         [Test]
@@ -161,10 +162,10 @@
             PipingSemiProbabilisticCalculationService.Calculate(calculation); 
 
             // Call
-            double result = calculation.SemiProbabilisticOutput.PipingFactorOfSafety;
+            RoundedDouble result = calculation.SemiProbabilisticOutput.PipingFactorOfSafety;
 
             // Assert
-            Assert.AreEqual(expectedResult, result, 1e-8);
+            Assert.AreEqual(expectedResult, result, GetAccuracy(result));
         }
 
         [Test]
@@ -191,10 +192,10 @@
             PipingSemiProbabilisticCalculationService.Calculate(calculation); 
 
             // Call
-            double result = calculation.SemiProbabilisticOutput.PipingFactorOfSafety;
+            RoundedDouble result = calculation.SemiProbabilisticOutput.PipingFactorOfSafety;
 
             // Assert
-            Assert.AreEqual(calculation.SemiProbabilisticOutput.RequiredReliability / calculation.SemiProbabilisticOutput.PipingReliability, result, 1e-8);
+            Assert.AreEqual(calculation.SemiProbabilisticOutput.RequiredReliability / calculation.SemiProbabilisticOutput.PipingReliability, result, GetAccuracy(result));
         }
 
         [Test]
@@ -218,11 +219,12 @@
             PipingSemiProbabilisticCalculationService.Calculate(pipingCalculation);
 
             // Assert
-            Assert.AreEqual(1.134713444, pipingCalculation.SemiProbabilisticOutput.PipingFactorOfSafety, 1e-8);
+            RoundedDouble result = pipingCalculation.SemiProbabilisticOutput.PipingFactorOfSafety;
+            Assert.AreEqual(1.134713444, result, GetAccuracy(result));
         }
 
         [Test]
-        public void Calculate_MissingOutput_ThrowsArgumentNullException()
+        public void Calculate_MissingOutput_ThrowsArgumentException()
         {
             // Setup
             var generalInput = new GeneralPipingInput();
@@ -232,7 +234,7 @@
             TestDelegate test = () => PipingSemiProbabilisticCalculationService.Calculate(pipingCalculation);
 
             // Assert
-            TestHelper.AssertThrowsArgumentExceptionAndTestMessage<ArgumentNullException>(test, "Cannot perform a semi-probabilistic calculation without output form the piping kernel.");
+            TestHelper.AssertThrowsArgumentExceptionAndTestMessage<ArgumentException>(test, "Cannot perform a semi-probabilistic calculation without output form the piping kernel.");
         }
 
         private PipingCalculation AsPipingCalculation(PipingOutput pipingOutput, SemiProbabilisticPipingInput semiProbabilisticPipingInput)
@@ -242,5 +244,10 @@
                 Output = pipingOutput
             };
         }
+
+        private static double GetAccuracy(RoundedDouble d)
+        {
+            return Math.Pow(10.0, -d.NumberOfDecimalPlaces);
+        }
     }
 }
\ No newline at end of file