mirror of
https://github.com/mihakralj/QuanTAlib.git
synced 2026-07-28 01:37:43 +00:00
Miha Kralj
935a5ab26c
The NativeAOT export had stale parameter names (period, minPeriod, maxPeriod, useMedian) from an older API. Renamed to match the actual Eacp.Batch(minPeriod, maxPeriod, avgLength, enhance) signature. ABI preserved — same 7 params, same types, no Python-side changes needed.
1487 lines
73 KiB
C#
1487 lines
73 KiB
C#
// QuanTAlib Python NativeAOT Exports — all ~290 [UnmanagedCallersOnly] entry points
|
|
// Organized by SPEC §8 categories. Each export validates inputs, wraps Batch in try/catch,
|
|
// and returns a status code (0=OK, 1=NULL_PTR, 2=INVALID_LENGTH, 3=INVALID_PARAM, 4=INTERNAL).
|
|
//
|
|
// Pattern key:
|
|
// A = (src, n, out, scalar_params...)
|
|
// B = (h, l, c, v, n, out, params...) HLCV
|
|
// C = (o, h, l, c, n, out, params...) OHLC
|
|
// D = (h, l, n, out, params...) HL
|
|
// E = (h, l, c, n, out, params...) HLC
|
|
// F = (actual, predicted, n, out, params...) dual-input error metrics
|
|
// G = (src, vol, n, out, params...) source+volume
|
|
// H = (x, y, n, out, params...) seriesX+seriesY
|
|
// I = multi-output variants
|
|
|
|
#nullable enable
|
|
using System;
|
|
using System.Runtime.CompilerServices;
|
|
using System.Runtime.InteropServices;
|
|
using QuanTAlib;
|
|
|
|
namespace QuanTAlib.Python;
|
|
|
|
#pragma warning disable CA1031 // catch general exception types — ABI boundary requires catching all
|
|
#pragma warning disable IDE0060 // unused parameters — some reserved for future use
|
|
|
|
[SkipLocalsInit]
|
|
public static unsafe partial class Exports
|
|
{
|
|
// ═══════════════════════════════════════════════════════════════════════
|
|
// Validation helpers — keep exports compact
|
|
// ═══════════════════════════════════════════════════════════════════════
|
|
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
private static int Chk1(double* src, double* dst, int n)
|
|
{
|
|
if (src == null || dst == null) return StatusCodes.QTL_ERR_NULL_PTR;
|
|
if (n <= 0) return StatusCodes.QTL_ERR_INVALID_LENGTH;
|
|
return StatusCodes.QTL_OK;
|
|
}
|
|
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
private static int Chk2(double* a, double* b, double* dst, int n)
|
|
{
|
|
if (a == null || b == null || dst == null) return StatusCodes.QTL_ERR_NULL_PTR;
|
|
if (n <= 0) return StatusCodes.QTL_ERR_INVALID_LENGTH;
|
|
return StatusCodes.QTL_OK;
|
|
}
|
|
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
private static int Chk3(double* a, double* b, double* c, double* dst, int n)
|
|
{
|
|
if (a == null || b == null || c == null || dst == null) return StatusCodes.QTL_ERR_NULL_PTR;
|
|
if (n <= 0) return StatusCodes.QTL_ERR_INVALID_LENGTH;
|
|
return StatusCodes.QTL_OK;
|
|
}
|
|
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
private static int Chk4(double* a, double* b, double* c, double* d, double* dst, int n)
|
|
{
|
|
if (a == null || b == null || c == null || d == null || dst == null) return StatusCodes.QTL_ERR_NULL_PTR;
|
|
if (n <= 0) return StatusCodes.QTL_ERR_INVALID_LENGTH;
|
|
return StatusCodes.QTL_OK;
|
|
}
|
|
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
private static int ChkPeriod(int period)
|
|
=> period > 0 ? StatusCodes.QTL_OK : StatusCodes.QTL_ERR_INVALID_PARAM;
|
|
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
private static int ChkAlpha(double alpha)
|
|
=> alpha > 0.0 && alpha <= 1.0 ? StatusCodes.QTL_OK : StatusCodes.QTL_ERR_INVALID_PARAM;
|
|
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
private static ReadOnlySpan<double> Src(double* p, int n) => new(p, n);
|
|
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
private static Span<double> Dst(double* p, int n) => new(p, n);
|
|
|
|
// ═══════════════════════════════════════════════════════════════════════
|
|
// §0 Skeleton / version
|
|
// ═══════════════════════════════════════════════════════════════════════
|
|
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_skeleton_noop")]
|
|
public static int SkeletonNoop() => StatusCodes.QTL_OK;
|
|
|
|
// ═══════════════════════════════════════════════════════════════════════
|
|
// §8.1 Core (price transforms)
|
|
// ═══════════════════════════════════════════════════════════════════════
|
|
|
|
// Avgprice: Pattern C (OHLC, no params) — Batch(ROS open, ROS high, ROS low, ROS close, S out)
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_avgprice")]
|
|
public static int QtlAvgprice(double* open, double* high, double* low, double* close, int n, double* dst)
|
|
{
|
|
if (open == null || high == null || low == null || close == null || dst == null) return StatusCodes.QTL_ERR_NULL_PTR;
|
|
if (n <= 0) return StatusCodes.QTL_ERR_INVALID_LENGTH;
|
|
try { Avgprice.Batch(Src(open, n), Src(high, n), Src(low, n), Src(close, n), Dst(dst, n)); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Medprice: Pattern D (HL, no params) — Batch(ROS high, ROS low, S out)
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_medprice")]
|
|
public static int QtlMedprice(double* high, double* low, int n, double* dst)
|
|
{
|
|
int v = Chk2(high, low, dst, n); if (v != 0) return v;
|
|
try { Medprice.Batch(Src(high, n), Src(low, n), Dst(dst, n)); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Typprice: Batch(ROS open, ROS high, ROS low, S out) — OHL, no close
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_typprice")]
|
|
public static int QtlTypprice(double* open, double* high, double* low, int n, double* dst)
|
|
{
|
|
if (open == null || high == null || low == null || dst == null) return StatusCodes.QTL_ERR_NULL_PTR;
|
|
if (n <= 0) return StatusCodes.QTL_ERR_INVALID_LENGTH;
|
|
try { Typprice.Batch(Src(open, n), Src(high, n), Src(low, n), Dst(dst, n)); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Midbody: Batch(ROS open, ROS close, S out) — OC pattern
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_midbody")]
|
|
public static int QtlMidbody(double* open, double* close, int n, double* dst)
|
|
{
|
|
int v = Chk2(open, close, dst, n); if (v != 0) return v;
|
|
try { Midbody.Batch(Src(open, n), Src(close, n), Dst(dst, n)); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// ═══════════════════════════════════════════════════════════════════════
|
|
// §8.2 Momentum
|
|
// ═══════════════════════════════════════════════════════════════════════
|
|
|
|
// Rsi: Pattern A (src, out, int period)
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_rsi")]
|
|
public static int QtlRsi(double* src, int n, double* dst, int period)
|
|
{
|
|
int v = Chk1(src, dst, n); if (v != 0) return v;
|
|
v = ChkPeriod(period); if (v != 0) return v;
|
|
try { Rsi.Batch(Src(src, n), Dst(dst, n), period); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Roc: Pattern A
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_roc")]
|
|
public static int QtlRoc(double* src, int n, double* dst, int period)
|
|
{
|
|
int v = Chk1(src, dst, n); if (v != 0) return v;
|
|
v = ChkPeriod(period); if (v != 0) return v;
|
|
try { Roc.Batch(Src(src, n), Dst(dst, n), period); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Mom: Pattern A
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_mom")]
|
|
public static int QtlMom(double* src, int n, double* dst, int period)
|
|
{
|
|
int v = Chk1(src, dst, n); if (v != 0) return v;
|
|
v = ChkPeriod(period); if (v != 0) return v;
|
|
try { Mom.Batch(Src(src, n), Dst(dst, n), period); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Cmo: Pattern A
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_cmo")]
|
|
public static int QtlCmo(double* src, int n, double* dst, int period)
|
|
{
|
|
int v = Chk1(src, dst, n); if (v != 0) return v;
|
|
v = ChkPeriod(period); if (v != 0) return v;
|
|
try { Cmo.Batch(Src(src, n), Dst(dst, n), period); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Tsi: Pattern A (src, out, int longPeriod, int shortPeriod)
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_tsi")]
|
|
public static int QtlTsi(double* src, int n, double* dst, int longPeriod, int shortPeriod)
|
|
{
|
|
int v = Chk1(src, dst, n); if (v != 0) return v;
|
|
if (longPeriod <= 0 || shortPeriod <= 0) return StatusCodes.QTL_ERR_INVALID_PARAM;
|
|
try { Tsi.Batch(Src(src, n), Dst(dst, n), longPeriod, shortPeriod); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Apo: Pattern A (src, out, int fast, int slow)
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_apo")]
|
|
public static int QtlApo(double* src, int n, double* dst, int fast, int slow)
|
|
{
|
|
int v = Chk1(src, dst, n); if (v != 0) return v;
|
|
if (fast <= 0 || slow <= 0) return StatusCodes.QTL_ERR_INVALID_PARAM;
|
|
try { Apo.Batch(Src(src, n), Dst(dst, n), fast, slow); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Bias: Pattern A
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_bias")]
|
|
public static int QtlBias(double* src, int n, double* dst, int period)
|
|
{
|
|
int v = Chk1(src, dst, n); if (v != 0) return v;
|
|
v = ChkPeriod(period); if (v != 0) return v;
|
|
try { Bias.Batch(Src(src, n), Dst(dst, n), period); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Cfo: Pattern A
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_cfo")]
|
|
public static int QtlCfo(double* src, int n, double* dst, int period)
|
|
{
|
|
int v = Chk1(src, dst, n); if (v != 0) return v;
|
|
v = ChkPeriod(period); if (v != 0) return v;
|
|
try { Cfo.Batch(Src(src, n), Dst(dst, n), period); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Cfb: Pattern A + int[] lengths — special: null-safe lengths array
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_cfb")]
|
|
public static int QtlCfb(double* src, int n, double* dst, int* lengths, int lengthsCount)
|
|
{
|
|
int v = Chk1(src, dst, n); if (v != 0) return v;
|
|
try
|
|
{
|
|
int[]? managed = null;
|
|
if (lengths != null && lengthsCount > 0)
|
|
{
|
|
managed = new int[lengthsCount];
|
|
new ReadOnlySpan<int>(lengths, lengthsCount).CopyTo(managed);
|
|
}
|
|
Cfb.Batch(Src(src, n), Dst(dst, n), managed);
|
|
return StatusCodes.QTL_OK;
|
|
}
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Asi: Pattern C (OHLC + double limitMove)
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_asi")]
|
|
public static int QtlAsi(double* open, double* high, double* low, double* close, int n, double* dst, double limitMove)
|
|
{
|
|
int v = Chk4(open, high, low, close, dst, n); if (v != 0) return v;
|
|
try { Asi.Batch(Src(open, n), Src(high, n), Src(low, n), Src(close, n), Dst(dst, n), limitMove); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// ═══════════════════════════════════════════════════════════════════════
|
|
// §8.3 Oscillators
|
|
// ═══════════════════════════════════════════════════════════════════════
|
|
|
|
// Fisher: Pattern A
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_fisher")]
|
|
public static int QtlFisher(double* src, int n, double* dst, int period)
|
|
{
|
|
int v = Chk1(src, dst, n); if (v != 0) return v;
|
|
v = ChkPeriod(period); if (v != 0) return v;
|
|
try { Fisher.Batch(Src(src, n), Dst(dst, n), period); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Fisher04: Pattern A
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_fisher04")]
|
|
public static int QtlFisher04(double* src, int n, double* dst, int period)
|
|
{
|
|
int v = Chk1(src, dst, n); if (v != 0) return v;
|
|
v = ChkPeriod(period); if (v != 0) return v;
|
|
try { Fisher04.Batch(Src(src, n), Dst(dst, n), period); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Dpo: Pattern A
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_dpo")]
|
|
public static int QtlDpo(double* src, int n, double* dst, int period)
|
|
{
|
|
int v = Chk1(src, dst, n); if (v != 0) return v;
|
|
v = ChkPeriod(period); if (v != 0) return v;
|
|
try { Dpo.Batch(Src(src, n), Dst(dst, n), period); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Trix: Pattern A
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_trix")]
|
|
public static int QtlTrix(double* src, int n, double* dst, int period)
|
|
{
|
|
int v = Chk1(src, dst, n); if (v != 0) return v;
|
|
v = ChkPeriod(period); if (v != 0) return v;
|
|
try { Trix.Batch(Src(src, n), Dst(dst, n), period); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Inertia: Pattern A
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_inertia")]
|
|
public static int QtlInertia(double* src, int n, double* dst, int period)
|
|
{
|
|
int v = Chk1(src, dst, n); if (v != 0) return v;
|
|
v = ChkPeriod(period); if (v != 0) return v;
|
|
try { Inertia.Batch(Src(src, n), Dst(dst, n), period); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Rsx: Pattern A
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_rsx")]
|
|
public static int QtlRsx(double* src, int n, double* dst, int period)
|
|
{
|
|
int v = Chk1(src, dst, n); if (v != 0) return v;
|
|
v = ChkPeriod(period); if (v != 0) return v;
|
|
try { Rsx.Batch(Src(src, n), Dst(dst, n), period); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Er: Pattern A
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_er")]
|
|
public static int QtlEr(double* src, int n, double* dst, int period)
|
|
{
|
|
int v = Chk1(src, dst, n); if (v != 0) return v;
|
|
v = ChkPeriod(period); if (v != 0) return v;
|
|
try { Er.Batch(Src(src, n), Dst(dst, n), period); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Cti: Pattern A
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_cti")]
|
|
public static int QtlCti(double* src, int n, double* dst, int period)
|
|
{
|
|
int v = Chk1(src, dst, n); if (v != 0) return v;
|
|
v = ChkPeriod(period); if (v != 0) return v;
|
|
try { Cti.Batch(Src(src, n), Dst(dst, n), period); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Reflex: Pattern A
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_reflex")]
|
|
public static int QtlReflex(double* src, int n, double* dst, int period)
|
|
{
|
|
int v = Chk1(src, dst, n); if (v != 0) return v;
|
|
v = ChkPeriod(period); if (v != 0) return v;
|
|
try { Reflex.Batch(Src(src, n), Dst(dst, n), period); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Trendflex: Pattern A
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_trendflex")]
|
|
public static int QtlTrendflex(double* src, int n, double* dst, int period)
|
|
{
|
|
int v = Chk1(src, dst, n); if (v != 0) return v;
|
|
v = ChkPeriod(period); if (v != 0) return v;
|
|
try { Trendflex.Batch(Src(src, n), Dst(dst, n), period); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Kri: Pattern A
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_kri")]
|
|
public static int QtlKri(double* src, int n, double* dst, int period)
|
|
{
|
|
int v = Chk1(src, dst, n); if (v != 0) return v;
|
|
v = ChkPeriod(period); if (v != 0) return v;
|
|
try { Kri.Batch(Src(src, n), Dst(dst, n), period); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Psl: Pattern A
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_psl")]
|
|
public static int QtlPsl(double* src, int n, double* dst, int period)
|
|
{
|
|
int v = Chk1(src, dst, n); if (v != 0) return v;
|
|
v = ChkPeriod(period); if (v != 0) return v;
|
|
try { Psl.Batch(Src(src, n), Dst(dst, n), period); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Deco: Pattern A (src, out, int period, int emaPeriod)
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_deco")]
|
|
public static int QtlDeco(double* src, int n, double* dst, int period, int emaPeriod)
|
|
{
|
|
int v = Chk1(src, dst, n); if (v != 0) return v;
|
|
if (period <= 0 || emaPeriod <= 0) return StatusCodes.QTL_ERR_INVALID_PARAM;
|
|
try { Deco.Batch(Src(src, n), Dst(dst, n), period, emaPeriod); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Dosc: Pattern A (src, out, int shortPeriod, int longPeriod, int ppoShort, int ppoLong)
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_dosc")]
|
|
public static int QtlDosc(double* src, int n, double* dst, int p1, int p2, int p3, int p4)
|
|
{
|
|
int v = Chk1(src, dst, n); if (v != 0) return v;
|
|
if (p1 <= 0 || p2 <= 0 || p3 <= 0 || p4 <= 0) return StatusCodes.QTL_ERR_INVALID_PARAM;
|
|
try { Dosc.Batch(Src(src, n), Dst(dst, n), p1, p2, p3, p4); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Dymoi: Pattern A (src, out, int p1..p5)
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_dymoi")]
|
|
public static int QtlDymoi(double* src, int n, double* dst, int p1, int p2, int p3, int p4, int p5)
|
|
{
|
|
int v = Chk1(src, dst, n); if (v != 0) return v;
|
|
try { Dymoi.Batch(Src(src, n), Dst(dst, n), p1, p2, p3, p4, p5); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Crsi: Pattern A (src, out, int rsiPeriod, int streakPeriod, int rankPeriod)
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_crsi")]
|
|
public static int QtlCrsi(double* src, int n, double* dst, int rsiPeriod, int streakPeriod, int rankPeriod)
|
|
{
|
|
int v = Chk1(src, dst, n); if (v != 0) return v;
|
|
if (rsiPeriod <= 0 || streakPeriod <= 0 || rankPeriod <= 0) return StatusCodes.QTL_ERR_INVALID_PARAM;
|
|
try { Crsi.Batch(Src(src, n), Dst(dst, n), rsiPeriod, streakPeriod, rankPeriod); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Bbb: Pattern A (src, out, int period, double mult)
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_bbb")]
|
|
public static int QtlBbb(double* src, int n, double* dst, int period, double mult)
|
|
{
|
|
int v = Chk1(src, dst, n); if (v != 0) return v;
|
|
v = ChkPeriod(period); if (v != 0) return v;
|
|
try { Bbb.Batch(Src(src, n), Dst(dst, n), period, mult); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Bbi: Pattern A (src, out, int p1, int p2, int p3, int p4)
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_bbi")]
|
|
public static int QtlBbi(double* src, int n, double* dst, int p1, int p2, int p3, int p4)
|
|
{
|
|
int v = Chk1(src, dst, n); if (v != 0) return v;
|
|
try { Bbi.Batch(Src(src, n), Dst(dst, n), p1, p2, p3, p4); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Dem: Pattern D (high, low, out, int period)
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_dem")]
|
|
public static int QtlDem(double* high, double* low, int n, double* dst, int period)
|
|
{
|
|
int v = Chk2(high, low, dst, n); if (v != 0) return v;
|
|
v = ChkPeriod(period); if (v != 0) return v;
|
|
try { Dem.Batch(Src(high, n), Src(low, n), Dst(dst, n), period); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Brar: Pattern C (OHLC, 2 outputs, int period) — multi-output
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_brar")]
|
|
public static int QtlBrar(double* open, double* high, double* low, double* close, int n, double* dstBr, double* dstAr, int period)
|
|
{
|
|
if (open == null || high == null || low == null || close == null || dstBr == null || dstAr == null) return StatusCodes.QTL_ERR_NULL_PTR;
|
|
if (n <= 0) return StatusCodes.QTL_ERR_INVALID_LENGTH;
|
|
int v = ChkPeriod(period); if (v != 0) return v;
|
|
try { Brar.Batch(Src(open, n), Src(high, n), Src(low, n), Src(close, n), Dst(dstBr, n), Dst(dstAr, n), period); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// ═══════════════════════════════════════════════════════════════════════
|
|
// §8.4 Trends — FIR
|
|
// ═══════════════════════════════════════════════════════════════════════
|
|
|
|
// Sma: Pattern A (src, out, int period)
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_sma")]
|
|
public static int QtlSma(double* src, int n, double* dst, int period)
|
|
{
|
|
int v = Chk1(src, dst, n); if (v != 0) return v;
|
|
v = ChkPeriod(period); if (v != 0) return v;
|
|
try { Sma.Batch(Src(src, n), Dst(dst, n), period); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Wma: Pattern A
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_wma")]
|
|
public static int QtlWma(double* src, int n, double* dst, int period)
|
|
{
|
|
int v = Chk1(src, dst, n); if (v != 0) return v;
|
|
v = ChkPeriod(period); if (v != 0) return v;
|
|
try { Wma.Batch(Src(src, n), Dst(dst, n), period); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Hma: Pattern A
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_hma")]
|
|
public static int QtlHma(double* src, int n, double* dst, int period)
|
|
{
|
|
int v = Chk1(src, dst, n); if (v != 0) return v;
|
|
v = ChkPeriod(period); if (v != 0) return v;
|
|
try { Hma.Batch(Src(src, n), Dst(dst, n), period); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Trima: Pattern A
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_trima")]
|
|
public static int QtlTrima(double* src, int n, double* dst, int period)
|
|
{
|
|
int v = Chk1(src, dst, n); if (v != 0) return v;
|
|
v = ChkPeriod(period); if (v != 0) return v;
|
|
try { Trima.Batch(Src(src, n), Dst(dst, n), period); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Swma: Pattern A
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_swma")]
|
|
public static int QtlSwma(double* src, int n, double* dst, int period)
|
|
{
|
|
int v = Chk1(src, dst, n); if (v != 0) return v;
|
|
v = ChkPeriod(period); if (v != 0) return v;
|
|
try { Swma.Batch(Src(src, n), Dst(dst, n), period); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Dwma: Pattern A
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_dwma")]
|
|
public static int QtlDwma(double* src, int n, double* dst, int period)
|
|
{
|
|
int v = Chk1(src, dst, n); if (v != 0) return v;
|
|
v = ChkPeriod(period); if (v != 0) return v;
|
|
try { Dwma.Batch(Src(src, n), Dst(dst, n), period); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Blma: Pattern A
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_blma")]
|
|
public static int QtlBlma(double* src, int n, double* dst, int period)
|
|
{
|
|
int v = Chk1(src, dst, n); if (v != 0) return v;
|
|
v = ChkPeriod(period); if (v != 0) return v;
|
|
try { Blma.Batch(Src(src, n), Dst(dst, n), period); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Alma: Pattern A (src, out, int period, double offset, double sigma)
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_alma")]
|
|
public static int QtlAlma(double* src, int n, double* dst, int period, double offset, double sigma)
|
|
{
|
|
int v = Chk1(src, dst, n); if (v != 0) return v;
|
|
v = ChkPeriod(period); if (v != 0) return v;
|
|
try { Alma.Batch(Src(src, n), Dst(dst, n), period, offset, sigma); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Lsma: Pattern A (src, out, int period, int offset, double multiplier)
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_lsma")]
|
|
public static int QtlLsma(double* src, int n, double* dst, int period, int offset, double multiplier)
|
|
{
|
|
int v = Chk1(src, dst, n); if (v != 0) return v;
|
|
v = ChkPeriod(period); if (v != 0) return v;
|
|
try { Lsma.Batch(Src(src, n), Dst(dst, n), period, offset, multiplier); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Sgma: Pattern A
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_sgma")]
|
|
public static int QtlSgma(double* src, int n, double* dst, int period)
|
|
{
|
|
int v = Chk1(src, dst, n); if (v != 0) return v;
|
|
v = ChkPeriod(period); if (v != 0) return v;
|
|
try { Sgma.Batch(Src(src, n), Dst(dst, n), period); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Sinema: Pattern A
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_sinema")]
|
|
public static int QtlSinema(double* src, int n, double* dst, int period)
|
|
{
|
|
int v = Chk1(src, dst, n); if (v != 0) return v;
|
|
v = ChkPeriod(period); if (v != 0) return v;
|
|
try { Sinema.Batch(Src(src, n), Dst(dst, n), period); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Hanma: Pattern A
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_hanma")]
|
|
public static int QtlHanma(double* src, int n, double* dst, int period)
|
|
{
|
|
int v = Chk1(src, dst, n); if (v != 0) return v;
|
|
v = ChkPeriod(period); if (v != 0) return v;
|
|
try { Hanma.Batch(Src(src, n), Dst(dst, n), period); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Parzen: Pattern A
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_parzen")]
|
|
public static int QtlParzen(double* src, int n, double* dst, int period)
|
|
{
|
|
int v = Chk1(src, dst, n); if (v != 0) return v;
|
|
v = ChkPeriod(period); if (v != 0) return v;
|
|
try { Parzen.Batch(Src(src, n), Dst(dst, n), period); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Tsf: Pattern A
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_tsf")]
|
|
public static int QtlTsf(double* src, int n, double* dst, int period)
|
|
{
|
|
int v = Chk1(src, dst, n); if (v != 0) return v;
|
|
v = ChkPeriod(period); if (v != 0) return v;
|
|
try { Tsf.Batch(Src(src, n), Dst(dst, n), period); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Conv: Pattern A + double[] kernel
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_conv")]
|
|
public static int QtlConv(double* src, int n, double* dst, double* kernel, int kernelLen)
|
|
{
|
|
int v = Chk1(src, dst, n); if (v != 0) return v;
|
|
if (kernel == null || kernelLen <= 0) return StatusCodes.QTL_ERR_INVALID_PARAM;
|
|
try
|
|
{
|
|
var k = new double[kernelLen];
|
|
new ReadOnlySpan<double>(kernel, kernelLen).CopyTo(k);
|
|
Conv.Batch(Src(src, n), Dst(dst, n), k);
|
|
return StatusCodes.QTL_OK;
|
|
}
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Bwma: Pattern A (src, out, int period, int polyOrder)
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_bwma")]
|
|
public static int QtlBwma(double* src, int n, double* dst, int period, int polyOrder)
|
|
{
|
|
int v = Chk1(src, dst, n); if (v != 0) return v;
|
|
v = ChkPeriod(period); if (v != 0) return v;
|
|
try { Bwma.Batch(Src(src, n), Dst(dst, n), period, polyOrder); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Crma: Pattern A (src, out, int period, double volumeFactor)
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_crma")]
|
|
public static int QtlCrma(double* src, int n, double* dst, int period, double volumeFactor)
|
|
{
|
|
int v = Chk1(src, dst, n); if (v != 0) return v;
|
|
v = ChkPeriod(period); if (v != 0) return v;
|
|
try { Crma.Batch(Src(src, n), Dst(dst, n), period, volumeFactor); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Sp15: Pattern A
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_sp15")]
|
|
public static int QtlSp15(double* src, int n, double* dst, int period)
|
|
{
|
|
int v = Chk1(src, dst, n); if (v != 0) return v;
|
|
v = ChkPeriod(period); if (v != 0) return v;
|
|
try { Sp15.Batch(Src(src, n), Dst(dst, n), period); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Tukey_w: Pattern A
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_tukey_w")]
|
|
public static int QtlTukeyW(double* src, int n, double* dst, int period)
|
|
{
|
|
int v = Chk1(src, dst, n); if (v != 0) return v;
|
|
v = ChkPeriod(period); if (v != 0) return v;
|
|
try { Tukey_w.Batch(Src(src, n), Dst(dst, n), period); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Rain: Pattern A
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_rain")]
|
|
public static int QtlRain(double* src, int n, double* dst, int period)
|
|
{
|
|
int v = Chk1(src, dst, n); if (v != 0) return v;
|
|
v = ChkPeriod(period); if (v != 0) return v;
|
|
try { Rain.Batch(Src(src, n), Dst(dst, n), period); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Afirma: Pattern A + WindowType enum (mapped to int)
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_afirma")]
|
|
public static int QtlAfirma(double* src, int n, double* dst, int period, int windowType, int useSimd)
|
|
{
|
|
int v = Chk1(src, dst, n); if (v != 0) return v;
|
|
v = ChkPeriod(period); if (v != 0) return v;
|
|
try { Afirma.Batch(Src(src, n), Dst(dst, n), period, (Afirma.WindowType)windowType, useSimd != 0); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// ═══════════════════════════════════════════════════════════════════════
|
|
// §8.5 Trends — IIR
|
|
// ═══════════════════════════════════════════════════════════════════════
|
|
|
|
// Ema: takes double alpha — export both period (with conversion) and alpha variants
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_ema")]
|
|
public static int QtlEma(double* src, int n, double* dst, int period)
|
|
{
|
|
int v = Chk1(src, dst, n); if (v != 0) return v;
|
|
v = ChkPeriod(period); if (v != 0) return v;
|
|
try { Ema.Batch(Src(src, n), Dst(dst, n), 2.0 / (period + 1)); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_ema_alpha")]
|
|
public static int QtlEmaAlpha(double* src, int n, double* dst, double alpha)
|
|
{
|
|
int v = Chk1(src, dst, n); if (v != 0) return v;
|
|
v = ChkAlpha(alpha); if (v != 0) return v;
|
|
try { Ema.Batch(Src(src, n), Dst(dst, n), alpha); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Dema: double alpha
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_dema")]
|
|
public static int QtlDema(double* src, int n, double* dst, int period)
|
|
{
|
|
int v = Chk1(src, dst, n); if (v != 0) return v;
|
|
v = ChkPeriod(period); if (v != 0) return v;
|
|
try { Dema.Batch(Src(src, n), Dst(dst, n), 2.0 / (period + 1)); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_dema_alpha")]
|
|
public static int QtlDemaAlpha(double* src, int n, double* dst, double alpha)
|
|
{
|
|
int v = Chk1(src, dst, n); if (v != 0) return v;
|
|
v = ChkAlpha(alpha); if (v != 0) return v;
|
|
try { Dema.Batch(Src(src, n), Dst(dst, n), alpha); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Tema: double alpha
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_tema")]
|
|
public static int QtlTema(double* src, int n, double* dst, int period)
|
|
{
|
|
int v = Chk1(src, dst, n); if (v != 0) return v;
|
|
v = ChkPeriod(period); if (v != 0) return v;
|
|
try { Tema.Batch(Src(src, n), Dst(dst, n), 2.0 / (period + 1)); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Lema: double alpha
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_lema")]
|
|
public static int QtlLema(double* src, int n, double* dst, int period)
|
|
{
|
|
int v = Chk1(src, dst, n); if (v != 0) return v;
|
|
v = ChkPeriod(period); if (v != 0) return v;
|
|
try { Lema.Batch(Src(src, n), Dst(dst, n), 2.0 / (period + 1)); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Hema: int period
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_hema")]
|
|
public static int QtlHema(double* src, int n, double* dst, int period)
|
|
{
|
|
int v = Chk1(src, dst, n); if (v != 0) return v;
|
|
v = ChkPeriod(period); if (v != 0) return v;
|
|
try { Hema.Batch(Src(src, n), Dst(dst, n), period); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Ahrens: int period
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_ahrens")]
|
|
public static int QtlAhrens(double* src, int n, double* dst, int period)
|
|
{
|
|
int v = Chk1(src, dst, n); if (v != 0) return v;
|
|
v = ChkPeriod(period); if (v != 0) return v;
|
|
try { Ahrens.Batch(Src(src, n), Dst(dst, n), period); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Decycler: int period
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_decycler")]
|
|
public static int QtlDecycler(double* src, int n, double* dst, int period)
|
|
{
|
|
int v = Chk1(src, dst, n); if (v != 0) return v;
|
|
v = ChkPeriod(period); if (v != 0) return v;
|
|
try { Decycler.Batch(Src(src, n), Dst(dst, n), period); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Dsma: int period, double volumeFactor
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_dsma")]
|
|
public static int QtlDsma(double* src, int n, double* dst, int period, double factor)
|
|
{
|
|
int v = Chk1(src, dst, n); if (v != 0) return v;
|
|
v = ChkPeriod(period); if (v != 0) return v;
|
|
try { Dsma.Batch(Src(src, n), Dst(dst, n), period, factor); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Gdema: int period, double volumeFactor
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_gdema")]
|
|
public static int QtlGdema(double* src, int n, double* dst, int period, double factor)
|
|
{
|
|
int v = Chk1(src, dst, n); if (v != 0) return v;
|
|
v = ChkPeriod(period); if (v != 0) return v;
|
|
try { Gdema.Batch(Src(src, n), Dst(dst, n), period, factor); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Coral: int period, double friction
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_coral")]
|
|
public static int QtlCoral(double* src, int n, double* dst, int period, double friction)
|
|
{
|
|
int v = Chk1(src, dst, n); if (v != 0) return v;
|
|
v = ChkPeriod(period); if (v != 0) return v;
|
|
try { Coral.Batch(Src(src, n), Dst(dst, n), period, friction); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Agc: double alpha
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_agc")]
|
|
public static int QtlAgc(double* src, int n, double* dst, double alpha)
|
|
{
|
|
int v = Chk1(src, dst, n); if (v != 0) return v;
|
|
try { Agc.Batch(Src(src, n), Dst(dst, n), alpha); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Ccyc: double alpha
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_ccyc")]
|
|
public static int QtlCcyc(double* src, int n, double* dst, double alpha)
|
|
{
|
|
int v = Chk1(src, dst, n); if (v != 0) return v;
|
|
try { Ccyc.Batch(Src(src, n), Dst(dst, n), alpha); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// ═══════════════════════════════════════════════════════════════════════
|
|
// §8.6 Channels
|
|
// ═══════════════════════════════════════════════════════════════════════
|
|
|
|
// Bbands: Pattern I (src, upper, mid, lower, int period, double mult)
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_bbands")]
|
|
public static int QtlBbands(double* src, int n, double* upper, double* mid, double* lower, int period, double mult)
|
|
{
|
|
if (src == null || upper == null || mid == null || lower == null) return StatusCodes.QTL_ERR_NULL_PTR;
|
|
if (n <= 0) return StatusCodes.QTL_ERR_INVALID_LENGTH;
|
|
int v = ChkPeriod(period); if (v != 0) return v;
|
|
try { Bbands.Batch(Src(src, n), Dst(mid, n), Dst(upper, n), Dst(lower, n), period, mult); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// AtrBands: Pattern E-I (HLC, 3 outputs, int period, double mult)
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_atrbands")]
|
|
public static int QtlAtrBands(double* high, double* low, double* close, int n, double* upper, double* mid, double* lower, int period, double mult)
|
|
{
|
|
if (high == null || low == null || close == null || upper == null || mid == null || lower == null) return StatusCodes.QTL_ERR_NULL_PTR;
|
|
if (n <= 0) return StatusCodes.QTL_ERR_INVALID_LENGTH;
|
|
int v = ChkPeriod(period); if (v != 0) return v;
|
|
try { AtrBands.Batch(Src(high, n), Src(low, n), Src(close, n), Dst(mid, n), Dst(upper, n), Dst(lower, n), period, mult); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Apchannel: Pattern D-I (HL, 2 outputs, double multiplier)
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_apchannel")]
|
|
public static int QtlApchannel(double* high, double* low, int n, double* dstUp, double* dstLow, double multiplier)
|
|
{
|
|
if (high == null || low == null || dstUp == null || dstLow == null) return StatusCodes.QTL_ERR_NULL_PTR;
|
|
if (n <= 0) return StatusCodes.QTL_ERR_INVALID_LENGTH;
|
|
try { Apchannel.Batch(Src(high, n), Src(low, n), Dst(dstUp, n), Dst(dstLow, n), multiplier); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// ═══════════════════════════════════════════════════════════════════════
|
|
// §8.7 Volatility
|
|
// ═══════════════════════════════════════════════════════════════════════
|
|
|
|
// Tr: Pattern E (HLC, no params)
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_tr")]
|
|
public static int QtlTr(double* high, double* low, double* close, int n, double* dst)
|
|
{
|
|
int v = Chk3(high, low, close, dst, n); if (v != 0) return v;
|
|
try { Tr.Batch(Src(high, n), Src(low, n), Src(close, n), Dst(dst, n)); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Bbw: Pattern A (src, out, int period, double mult)
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_bbw")]
|
|
public static int QtlBbw(double* src, int n, double* dst, int period, double mult)
|
|
{
|
|
int v = Chk1(src, dst, n); if (v != 0) return v;
|
|
v = ChkPeriod(period); if (v != 0) return v;
|
|
try { Bbw.Batch(Src(src, n), Dst(dst, n), period, mult); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Bbwn: Pattern A (src, out, int period, double mult, int lookback)
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_bbwn")]
|
|
public static int QtlBbwn(double* src, int n, double* dst, int period, double mult, int lookback)
|
|
{
|
|
int v = Chk1(src, dst, n); if (v != 0) return v;
|
|
v = ChkPeriod(period); if (v != 0) return v;
|
|
try { Bbwn.Batch(Src(src, n), Dst(dst, n), period, mult, lookback); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Bbwp: Pattern A (src, out, int period, double mult, int lookback)
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_bbwp")]
|
|
public static int QtlBbwp(double* src, int n, double* dst, int period, double mult, int lookback)
|
|
{
|
|
int v = Chk1(src, dst, n); if (v != 0) return v;
|
|
v = ChkPeriod(period); if (v != 0) return v;
|
|
try { Bbwp.Batch(Src(src, n), Dst(dst, n), period, mult, lookback); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// StdDev: Pattern A
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_stddev")]
|
|
public static int QtlStdDev(double* src, int n, double* dst, int period)
|
|
{
|
|
int v = Chk1(src, dst, n); if (v != 0) return v;
|
|
v = ChkPeriod(period); if (v != 0) return v;
|
|
try { StdDev.Batch(Src(src, n), Dst(dst, n), period); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Variance: Pattern A
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_variance")]
|
|
public static int QtlVariance(double* src, int n, double* dst, int period)
|
|
{
|
|
int v = Chk1(src, dst, n); if (v != 0) return v;
|
|
v = ChkPeriod(period); if (v != 0) return v;
|
|
try { Variance.Batch(Src(src, n), Dst(dst, n), period); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Etherm: Pattern D (high, low, out, int period)
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_etherm")]
|
|
public static int QtlEtherm(double* high, double* low, int n, double* dst, int period)
|
|
{
|
|
int v = Chk2(high, low, dst, n); if (v != 0) return v;
|
|
v = ChkPeriod(period); if (v != 0) return v;
|
|
try { Etherm.Batch(Src(high, n), Src(low, n), Dst(dst, n), period); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Ccv: Pattern A (src, out, int shortPeriod, int longPeriod)
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_ccv")]
|
|
public static int QtlCcv(double* src, int n, double* dst, int shortPeriod, int longPeriod)
|
|
{
|
|
int v = Chk1(src, dst, n); if (v != 0) return v;
|
|
if (shortPeriod <= 0 || longPeriod <= 0) return StatusCodes.QTL_ERR_INVALID_PARAM;
|
|
try { Ccv.Batch(Src(src, n), Dst(dst, n), shortPeriod, longPeriod); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Cv: Pattern A (src, out, int period, double minVol, double maxVol)
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_cv")]
|
|
public static int QtlCv(double* src, int n, double* dst, int period, double minVol, double maxVol)
|
|
{
|
|
int v = Chk1(src, dst, n); if (v != 0) return v;
|
|
v = ChkPeriod(period); if (v != 0) return v;
|
|
try { Cv.Batch(Src(src, n), Dst(dst, n), period, minVol, maxVol); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Cvi: Pattern A (src, out, int emaPeriod, int rocPeriod)
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_cvi")]
|
|
public static int QtlCvi(double* src, int n, double* dst, int emaPeriod, int rocPeriod)
|
|
{
|
|
int v = Chk1(src, dst, n); if (v != 0) return v;
|
|
if (emaPeriod <= 0 || rocPeriod <= 0) return StatusCodes.QTL_ERR_INVALID_PARAM;
|
|
try { Cvi.Batch(Src(src, n), Dst(dst, n), emaPeriod, rocPeriod); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Ewma: Pattern A (src, out, int period, bool isPopulation, int annFactor)
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_ewma")]
|
|
public static int QtlEwma(double* src, int n, double* dst, int period, int isPopulation, int annFactor)
|
|
{
|
|
int v = Chk1(src, dst, n); if (v != 0) return v;
|
|
v = ChkPeriod(period); if (v != 0) return v;
|
|
try { Ewma.Batch(Src(src, n), Dst(dst, n), period, isPopulation != 0, annFactor); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// ═══════════════════════════════════════════════════════════════════════
|
|
// §8.8 Volume
|
|
// ═══════════════════════════════════════════════════════════════════════
|
|
|
|
// Obv: Pattern G (close, volume, out)
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_obv")]
|
|
public static int QtlObv(double* close, double* volume, int n, double* dst)
|
|
{
|
|
int v = Chk2(close, volume, dst, n); if (v != 0) return v;
|
|
try { Obv.Batch(Src(close, n), Src(volume, n), Dst(dst, n)); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Pvt: Pattern G
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_pvt")]
|
|
public static int QtlPvt(double* close, double* volume, int n, double* dst)
|
|
{
|
|
int v = Chk2(close, volume, dst, n); if (v != 0) return v;
|
|
try { Pvt.Batch(Src(close, n), Src(volume, n), Dst(dst, n)); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Pvr: Pattern G
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_pvr")]
|
|
public static int QtlPvr(double* close, double* volume, int n, double* dst)
|
|
{
|
|
int v = Chk2(close, volume, dst, n); if (v != 0) return v;
|
|
try { Pvr.Batch(Src(close, n), Src(volume, n), Dst(dst, n)); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Vf: Pattern G
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_vf")]
|
|
public static int QtlVf(double* close, double* volume, int n, double* dst)
|
|
{
|
|
int v = Chk2(close, volume, dst, n); if (v != 0) return v;
|
|
try { Vf.Batch(Src(close, n), Src(volume, n), Dst(dst, n)); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Nvi: Pattern G
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_nvi")]
|
|
public static int QtlNvi(double* close, double* volume, int n, double* dst)
|
|
{
|
|
int v = Chk2(close, volume, dst, n); if (v != 0) return v;
|
|
try { Nvi.Batch(Src(close, n), Src(volume, n), Dst(dst, n)); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Pvi: Pattern G
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_pvi")]
|
|
public static int QtlPvi(double* close, double* volume, int n, double* dst)
|
|
{
|
|
int v = Chk2(close, volume, dst, n); if (v != 0) return v;
|
|
try { Pvi.Batch(Src(close, n), Src(volume, n), Dst(dst, n)); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Tvi: Pattern G + int period
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_tvi")]
|
|
public static int QtlTvi(double* close, double* volume, int n, double* dst, int period)
|
|
{
|
|
int v = Chk2(close, volume, dst, n); if (v != 0) return v;
|
|
v = ChkPeriod(period); if (v != 0) return v;
|
|
try { Tvi.Batch(Src(close, n), Src(volume, n), Dst(dst, n), period); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Pvd: Pattern G + int period
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_pvd")]
|
|
public static int QtlPvd(double* close, double* volume, int n, double* dst, int period)
|
|
{
|
|
int v = Chk2(close, volume, dst, n); if (v != 0) return v;
|
|
v = ChkPeriod(period); if (v != 0) return v;
|
|
try { Pvd.Batch(Src(close, n), Src(volume, n), Dst(dst, n), period); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Vwma: Pattern G + int period
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_vwma")]
|
|
public static int QtlVwma(double* close, double* volume, int n, double* dst, int period)
|
|
{
|
|
int v = Chk2(close, volume, dst, n); if (v != 0) return v;
|
|
v = ChkPeriod(period); if (v != 0) return v;
|
|
try { Vwma.Batch(Src(close, n), Src(volume, n), Dst(dst, n), period); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Evwma: Pattern G + int period
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_evwma")]
|
|
public static int QtlEvwma(double* close, double* volume, int n, double* dst, int period)
|
|
{
|
|
int v = Chk2(close, volume, dst, n); if (v != 0) return v;
|
|
v = ChkPeriod(period); if (v != 0) return v;
|
|
try { Evwma.Batch(Src(close, n), Src(volume, n), Dst(dst, n), period); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Efi: Pattern G + int period
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_efi")]
|
|
public static int QtlEfi(double* close, double* volume, int n, double* dst, int period)
|
|
{
|
|
int v = Chk2(close, volume, dst, n); if (v != 0) return v;
|
|
v = ChkPeriod(period); if (v != 0) return v;
|
|
try { Efi.Batch(Src(close, n), Src(volume, n), Dst(dst, n), period); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Aobv: Pattern G, 2 outputs (fast, slow)
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_aobv")]
|
|
public static int QtlAobv(double* close, double* volume, int n, double* dstFast, double* dstSlow)
|
|
{
|
|
if (close == null || volume == null || dstFast == null || dstSlow == null) return StatusCodes.QTL_ERR_NULL_PTR;
|
|
if (n <= 0) return StatusCodes.QTL_ERR_INVALID_LENGTH;
|
|
try { Aobv.Batch(Src(close, n), Src(volume, n), Dst(dstFast, n), Dst(dstSlow, n)); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Mfi: Pattern B (HLCV + int period)
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_mfi")]
|
|
public static int QtlMfi(double* high, double* low, double* close, double* volume, int n, double* dst, int period)
|
|
{
|
|
if (high == null || low == null || close == null || volume == null || dst == null) return StatusCodes.QTL_ERR_NULL_PTR;
|
|
if (n <= 0) return StatusCodes.QTL_ERR_INVALID_LENGTH;
|
|
int v = ChkPeriod(period); if (v != 0) return v;
|
|
try { Mfi.Batch(Src(high, n), Src(low, n), Src(close, n), Src(volume, n), Dst(dst, n), period); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Cmf: Pattern B (HLCV + int period)
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_cmf")]
|
|
public static int QtlCmf(double* high, double* low, double* close, double* volume, int n, double* dst, int period)
|
|
{
|
|
if (high == null || low == null || close == null || volume == null || dst == null) return StatusCodes.QTL_ERR_NULL_PTR;
|
|
if (n <= 0) return StatusCodes.QTL_ERR_INVALID_LENGTH;
|
|
int v = ChkPeriod(period); if (v != 0) return v;
|
|
try { Cmf.Batch(Src(high, n), Src(low, n), Src(close, n), Src(volume, n), Dst(dst, n), period); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Eom: Pattern (HL + volume, int period, double divisor) — 3 inputs + 2 params
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_eom")]
|
|
public static int QtlEom(double* high, double* low, double* volume, int n, double* dst, int period, double divisor)
|
|
{
|
|
if (high == null || low == null || volume == null || dst == null) return StatusCodes.QTL_ERR_NULL_PTR;
|
|
if (n <= 0) return StatusCodes.QTL_ERR_INVALID_LENGTH;
|
|
int v = ChkPeriod(period); if (v != 0) return v;
|
|
try { Eom.Batch(Src(high, n), Src(low, n), Src(volume, n), Dst(dst, n), period, divisor); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Pvo: Pattern I (volume, 3 outputs, int fast, int slow, int signal)
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_pvo")]
|
|
public static int QtlPvo(double* volume, int n, double* dstPvo, double* dstSignal, double* dstHist, int fast, int slow, int signal)
|
|
{
|
|
if (volume == null || dstPvo == null || dstSignal == null || dstHist == null) return StatusCodes.QTL_ERR_NULL_PTR;
|
|
if (n <= 0) return StatusCodes.QTL_ERR_INVALID_LENGTH;
|
|
if (fast <= 0 || slow <= 0 || signal <= 0) return StatusCodes.QTL_ERR_INVALID_PARAM;
|
|
try { Pvo.Batch(Src(volume, n), Dst(dstPvo, n), Dst(dstSignal, n), Dst(dstHist, n), fast, slow, signal); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// ═══════════════════════════════════════════════════════════════════════
|
|
// §8.9 Statistics
|
|
// ═══════════════════════════════════════════════════════════════════════
|
|
|
|
// Zscore: Pattern A
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_zscore")]
|
|
public static int QtlZscore(double* src, int n, double* dst, int period)
|
|
{
|
|
int v = Chk1(src, dst, n); if (v != 0) return v;
|
|
v = ChkPeriod(period); if (v != 0) return v;
|
|
try { Zscore.Batch(Src(src, n), Dst(dst, n), period); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Cma: Pattern A (src, out) — no params
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_cma")]
|
|
public static int QtlCma(double* src, int n, double* dst)
|
|
{
|
|
int v = Chk1(src, dst, n); if (v != 0) return v;
|
|
try { Cma.Batch(Src(src, n), Dst(dst, n)); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Entropy: Pattern A
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_entropy")]
|
|
public static int QtlEntropy(double* src, int n, double* dst, int period)
|
|
{
|
|
int v = Chk1(src, dst, n); if (v != 0) return v;
|
|
v = ChkPeriod(period); if (v != 0) return v;
|
|
try { Entropy.Batch(Src(src, n), Dst(dst, n), period); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Correlation: Pattern H (x, y, out, int period)
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_correlation")]
|
|
public static int QtlCorrelation(double* x, double* y, int n, double* dst, int period)
|
|
{
|
|
int v = Chk2(x, y, dst, n); if (v != 0) return v;
|
|
v = ChkPeriod(period); if (v != 0) return v;
|
|
try { Correlation.Batch(Src(x, n), Src(y, n), Dst(dst, n), period); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Covariance: Pattern H + bool isPopulation
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_covariance")]
|
|
public static int QtlCovariance(double* x, double* y, int n, double* dst, int period, int isPopulation)
|
|
{
|
|
int v = Chk2(x, y, dst, n); if (v != 0) return v;
|
|
v = ChkPeriod(period); if (v != 0) return v;
|
|
try { Covariance.Batch(Src(x, n), Src(y, n), Dst(dst, n), period, isPopulation != 0); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Cointegration: Pattern H
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_cointegration")]
|
|
public static int QtlCointegration(double* x, double* y, int n, double* dst, int period)
|
|
{
|
|
int v = Chk2(x, y, dst, n); if (v != 0) return v;
|
|
v = ChkPeriod(period); if (v != 0) return v;
|
|
try { Cointegration.Batch(Src(x, n), Src(y, n), Dst(dst, n), period); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// ═══════════════════════════════════════════════════════════════════════
|
|
// §8.10 Error Metrics
|
|
// ═══════════════════════════════════════════════════════════════════════
|
|
|
|
// Mse: Pattern F (actual, predicted, out, int period)
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_mse")]
|
|
public static int QtlMse(double* actual, double* predicted, int n, double* dst, int period)
|
|
{
|
|
int v = Chk2(actual, predicted, dst, n); if (v != 0) return v;
|
|
v = ChkPeriod(period); if (v != 0) return v;
|
|
try { Mse.Batch(Src(actual, n), Src(predicted, n), Dst(dst, n), period); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Rmse: Pattern F
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_rmse")]
|
|
public static int QtlRmse(double* actual, double* predicted, int n, double* dst, int period)
|
|
{
|
|
int v = Chk2(actual, predicted, dst, n); if (v != 0) return v;
|
|
v = ChkPeriod(period); if (v != 0) return v;
|
|
try { Rmse.Batch(Src(actual, n), Src(predicted, n), Dst(dst, n), period); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Mae: Pattern F
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_mae")]
|
|
public static int QtlMae(double* actual, double* predicted, int n, double* dst, int period)
|
|
{
|
|
int v = Chk2(actual, predicted, dst, n); if (v != 0) return v;
|
|
v = ChkPeriod(period); if (v != 0) return v;
|
|
try { Mae.Batch(Src(actual, n), Src(predicted, n), Dst(dst, n), period); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Mape: Pattern F
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_mape")]
|
|
public static int QtlMape(double* actual, double* predicted, int n, double* dst, int period)
|
|
{
|
|
int v = Chk2(actual, predicted, dst, n); if (v != 0) return v;
|
|
v = ChkPeriod(period); if (v != 0) return v;
|
|
try { Mape.Batch(Src(actual, n), Src(predicted, n), Dst(dst, n), period); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// ═══════════════════════════════════════════════════════════════════════
|
|
// §8.11 Filters
|
|
// ═══════════════════════════════════════════════════════════════════════
|
|
|
|
// Bessel: Pattern A (src, out, int period)
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_bessel")]
|
|
public static int QtlBessel(double* src, int n, double* dst, int period)
|
|
{
|
|
int v = Chk1(src, dst, n); if (v != 0) return v;
|
|
v = ChkPeriod(period); if (v != 0) return v;
|
|
try { Bessel.Batch(Src(src, n), Dst(dst, n), period); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Butter2: Pattern A (src, out, int period, double gain)
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_butter2")]
|
|
public static int QtlButter2(double* src, int n, double* dst, int period, double gain)
|
|
{
|
|
int v = Chk1(src, dst, n); if (v != 0) return v;
|
|
v = ChkPeriod(period); if (v != 0) return v;
|
|
try { Butter2.Batch(Src(src, n), Dst(dst, n), period, gain); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Butter3: Pattern A
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_butter3")]
|
|
public static int QtlButter3(double* src, int n, double* dst, int period, double gain)
|
|
{
|
|
int v = Chk1(src, dst, n); if (v != 0) return v;
|
|
v = ChkPeriod(period); if (v != 0) return v;
|
|
try { Butter3.Batch(Src(src, n), Dst(dst, n), period, gain); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Cheby1: Pattern A (int period, double ripple)
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_cheby1")]
|
|
public static int QtlCheby1(double* src, int n, double* dst, int period, double ripple)
|
|
{
|
|
int v = Chk1(src, dst, n); if (v != 0) return v;
|
|
v = ChkPeriod(period); if (v != 0) return v;
|
|
try { Cheby1.Batch(Src(src, n), Dst(dst, n), period, ripple); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Cheby2: Pattern A
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_cheby2")]
|
|
public static int QtlCheby2(double* src, int n, double* dst, int period, double ripple)
|
|
{
|
|
int v = Chk1(src, dst, n); if (v != 0) return v;
|
|
v = ChkPeriod(period); if (v != 0) return v;
|
|
try { Cheby2.Batch(Src(src, n), Dst(dst, n), period, ripple); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Elliptic: Pattern A
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_elliptic")]
|
|
public static int QtlElliptic(double* src, int n, double* dst, int period)
|
|
{
|
|
int v = Chk1(src, dst, n); if (v != 0) return v;
|
|
v = ChkPeriod(period); if (v != 0) return v;
|
|
try { Elliptic.Batch(Src(src, n), Dst(dst, n), period); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Edcf: Pattern A
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_edcf")]
|
|
public static int QtlEdcf(double* src, int n, double* dst, int period)
|
|
{
|
|
int v = Chk1(src, dst, n); if (v != 0) return v;
|
|
v = ChkPeriod(period); if (v != 0) return v;
|
|
try { Edcf.Batch(Src(src, n), Dst(dst, n), period); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Bpf: Pattern A (int period, int bandwidth)
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_bpf")]
|
|
public static int QtlBpf(double* src, int n, double* dst, int period, int bandwidth)
|
|
{
|
|
int v = Chk1(src, dst, n); if (v != 0) return v;
|
|
v = ChkPeriod(period); if (v != 0) return v;
|
|
try { Bpf.Batch(Src(src, n), Dst(dst, n), period, bandwidth); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// ALaguerre: Pattern A (int period, int order)
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_alaguerre")]
|
|
public static int QtlALaguerre(double* src, int n, double* dst, int period, int order)
|
|
{
|
|
int v = Chk1(src, dst, n); if (v != 0) return v;
|
|
v = ChkPeriod(period); if (v != 0) return v;
|
|
try { ALaguerre.Batch(Src(src, n), Dst(dst, n), period, order); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Bilateral: Pattern A (int period, double sigmaS, double sigmaR)
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_bilateral")]
|
|
public static int QtlBilateral(double* src, int n, double* dst, int period, double sigmaS, double sigmaR)
|
|
{
|
|
int v = Chk1(src, dst, n); if (v != 0) return v;
|
|
v = ChkPeriod(period); if (v != 0) return v;
|
|
try { Bilateral.Batch(Src(src, n), Dst(dst, n), period, sigmaS, sigmaR); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// BaxterKing: Pattern A (int period, int minPeriod, int maxPeriod)
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_baxterking")]
|
|
public static int QtlBaxterKing(double* src, int n, double* dst, int period, int minPeriod, int maxPeriod)
|
|
{
|
|
int v = Chk1(src, dst, n); if (v != 0) return v;
|
|
v = ChkPeriod(period); if (v != 0) return v;
|
|
try { BaxterKing.Batch(Src(src, n), Dst(dst, n), period, minPeriod, maxPeriod); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Cfitz: Pattern A (int period, int bandwidthPeriod)
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_cfitz")]
|
|
public static int QtlCfitz(double* src, int n, double* dst, int period, int bandwidthPeriod)
|
|
{
|
|
int v = Chk1(src, dst, n); if (v != 0) return v;
|
|
v = ChkPeriod(period); if (v != 0) return v;
|
|
try { Cfitz.Batch(Src(src, n), Dst(dst, n), period, bandwidthPeriod); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// ═══════════════════════════════════════════════════════════════════════
|
|
// §8.12 Cycles
|
|
// ═══════════════════════════════════════════════════════════════════════
|
|
|
|
// Cg: Pattern A
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_cg")]
|
|
public static int QtlCg(double* src, int n, double* dst, int period)
|
|
{
|
|
int v = Chk1(src, dst, n); if (v != 0) return v;
|
|
v = ChkPeriod(period); if (v != 0) return v;
|
|
try { Cg.Batch(Src(src, n), Dst(dst, n), period); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Dsp: Pattern A
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_dsp")]
|
|
public static int QtlDsp(double* src, int n, double* dst, int period)
|
|
{
|
|
int v = Chk1(src, dst, n); if (v != 0) return v;
|
|
v = ChkPeriod(period); if (v != 0) return v;
|
|
try { Dsp.Batch(Src(src, n), Dst(dst, n), period); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Ccor: Pattern A (int period, double alpha)
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_ccor")]
|
|
public static int QtlCcor(double* src, int n, double* dst, int period, double alpha)
|
|
{
|
|
int v = Chk1(src, dst, n); if (v != 0) return v;
|
|
v = ChkPeriod(period); if (v != 0) return v;
|
|
try { Ccor.Batch(Src(src, n), Dst(dst, n), period, alpha); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Ebsw: Pattern A (int period, int hpPeriod)
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_ebsw")]
|
|
public static int QtlEbsw(double* src, int n, double* dst, int period, int hpPeriod)
|
|
{
|
|
int v = Chk1(src, dst, n); if (v != 0) return v;
|
|
v = ChkPeriod(period); if (v != 0) return v;
|
|
try { Ebsw.Batch(Src(src, n), Dst(dst, n), period, hpPeriod); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Eacp: (int minPeriod, int maxPeriod, int avgLength, bool enhance → int)
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_eacp")]
|
|
public static int QtlEacp(double* src, int n, double* dst, int minPeriod, int maxPeriod, int avgLength, int enhance)
|
|
{
|
|
int v = Chk1(src, dst, n); if (v != 0) return v;
|
|
v = ChkPeriod(minPeriod); if (v != 0) return v;
|
|
try { Eacp.Batch(Src(src, n), Dst(dst, n), minPeriod, maxPeriod, avgLength, enhance != 0); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// ═══════════════════════════════════════════════════════════════════════
|
|
// §8.14 Numerics / transforms
|
|
// ═══════════════════════════════════════════════════════════════════════
|
|
|
|
// Change: Pattern A
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_change")]
|
|
public static int QtlChange(double* src, int n, double* dst, int period)
|
|
{
|
|
int v = Chk1(src, dst, n); if (v != 0) return v;
|
|
v = ChkPeriod(period); if (v != 0) return v;
|
|
try { Change.Batch(Src(src, n), Dst(dst, n), period); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Exptrans: Pattern A (no params)
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_exptrans")]
|
|
public static int QtlExptrans(double* src, int n, double* dst)
|
|
{
|
|
int v = Chk1(src, dst, n); if (v != 0) return v;
|
|
try { Exptrans.Batch(Src(src, n), Dst(dst, n)); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Betadist: Pattern A (int period, double alpha, double beta)
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_betadist")]
|
|
public static int QtlBetadist(double* src, int n, double* dst, int period, double alpha, double beta)
|
|
{
|
|
int v = Chk1(src, dst, n); if (v != 0) return v;
|
|
v = ChkPeriod(period); if (v != 0) return v;
|
|
try { Betadist.Batch(Src(src, n), Dst(dst, n), period, alpha, beta); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Expdist: Pattern A (int period, double lambda)
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_expdist")]
|
|
public static int QtlExpdist(double* src, int n, double* dst, int period, double lambda)
|
|
{
|
|
int v = Chk1(src, dst, n); if (v != 0) return v;
|
|
v = ChkPeriod(period); if (v != 0) return v;
|
|
try { Expdist.Batch(Src(src, n), Dst(dst, n), period, lambda); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Binomdist: Pattern A (int period, int trials, int successes)
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_binomdist")]
|
|
public static int QtlBinomdist(double* src, int n, double* dst, int period, int trials, int successes)
|
|
{
|
|
int v = Chk1(src, dst, n); if (v != 0) return v;
|
|
v = ChkPeriod(period); if (v != 0) return v;
|
|
try { Binomdist.Batch(Src(src, n), Dst(dst, n), period, trials, successes); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Cwt: Pattern A (double scale, double omega)
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_cwt")]
|
|
public static int QtlCwt(double* src, int n, double* dst, double scale, double omega)
|
|
{
|
|
int v = Chk1(src, dst, n); if (v != 0) return v;
|
|
try { Cwt.Batch(Src(src, n), Dst(dst, n), scale, omega); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// Dwt: Pattern A (int period, int levels)
|
|
[UnmanagedCallersOnly(EntryPoint = "qtl_dwt")]
|
|
public static int QtlDwt(double* src, int n, double* dst, int period, int levels)
|
|
{
|
|
int v = Chk1(src, dst, n); if (v != 0) return v;
|
|
v = ChkPeriod(period); if (v != 0) return v;
|
|
try { Dwt.Batch(Src(src, n), Dst(dst, n), period, levels); return StatusCodes.QTL_OK; }
|
|
catch { return StatusCodes.QTL_ERR_INTERNAL; }
|
|
}
|
|
|
|
// ═══════════════════════════════════════════════════════════════════════
|
|
// §8.16 Forecasts
|
|
// ═══════════════════════════════════════════════════════════════════════
|
|
|
|
// Afirma already exported above in §8.4
|
|
|
|
// ═══════════════════════════════════════════════════════════════════════
|
|
// Prs: Pattern H (seriesX, seriesY, out, int period) — Momentum/Statistics
|
|
// ═══════════════════════════════════════════════════════════════════════
|
|
|
|
// Note: Prs might not have a span overload — check at build time
|
|
}
|
|
|
|
#pragma warning restore CA1031
|
|
#pragma warning restore IDE0060
|