additional sequences class tests

src/main/java/gov/usgs/earthquake/nshmp/data/Sequences.java

@@ -20,6 +20,10 @@ public class Sequences {
 
   private Sequences() {}
 
+  /**
+   * Check that the supplied arrays are not empty, are the same size, and that
+   * the supplied xs increase monotonically.
+   */
   static void validateArrays(double[] xs, double[] ys) {
     checkArgument(xs.length > 0, "x-values may not be empty");
     checkArgument(xs.length == ys.length, "x- and y-values are different sizes");
@@ -30,9 +34,10 @@ public class Sequences {
 
   /**
    * Trim points from the start or end of a sequence for which y-values are
-   * zero. If no such leading or trailing points exist, sequence conatins only a
+   * zero. If no such leading or trailing points exist, sequence contains only a
    * single point, or all y-values are zero, method returns the supplied
-   * sequence.
+   * sequence. If supplied sequence is mutable, returned sequence is mutable;
+   * otherwise returned sequence is immutable.
    */
   static XySequence trim(ArrayXySequence xy) {
     if (xy.size() == 1 || xy.isClear()) {
@@ -93,7 +98,7 @@ public class Sequences {
     return ((int) Maths.round(((max - min) / delta), 6)) + 1;
   }
 
-  /*
+  /**
    * Ensure validity of sequence discretization parameters. Confirms that for a
    * specified range [min..max] and Δ that (1) min, max, and Δ are finite, (2)
    * max > min, and (3) Δ > 0. Returns the supplied Δ for use inline.
@@ -107,8 +112,9 @@ public class Sequences {
     return Δ;
   }
 
-  // TODO docs; consider moving to cumulate method in data/sequence package;
-  // not necessarily MFD specific
+  /**
+   * Create a new XySequence with reverse cumulative values.
+   */
   public static XySequence toCumulative(XySequence incremental) {
     MutableXySequence cumulative = MutableXySequence.copyOf(incremental);
     double sum = 0.0;
@@ -216,32 +222,12 @@ public class Sequences {
           : sequence;
     }
 
-    /*
-     * TODO clean
-     *
-     * Method rounds (max-min)/Δ to 1e-6 before casting to an integer to
-     * determine the number of elements in the sequence. If (max-min)/Δ is
-     * reasonably close to an integer but max is off by some double-precision
-     * error (e.g. 6.7999999999), then max of 6.8 will be the upper end of the
-     * sequence.
-     */
-    // private static double[] buildSequence(double min, double max, double Δ) {
-    // checkSequenceParameters(min, max, Δ);
-    // int size = ((int) Maths.round(((max - min) / Δ), 6)) + 1;
-    // checkArgument(Range.openClosed(0, 100000).contains(size), "sequence
-    // size");
-    // return IntStream.range(0, size)
-    // .mapToDouble(i -> min + Δ * i)
-    // .toArray();
-    // }
-
     private static double[] buildSequence(double min, double Δ, int size) {
       checkArgument(Range.openClosed(0, 100000).contains(size), "sequence size");
       return IntStream.range(0, size)
           .mapToDouble(i -> min + Δ * i)
           .toArray();
     }
-
   }
 
 }

src/test/java/gov/usgs/earthquake/nshmp/data/SequencesTests.java

 package gov.usgs.earthquake.nshmp.data;
 
 import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertSame;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 
 import java.util.Arrays;
+import java.util.Optional;
 
 import org.junit.jupiter.api.Test;
 
@@ -12,6 +15,76 @@ import com.google.common.primitives.Doubles;
 
 class SequencesTests {
 
+  @Test
+  final void validateArraysTests() {
+    // empty xs array
+    assertThrows(IllegalArgumentException.class, () -> {
+      Sequences.validateArrays(new double[0], new double[0]);
+    });
+    // xs and ys different sizes
+    assertThrows(IllegalArgumentException.class, () -> {
+      Sequences.validateArrays(new double[2], new double[3]);
+    });
+    // xs not monotonic
+    assertThrows(IllegalArgumentException.class, () -> {
+      Sequences.validateArrays(new double[] { 1, 0 }, new double[2]);
+    });
+    // xs not monotonic
+    assertDoesNotThrow(() -> {
+      Sequences.validateArrays(new double[] { 0, 1 }, new double[2]);
+    });
+    // single values makes it through monotonic test
+    assertDoesNotThrow(() -> {
+      Sequences.validateArrays(new double[1], new double[1]);
+    });
+  }
+
+  @Test
+  final void trimTests() {
+    double[] xs1 = new double[1];
+    double[] ys1 = new double[1];
+
+    double[] xs3 = new double[] { 1, 2, 3 };
+    double[] ys3zero = new double[3];
+    double[] ys3ones = new double[] { 1, 1, 1 };
+
+    // size and clear check
+    ArrayXySequence xy1 = (ArrayXySequence) XySequence.create(xs1, ys1);
+    assertSame(xy1, Sequences.trim(xy1));
+    ArrayXySequence xy3a = (ArrayXySequence) XySequence.create(xs3, ys3zero);
+    assertSame(xy3a, Sequences.trim(xy3a));
+
+    // start and end y values > 0
+    ArrayXySequence xy3b = (ArrayXySequence) XySequence.create(xs3, ys3ones);
+    assertSame(xy3b, Sequences.trim(xy3b));
+
+    double[] xs4toTrim = new double[] { 1, 2, 3, 4 };
+    double[] ys4toTrim = new double[] { 1, 1, 1, 0 };
+    double[] xs4expect = new double[] { 1, 2, 3 };
+    double[] ys4expect = new double[] { 1, 1, 1 };
+
+    // extra test that gets upper end y = 0
+    ArrayXySequence xy4toTrim = (ArrayXySequence) XySequence.create(xs4toTrim, ys4toTrim);
+    ArrayXySequence xy4expect = (ArrayXySequence) XySequence.create(xs4expect, ys4expect);
+    assertEquals(xy4expect, Sequences.trim(xy4toTrim));
+
+    double[] xs5toTrim = new double[] { 1, 2, 3, 4, 5 };
+    double[] ys5toTrim = new double[] { 0, 1, 1, 1, 0 };
+    double[] xs5expect = new double[] { 2, 3, 4 };
+    double[] ys5expect = new double[] { 1, 1, 1 };
+
+    // immutable trimmed
+    ArrayXySequence xy5toTrim = (ArrayXySequence) XySequence.create(xs5toTrim, ys5toTrim);
+    ArrayXySequence xy5expect = (ArrayXySequence) XySequence.create(xs5expect, ys5expect);
+    assertEquals(xy5expect, Sequences.trim(xy5toTrim));
+
+    // mutable trimmed
+    MutableArrayXySequence xy5toTrimMutable = (MutableArrayXySequence) MutableXySequence.create(
+        xs5toTrim,
+        Optional.of(ys5toTrim));
+    assertEquals(xy5expect, Sequences.trim(xy5toTrimMutable));
+  }
+
   @Test
   final void nonZeroIndexTests() {
     double[] values = new double[] { 0.0, 0.0, 1.0, 1.0, 0.0, 0.0 };
@@ -25,6 +98,17 @@ class SequencesTests {
     assertEquals(-1, Sequences.lastNonZeroIndex(zeros), 0.0);
   }
 
+  @Test
+  final void toCumulativeTests() {
+    double[] xs = new double[] { 1, 2, 3, 4, 5 };
+    double[] ys = new double[] { 1, 1, 1, 1, 1 };
+    double[] ysExpect = new double[] { 5, 4, 3, 2, 1 };
+
+    XySequence xyActual = Sequences.toCumulative(XySequence.create(xs, ys));
+    XySequence xyExpect = XySequence.create(xs, ysExpect);
+    assertEquals(xyExpect, xyActual);
+  }
+
   @Test
   final void arrayBuilderTests() {