qntjs-lib 1.0.0

package/README.md

@@ -0,0 +1,60 @@
+# qntjs-lib
+
+A compact JavaScript/TypeScript library of numerical helpers and technical-analysis indicators.
+
+This repository provides a comprehensive set of TA indicators (EMA, TEMA, T3, MFI, KAMA, etc.), vectorized math functions, array utilities, and statistical helpers.
+
+For best performance, functions operate and return typed arrays like Float64Array.
+For convenience, the same functions are also exposed with number[] return types.
+
+Most functions skip NaN by default in their calculations. 
+Some functions accept boolean skipna to skip or not NaN.
+When skipna=false is passed to these functions, a fast dense path is executed. 
+
+**Quick Start**
+
+Install:
+
+```bash
+npm install qntjs-lib
+```
+
+Basic usage:
+
+```js
+import { ta, arr } from 'qntjs-lib';
+
+const prices = [1,2,3,4,5,6,7];
+const out = ta.ema(prices, 3);
+console.log(out);
+```
+
+API highlights
+
+- `ta.*` — technical indicators (e.g. `ta.ema`, `ta.t3`, `ta.mfi`, `ta.kama`)
+- `arr.*` — array utilities
+- `math.*` — math helpers
+
+Tests & development
+
+Run tests:
+
+```bash
+npm test
+```
+
+Run build (produce distributable artifacts):
+
+```bash
+npm run build
+```
+
+Contributing
+
+- Open an issue to discuss larger changes.
+- Run tests and keep coverage high for changes to core algorithms.
+- Follow the existing style and types in `src/`.
+
+License
+
+See `LICENSE` in the repo root.

package/dist/arr/arr.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Elementwise equality comparison of two arrays, treating NaNs as equal.
+ * If `precision` is provided, numeric comparison uses a tolerance of 10^-precision.
+ * @param source1 First input array
+ * @param source2 Second input array
+ * @param precision Optional decimal precision for fuzzy equality
+ * @returns `true` if arrays are equal, `false` otherwise
+ */
+declare function equals(source1: ArrayLike<number>, source2: ArrayLike<number>, precision?: number): boolean;
+/**
+ * Return true if all elements are NaN.
+ * @param source Input array
+ * @returns `true` when every entry is NaN
+ */
+declare function allna(source: ArrayLike<number>): boolean;
+/**
+ * Count NaN entries in `source`.
+ * @param source Input array
+ * @returns Number of NaNs in the array
+ */
+declare function countna(source: ArrayLike<number>): number;
+/**
+ * Test whether any of the provided arrays contains a NaN at the same index.
+ * Performs a single-pass scan across arrays and exits early on the first NaN.
+ * @param sources One or more input arrays
+ * @returns `true` if any NaN is found, otherwise `false`
+ */
+declare function havena(...sources: ArrayLike<number>[]): boolean;
+/**
+ * Return a mask indicating NaN positions: 1 for NaN, 0 otherwise.
+ * @param source Input array
+ * @returns Float64Array mask of 0/1 values
+ */
+declare function isna(source: ArrayLike<number>): Float64Array;
+/**
+ * Inverse of `isna`: mask with 1 for valid numbers and 0 for NaNs.
+ * @param source Input array
+ * @returns Float64Array mask of 0/1 values
+ */
+declare function notna(source: ArrayLike<number>): Float64Array;
+/**
+ * Replace NaNs with `value`. When `inplace=true` and `source` is a Float64Array,
+ * the original buffer is mutated.
+ * @param source Input array
+ * @param value Replacement value for NaNs
+ * @param inplace Whether to mutate the input when possible
+ * @returns Float64Array with NaNs replaced
+ */
+declare function fillna(source: ArrayLike<number>, value: number, inplace?: boolean): Float64Array;
+/**
+ * Forward-fill NaNs: propagate the last valid value forward. Leading NaNs remain NaN.
+ * @param source Input array
+ * @param inplace Whether to mutate the input when possible
+ * @returns Float64Array with forward-filled values
+ */
+declare function ffill(source: ArrayLike<number>, inplace?: boolean): Float64Array;
+/**
+ * Backward-fill NaNs: propagate the next valid value backward. Trailing NaNs remain NaN.
+ * @param source Input array
+ * @param inplace Whether to mutate the input when possible
+ * @returns Float64Array with backward-filled values
+ */
+declare function bfill(source: ArrayLike<number>, inplace?: boolean): Float64Array;
+export declare function lag(source: ArrayLike<number>, shift?: number): Float64Array;
+/**
+ * Replace occurrences of `fromValue` with `toValue`. If `fromValue` is NaN,
+ * NaN entries are replaced.
+ * @param source Input array
+ * @param fromValue Value to replace (may be NaN)
+ * @param toValue Replacement value
+ * @param inplace Whether to mutate the input when possible
+ * @returns Float64Array with replacements applied
+ */
+declare function replace(source: ArrayLike<number>, fromValue: number, toValue: number, inplace?: boolean): Float64Array;
+/**
+ * Remove NaN entries from `source` and return a compacted Float64Array.
+ * @param source Input array
+ * @returns New Float64Array containing only the non-NaN values
+ */
+declare function dropna(source: ArrayLike<number>): Float64Array;
+export { isna, notna, fillna, ffill, bfill, replace, dropna, allna, equals, countna, havena };