Add TA Methods : barssince, correlation highestbars, lowestbars, mode, percentile* percentrank, valuewhen

Author: alaa-eddine

docs/api-coverage/ta.md

@@ -89,14 +89,13 @@ All functions listed below are verified to exist in Pine Script v5.
 | `ta.highest()`                         | ✅     | Highest Value             |
 | `ta.lowest()`                          | ✅     | Lowest Value              |
 | `ta.median()`                          | ✅     | Median Value              |
-| `ta.mode()`                            | ⬜     | Mode Value                |
-| `ta.highestbars()`                     | ⬜     | Bars Since Highest        |
-| `ta.lowestbars()`                      | ⬜     | Bars Since Lowest         |
-| `ta.percentrank()`                     | ⬜     | Percentile Rank           |
-| `ta.percentile_linear_interpolation()` | ⬜     | Percentile (Linear)       |
-| `ta.percentile_nearest_rank()`         | ⬜     | Percentile (Nearest Rank) |
-| `ta.correlation()`                     | ⬜     | Correlation Coefficient   |
-| `ta.covariance()`                      | ⬜     | Covariance                |
+| `ta.mode()`                            | ✅     | Mode Value                |
+| `ta.highestbars()`                     | ✅     | Bars Since Highest        |
+| `ta.lowestbars()`                      | ✅     | Bars Since Lowest         |
+| `ta.percentrank()`                     | ✅     | Percentile Rank           |
+| `ta.percentile_linear_interpolation()` | ✅     | Percentile (Linear)       |
+| `ta.percentile_nearest_rank()`         | ✅     | Percentile (Nearest Rank) |
+| `ta.correlation()`                     | ✅     | Correlation Coefficient   |
 
 ### Support & Resistance
 
@@ -110,7 +109,7 @@ All functions listed below are verified to exist in Pine Script v5.
 | Function         | Status | Description              |
 | ---------------- | ------ | ------------------------ |
 | `ta.valuewhen()` | ⬜     | Value When Condition Met |
-| `ta.barssince()` | ⬜     | Bars Since Condition     |
+| `ta.barssince()` | ✅     | Bars Since Condition     |
 | `ta.cum()`       | ✅     | Cumulative Sum           |
 
 ### Notes

src/namespaces/ta/methods/barssince.ts

@@ -0,0 +1,35 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+
+import { Series } from '../../../Series';
+
+/**
+ * Bars Since
+ *
+ * Counts the number of bars since the last time the condition was true.
+ */
+export function barssince(context: any) {
+    return (condition: any, _callId?: string) => {
+        if (!context.taState) context.taState = {};
+        const stateKey = _callId || 'barssince';
+
+        if (!context.taState[stateKey]) {
+            context.taState[stateKey] = {
+                lastTrueIndex: null,
+            };
+        }
+        const state = context.taState[stateKey];
+
+        const cond = Series.from(condition).get(0);
+
+        if (cond) {
+            state.lastTrueIndex = context.idx;
+            return 0;
+        }
+
+        if (state.lastTrueIndex === null) {
+            return NaN;
+        }
+
+        return context.idx - state.lastTrueIndex;
+    };
+}

src/namespaces/ta/methods/correlation.ts

@@ -0,0 +1,54 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+
+import { Series } from '../../../Series';
+
+/**
+ * Correlation Coefficient
+ *
+ * Describes the degree to which two series tend to deviate from their ta.sma() values.
+ * r = cov(X, Y) / (stdev(X) * stdev(Y))
+ */
+export function correlation(context: any) {
+    return (source1: any, source2: any, _length: any, _callId?: string) => {
+        const length = Series.from(_length).get(0);
+        const s1 = Series.from(source1);
+        const s2 = Series.from(source2);
+
+        if (context.idx < length - 1) {
+            return NaN;
+        }
+
+        let sumX = 0;
+        let sumY = 0;
+        let sumXY = 0;
+        let sumX2 = 0;
+        let sumY2 = 0;
+        let count = 0;
+
+        for (let i = 0; i < length; i++) {
+            const x = s1.get(i);
+            const y = s2.get(i);
+
+            if (isNaN(x) || isNaN(y)) continue;
+
+            sumX += x;
+            sumY += y;
+            sumXY += x * y;
+            sumX2 += x * x;
+            sumY2 += y * y;
+            count++;
+        }
+
+        if (count < 2) return NaN; // Need at least 2 points
+
+        const numerator = count * sumXY - sumX * sumY;
+        const denominatorX = count * sumX2 - sumX * sumX;
+        const denominatorY = count * sumY2 - sumY * sumY;
+
+        if (denominatorX <= 0 || denominatorY <= 0) return context.precision(0);
+
+        const r = numerator / Math.sqrt(denominatorX * denominatorY);
+        return context.precision(r);
+    };
+}
+

src/namespaces/ta/methods/highestbars.ts

@@ -0,0 +1,37 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+
+import { Series } from '../../../Series';
+
+/**
+ * Highest Bars
+ *
+ * Returns the offset to the highest value over a given length.
+ * Formula: Offset to the highest bar (negative value).
+ */
+export function highestbars(context: any) {
+    return (source: any, _length: any, _callId?: string) => {
+        const length = Series.from(_length).get(0);
+        const series = Series.from(source);
+
+        if (context.idx < length - 1) {
+            return NaN;
+        }
+
+        let maxVal = -Infinity;
+        let maxOffset = NaN;
+
+        for (let i = 0; i < length; i++) {
+            const val = series.get(i);
+            
+            if (isNaN(val)) continue;
+
+            if (isNaN(maxOffset) || val > maxVal) {
+                maxVal = val;
+                maxOffset = -i;
+            }
+        }
+
+        return maxOffset;
+    };
+}
+

src/namespaces/ta/methods/lowestbars.ts

@@ -0,0 +1,37 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+
+import { Series } from '../../../Series';
+
+/**
+ * Lowest Bars
+ *
+ * Returns the offset to the lowest value over a given length.
+ * Formula: Offset to the lowest bar (negative value).
+ */
+export function lowestbars(context: any) {
+    return (source: any, _length: any, _callId?: string) => {
+        const length = Series.from(_length).get(0);
+        const series = Series.from(source);
+
+        if (context.idx < length - 1) {
+            return NaN;
+        }
+
+        let minVal = Infinity;
+        let minOffset = NaN;
+
+        for (let i = 0; i < length; i++) {
+            const val = series.get(i);
+            
+            if (isNaN(val)) continue;
+
+            if (isNaN(minOffset) || val < minVal) {
+                minVal = val;
+                minOffset = -i;
+            }
+        }
+
+        return minOffset;
+    };
+}
+

src/namespaces/ta/methods/mode.ts

@@ -0,0 +1,47 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+
+import { Series } from '../../../Series';
+
+/**
+ * Mode
+ *
+ * Returns the mode of the series. If there are several values with the same frequency, returns the smallest value.
+ */
+export function mode(context: any) {
+    return (source: any, _length: any, _callId?: string) => {
+        const length = Series.from(_length).get(0);
+        const series = Series.from(source);
+
+        if (context.idx < length - 1) {
+            return NaN;
+        }
+
+        const counts = new Map<number, number>();
+        
+        for (let i = 0; i < length; i++) {
+            const val = series.get(i);
+            if (isNaN(val)) continue;
+            
+            counts.set(val, (counts.get(val) || 0) + 1);
+        }
+
+        if (counts.size === 0) return NaN;
+
+        let modeVal = NaN;
+        let maxFreq = -1;
+
+        for (const [val, freq] of counts.entries()) {
+            if (freq > maxFreq) {
+                maxFreq = freq;
+                modeVal = val;
+            } else if (freq === maxFreq) {
+                if (val < modeVal) {
+                    modeVal = val;
+                }
+            }
+        }
+
+        return modeVal; // Should I return int or float? Input determines it. Return value is as-is.
+    };
+}
+

src/namespaces/ta/methods/percentile_linear_interpolation.ts

@@ -0,0 +1,47 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+
+import { Series } from '../../../Series';
+
+/**
+ * Percentile Linear Interpolation
+ *
+ * Calculates percentile using method of linear interpolation between the two nearest ranks.
+ */
+export function percentile_linear_interpolation(context: any) {
+    return (source: any, _length: any, _percentage: any, _callId?: string) => {
+        const length = Series.from(_length).get(0);
+        const percentage = Series.from(_percentage).get(0);
+        const series = Series.from(source);
+
+        if (context.idx < length - 1) {
+            return NaN;
+        }
+
+        const values: number[] = [];
+        for (let i = 0; i < length; i++) {
+            const val = series.get(i);
+            if (isNaN(val)) return NaN;
+            values.push(val);
+        }
+
+        values.sort((a, b) => a - b);
+
+        // Formula inferred from test data: index = (percentage / 100) * length - 0.5
+        let index = (percentage / 100) * length - 0.5;
+        
+        if (index < 0) index = 0;
+        if (index > length - 1) index = length - 1;
+
+        const lowerIndex = Math.floor(index);
+        const upperIndex = Math.ceil(index);
+        
+        if (lowerIndex === upperIndex) {
+            return context.precision(values[lowerIndex]);
+        }
+
+        const fraction = index - lowerIndex;
+        const result = values[lowerIndex] + fraction * (values[upperIndex] - values[lowerIndex]);
+
+        return context.precision(result);
+    };
+}

src/namespaces/ta/methods/percentile_nearest_rank.ts

@@ -0,0 +1,42 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+
+import { Series } from '../../../Series';
+
+/**
+ * Percentile Nearest Rank
+ *
+ * Calculates percentile using method of Nearest Rank.
+ * A percentile calculated using the Nearest Rank method will always be a member of the input data set.
+ */
+export function percentile_nearest_rank(context: any) {
+    return (source: any, _length: any, _percentage: any, _callId?: string) => {
+        const length = Series.from(_length).get(0);
+        const percentage = Series.from(_percentage).get(0);
+        const series = Series.from(source);
+
+        if (context.idx < length - 1) {
+            return NaN;
+        }
+
+        const values: number[] = [];
+        for (let i = 0; i < length; i++) {
+            const val = series.get(i);
+            if (!isNaN(val)) {
+                values.push(val);
+            }
+        }
+
+        if (values.length === 0) return NaN;
+
+        values.sort((a, b) => a - b);
+
+        // Nearest Rank: index = ceil(P/100 * N) - 1
+        let index = Math.ceil((percentage / 100) * values.length) - 1;
+
+        if (index < 0) index = 0;
+        if (index >= values.length) index = values.length - 1;
+
+        return context.precision(values[index]);
+    };
+}
+

src/namespaces/ta/methods/percentrank.ts

@@ -0,0 +1,40 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+
+import { Series } from '../../../Series';
+
+/**
+ * Percent Rank
+ *
+ * Returns the percentage of values in the last length previous bars that are less than or equal to the current value.
+ */
+export function percentrank(context: any) {
+    return (source: any, _length: any, _callId?: string) => {
+        const length = Series.from(_length).get(0);
+        const series = Series.from(source);
+
+        if (context.idx < length) {
+            return NaN;
+        }
+
+        const currentValue = series.get(0);
+        if (isNaN(currentValue)) return NaN;
+
+        let count = 0;
+        let validValues = 0;
+
+        for (let i = 1; i <= length; i++) {
+            const val = series.get(i);
+
+            if (isNaN(val)) continue;
+            validValues++;
+
+            if (val <= currentValue) {
+                count++;
+            }
+        }
+
+        if (validValues === 0) return NaN;
+
+        return context.precision((count / validValues) * 100);
+    };
+}