@khanacademy/kmath 0.0.4 → 0.0.6

package/.babelrc.js

@@ -5,4 +5,4 @@
  *
  * We should remove this when jest is fixed.
  */
-module.exports = require("../../config/build/babel.config");
+module.exports = require("../../config/build/babel.config.js");

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @khanacademy/kmath
 
+## 0.0.6
+
+### Patch Changes
+
+-   98d283ff: Fix storybook
+
+## 0.0.5
+
+### Patch Changes
+
+-   1c1f7717: Enhance Flow types for kmath's vector and point
+
 ## 0.0.4
 
 ### Patch Changes

package/README.md

@@ -1,6 +1,7 @@
-# kmath
-
-Javascript Numeric Math Utilities
+<h1 align="center">
+    <img alt="kmath" src="logo.svg" width="50" /> <br />
+    kmath - Javascript Numeric Math Utilities
+</h1>
 
 ## Overview
 
@@ -38,38 +39,40 @@ After cloning or downloading kmath, you can install it by running
 To play around with the available interfaces, you can load kmath
 into a Node repl:
 
-    $ node
-    > var kmath = require("@khanacademy/kmath");
-    > kmath.vector.add([1, 2], [3, 4])
-    [4, 6]
+```js
+import {vector} from "@khanacademy/kmath";
+vector.add([1, 2], [3, 4]) // [4, 6]
+```
 
 ## Usage overview
 
 kmath has 5 basic types:
 
--   number
--   vector
--   point
--   ray
--   line
+-   `number`
+-   `vector`
+-   `point`
+-   `ray`
+-   `line`
 
 Each has its own representation:
 
--   number: a js number (i.e. `5`)
--   vector: a js array of numbers (i.e. `[5, 6]`)
--   point: a js array of numbers (i.e. `[5, 6]`)
--   ray: a js array of two points (i.e. `[[5, 6], [1, 2]]`)
--   line: a js array of two points (i.e. `[[5, 6], [1, 2]]`)
+-   `number`: a js number (i.e. `5`)
+-   `vector`: a js array of numbers (i.e. `[5, 6]`)
+-   `point`: a js array of numbers (i.e. `[5, 6]`)
+-   `ray`: a js array of two points (i.e. `[[5, 6], [1, 2]]`)
+-   `line`: a js array of two points (i.e. `[[5, 6], [1, 2]]`)
 
 kmath functions usually take an argument of the corresponding type as
 the first parameter, and other parameters afterwards. For example, to
 rotate the point `[1, 1]` by 90 degrees around `[0, 0]`, one might use:
 
-    kmath.point.rotateDeg([1, 1], 90, [0, 0])
+```js
+point.rotateDeg([1, 1], 90, [0, 0])
+```
 
 Documentation for specific functions for each type is provided below.
 
-## kmath.number
+## number
 
 #### `number.DEFAULT_TOLERANCE === 1e-9`
 
@@ -131,7 +134,7 @@ is found, `[decimal, 1]` is returned.
 `tolerance` defaults to `number.EPSILON`. `maxDenominator` defaults to
 `1000`.
 
-## kmath.vector
+## vector
 
 #### `vector.is(maybeAVector, [dimension])`
 
@@ -141,22 +144,24 @@ only returns true if `maybeAVector` is a vector with dimension `dimension`.
 #### `vector.equal(v1, v2, [tolerance])`
 
 Returns true if `v1` and `v2` are equal within `tolerance`. If `tolerance`
-is not specified, `kmath.number.DEFAULT_TOLERANCE` is used. Each dimension
+is not specified, `number.DEFAULT_TOLERANCE` is used. Each dimension
 is compared individually, rather than comparing length and direction.
 
 If `v1` and `v2` have different lengths, this function returns `false`.
 
-    kmath.vector.equal([1, 2], [1, 3])
-    => false
-    kmath.vector.equal([1, 2], [1, 2, 3])
-    => false
-    kmath.vector.equal([1, 2], [1, 2])
-    => true
+```js
+vector.equal([1, 2], [1, 3])
+=> false
+vector.equal([1, 2], [1, 2, 3])
+=> false
+vector.equal([1, 2], [1, 2])
+=> true
+```
 
 #### `vector.codirectional(v1, v2, [tolerance])`
 
 Returns true if `v1` and `v2` have the same direction within `tolerance`.
-If `tolerance` is unspecified, `kmath.number.DEFAULT_TOLERANCE` is used.
+If `tolerance` is unspecified, `number.DEFAULT_TOLERANCE` is used.
 Note that tolerance is checked after normalization.
 
 If `v1` and `v2` are different lengths, this function returns `false`,
@@ -165,14 +170,16 @@ regardless of whether they are codirectional in the existing dimensions.
 This function defines the zero-vector as trivially codirectional with
 every vector.
 
-    kmath.vector.codirectional([1, 2], [2, 4])
-    => true
-    kmath.vector.codirectinoal([1, 2], [0, 0])
-    => true
-    kmath.vector.codirectional([1, 2], [1, 2, 0])
-    => false
-    kmath.vector.codirectional([1, 2], [-2, -4])
-    => false
+```js
+vector.codirectional([1, 2], [2, 4])
+=> true
+vector.codirectinoal([1, 2], [0, 0])
+=> true
+vector.codirectional([1, 2], [1, 2, 0])
+=> false
+vector.codirectional([1, 2], [-2, -4])
+=> false
+```
 
 #### `vector.colinear(v1, v2, [tolerance])`
 
@@ -182,8 +189,10 @@ or `v1` and `-v2` being codirectional, or whether there is some
 `scaleFactor` such that `vector.equal(vector.scale(v1, scaleFactor), v2)`
 is true.
 
-    kmath.vector.colinear([1, 2], [-2, -4])
-    => true
+```js
+kmath.vector.colinear([1, 2], [-2, -4])
+=> true
+```
 
 #### `vector.normalize(v)`
 
@@ -201,15 +210,19 @@ Returns the dot product of cartesian vectors `v1` and `v2`.
 
 Adds multiple cartesian vectors together.
 
-    kmath.vector.add([1, 2], [3, 4])
-    => [4, 6]
+```js
+kmath.vector.add([1, 2], [3, 4])
+=> [4, 6]
+```
 
 #### `vector.subtract(v1, v2)`
 
 Subtracts the cartesian vector `v2` from the cartesian vector `v1`.
 
-    kmath.vector.subtract([4, 6], [1, 2])
-    => [3, 4]
+```js
+kmath.vector.subtract([4, 6], [1, 2])
+=> [3, 4]
+```
 
 #### `vector.negate(v)`
 
@@ -220,46 +233,56 @@ Negates the cartesian vector `v`. This has the same effect as scaling
 
 Scales the cartesian vector `v` by `scalar`.
 
-    kmath.vector.scale([1, 2], 2)
-    => [2, 4]
+```js
+kmath.vector.scale([1, 2], 2)
+=> [2, 4]
+```
 
 #### `vector.polarRadFromCart(v)`
 
 Returns a polar vector `[length, angle]` from the two-dimensional cartesian
 vector `v`, where `angle` is measured in radians.
 
-    kmath.vector.polarRadFromCart([1, 1])
-    => [1.4142135623730951, 0.7853981633974483]
+```js
+kmath.vector.polarRadFromCart([1, 1])
+=> [1.4142135623730951, 0.7853981633974483]
+```
 
 #### `vector.polarDegFromCart(v)`
 
 Returns a polar vector `[length, angle]` from the two-dimensional cartesian
 vector `v`, where `angle` is measured in degrees.
 
-    kmath.vector.polarDegFromCart([0, 2])
-    => [2, 90]
+```js
+kmath.vector.polarDegFromCart([0, 2])
+=> [2, 90]
+```
 
 #### `vector.cartFromPolarRad(polar)` or `vector.cartFromPolarRad(length, angle)`
 
 Returns a two-dimensional cartesian vector from the polar vector input,
 where the input angle is measured in radians.
 
-    kmath.vector.cartFromPolarRad([2, Math.PI])
-    => [-2, 0]  // Note: a very small nonzero number is actually returned here,
-                // due to numerical inaccuracy.
-    kmath.vector.cartFromPolarRad(Math.pow(2, 0.5), Math.PI/4)
-    => [1, 1]
+```js
+kmath.vector.cartFromPolarRad([2, Math.PI])
+=> [-2, 0]  // Note: a very small nonzero number is actually returned here,
+            // due to numerical inaccuracy.
+kmath.vector.cartFromPolarRad(Math.pow(2, 0.5), Math.PI/4)
+=> [1, 1]
+```
 
 #### `vector.cartFromPolarDeg(polar)` or `vector.cartFromPolarDeg(length, angle)`
 
 Returns a two-dimensional cartesian vector from the polar vector input,
 where the input angle is measured in degrees.
 
-    kmath.vector.cartFromPolarRad([2, 90])
-    => [-2, 0]  // Note: a very small nonzero number is actually returned here,
-                // due to numerical inaccuracy.
-    kmath.vector.cartFromPolarRad(Math.pow(2, 0.5), 45)
-    => [1, 1]
+```js
+kmath.vector.cartFromPolarRad([2, 90])
+=> [-2, 0]  // Note: a very small nonzero number is actually returned here,
+            // due to numerical inaccuracy.
+kmath.vector.cartFromPolarRad(Math.pow(2, 0.5), 45)
+=> [1, 1]
+```
 
 #### `vector.rotateRad(v, angle)`
 
@@ -314,12 +337,14 @@ is compared individually.
 
 If `p1` and `p2` have different lengths, this function returns `false`.
 
-    kmath.point.equal([1, 2], [1, 3])
-    => false
-    kmath.point.equal([1, 2], [1, 2, 3])
-    => false
-    kmath.point.equal([1, 2], [1, 2])
-    => true
+```js
+kmath.point.equal([1, 2], [1, 3])
+=> false
+kmath.point.equal([1, 2], [1, 2, 3])
+=> false
+kmath.point.equal([1, 2], [1, 2])
+=> true
+```
 
 #### `point.addVector(p, *vectors)` or `point.addVectors(p, *vectors)`
 
@@ -342,8 +367,10 @@ Returns the distance between `p` and the line `theLine`.
 For example, to find the distance from the origin to the
 `y = 5` line, one could write:
 
-    kmath.point.distanceToLine([0, 0], [[-1, 5], [1, 5]])
-    => 5
+```js
+kmath.point.distanceToLine([0, 0], [[-1, 5], [1, 5]])
+=> 5
+```
 
 #### `point.reflectOverLine(p, theLine)`
 
@@ -352,8 +379,10 @@ Returns the reflection of `p` over the line `theLine`.
 For example, to reflect the origin over the line `y = 5`,
 one could write:
 
-    kmath.point.reflectOverLine([0, 0], [[-1, 5], [1, 5]])
-    => [0, 10]
+```js
+kmath.point.reflectOverLine([0, 0], [[-1, 5], [1, 5]])
+=> [0, 10]
+```
 
 #### `point.compare(p1, p2, [equalityTolerance])`
 
@@ -370,38 +399,46 @@ few equalityTolerances could appear in the wrong order.
 Returns a polar point `[length, angle]` from the two-dimensional cartesian
 point `v`, where `angle` is measured in radians.
 
-    kmath.point.polarRadFromCart([1, 1])
-    => [1.4142135623730951, 0.7853981633974483]
+```js
+kmath.point.polarRadFromCart([1, 1])
+=> [1.4142135623730951, 0.7853981633974483]
+```
 
 #### `point.polarDegFromCart(p)`
 
 Returns a polar point `[length, angle]` from the two-dimensional cartesian
 point `v`, where `angle` is measured in degrees.
 
-    kmath.point.polarDegFromCart([0, 2])
-    => [2, 90]
+```js
+kmath.point.polarDegFromCart([0, 2])
+=> [2, 90]
+```
 
 #### `point.cartFromPolarRad(polar)` or `point.cartFromPolarRad(length, angle)`
 
 Returns a two-dimensional cartesian point from the polar point input,
 where the input angle is measured in radians.
 
-    kmath.point.cartFromPolarRad([2, Math.PI])
-    => [-2, 0]  // Note: a very small nonzero number is actually returned here,
-                // due to numerical inaccuracy.
-    kmath.point.cartFromPolarRad(Math.pow(2, 0.5), Math.PI/4)
-    => [1, 1]
+```js
+kmath.point.cartFromPolarRad(2, Math.PI)
+=> [-2, 0]  // Note: a very small nonzero number is actually returned here,
+            // due to numerical inaccuracy.
+kmath.point.cartFromPolarRad(Math.pow(2, 0.5), Math.PI/4)
+=> [1, 1]
+```
 
 #### `point.cartFromPolarDeg(polar)` or `point.cartFromPolarDeg(length, angle)`
 
 Returns a two-dimensional cartesian point from the polar point input,
 where the input angle is measured in degrees.
 
-    kmath.point.cartFromPolarRad([2, 90])
-    => [-2, 0]  // Note: a very small nonzero number is actually returned here,
-                // due to numerical inaccuracy.
-    kmath.point.cartFromPolarRad(Math.pow(2, 0.5), 45)
-    => [1, 1]
+```js
+kmath.point.cartFromPolarRad([2, 90])
+=> [-2, 0]  // Note: a very small nonzero number is actually returned here,
+            // due to numerical inaccuracy.
+kmath.point.cartFromPolarRad(Math.pow(2, 0.5), 45)
+=> [1, 1]
+```
 
 #### `point.rotateRad(p, angle, center)`
 
@@ -449,8 +486,10 @@ If unspecified, `tolerance` defaults to `kmath.number.DEFAULT_TOLERANCE`.
 
 Returns the midpoint of the line `theLine`.
 
-    kmath.line.midpoint([[0, 5], [5, 0]])
-    => [2.5, 2.5]
+```js
+kmath.line.midpoint([[0, 5], [5, 0]])
+=> [2.5, 2.5]
+```
 
 #### `line.distanceToPoint(theLine, p)`
 
@@ -462,4 +501,4 @@ Returns the reflection of `p` over `theLine`.
 
 ## License
 
-MIT. See the LICENSE file for more information.
+MIT. See the [LICENSE](../../LICENSE) file for more information.