@khanacademy/perseus 19.0.0 → 19.1.1

package/src/util/geometry.test.ts

@@ -0,0 +1,75 @@
+import {clockwise, reverseVector} from "./geometry";
+
+describe("reverseVector", () => {
+    it("flips the sign of zero", () => {
+        // This is a characterization test for legacy behavior. It might not
+        // actually be desired behavior.
+        expect(reverseVector([0, 0])).toEqual([-0, -0]);
+    });
+
+    it("flips the sign of each component", () => {
+        expect(reverseVector([1, -5])).toEqual([-1, 5]);
+    });
+});
+
+describe("clockwise", () => {
+    it("returns false given no points", () => {
+        expect(clockwise([])).toBe(false);
+    });
+
+    it("returns false given a single point at the origin", () => {
+        expect(clockwise([[0, 0]])).toBe(false);
+    });
+
+    it("returns false given a single point not at the origin", () => {
+        expect(clockwise([[7, 7]])).toBe(false);
+    });
+
+    it("returns false given two identical points", () => {
+        expect(
+            clockwise([
+                [7, 7],
+                [7, 7],
+            ]),
+        ).toBe(false);
+    });
+
+    it("returns false given two different points", () => {
+        expect(
+            clockwise([
+                [8, 8],
+                [7, 7],
+            ]),
+        ).toBe(false);
+    });
+
+    it("returns true given a clockwise triangle in the first quadrant", () => {
+        expect(
+            clockwise([
+                [0, 1],
+                [1, 0],
+                [0, 0],
+            ]),
+        ).toBe(true);
+    });
+
+    it("returns false given a counter-clockwise triangle in the first quadrant", () => {
+        expect(
+            clockwise([
+                [1, 0],
+                [0, 1],
+                [0, 0],
+            ]),
+        ).toBe(false);
+    });
+
+    it("returns true given a clockwise triangle in the second quadrant", () => {
+        expect(
+            clockwise([
+                [0, 1],
+                [0, 0],
+                [-1, 0],
+            ]),
+        ).toBe(true);
+    });
+});

package/src/util/geometry.ts

@@ -7,6 +7,8 @@ import _ from "underscore";
 
 import Util from "../util";
 
+import {sum} from "./math";
+
 import type {Coord, Line} from "../interactive2/types";
 
 const {eq, deepEq} = Util;
@@ -83,6 +85,23 @@ export function vector(a, b) {
     });
 }
 
+export function reverseVector(vector: Coord): Coord {
+    return [-vector[0], -vector[1]];
+}
+
+// Returns whether connecting the given sequence of `points` forms a clockwise
+// path (assuming a closed loop, where the last point connects back to the
+// first).
+export function clockwise(points: Coord[]): boolean {
+    const segments = _.zip(points, points.slice(1).concat(points.slice(0, 1)));
+    const areas = _.map(segments, function (segment) {
+        const p1 = segment[0];
+        const p2 = segment[1];
+        return (p2[0] - p1[0]) * (p2[1] + p1[1]);
+    });
+    return sum(areas) > 0;
+}
+
 export function magnitude(v: ReadonlyArray<Coord>): number {
     return Math.sqrt(
         _.reduce(