subseq of points from start

frontend/src/Point.elm

@@ -1,4 +1,4 @@
-module Point exposing(Pos, Point, decoder, downsample, duration)
+module Point exposing(Pos, Point, decoder, downsample, duration, subseq)
 
 import Json.Decode as D
 
@@ -62,3 +62,13 @@ duration points =
     case points of
         (p::ps) -> (last p ps).time - p.time
         _ -> 0
+
+subseq points start dur =
+    case points of
+        [] -> []
+        (p::ps) ->
+            if p.time < start
+            then subseq ps start dur
+            else if p.time >= (start + dur)
+                 then []
+                 else p::(subseq ps start dur)

frontend/tests/PointTest.elm

@@ -1,6 +1,6 @@
 module PointTest exposing (specs)
 
-import Point exposing (Point, Pos, downsample)
+import Point exposing (Point, Pos, downsample, subseq)
 import Test exposing (..)
 import Expect exposing (Expectation)
 
@@ -19,17 +19,34 @@ maybe default val =
 
 specs: Test
 specs =
-    describe "downsample"
+    describe "Point"
-        [ test "it returns no more points than requested" <|
+        [ describe "downsample"
-              \_ ->
+              [ test "it returns no more points than requested" <|
-              let orig = (points 10)
+                    \_ ->
-                  sampled = Point.downsample 5 orig
+                    let orig = (points 10)
-              in Expect.equal 5 (List.length sampled)
+                        sampled = Point.downsample 5 orig
-        , test "it drops points which are too close together" <|
+                    in Expect.equal 5 (List.length sampled)
-              \_ ->
+              , test "it drops points which are too close together" <|
-              let orig = List.map newPoint [ 0, 1, 2, 3, 4, 10, 500, 1000 ]
+                  \_ ->
-                  sampled = Point.downsample 10 orig
+                      let orig = List.map newPoint [ 0, 1, 2, 3, 4, 10, 500, 1000 ]
-                  idx p = maybe 0 p.power
+                          sampled = Point.downsample 10 orig
-              in Expect.equalLists [0, 500, 1000] (List.map idx sampled)
+                          idx p = maybe 0 p.power
-
+                      in Expect.equalLists [0, 500, 1000] (List.map idx sampled)
+              ]
+        , describe "subseq"
+            [ test "chooses only points in the time range" <|
+                  \_ ->
+                  let orig = (points 50)
+                      s = 1731437087
+                      d = 40
+                      subs = subseq orig s d
+                  in Expect.equal True
+                      (List.all (\ p -> p.time >= s && p.time <= s + d) subs)
+            , test "is empty if no points" <|
+                  \_ ->
+                      Expect.equalLists [] (subseq [] 10 10)
+            , test "is empty if no time" <|
+                  \_ ->
+                      Expect.equalLists (subseq (points 50) 1731437067 0) []
+            ]
         ]