quantiler interface

dist/uv/interfaces.go

@@ -0,0 +1,7 @@
+package uv
+
+// Quantiler defines distributions that have computable quantiles. That is,
+// which accept a probability on [0,1] and return a member in their support.
+type Quantiler interface {
+	Quantile(p float64) (q float64, err error)
+}

dist/uv/lognormal.go

@@ -28,6 +28,11 @@ func NewLogNormal(location, scale float64) (ln *LogNormal, err error) {
 }
 
 // Quantile is the inverse function of the log normal CDF.
-func (ln *LogNormal) Quantile(p float64) float64 {
-	return math.Exp(ln.Location + ln.Scale*mathext.NormalQuantile(p))
+func (ln *LogNormal) Quantile(p float64) (q float64, err error) {
+	if p < 0 || p > 1 {
+		err := errors.New("probabilities must be between 0 and 1")
+		return q, err
+	}
+	q = math.Exp(ln.Location + ln.Scale*mathext.NormalQuantile(p))
+	return q, nil
 }

dist/uv/lognormal_test.go

@@ -61,9 +61,27 @@ func TestLogNormalQuantile(t *testing.T) {
 
 	ln, err := uv.NewLogNormal(loc, scale)
 	if err != nil {
-		t.Error("unexpected error in NewNormal,", err)
+		t.Error("unexpected error in NewLogNormal,", err)
 	}
-	if math.Abs(ln.Quantile(0.5)-math.Exp(loc)) > 1e-8 {
-		t.Errorf("expected median quantile %v, but got %v", math.Exp(loc), ln.Quantile(0.5))
+	q, err := ln.Quantile(0.5)
+	if err != nil {
+		t.Error("unexpected error in Quantile,", err)
+	}
+	if math.Abs(q-math.Exp(loc)) > 1e-8 {
+		t.Errorf("expected median quantile %v, but got %v", math.Exp(loc), q)
+	}
+}
+
+func TestLogNormalQuantileErrs(t *testing.T) {
+	loc := 0.0
+	scale := 1.0
+
+	ln, err := uv.NewLogNormal(loc, scale)
+	if err != nil {
+		t.Error("unexpected error in NewLogNormal,", err)
+	}
+	_, err = ln.Quantile(2)
+	if err == nil {
+		t.Error("expected error, but it was nil")
 	}
 }

dist/uv/normal.go

@@ -38,6 +38,11 @@ func (n *Normal) Variance() float64 {
 }
 
 // Quantile is the inverse function of the CDF.
-func (n *Normal) Quantile(p float64) float64 {
-	return n.Location + n.Scale*mathext.NormalQuantile(p)
+func (n *Normal) Quantile(p float64) (q float64, err error) {
+	if p < 0 || p > 1 {
+		err := errors.New("probabilities must be between 0 and 1")
+		return q, err
+	}
+	q = n.Location + n.Scale*mathext.NormalQuantile(p)
+	return q, nil
 }

dist/uv/normal_test.go

@@ -28,7 +28,6 @@ func TestNewNormal(t *testing.T) {
 			if n.Scale != tc.scale {
 				t.Errorf("expected Scale %v, but got %v", tc.scale, n.Scale)
 			}
-
 		})
 	}
 }
@@ -88,7 +87,25 @@ func TestNormalQuantile(t *testing.T) {
 	if err != nil {
 		t.Error("unexpected error in NewNormal,", err)
 	}
-	if math.Abs(n.Quantile(0.5)-loc) > 1e-8 {
-		t.Errorf("expected median quantile %v, but got %v", loc, n.Quantile(0.5))
+	q, err := n.Quantile(0.5)
+	if err != nil {
+		t.Error("unexpected error in Quantile,", err)
+	}
+	if math.Abs(q-loc) > 1e-8 {
+		t.Errorf("expected median quantile %v, but got %v", loc, q)
+	}
+}
+
+func TestNormalQuantileErrs(t *testing.T) {
+	loc := 0.0
+	scale := 1.0
+
+	n, err := uv.NewNormal(loc, scale)
+	if err != nil {
+		t.Error("unexpected error in NewNormal,", err)
+	}
+	_, err = n.Quantile(2)
+	if err == nil {
+		t.Error("expected error, but it was nil")
 	}
 }