openalgo-script 0.4.0 → 0.6.0

package/src/core/stdlib/calendar/civil.ts

@@ -29,7 +29,10 @@ export interface Civil {
 /** Days from 1970-01-01 to this civil date. */
 export function dayNumber(year: number, month: number, day: number): number {
   const shifted = month <= 2 ? year - 1 : year;
-  const era = Math.floor((shifted >= 0 ? shifted : shifted - 399) / 400);
+  // A floor division, and nothing added to it: the published form subtracts 399
+  // from a negative year so that a truncating division floors, and this one
+  // already does. Doing both put every date before about 1 BCE one day early.
+  const era = Math.floor(shifted / 400);
   const yearOfEra = shifted - era * 400;
   const dayOfYear = Math.floor((153 * (month + (month > 2 ? -3 : 9)) + 2) / 5) + day - 1;
   const dayOfEra = yearOfEra * 365 + Math.floor(yearOfEra / 4) - Math.floor(yearOfEra / 100) + dayOfYear;
@@ -39,7 +42,7 @@ export function dayNumber(year: number, month: number, day: number): number {
 /** The civil date a day number names, the exact inverse of `dayNumber`. */
 export function dateOfDay(days: number): { year: number; month: number; day: number } {
   const shifted = days + 719468;
-  const era = Math.floor((shifted >= 0 ? shifted : shifted - 146096) / 146097);
+  const era = Math.floor(shifted / 146097);
   const dayOfEra = shifted - era * 146097;
   const yearOfEra = Math.floor(
     (dayOfEra - Math.floor(dayOfEra / 1460) + Math.floor(dayOfEra / 36524) - Math.floor(dayOfEra / 146096)) / 365,

package/src/core/stdlib/index.ts

@@ -105,6 +105,7 @@ export {
   roundTo,
   roundToStep,
   roundToTick,
+  scaleOf,
   sign,
   sin,
   sqrt,

package/src/core/stdlib/maths/index.ts

@@ -18,6 +18,7 @@ export {
   roundTo,
   roundToStep,
   roundToTick,
+  scaleOf,
   trunc,
 } from './rounding.js';
 

package/src/core/stdlib/maths/rounding.ts

@@ -31,6 +31,28 @@ export function round(x: Value): Value {
   return isPresent(x) ? result(roundHalfAway(x)) : NONE;
 }
 
+/**
+ * Ten to each whole power a binary64 can hold, as the binary64 nearest to it.
+ *
+ * `stdlib.md` 20.7: the scale a fixed decimal rounding or conversion multiplies
+ * by is the nearest binary64 to the power of ten, the value the literal `1e23`
+ * reads as, and not what a floating point power returns, which is an ulp away
+ * from it for one count on this engine's host. Built once from exact integer
+ * arithmetic, and it is the one table: `text(x, decimals)` in the engine's
+ * library scales by it through `scaleOf` rather than holding a copy.
+ */
+const POWERS_OF_TEN: readonly number[] = Array.from({ length: 309 }, (_, count) =>
+  Number(10n ** BigInt(count)),
+);
+
+/**
+ * The scale for a digit count: the nearest binary64 to ten to that power, and
+ * past the last finite power the infinity the power would have been.
+ */
+export function scaleOf(decimals: number): number {
+  return POWERS_OF_TEN[decimals] ?? Infinity;
+}
+
 /**
  * `round(x, decimals)`: to a fixed number of decimals, halves away from zero.
  *
@@ -40,7 +62,7 @@ export function round(x: Value): Value {
 export function roundTo(x: Value, decimals: number): Value {
   if (!isPresent(x)) return NONE;
   if (!Number.isInteger(decimals) || decimals < 0) return NONE;
-  const scale = Math.pow(10, decimals);
+  const scale = scaleOf(decimals);
   return result(roundHalfAway(x * scale) / scale);
 }
 

package/src/core/version/version.generated.ts

@@ -4,7 +4,7 @@
 // spec/compiled-program.md, so neither can drift from the thing it names.
 
 /** This build's package version. The release refuses to publish unless the tag, the manifest and this agree. */
-export const VERSION = "0.4.0";
+export const VERSION = "0.6.0";
 
 /**
  * The compiled program format this compiler emits.