pocv comparisons use +/- sigma

graph/DelayNormal1.cc

@@ -24,6 +24,8 @@
 #include "Fuzzy.hh"
 #include "Units.hh"
 #include "StaState.hh"
+// temporary hack
+#include "Sta.hh"
 
 // SSTA compilation.
 #if (SSTA == 1)
@@ -162,32 +164,31 @@ Delay::operator-=(const Delay &delay)
 bool
 Delay::operator==(const Delay &delay) const
 {
-  return mean_ == delay.mean_
+  return fuzzyEqual(*this, delay);
-    && sigma2_ == delay.sigma2_;
 }
 
 bool
 Delay::operator>(const Delay &delay) const
 {
-  return mean_ > delay.mean_;
+  return fuzzyGreater(*this, delay);
 }
 
 bool
 Delay::operator>=(const Delay &delay) const
 {
-  return mean_ >= delay.mean_;
+  return fuzzyGreaterEqual(*this, delay);
 }
 
 bool
 Delay::operator<(const Delay &delay) const
 {
-  return mean_ < delay.mean_;
+  return fuzzyLess(*this, delay);
 }
 
 bool
 Delay::operator<=(const Delay &delay) const
 {
-  return mean_ <= delay.mean_;
+  return fuzzyLessEqual(*this, delay);
 }
 
 ////////////////////////////////////////////////////////////////
@@ -241,28 +242,36 @@ bool
 fuzzyLess(const Delay &delay1,
 	  const Delay &delay2)
 {
-  return fuzzyLess(delay1.mean(), delay2.mean());
+  Sta *sta = Sta::sta();
+  return fuzzyLess(delayAsFloat(delay1, EarlyLate::early(), sta),
+		   delayAsFloat(delay2, EarlyLate::early(), sta));
 }
 
 bool
 fuzzyLess(const Delay &delay1,
 	  float delay2)
 {
-  return fuzzyLess(delay1.mean(), delay2);
+  Sta *sta = Sta::sta();
+  return fuzzyLess(delayAsFloat(delay1, EarlyLate::early(), sta),
+		   delay2);
 }
 
 bool
 fuzzyLessEqual(const Delay &delay1,
 	       const Delay &delay2)
 {
-  return fuzzyLessEqual(delay1.mean(), delay2.mean());
+  Sta *sta = Sta::sta();
+  return fuzzyLessEqual(delayAsFloat(delay1, EarlyLate::early(), sta),
+			delayAsFloat(delay2, EarlyLate::early(), sta));
 }
 
 bool
 fuzzyLessEqual(const Delay &delay1,
 	       float delay2)
 {
-  return fuzzyLessEqual(delay1.mean(), delay2);
+  Sta *sta = Sta::sta();
+  return fuzzyLessEqual(delayAsFloat(delay1, EarlyLate::early(), sta),
+			delay2);
 }
 
 bool
@@ -271,37 +280,45 @@ fuzzyLessEqual(const Delay &delay1,
 	       const MinMax *min_max)
 {
   if (min_max == MinMax::max())
-    return fuzzyLessEqual(delay1.mean(), delay2.mean());
+    return fuzzyLessEqual(delay1, delay2);
   else
-    return fuzzyGreaterEqual(delay1.mean(), delay2.mean());
+    return fuzzyGreaterEqual(delay1, delay2);
 }
 
 bool
 fuzzyGreater(const Delay &delay1,
 	     const Delay &delay2)
 {
-  return fuzzyGreater(delay1.mean(), delay2.mean());
+  Sta *sta = Sta::sta();
+  return fuzzyGreater(delayAsFloat(delay1, EarlyLate::late(), sta),
+		      delayAsFloat(delay2, EarlyLate::late(), sta));
 }
 
 bool
 fuzzyGreater(const Delay &delay1,
 	     float delay2)
 {
-  return fuzzyGreater(delay1.mean(), delay2);
+  Sta *sta = Sta::sta();
+  return fuzzyGreater(delayAsFloat(delay1, EarlyLate::late(), sta),
+		      delay2);
 }
 
 bool
 fuzzyGreaterEqual(const Delay &delay1,
 		  const Delay &delay2)
 {
-  return fuzzyGreaterEqual(delay1.mean(), delay2.mean());
+  Sta *sta = Sta::sta();
+  return fuzzyGreaterEqual(delayAsFloat(delay1, EarlyLate::late(), sta),
+			   delayAsFloat(delay2, EarlyLate::late(), sta));
 }
 
 bool
 fuzzyGreaterEqual(const Delay &delay1,
 		  float delay2)
 {
-  return fuzzyGreaterEqual(delay1.mean(), delay2);
+  Sta *sta = Sta::sta();
+  return fuzzyGreaterEqual(delayAsFloat(delay1, EarlyLate::late(), sta),
+			   delay2);
 }
 
 bool
@@ -310,9 +327,9 @@ fuzzyGreater(const Delay &delay1,
 	     const MinMax *min_max)
 {
   if (min_max == MinMax::max())
-    return fuzzyGreater(delay1.mean(), delay2.mean());
+    return fuzzyGreater(delay1, delay2);
   else
-    return fuzzyLess(delay1.mean(), delay2.mean());
+    return fuzzyLess(delay1, delay2);
 }
 
 bool
@@ -321,9 +338,9 @@ fuzzyGreaterEqual(const Delay &delay1,
 		  const MinMax *min_max)
 {
   if (min_max == MinMax::max())
-    return fuzzyGreaterEqual(delay1.mean(), delay2.mean());
+    return fuzzyGreaterEqual(delay1, delay2);
   else
-    return fuzzyLessEqual(delay1.mean(), delay2.mean());
+    return fuzzyLessEqual(delay1, delay2);
 }
 
 bool
@@ -332,9 +349,9 @@ fuzzyLess(const Delay &delay1,
 	  const MinMax *min_max)
 {
   if (min_max == MinMax::max())
-    return fuzzyLess(delay1.mean(), delay2.mean());
+    return fuzzyLess(delay1, delay2);
   else
-    return fuzzyGreater(delay1.mean(), delay2.mean());
+    return fuzzyGreater(delay1, delay2);
 }
 
 float

graph/DelayNormal2.cc

@@ -190,25 +190,25 @@ Delay::operator==(const Delay &delay) const
 bool
 Delay::operator>(const Delay &delay) const
 {
-  return mean_ > delay.mean_;
+  return mean_ + sqrt(sigma2_late_) > delay.mean_ + sqrt(delay.sigma2_late_);
 }
 
 bool
 Delay::operator>=(const Delay &delay) const
 {
-  return mean_ >= delay.mean_;
+  return mean_ + sqrt(sigma2_late_) >= delay.mean_ + sqrt(delay.sigma2_late_);
 }
 
 bool
 Delay::operator<(const Delay &delay) const
 {
-  return mean_ < delay.mean_;
+  return mean_ - sqrt(sigma2_early_) < delay.mean_ - sqrt(delay.sigma2_early_);
 }
 
 bool
 Delay::operator<=(const Delay &delay) const
 {
-  return mean_ <= delay.mean_;
+  return mean_ - sqrt(sigma2_early_) <= delay.mean_ - sqrt(delay.sigma2_early_);
 }
 
 ////////////////////////////////////////////////////////////////
@@ -265,28 +265,36 @@ bool
 fuzzyLess(const Delay &delay1,
 	  const Delay &delay2)
 {
-  return fuzzyLess(delay1.mean(), delay2.mean());
+  Sta *sta = Sta::sta();
+  return fuzzyLess(delayAsFloat(delay1, EarlyLate::early(), sta),
+		   delayAsFloat(delay2, EarlyLate::early(), sta));
 }
 
 bool
 fuzzyLess(const Delay &delay1,
 	  float delay2)
 {
-  return fuzzyLess(delay1.mean(), delay2);
+  Sta *sta = Sta::sta();
+  return fuzzyLess(delayAsFloat(delay1, EarlyLate::early(), sta),
+		   delay2);
 }
 
 bool
 fuzzyLessEqual(const Delay &delay1,
 	       const Delay &delay2)
 {
-  return fuzzyLessEqual(delay1.mean(), delay2.mean());
+  Sta *sta = Sta::sta();
+  return fuzzyLessEqual(delayAsFloat(delay1, EarlyLate::early(), sta),
+			delayAsFloat(delay2, EarlyLate::early(), sta));
 }
 
 bool
 fuzzyLessEqual(const Delay &delay1,
 		    float delay2)
 {
-  return fuzzyLessEqual(delay1.mean(), delay2);
+  Sta *sta = Sta::sta();
+  return fuzzyLessEqual(delayAsFloat(delay1, EarlyLate::early(), sta),
+			delay2);
 }
 
 bool
@@ -295,37 +303,45 @@ fuzzyLessEqual(const Delay &delay1,
 	       const MinMax *min_max)
 {
   if (min_max == MinMax::max())
-    return fuzzyLessEqual(delay1.mean(), delay2.mean());
+    return fuzzyLessEqual(delay1, delay2);
   else
-    return fuzzyGreaterEqual(delay1.mean(), delay2.mean());
+    return fuzzyGreaterEqual(delay1, delay2);
 }
 
 bool
 fuzzyGreater(const Delay &delay1,
 	     const Delay &delay2)
 {
-  return fuzzyGreater(delay1.mean(), delay2.mean());
+  Sta *sta = Sta::sta();
+  return fuzzyGreater(delayAsFloat(delay1, EarlyLate::late(), sta),
+		      delayAsFloat(delay2, EarlyLate::late(), sta));
 }
 
 bool
 fuzzyGreater(const Delay &delay1,
 	     float delay2)
 {
-  return fuzzyGreater(delay1.mean(), delay2);
+  Sta *sta = Sta::sta();
+  return fuzzyGreaterEqual(delayAsFloat(delay1, EarlyLate::late(), sta),
+			   delayAsFloat(delay2, EarlyLate::late(), sta));
 }
 
 bool
 fuzzyGreaterEqual(const Delay &delay1,
 		  const Delay &delay2)
 {
-  return fuzzyGreaterEqual(delay1.mean(), delay2.mean());
+  Sta *sta = Sta::sta();
+  return fuzzyGreaterEqual(delayAsFloat(delay1, EarlyLate::late(), sta),
+			   delay2);
 }
 
 bool
 fuzzyGreaterEqual(const Delay &delay1,
 		  float delay2)
 {
-  return fuzzyGreaterEqual(delay1.mean(), delay2);
+  Sta *sta = Sta::sta();
+  return fuzzyGreaterEqual(delayAsFloat(delay1, EarlyLate::late(), sta),
+			   delay2);
 }
 
 bool
@@ -334,9 +350,9 @@ fuzzyGreater(const Delay &delay1,
 	     const MinMax *min_max)
 {
   if (min_max == MinMax::max())
-    return fuzzyGreater(delay1.mean(), delay2.mean());
+    return fuzzyGreater(delay1, delay2);
   else
-    return fuzzyLess(delay1.mean(), delay2.mean());
+    return fuzzyLess(delay1, delay2);
 }
 
 bool
@@ -345,9 +361,9 @@ fuzzyGreaterEqual(const Delay &delay1,
 		  const MinMax *min_max)
 {
   if (min_max == MinMax::max())
-    return fuzzyGreaterEqual(delay1.mean(), delay2.mean());
+    return fuzzyGreaterEqual(delay1, delay2);
   else
-    return fuzzyLessEqual(delay1.mean(), delay2.mean());
+    return fuzzyLessEqual(delay1, delay2);
 }
 
 bool
@@ -356,52 +372,9 @@ fuzzyLess(const Delay &delay1,
 	  const MinMax *min_max)
 {
   if (min_max == MinMax::max())
-    return fuzzyLess(delay1.mean(), delay2.mean());
+    return fuzzyLess(delay1, delay2);
   else
-    return fuzzyGreater(delay1.mean(), delay2.mean());
+    return fuzzyGreater(delay1, delay2);
-}
-
-Delay
-operator+(float delay1,
-	  const Delay &delay2)
-{
-  return Delay(delay1 + delay2.mean(),
-	       delay2.sigma2Early(),
-	       delay2.sigma2Late());
-}
-
-Delay
-operator/(float delay1,
-	  const Delay &delay2)
-{
-  return Delay(delay1 / delay2.mean(),
-	       delay2.sigma2Early(),
-	       delay2.sigma2Late());
-}
-
-Delay
-operator*(const Delay &delay1,
-	  float delay2)
-{
-  return Delay(delay1.mean() * delay2,
-	       delay1.sigma2Early() * delay2 * delay2,
-	       delay1.sigma2Late() * delay2 * delay2);
-}
-
-Delay
-delayRemove(const Delay &delay1,
-	    const Delay &delay2)
-{
-  return Delay(delay1.mean() - delay2.mean(),
-	       delay1.sigma2Early() - delay2.sigma2Early(),
-	       delay1.sigma2Late() - delay2.sigma2Late());
-}
-
-float
-delayRatio(const Delay &delay1,
-	   const Delay &delay2)
-{
-  return delay1.mean() / delay2.mean();
 }
 
 float
@@ -463,6 +436,49 @@ delayAsString(const Delay &delay,
   return sta->units()->timeUnit()->asString(mean_sigma, digits);
 }
 
+Delay
+delayRemove(const Delay &delay1,
+	    const Delay &delay2)
+{
+  return Delay(delay1.mean() - delay2.mean(),
+	       delay1.sigma2Early() - delay2.sigma2Early(),
+	       delay1.sigma2Late() - delay2.sigma2Late());
+}
+
+float
+delayRatio(const Delay &delay1,
+	   const Delay &delay2)
+{
+  return delay1.mean() / delay2.mean();
+}
+
+Delay
+operator+(float delay1,
+	  const Delay &delay2)
+{
+  return Delay(delay1 + delay2.mean(),
+	       delay2.sigma2Early(),
+	       delay2.sigma2Late());
+}
+
+Delay
+operator/(float delay1,
+	  const Delay &delay2)
+{
+  return Delay(delay1 / delay2.mean(),
+	       delay2.sigma2Early(),
+	       delay2.sigma2Late());
+}
+
+Delay
+operator*(const Delay &delay1,
+	  float delay2)
+{
+  return Delay(delay1.mean() * delay2,
+	       delay1.sigma2Early() * delay2 * delay2,
+	       delay1.sigma2Late() * delay2 * delay2);
+}
+
 } // namespace
 
 #endif // (SSTA == 2)