Commit to the lo/hi arg ordering having to match the step value, with omitted step being positive. Closes #17

Author: tabatkins

README.md

@@ -52,7 +52,11 @@ returns a random `Number` in the range `(lo, hi)`
 (that is, not containing either `lo` or `hi`)
 with a uniform distribution.
 
-If there are no floats between `lo` and `hi`,
+If `lo` is greater than `hi`,
+throws a {{RangeError}}.
+
+If `lo` and `hi` are either equal or consecutive floats
+(such that there are no floats between them),
 returns `lo` unless the `excludeMin` option is true;
 otherwise, returns `hi` unless the `excludeMax` option is true;
 otherwise, throws a {{RangeError}}.
@@ -73,7 +77,7 @@ Specifically:
 
 1. Let `epsilon` be a small value related to `step`, chosen to match [`Iterator.range` issue #64](https://github.com/tc39/proposal-iterator.range/issues/64#issuecomment-2881243363)).
 2. Let `minN` be 0 if the `excludeMin` option is false, or 1 if it's true.
-3. Let `maxN` be the largest integer such that `lo + maxN*step` is less than or equal to `hi`, if the `excludeMax` option is false, or less than `hi`, if it's true.
+3. Let `maxN` be the largest integer such that `lo + maxN*step` is less than or equal to `hi`, if the `excludeMax` option is false, or less than `hi`, if it's true. (Or the opposite comparisons, if `step` is negative.)
 4. If the `excludeMax` option is false,
     and `lo + maxN*step` is not within `epsilon` of `hi`,
     but `lo + (maxN+1)*step` is
@@ -88,6 +92,11 @@ Specifically:
 > This `step`/`epsilon` behavior is taken directly from [CSS's `random()` function](https://drafts.csswg.org/css-values-5/#random).
 > It's also [being proposed for `Iterator.range()`](https://github.com/tc39/proposal-iterator.range/issues/64#issuecomment-2881243363).
 
+If `step` is positive, `lo` must be less than or equal to `hi`,
+or else a {{RangeError}} is thrown.
+If `step` is negative, `lo` must be greater than or equal to `hi`,
+or else a {{RangeError}} is thrown.
+
 
 ## `Random.range(...)` ##
 
@@ -125,6 +134,10 @@ it excludes `lo` and `hi`.
 If the range thus contains no possible values,
 throws a RangeError.
 
+Has the same constraints on `lo` vs `hi` ordering,
+and the relationship with positive, negative, or omitted `step`,
+as `Random.number()`.
+
 
 > [!NOTE]
 > [Issue 19](https://github.com/tc39/proposal-random-functions/issues/19) discusses what algorithm to use. Current plan uses 2 64-bit chunks if the lo-hi range contains less than 2^63 values. If the range is larger, the algorithm uses approximately N+1 64-bit chunks, where N is the number of 64-bit chunks it takes to represent the range in the first place (with an ignorable chance of rejection, requiring another set of chunks). Either way, *every* int in the range is possible and has a uniform chance, unlike `Random.number(lo, hi, {step:1})` for large ranges. (For `.int()`, if the range leaves the safe integer range, the values have non-uniform chances but are relative to the number of integers they represent, so the statistics are as close to uniform as possible.)