Add the Java binding over the C ABI hub (Panama/FFM) (#233)
Adds a Java binding (`bindings/java`) over the C ABI hub — the fourth language stecker after C#, Go and R, reaching the hub through the Java Foreign Function & Memory API (Panama, `java.lang.foreign`, final in Java 22) rather than JNI or jextract. ## What's here - **`bindings/java`** — a Maven module (`org.wickra:wickra`) exposing all 514 indicators as idiomatic `AutoCloseable` classes. The downcall handles (`internal/NativeMethods.java`), the per-indicator wrappers and the output records are generated from `bindings/c/include/wickra.h` (same eight-archetype taxonomy as the C#/Go/R generators: scalar/batch, multi-output, bars, profile, values-profile, array-input). The opaque handle is a `MemorySegment` freed by a registered `java.lang.ref.Cleaner` action; multi-output returns a `record` (`null` at warmup), bars a `record[]`, profiles a record with a trailing `double[]`. The hand-written `WickraNative` resolves the native library (a bundled per-platform copy, or a `target/release` fallback for local development) and validates it against a sentinel symbol. repr(C) struct offsets are computed in the generator so the FFM reads land on the exact bytes. - **`examples/java`** — the full example suite mirroring C/C#/Go/R: streaming, backtest, multi_timeframe, parallel_assets (parallel streams), three strategies, and `FetchBtcusdt`/`LiveBinance`. - **CI** — a `java` job builds the C ABI library, sets up JDK 22 (Temurin, with a CDN-flake retry), runs the archetype test suite and the seven offline examples on Linux, macOS and Windows. - **Release** — a gated `java-publish` job (skipped until the `JAVA_PUBLISH_ENABLED` repository variable is set) stages the native libraries from the `wickra-c-<triple>.tar.gz` assets into the binding's resources and deploys to Maven Central with GPG signing. Independent of the GitHub-release job, like the NuGet job. - **Docs** — Java added to the README languages table, project layout, building/testing and comparison table, CONTRIBUTING, ARCHITECTURE, the examples index, the issue/PR templates, the About-description template, and the other binding READMEs. ## Requirements Java 22+ (the FFM API is final since Java 22). The binding requires `--enable-native-access=ALL-UNNAMED` at runtime; the test and example runners pass it automatically. No Rust crate or `Cargo.toml` change — the Java binding is standalone and additive. The generated `*.java` are committed (like the node `index.js`/`index.d.ts`); the generator stays private.
This commit is contained in:
kingchenc
@@ -0,0 +1,6 @@
|
||||
# Maven build output
|
||||
target/
|
||||
|
||||
# Native libraries staged for packaging (produced by the release pipeline from
|
||||
# the wickra-c-<triple>.tar.gz assets; never committed to source).
|
||||
src/main/resources/native/
|
||||
@@ -0,0 +1,102 @@
|
||||
# Wickra — Java
|
||||
|
||||
[](https://github.com/wickra-lib/wickra/actions/workflows/ci.yml)
|
||||
[](https://codecov.io/gh/wickra-lib/wickra)
|
||||
[](https://central.sonatype.com/artifact/org.wickra/wickra)
|
||||
[](https://github.com/wickra-lib/wickra#license)
|
||||
|
||||
**Streaming-first technical indicators for the JVM, on the Java Foreign Function
|
||||
& Memory API — prebuilt native library, no JNI, no system dependencies.**
|
||||
|
||||
Wickra is a multi-language technical-analysis library with a Rust core and
|
||||
bindings for Python, Node.js and WebAssembly, plus a C ABI for C/C++, C#, Go, Java, R
|
||||
and any other C-capable language. Every indicator is an O(1) streaming state
|
||||
machine, so live trading bots and historical backtests share the exact same
|
||||
implementation. This package is the Java binding; it consumes the C ABI hub
|
||||
through the Panama FFM API (`java.lang.foreign`) and exposes all 514
|
||||
streaming-first indicators as idiomatic `AutoCloseable` classes.
|
||||
|
||||
## Requirements
|
||||
|
||||
- **Java 22 or later** (the FFM API is final since Java 22; no preview flag).
|
||||
- The FFM API is *restricted*: pass `--enable-native-access=ALL-UNNAMED` when you
|
||||
run your application to silence the native-access warning.
|
||||
|
||||
## Install
|
||||
|
||||
Maven:
|
||||
|
||||
```xml
|
||||
<dependency>
|
||||
<groupId>org.wickra</groupId>
|
||||
<artifactId>wickra</artifactId>
|
||||
<version>0.7.8</version>
|
||||
</dependency>
|
||||
```
|
||||
|
||||
Gradle:
|
||||
|
||||
```kotlin
|
||||
implementation("org.wickra:wickra:0.7.8")
|
||||
```
|
||||
|
||||
The native library ships prebuilt per platform (Linux, macOS, Windows — x64 and
|
||||
arm64) inside the jar and is extracted automatically on first use. There is
|
||||
nothing to compile.
|
||||
|
||||
## Quick start
|
||||
|
||||
```java
|
||||
import org.wickra.Ema;
|
||||
import org.wickra.Rsi;
|
||||
|
||||
// Batch: run an indicator over a whole series (NaN at warmup positions).
|
||||
double[] prices = new double[1000];
|
||||
for (int i = 0; i < prices.length; i++) {
|
||||
prices[i] = 100.0 + i * 0.1;
|
||||
}
|
||||
try (Ema ema = new Ema(20)) {
|
||||
double[] values = ema.batch(prices);
|
||||
}
|
||||
|
||||
// Streaming: the same indicator, fed tick by tick in O(1).
|
||||
try (Rsi rsi = new Rsi(14)) {
|
||||
for (double price : liveFeed) {
|
||||
double value = rsi.update(price); // NaN during warmup, no recomputation
|
||||
if (Double.isFinite(value) && value > 70) {
|
||||
System.out.println("overbought");
|
||||
}
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
`batch(prices)` and feeding the same prices through `update()` produce identical
|
||||
values — the equivalence is enforced by the test suite. Multi-output indicators
|
||||
(MACD, Bollinger, ADX, …) return a `record`, `null` while warming up. Each
|
||||
indicator owns a native handle freed by a `Cleaner`; `close()` releases it
|
||||
eagerly (use try-with-resources).
|
||||
|
||||
## Documentation
|
||||
|
||||
The full indicator catalogue, guides, quickstarts, and API reference live in
|
||||
the main repository and documentation site:
|
||||
|
||||
- **Repository & full indicator list:** <https://github.com/wickra-lib/wickra>
|
||||
- **Docs** (quickstarts, cookbook, TA-Lib migration): <https://docs.wickra.org>
|
||||
- **Runnable examples:** [`examples/java/`](https://github.com/wickra-lib/wickra/tree/main/examples/java)
|
||||
|
||||
Wickra ships native bindings for Python, Node.js, WebAssembly and Rust, plus a
|
||||
C ABI hub that any C-capable language (C, C++, Go, C#, Java, R) links against —
|
||||
all exposing the same indicators from the shared, `unsafe`-forbidden Rust core.
|
||||
|
||||
## Disclaimer
|
||||
|
||||
Wickra is an indicator toolkit, not a trading system. The values it computes
|
||||
are deterministic transforms of the input data — they are not financial advice
|
||||
and do not predict the market. Any use in a live trading context is at your own
|
||||
risk. The library is provided **as is**, without warranty of any kind.
|
||||
|
||||
## License
|
||||
|
||||
Licensed under either of [Apache-2.0](https://github.com/wickra-lib/wickra/blob/main/LICENSE-APACHE)
|
||||
or [MIT](https://github.com/wickra-lib/wickra/blob/main/LICENSE-MIT) at your option.
|
||||
@@ -0,0 +1,171 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<project xmlns="http://maven.apache.org/POM/4.0.0"
|
||||
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
|
||||
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
|
||||
<modelVersion>4.0.0</modelVersion>
|
||||
|
||||
<groupId>org.wickra</groupId>
|
||||
<artifactId>wickra</artifactId>
|
||||
<version>0.7.8</version>
|
||||
<packaging>jar</packaging>
|
||||
|
||||
<name>Wickra</name>
|
||||
<description>High-performance streaming technical-analysis indicators (514 indicators) for the
|
||||
JVM, backed by the native Rust core through the Wickra C ABI via the Java FFM API (Panama).</description>
|
||||
<url>https://github.com/wickra-lib/wickra</url>
|
||||
|
||||
<licenses>
|
||||
<license>
|
||||
<name>MIT</name>
|
||||
<url>https://opensource.org/licenses/MIT</url>
|
||||
<distribution>repo</distribution>
|
||||
</license>
|
||||
<license>
|
||||
<name>Apache-2.0</name>
|
||||
<url>https://www.apache.org/licenses/LICENSE-2.0</url>
|
||||
<distribution>repo</distribution>
|
||||
</license>
|
||||
</licenses>
|
||||
|
||||
<developers>
|
||||
<developer>
|
||||
<id>kingchenc</id>
|
||||
<name>kingchenc</name>
|
||||
<url>https://github.com/kingchenc</url>
|
||||
</developer>
|
||||
</developers>
|
||||
|
||||
<scm>
|
||||
<connection>scm:git:https://github.com/wickra-lib/wickra.git</connection>
|
||||
<developerConnection>scm:git:https://github.com/wickra-lib/wickra.git</developerConnection>
|
||||
<url>https://github.com/wickra-lib/wickra</url>
|
||||
</scm>
|
||||
|
||||
<properties>
|
||||
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
|
||||
<maven.compiler.release>22</maven.compiler.release>
|
||||
<junit.version>5.10.2</junit.version>
|
||||
<!-- The FFM API is restricted; grant native access to the unnamed module so
|
||||
tests and examples run without warnings. Consumers pass the same flag. -->
|
||||
<native.access.arg>--enable-native-access=ALL-UNNAMED</native.access.arg>
|
||||
</properties>
|
||||
|
||||
<dependencies>
|
||||
<dependency>
|
||||
<groupId>org.junit.jupiter</groupId>
|
||||
<artifactId>junit-jupiter</artifactId>
|
||||
<version>${junit.version}</version>
|
||||
<scope>test</scope>
|
||||
</dependency>
|
||||
</dependencies>
|
||||
|
||||
<build>
|
||||
<plugins>
|
||||
<plugin>
|
||||
<groupId>org.apache.maven.plugins</groupId>
|
||||
<artifactId>maven-compiler-plugin</artifactId>
|
||||
<version>3.13.0</version>
|
||||
</plugin>
|
||||
|
||||
<plugin>
|
||||
<groupId>org.apache.maven.plugins</groupId>
|
||||
<artifactId>maven-surefire-plugin</artifactId>
|
||||
<version>3.2.5</version>
|
||||
<configuration>
|
||||
<argLine>${native.access.arg}</argLine>
|
||||
</configuration>
|
||||
</plugin>
|
||||
|
||||
<plugin>
|
||||
<groupId>org.apache.maven.plugins</groupId>
|
||||
<artifactId>maven-jar-plugin</artifactId>
|
||||
<version>3.4.1</version>
|
||||
<configuration>
|
||||
<archive>
|
||||
<manifestEntries>
|
||||
<!-- Grant native access when the jar is run directly. -->
|
||||
<Enable-Native-Access>ALL-UNNAMED</Enable-Native-Access>
|
||||
</manifestEntries>
|
||||
</archive>
|
||||
</configuration>
|
||||
</plugin>
|
||||
</plugins>
|
||||
</build>
|
||||
|
||||
<profiles>
|
||||
<!--
|
||||
Release profile (CI only, gated): attaches source + javadoc jars, GPG-signs
|
||||
every artifact, and publishes to Maven Central via the central-publishing
|
||||
plugin. The native libraries are unpacked from the wickra-c-<triple>.tar.gz
|
||||
release assets into src/main/resources/native/<os>-<arch>/ before `mvn deploy`,
|
||||
so the published jar carries every platform's library.
|
||||
-->
|
||||
<profile>
|
||||
<id>release</id>
|
||||
<build>
|
||||
<plugins>
|
||||
<plugin>
|
||||
<groupId>org.apache.maven.plugins</groupId>
|
||||
<artifactId>maven-source-plugin</artifactId>
|
||||
<version>3.3.1</version>
|
||||
<executions>
|
||||
<execution>
|
||||
<id>attach-sources</id>
|
||||
<goals><goal>jar-no-fork</goal></goals>
|
||||
</execution>
|
||||
</executions>
|
||||
</plugin>
|
||||
|
||||
<plugin>
|
||||
<groupId>org.apache.maven.plugins</groupId>
|
||||
<artifactId>maven-javadoc-plugin</artifactId>
|
||||
<version>3.7.0</version>
|
||||
<configuration>
|
||||
<!-- Generated members are self-descriptive; do not fail on doclint. -->
|
||||
<doclint>none</doclint>
|
||||
<quiet>true</quiet>
|
||||
</configuration>
|
||||
<executions>
|
||||
<execution>
|
||||
<id>attach-javadocs</id>
|
||||
<goals><goal>jar</goal></goals>
|
||||
</execution>
|
||||
</executions>
|
||||
</plugin>
|
||||
|
||||
<plugin>
|
||||
<groupId>org.apache.maven.plugins</groupId>
|
||||
<artifactId>maven-gpg-plugin</artifactId>
|
||||
<version>3.2.4</version>
|
||||
<executions>
|
||||
<execution>
|
||||
<id>sign-artifacts</id>
|
||||
<phase>verify</phase>
|
||||
<goals><goal>sign</goal></goals>
|
||||
<configuration>
|
||||
<!-- Non-interactive signing on CI: modern GPG needs loopback
|
||||
pinentry to take the passphrase from the env without a TTY. -->
|
||||
<gpgArguments>
|
||||
<arg>--pinentry-mode</arg>
|
||||
<arg>loopback</arg>
|
||||
</gpgArguments>
|
||||
</configuration>
|
||||
</execution>
|
||||
</executions>
|
||||
</plugin>
|
||||
|
||||
<plugin>
|
||||
<groupId>org.sonatype.central</groupId>
|
||||
<artifactId>central-publishing-maven-plugin</artifactId>
|
||||
<version>0.5.0</version>
|
||||
<extensions>true</extensions>
|
||||
<configuration>
|
||||
<publishingServerId>central</publishingServerId>
|
||||
<autoPublish>true</autoPublish>
|
||||
</configuration>
|
||||
</plugin>
|
||||
</plugins>
|
||||
</build>
|
||||
</profile>
|
||||
</profiles>
|
||||
</project>
|
||||
@@ -0,0 +1,86 @@
|
||||
// Generated from bindings/c/include/wickra.h. Do not edit by hand.
|
||||
package org.wickra;
|
||||
|
||||
import org.wickra.internal.NativeMethods;
|
||||
import org.wickra.internal.WickraNative;
|
||||
import java.lang.foreign.Arena;
|
||||
import java.lang.foreign.MemorySegment;
|
||||
import java.lang.ref.Cleaner;
|
||||
import static java.lang.foreign.ValueLayout.*;
|
||||
|
||||
/** Streaming AbandonedBaby indicator over the Wickra C ABI. Not thread-safe; close when done. */
|
||||
public final class AbandonedBaby implements AutoCloseable {
|
||||
private final MemorySegment handle;
|
||||
private final Cleaner.Cleanable cleanable;
|
||||
|
||||
public AbandonedBaby() {
|
||||
MemorySegment h;
|
||||
try {
|
||||
h = (MemorySegment) NativeMethods.WICKRA_ABANDONED_BABY_NEW.invokeExact();
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
if (h.address() == 0L) {
|
||||
throw new IllegalArgumentException("invalid AbandonedBaby parameters");
|
||||
}
|
||||
this.handle = h;
|
||||
this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_ABANDONED_BABY_FREE);
|
||||
}
|
||||
|
||||
/** Push one observation; returns the indicator value (NaN during warmup). */
|
||||
public double update(double open, double high, double low, double close, double volume, long timestamp) {
|
||||
try {
|
||||
return (double) NativeMethods.WICKRA_ABANDONED_BABY_UPDATE.invokeExact(handle, open, high, low, close, volume, timestamp);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Vectorized update over a whole series; NaN at warmup positions. */
|
||||
public double[] batch(double[] open, double[] high, double[] low, double[] close, double[] volume, double[] timestamp) {
|
||||
int n = open.length;
|
||||
if (high.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (low.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (close.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (volume.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (timestamp.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
try (Arena a = Arena.ofConfined()) {
|
||||
MemorySegment openSeg = a.allocateFrom(JAVA_DOUBLE, open);
|
||||
MemorySegment highSeg = a.allocateFrom(JAVA_DOUBLE, high);
|
||||
MemorySegment lowSeg = a.allocateFrom(JAVA_DOUBLE, low);
|
||||
MemorySegment closeSeg = a.allocateFrom(JAVA_DOUBLE, close);
|
||||
MemorySegment volumeSeg = a.allocateFrom(JAVA_DOUBLE, volume);
|
||||
MemorySegment timestampSeg = a.allocateFrom(JAVA_DOUBLE, timestamp);
|
||||
MemorySegment outSeg = a.allocate(JAVA_DOUBLE.byteSize() * n);
|
||||
NativeMethods.WICKRA_ABANDONED_BABY_BATCH.invokeExact(handle, openSeg, highSeg, lowSeg, closeSeg, volumeSeg, timestampSeg, outSeg, (long) n);
|
||||
double[] out = new double[n];
|
||||
MemorySegment.copy(outSeg, JAVA_DOUBLE, 0L, out, 0, n);
|
||||
return out;
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Reset to the just-constructed state. */
|
||||
public void reset() {
|
||||
try {
|
||||
NativeMethods.WICKRA_ABANDONED_BABY_RESET.invokeExact(handle);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
@Override public void close() {
|
||||
cleanable.clean();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,86 @@
|
||||
// Generated from bindings/c/include/wickra.h. Do not edit by hand.
|
||||
package org.wickra;
|
||||
|
||||
import org.wickra.internal.NativeMethods;
|
||||
import org.wickra.internal.WickraNative;
|
||||
import java.lang.foreign.Arena;
|
||||
import java.lang.foreign.MemorySegment;
|
||||
import java.lang.ref.Cleaner;
|
||||
import static java.lang.foreign.ValueLayout.*;
|
||||
|
||||
/** Streaming Abcd indicator over the Wickra C ABI. Not thread-safe; close when done. */
|
||||
public final class Abcd implements AutoCloseable {
|
||||
private final MemorySegment handle;
|
||||
private final Cleaner.Cleanable cleanable;
|
||||
|
||||
public Abcd() {
|
||||
MemorySegment h;
|
||||
try {
|
||||
h = (MemorySegment) NativeMethods.WICKRA_ABCD_NEW.invokeExact();
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
if (h.address() == 0L) {
|
||||
throw new IllegalArgumentException("invalid Abcd parameters");
|
||||
}
|
||||
this.handle = h;
|
||||
this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_ABCD_FREE);
|
||||
}
|
||||
|
||||
/** Push one observation; returns the indicator value (NaN during warmup). */
|
||||
public double update(double open, double high, double low, double close, double volume, long timestamp) {
|
||||
try {
|
||||
return (double) NativeMethods.WICKRA_ABCD_UPDATE.invokeExact(handle, open, high, low, close, volume, timestamp);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Vectorized update over a whole series; NaN at warmup positions. */
|
||||
public double[] batch(double[] open, double[] high, double[] low, double[] close, double[] volume, double[] timestamp) {
|
||||
int n = open.length;
|
||||
if (high.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (low.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (close.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (volume.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (timestamp.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
try (Arena a = Arena.ofConfined()) {
|
||||
MemorySegment openSeg = a.allocateFrom(JAVA_DOUBLE, open);
|
||||
MemorySegment highSeg = a.allocateFrom(JAVA_DOUBLE, high);
|
||||
MemorySegment lowSeg = a.allocateFrom(JAVA_DOUBLE, low);
|
||||
MemorySegment closeSeg = a.allocateFrom(JAVA_DOUBLE, close);
|
||||
MemorySegment volumeSeg = a.allocateFrom(JAVA_DOUBLE, volume);
|
||||
MemorySegment timestampSeg = a.allocateFrom(JAVA_DOUBLE, timestamp);
|
||||
MemorySegment outSeg = a.allocate(JAVA_DOUBLE.byteSize() * n);
|
||||
NativeMethods.WICKRA_ABCD_BATCH.invokeExact(handle, openSeg, highSeg, lowSeg, closeSeg, volumeSeg, timestampSeg, outSeg, (long) n);
|
||||
double[] out = new double[n];
|
||||
MemorySegment.copy(outSeg, JAVA_DOUBLE, 0L, out, 0, n);
|
||||
return out;
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Reset to the just-constructed state. */
|
||||
public void reset() {
|
||||
try {
|
||||
NativeMethods.WICKRA_ABCD_RESET.invokeExact(handle);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
@Override public void close() {
|
||||
cleanable.clean();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,72 @@
|
||||
// Generated from bindings/c/include/wickra.h. Do not edit by hand.
|
||||
package org.wickra;
|
||||
|
||||
import org.wickra.internal.NativeMethods;
|
||||
import org.wickra.internal.WickraNative;
|
||||
import java.lang.foreign.Arena;
|
||||
import java.lang.foreign.MemorySegment;
|
||||
import java.lang.ref.Cleaner;
|
||||
import static java.lang.foreign.ValueLayout.*;
|
||||
|
||||
/** Streaming AbsoluteBreadthIndex indicator over the Wickra C ABI. Not thread-safe; close when done. */
|
||||
public final class AbsoluteBreadthIndex implements AutoCloseable {
|
||||
private final MemorySegment handle;
|
||||
private final Cleaner.Cleanable cleanable;
|
||||
|
||||
public AbsoluteBreadthIndex() {
|
||||
MemorySegment h;
|
||||
try {
|
||||
h = (MemorySegment) NativeMethods.WICKRA_ABSOLUTE_BREADTH_INDEX_NEW.invokeExact();
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
if (h.address() == 0L) {
|
||||
throw new IllegalArgumentException("invalid AbsoluteBreadthIndex parameters");
|
||||
}
|
||||
this.handle = h;
|
||||
this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_ABSOLUTE_BREADTH_INDEX_FREE);
|
||||
}
|
||||
|
||||
/** Push one observation; returns the indicator value (NaN during warmup). */
|
||||
public double update(double[] change, double[] volume, double[] newHigh, double[] newLow, double[] aboveMa, double[] onBuySignal, long timestamp) {
|
||||
if (volume.length != change.length) {
|
||||
throw new IllegalArgumentException("input arrays in the same group must have equal length");
|
||||
}
|
||||
if (newHigh.length != change.length) {
|
||||
throw new IllegalArgumentException("input arrays in the same group must have equal length");
|
||||
}
|
||||
if (newLow.length != change.length) {
|
||||
throw new IllegalArgumentException("input arrays in the same group must have equal length");
|
||||
}
|
||||
if (aboveMa.length != change.length) {
|
||||
throw new IllegalArgumentException("input arrays in the same group must have equal length");
|
||||
}
|
||||
if (onBuySignal.length != change.length) {
|
||||
throw new IllegalArgumentException("input arrays in the same group must have equal length");
|
||||
}
|
||||
try (Arena a = Arena.ofConfined()) {
|
||||
MemorySegment changeSeg = a.allocateFrom(JAVA_DOUBLE, change);
|
||||
MemorySegment volumeSeg = a.allocateFrom(JAVA_DOUBLE, volume);
|
||||
MemorySegment newHighSeg = a.allocateFrom(JAVA_DOUBLE, newHigh);
|
||||
MemorySegment newLowSeg = a.allocateFrom(JAVA_DOUBLE, newLow);
|
||||
MemorySegment aboveMaSeg = a.allocateFrom(JAVA_DOUBLE, aboveMa);
|
||||
MemorySegment onBuySignalSeg = a.allocateFrom(JAVA_DOUBLE, onBuySignal);
|
||||
return (double) NativeMethods.WICKRA_ABSOLUTE_BREADTH_INDEX_UPDATE.invokeExact(handle, changeSeg, volumeSeg, newHighSeg, newLowSeg, aboveMaSeg, onBuySignalSeg, (long) change.length, timestamp);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Reset to the just-constructed state. */
|
||||
public void reset() {
|
||||
try {
|
||||
NativeMethods.WICKRA_ABSOLUTE_BREADTH_INDEX_RESET.invokeExact(handle);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
@Override public void close() {
|
||||
cleanable.clean();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,62 @@
|
||||
// Generated from bindings/c/include/wickra.h. Do not edit by hand.
|
||||
package org.wickra;
|
||||
|
||||
import org.wickra.internal.NativeMethods;
|
||||
import org.wickra.internal.WickraNative;
|
||||
import java.lang.foreign.Arena;
|
||||
import java.lang.foreign.MemorySegment;
|
||||
import java.lang.ref.Cleaner;
|
||||
import static java.lang.foreign.ValueLayout.*;
|
||||
|
||||
/** Streaming AccelerationBands indicator over the Wickra C ABI. Not thread-safe; close when done. */
|
||||
public final class AccelerationBands implements AutoCloseable {
|
||||
private final MemorySegment handle;
|
||||
private final Cleaner.Cleanable cleanable;
|
||||
|
||||
public AccelerationBands(int period, double factor) {
|
||||
if (period < 0) {
|
||||
throw new IllegalArgumentException("period must be non-negative");
|
||||
}
|
||||
MemorySegment h;
|
||||
try {
|
||||
h = (MemorySegment) NativeMethods.WICKRA_ACCELERATION_BANDS_NEW.invokeExact((long) period, factor);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
if (h.address() == 0L) {
|
||||
throw new IllegalArgumentException("invalid AccelerationBands parameters");
|
||||
}
|
||||
this.handle = h;
|
||||
this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_ACCELERATION_BANDS_FREE);
|
||||
}
|
||||
|
||||
/** Push one observation; returns the result, or null during warmup. */
|
||||
public AccelerationBandsOutput update(double open, double high, double low, double close, double volume, long timestamp) {
|
||||
try (Arena a = Arena.ofConfined()) {
|
||||
MemorySegment out = a.allocate(24L);
|
||||
byte ok = (byte) NativeMethods.WICKRA_ACCELERATION_BANDS_UPDATE.invokeExact(handle, open, high, low, close, volume, timestamp, out);
|
||||
if (ok == 0) {
|
||||
return null;
|
||||
}
|
||||
return new AccelerationBandsOutput(
|
||||
out.get(JAVA_DOUBLE, 0L),
|
||||
out.get(JAVA_DOUBLE, 8L),
|
||||
out.get(JAVA_DOUBLE, 16L));
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Reset to the just-constructed state. */
|
||||
public void reset() {
|
||||
try {
|
||||
NativeMethods.WICKRA_ACCELERATION_BANDS_RESET.invokeExact(handle);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
@Override public void close() {
|
||||
cleanable.clean();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,5 @@
|
||||
// Generated from bindings/c/include/wickra.h. Do not edit by hand.
|
||||
package org.wickra;
|
||||
|
||||
/** Output record produced by the matching indicator. */
|
||||
public record AccelerationBandsOutput(double upper, double middle, double lower) {}
|
||||
@@ -0,0 +1,95 @@
|
||||
// Generated from bindings/c/include/wickra.h. Do not edit by hand.
|
||||
package org.wickra;
|
||||
|
||||
import org.wickra.internal.NativeMethods;
|
||||
import org.wickra.internal.WickraNative;
|
||||
import java.lang.foreign.Arena;
|
||||
import java.lang.foreign.MemorySegment;
|
||||
import java.lang.ref.Cleaner;
|
||||
import static java.lang.foreign.ValueLayout.*;
|
||||
|
||||
/** Streaming AcceleratorOscillator indicator over the Wickra C ABI. Not thread-safe; close when done. */
|
||||
public final class AcceleratorOscillator implements AutoCloseable {
|
||||
private final MemorySegment handle;
|
||||
private final Cleaner.Cleanable cleanable;
|
||||
|
||||
public AcceleratorOscillator(int aoFast, int aoSlow, int signalPeriod) {
|
||||
if (aoFast < 0) {
|
||||
throw new IllegalArgumentException("aoFast must be non-negative");
|
||||
}
|
||||
if (aoSlow < 0) {
|
||||
throw new IllegalArgumentException("aoSlow must be non-negative");
|
||||
}
|
||||
if (signalPeriod < 0) {
|
||||
throw new IllegalArgumentException("signalPeriod must be non-negative");
|
||||
}
|
||||
MemorySegment h;
|
||||
try {
|
||||
h = (MemorySegment) NativeMethods.WICKRA_ACCELERATOR_OSCILLATOR_NEW.invokeExact((long) aoFast, (long) aoSlow, (long) signalPeriod);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
if (h.address() == 0L) {
|
||||
throw new IllegalArgumentException("invalid AcceleratorOscillator parameters");
|
||||
}
|
||||
this.handle = h;
|
||||
this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_ACCELERATOR_OSCILLATOR_FREE);
|
||||
}
|
||||
|
||||
/** Push one observation; returns the indicator value (NaN during warmup). */
|
||||
public double update(double open, double high, double low, double close, double volume, long timestamp) {
|
||||
try {
|
||||
return (double) NativeMethods.WICKRA_ACCELERATOR_OSCILLATOR_UPDATE.invokeExact(handle, open, high, low, close, volume, timestamp);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Vectorized update over a whole series; NaN at warmup positions. */
|
||||
public double[] batch(double[] open, double[] high, double[] low, double[] close, double[] volume, double[] timestamp) {
|
||||
int n = open.length;
|
||||
if (high.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (low.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (close.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (volume.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (timestamp.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
try (Arena a = Arena.ofConfined()) {
|
||||
MemorySegment openSeg = a.allocateFrom(JAVA_DOUBLE, open);
|
||||
MemorySegment highSeg = a.allocateFrom(JAVA_DOUBLE, high);
|
||||
MemorySegment lowSeg = a.allocateFrom(JAVA_DOUBLE, low);
|
||||
MemorySegment closeSeg = a.allocateFrom(JAVA_DOUBLE, close);
|
||||
MemorySegment volumeSeg = a.allocateFrom(JAVA_DOUBLE, volume);
|
||||
MemorySegment timestampSeg = a.allocateFrom(JAVA_DOUBLE, timestamp);
|
||||
MemorySegment outSeg = a.allocate(JAVA_DOUBLE.byteSize() * n);
|
||||
NativeMethods.WICKRA_ACCELERATOR_OSCILLATOR_BATCH.invokeExact(handle, openSeg, highSeg, lowSeg, closeSeg, volumeSeg, timestampSeg, outSeg, (long) n);
|
||||
double[] out = new double[n];
|
||||
MemorySegment.copy(outSeg, JAVA_DOUBLE, 0L, out, 0, n);
|
||||
return out;
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Reset to the just-constructed state. */
|
||||
public void reset() {
|
||||
try {
|
||||
NativeMethods.WICKRA_ACCELERATOR_OSCILLATOR_RESET.invokeExact(handle);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
@Override public void close() {
|
||||
cleanable.clean();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,86 @@
|
||||
// Generated from bindings/c/include/wickra.h. Do not edit by hand.
|
||||
package org.wickra;
|
||||
|
||||
import org.wickra.internal.NativeMethods;
|
||||
import org.wickra.internal.WickraNative;
|
||||
import java.lang.foreign.Arena;
|
||||
import java.lang.foreign.MemorySegment;
|
||||
import java.lang.ref.Cleaner;
|
||||
import static java.lang.foreign.ValueLayout.*;
|
||||
|
||||
/** Streaming AdOscillator indicator over the Wickra C ABI. Not thread-safe; close when done. */
|
||||
public final class AdOscillator implements AutoCloseable {
|
||||
private final MemorySegment handle;
|
||||
private final Cleaner.Cleanable cleanable;
|
||||
|
||||
public AdOscillator() {
|
||||
MemorySegment h;
|
||||
try {
|
||||
h = (MemorySegment) NativeMethods.WICKRA_AD_OSCILLATOR_NEW.invokeExact();
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
if (h.address() == 0L) {
|
||||
throw new IllegalArgumentException("invalid AdOscillator parameters");
|
||||
}
|
||||
this.handle = h;
|
||||
this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_AD_OSCILLATOR_FREE);
|
||||
}
|
||||
|
||||
/** Push one observation; returns the indicator value (NaN during warmup). */
|
||||
public double update(double open, double high, double low, double close, double volume, long timestamp) {
|
||||
try {
|
||||
return (double) NativeMethods.WICKRA_AD_OSCILLATOR_UPDATE.invokeExact(handle, open, high, low, close, volume, timestamp);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Vectorized update over a whole series; NaN at warmup positions. */
|
||||
public double[] batch(double[] open, double[] high, double[] low, double[] close, double[] volume, double[] timestamp) {
|
||||
int n = open.length;
|
||||
if (high.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (low.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (close.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (volume.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (timestamp.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
try (Arena a = Arena.ofConfined()) {
|
||||
MemorySegment openSeg = a.allocateFrom(JAVA_DOUBLE, open);
|
||||
MemorySegment highSeg = a.allocateFrom(JAVA_DOUBLE, high);
|
||||
MemorySegment lowSeg = a.allocateFrom(JAVA_DOUBLE, low);
|
||||
MemorySegment closeSeg = a.allocateFrom(JAVA_DOUBLE, close);
|
||||
MemorySegment volumeSeg = a.allocateFrom(JAVA_DOUBLE, volume);
|
||||
MemorySegment timestampSeg = a.allocateFrom(JAVA_DOUBLE, timestamp);
|
||||
MemorySegment outSeg = a.allocate(JAVA_DOUBLE.byteSize() * n);
|
||||
NativeMethods.WICKRA_AD_OSCILLATOR_BATCH.invokeExact(handle, openSeg, highSeg, lowSeg, closeSeg, volumeSeg, timestampSeg, outSeg, (long) n);
|
||||
double[] out = new double[n];
|
||||
MemorySegment.copy(outSeg, JAVA_DOUBLE, 0L, out, 0, n);
|
||||
return out;
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Reset to the just-constructed state. */
|
||||
public void reset() {
|
||||
try {
|
||||
NativeMethods.WICKRA_AD_OSCILLATOR_RESET.invokeExact(handle);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
@Override public void close() {
|
||||
cleanable.clean();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,72 @@
|
||||
// Generated from bindings/c/include/wickra.h. Do not edit by hand.
|
||||
package org.wickra;
|
||||
|
||||
import org.wickra.internal.NativeMethods;
|
||||
import org.wickra.internal.WickraNative;
|
||||
import java.lang.foreign.Arena;
|
||||
import java.lang.foreign.MemorySegment;
|
||||
import java.lang.ref.Cleaner;
|
||||
import static java.lang.foreign.ValueLayout.*;
|
||||
|
||||
/** Streaming AdVolumeLine indicator over the Wickra C ABI. Not thread-safe; close when done. */
|
||||
public final class AdVolumeLine implements AutoCloseable {
|
||||
private final MemorySegment handle;
|
||||
private final Cleaner.Cleanable cleanable;
|
||||
|
||||
public AdVolumeLine() {
|
||||
MemorySegment h;
|
||||
try {
|
||||
h = (MemorySegment) NativeMethods.WICKRA_AD_VOLUME_LINE_NEW.invokeExact();
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
if (h.address() == 0L) {
|
||||
throw new IllegalArgumentException("invalid AdVolumeLine parameters");
|
||||
}
|
||||
this.handle = h;
|
||||
this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_AD_VOLUME_LINE_FREE);
|
||||
}
|
||||
|
||||
/** Push one observation; returns the indicator value (NaN during warmup). */
|
||||
public double update(double[] change, double[] volume, double[] newHigh, double[] newLow, double[] aboveMa, double[] onBuySignal, long timestamp) {
|
||||
if (volume.length != change.length) {
|
||||
throw new IllegalArgumentException("input arrays in the same group must have equal length");
|
||||
}
|
||||
if (newHigh.length != change.length) {
|
||||
throw new IllegalArgumentException("input arrays in the same group must have equal length");
|
||||
}
|
||||
if (newLow.length != change.length) {
|
||||
throw new IllegalArgumentException("input arrays in the same group must have equal length");
|
||||
}
|
||||
if (aboveMa.length != change.length) {
|
||||
throw new IllegalArgumentException("input arrays in the same group must have equal length");
|
||||
}
|
||||
if (onBuySignal.length != change.length) {
|
||||
throw new IllegalArgumentException("input arrays in the same group must have equal length");
|
||||
}
|
||||
try (Arena a = Arena.ofConfined()) {
|
||||
MemorySegment changeSeg = a.allocateFrom(JAVA_DOUBLE, change);
|
||||
MemorySegment volumeSeg = a.allocateFrom(JAVA_DOUBLE, volume);
|
||||
MemorySegment newHighSeg = a.allocateFrom(JAVA_DOUBLE, newHigh);
|
||||
MemorySegment newLowSeg = a.allocateFrom(JAVA_DOUBLE, newLow);
|
||||
MemorySegment aboveMaSeg = a.allocateFrom(JAVA_DOUBLE, aboveMa);
|
||||
MemorySegment onBuySignalSeg = a.allocateFrom(JAVA_DOUBLE, onBuySignal);
|
||||
return (double) NativeMethods.WICKRA_AD_VOLUME_LINE_UPDATE.invokeExact(handle, changeSeg, volumeSeg, newHighSeg, newLowSeg, aboveMaSeg, onBuySignalSeg, (long) change.length, timestamp);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Reset to the just-constructed state. */
|
||||
public void reset() {
|
||||
try {
|
||||
NativeMethods.WICKRA_AD_VOLUME_LINE_RESET.invokeExact(handle);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
@Override public void close() {
|
||||
cleanable.clean();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,89 @@
|
||||
// Generated from bindings/c/include/wickra.h. Do not edit by hand.
|
||||
package org.wickra;
|
||||
|
||||
import org.wickra.internal.NativeMethods;
|
||||
import org.wickra.internal.WickraNative;
|
||||
import java.lang.foreign.Arena;
|
||||
import java.lang.foreign.MemorySegment;
|
||||
import java.lang.ref.Cleaner;
|
||||
import static java.lang.foreign.ValueLayout.*;
|
||||
|
||||
/** Streaming AdaptiveCci indicator over the Wickra C ABI. Not thread-safe; close when done. */
|
||||
public final class AdaptiveCci implements AutoCloseable {
|
||||
private final MemorySegment handle;
|
||||
private final Cleaner.Cleanable cleanable;
|
||||
|
||||
public AdaptiveCci(int period) {
|
||||
if (period < 0) {
|
||||
throw new IllegalArgumentException("period must be non-negative");
|
||||
}
|
||||
MemorySegment h;
|
||||
try {
|
||||
h = (MemorySegment) NativeMethods.WICKRA_ADAPTIVE_CCI_NEW.invokeExact((long) period);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
if (h.address() == 0L) {
|
||||
throw new IllegalArgumentException("invalid AdaptiveCci parameters");
|
||||
}
|
||||
this.handle = h;
|
||||
this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_ADAPTIVE_CCI_FREE);
|
||||
}
|
||||
|
||||
/** Push one observation; returns the indicator value (NaN during warmup). */
|
||||
public double update(double open, double high, double low, double close, double volume, long timestamp) {
|
||||
try {
|
||||
return (double) NativeMethods.WICKRA_ADAPTIVE_CCI_UPDATE.invokeExact(handle, open, high, low, close, volume, timestamp);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Vectorized update over a whole series; NaN at warmup positions. */
|
||||
public double[] batch(double[] open, double[] high, double[] low, double[] close, double[] volume, double[] timestamp) {
|
||||
int n = open.length;
|
||||
if (high.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (low.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (close.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (volume.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (timestamp.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
try (Arena a = Arena.ofConfined()) {
|
||||
MemorySegment openSeg = a.allocateFrom(JAVA_DOUBLE, open);
|
||||
MemorySegment highSeg = a.allocateFrom(JAVA_DOUBLE, high);
|
||||
MemorySegment lowSeg = a.allocateFrom(JAVA_DOUBLE, low);
|
||||
MemorySegment closeSeg = a.allocateFrom(JAVA_DOUBLE, close);
|
||||
MemorySegment volumeSeg = a.allocateFrom(JAVA_DOUBLE, volume);
|
||||
MemorySegment timestampSeg = a.allocateFrom(JAVA_DOUBLE, timestamp);
|
||||
MemorySegment outSeg = a.allocate(JAVA_DOUBLE.byteSize() * n);
|
||||
NativeMethods.WICKRA_ADAPTIVE_CCI_BATCH.invokeExact(handle, openSeg, highSeg, lowSeg, closeSeg, volumeSeg, timestampSeg, outSeg, (long) n);
|
||||
double[] out = new double[n];
|
||||
MemorySegment.copy(outSeg, JAVA_DOUBLE, 0L, out, 0, n);
|
||||
return out;
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Reset to the just-constructed state. */
|
||||
public void reset() {
|
||||
try {
|
||||
NativeMethods.WICKRA_ADAPTIVE_CCI_RESET.invokeExact(handle);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
@Override public void close() {
|
||||
cleanable.clean();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,66 @@
|
||||
// Generated from bindings/c/include/wickra.h. Do not edit by hand.
|
||||
package org.wickra;
|
||||
|
||||
import org.wickra.internal.NativeMethods;
|
||||
import org.wickra.internal.WickraNative;
|
||||
import java.lang.foreign.Arena;
|
||||
import java.lang.foreign.MemorySegment;
|
||||
import java.lang.ref.Cleaner;
|
||||
import static java.lang.foreign.ValueLayout.*;
|
||||
|
||||
/** Streaming AdaptiveCycle indicator over the Wickra C ABI. Not thread-safe; close when done. */
|
||||
public final class AdaptiveCycle implements AutoCloseable {
|
||||
private final MemorySegment handle;
|
||||
private final Cleaner.Cleanable cleanable;
|
||||
|
||||
public AdaptiveCycle() {
|
||||
MemorySegment h;
|
||||
try {
|
||||
h = (MemorySegment) NativeMethods.WICKRA_ADAPTIVE_CYCLE_NEW.invokeExact();
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
if (h.address() == 0L) {
|
||||
throw new IllegalArgumentException("invalid AdaptiveCycle parameters");
|
||||
}
|
||||
this.handle = h;
|
||||
this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_ADAPTIVE_CYCLE_FREE);
|
||||
}
|
||||
|
||||
/** Push one observation; returns the indicator value (NaN during warmup). */
|
||||
public double update(double value) {
|
||||
try {
|
||||
return (double) NativeMethods.WICKRA_ADAPTIVE_CYCLE_UPDATE.invokeExact(handle, value);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Vectorized update over a whole series; NaN at warmup positions. */
|
||||
public double[] batch(double[] input) {
|
||||
int n = input.length;
|
||||
try (Arena a = Arena.ofConfined()) {
|
||||
MemorySegment inputSeg = a.allocateFrom(JAVA_DOUBLE, input);
|
||||
MemorySegment outSeg = a.allocate(JAVA_DOUBLE.byteSize() * n);
|
||||
NativeMethods.WICKRA_ADAPTIVE_CYCLE_BATCH.invokeExact(handle, inputSeg, outSeg, (long) n);
|
||||
double[] out = new double[n];
|
||||
MemorySegment.copy(outSeg, JAVA_DOUBLE, 0L, out, 0, n);
|
||||
return out;
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Reset to the just-constructed state. */
|
||||
public void reset() {
|
||||
try {
|
||||
NativeMethods.WICKRA_ADAPTIVE_CYCLE_RESET.invokeExact(handle);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
@Override public void close() {
|
||||
cleanable.clean();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,69 @@
|
||||
// Generated from bindings/c/include/wickra.h. Do not edit by hand.
|
||||
package org.wickra;
|
||||
|
||||
import org.wickra.internal.NativeMethods;
|
||||
import org.wickra.internal.WickraNative;
|
||||
import java.lang.foreign.Arena;
|
||||
import java.lang.foreign.MemorySegment;
|
||||
import java.lang.ref.Cleaner;
|
||||
import static java.lang.foreign.ValueLayout.*;
|
||||
|
||||
/** Streaming AdaptiveLaguerreFilter indicator over the Wickra C ABI. Not thread-safe; close when done. */
|
||||
public final class AdaptiveLaguerreFilter implements AutoCloseable {
|
||||
private final MemorySegment handle;
|
||||
private final Cleaner.Cleanable cleanable;
|
||||
|
||||
public AdaptiveLaguerreFilter(int period) {
|
||||
if (period < 0) {
|
||||
throw new IllegalArgumentException("period must be non-negative");
|
||||
}
|
||||
MemorySegment h;
|
||||
try {
|
||||
h = (MemorySegment) NativeMethods.WICKRA_ADAPTIVE_LAGUERRE_FILTER_NEW.invokeExact((long) period);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
if (h.address() == 0L) {
|
||||
throw new IllegalArgumentException("invalid AdaptiveLaguerreFilter parameters");
|
||||
}
|
||||
this.handle = h;
|
||||
this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_ADAPTIVE_LAGUERRE_FILTER_FREE);
|
||||
}
|
||||
|
||||
/** Push one observation; returns the indicator value (NaN during warmup). */
|
||||
public double update(double value) {
|
||||
try {
|
||||
return (double) NativeMethods.WICKRA_ADAPTIVE_LAGUERRE_FILTER_UPDATE.invokeExact(handle, value);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Vectorized update over a whole series; NaN at warmup positions. */
|
||||
public double[] batch(double[] input) {
|
||||
int n = input.length;
|
||||
try (Arena a = Arena.ofConfined()) {
|
||||
MemorySegment inputSeg = a.allocateFrom(JAVA_DOUBLE, input);
|
||||
MemorySegment outSeg = a.allocate(JAVA_DOUBLE.byteSize() * n);
|
||||
NativeMethods.WICKRA_ADAPTIVE_LAGUERRE_FILTER_BATCH.invokeExact(handle, inputSeg, outSeg, (long) n);
|
||||
double[] out = new double[n];
|
||||
MemorySegment.copy(outSeg, JAVA_DOUBLE, 0L, out, 0, n);
|
||||
return out;
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Reset to the just-constructed state. */
|
||||
public void reset() {
|
||||
try {
|
||||
NativeMethods.WICKRA_ADAPTIVE_LAGUERRE_FILTER_RESET.invokeExact(handle);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
@Override public void close() {
|
||||
cleanable.clean();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,69 @@
|
||||
// Generated from bindings/c/include/wickra.h. Do not edit by hand.
|
||||
package org.wickra;
|
||||
|
||||
import org.wickra.internal.NativeMethods;
|
||||
import org.wickra.internal.WickraNative;
|
||||
import java.lang.foreign.Arena;
|
||||
import java.lang.foreign.MemorySegment;
|
||||
import java.lang.ref.Cleaner;
|
||||
import static java.lang.foreign.ValueLayout.*;
|
||||
|
||||
/** Streaming AdaptiveRsi indicator over the Wickra C ABI. Not thread-safe; close when done. */
|
||||
public final class AdaptiveRsi implements AutoCloseable {
|
||||
private final MemorySegment handle;
|
||||
private final Cleaner.Cleanable cleanable;
|
||||
|
||||
public AdaptiveRsi(int period) {
|
||||
if (period < 0) {
|
||||
throw new IllegalArgumentException("period must be non-negative");
|
||||
}
|
||||
MemorySegment h;
|
||||
try {
|
||||
h = (MemorySegment) NativeMethods.WICKRA_ADAPTIVE_RSI_NEW.invokeExact((long) period);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
if (h.address() == 0L) {
|
||||
throw new IllegalArgumentException("invalid AdaptiveRsi parameters");
|
||||
}
|
||||
this.handle = h;
|
||||
this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_ADAPTIVE_RSI_FREE);
|
||||
}
|
||||
|
||||
/** Push one observation; returns the indicator value (NaN during warmup). */
|
||||
public double update(double value) {
|
||||
try {
|
||||
return (double) NativeMethods.WICKRA_ADAPTIVE_RSI_UPDATE.invokeExact(handle, value);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Vectorized update over a whole series; NaN at warmup positions. */
|
||||
public double[] batch(double[] input) {
|
||||
int n = input.length;
|
||||
try (Arena a = Arena.ofConfined()) {
|
||||
MemorySegment inputSeg = a.allocateFrom(JAVA_DOUBLE, input);
|
||||
MemorySegment outSeg = a.allocate(JAVA_DOUBLE.byteSize() * n);
|
||||
NativeMethods.WICKRA_ADAPTIVE_RSI_BATCH.invokeExact(handle, inputSeg, outSeg, (long) n);
|
||||
double[] out = new double[n];
|
||||
MemorySegment.copy(outSeg, JAVA_DOUBLE, 0L, out, 0, n);
|
||||
return out;
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Reset to the just-constructed state. */
|
||||
public void reset() {
|
||||
try {
|
||||
NativeMethods.WICKRA_ADAPTIVE_RSI_RESET.invokeExact(handle);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
@Override public void close() {
|
||||
cleanable.clean();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,86 @@
|
||||
// Generated from bindings/c/include/wickra.h. Do not edit by hand.
|
||||
package org.wickra;
|
||||
|
||||
import org.wickra.internal.NativeMethods;
|
||||
import org.wickra.internal.WickraNative;
|
||||
import java.lang.foreign.Arena;
|
||||
import java.lang.foreign.MemorySegment;
|
||||
import java.lang.ref.Cleaner;
|
||||
import static java.lang.foreign.ValueLayout.*;
|
||||
|
||||
/** Streaming Adl indicator over the Wickra C ABI. Not thread-safe; close when done. */
|
||||
public final class Adl implements AutoCloseable {
|
||||
private final MemorySegment handle;
|
||||
private final Cleaner.Cleanable cleanable;
|
||||
|
||||
public Adl() {
|
||||
MemorySegment h;
|
||||
try {
|
||||
h = (MemorySegment) NativeMethods.WICKRA_ADL_NEW.invokeExact();
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
if (h.address() == 0L) {
|
||||
throw new IllegalArgumentException("invalid Adl parameters");
|
||||
}
|
||||
this.handle = h;
|
||||
this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_ADL_FREE);
|
||||
}
|
||||
|
||||
/** Push one observation; returns the indicator value (NaN during warmup). */
|
||||
public double update(double open, double high, double low, double close, double volume, long timestamp) {
|
||||
try {
|
||||
return (double) NativeMethods.WICKRA_ADL_UPDATE.invokeExact(handle, open, high, low, close, volume, timestamp);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Vectorized update over a whole series; NaN at warmup positions. */
|
||||
public double[] batch(double[] open, double[] high, double[] low, double[] close, double[] volume, double[] timestamp) {
|
||||
int n = open.length;
|
||||
if (high.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (low.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (close.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (volume.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (timestamp.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
try (Arena a = Arena.ofConfined()) {
|
||||
MemorySegment openSeg = a.allocateFrom(JAVA_DOUBLE, open);
|
||||
MemorySegment highSeg = a.allocateFrom(JAVA_DOUBLE, high);
|
||||
MemorySegment lowSeg = a.allocateFrom(JAVA_DOUBLE, low);
|
||||
MemorySegment closeSeg = a.allocateFrom(JAVA_DOUBLE, close);
|
||||
MemorySegment volumeSeg = a.allocateFrom(JAVA_DOUBLE, volume);
|
||||
MemorySegment timestampSeg = a.allocateFrom(JAVA_DOUBLE, timestamp);
|
||||
MemorySegment outSeg = a.allocate(JAVA_DOUBLE.byteSize() * n);
|
||||
NativeMethods.WICKRA_ADL_BATCH.invokeExact(handle, openSeg, highSeg, lowSeg, closeSeg, volumeSeg, timestampSeg, outSeg, (long) n);
|
||||
double[] out = new double[n];
|
||||
MemorySegment.copy(outSeg, JAVA_DOUBLE, 0L, out, 0, n);
|
||||
return out;
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Reset to the just-constructed state. */
|
||||
public void reset() {
|
||||
try {
|
||||
NativeMethods.WICKRA_ADL_RESET.invokeExact(handle);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
@Override public void close() {
|
||||
cleanable.clean();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,86 @@
|
||||
// Generated from bindings/c/include/wickra.h. Do not edit by hand.
|
||||
package org.wickra;
|
||||
|
||||
import org.wickra.internal.NativeMethods;
|
||||
import org.wickra.internal.WickraNative;
|
||||
import java.lang.foreign.Arena;
|
||||
import java.lang.foreign.MemorySegment;
|
||||
import java.lang.ref.Cleaner;
|
||||
import static java.lang.foreign.ValueLayout.*;
|
||||
|
||||
/** Streaming AdvanceBlock indicator over the Wickra C ABI. Not thread-safe; close when done. */
|
||||
public final class AdvanceBlock implements AutoCloseable {
|
||||
private final MemorySegment handle;
|
||||
private final Cleaner.Cleanable cleanable;
|
||||
|
||||
public AdvanceBlock() {
|
||||
MemorySegment h;
|
||||
try {
|
||||
h = (MemorySegment) NativeMethods.WICKRA_ADVANCE_BLOCK_NEW.invokeExact();
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
if (h.address() == 0L) {
|
||||
throw new IllegalArgumentException("invalid AdvanceBlock parameters");
|
||||
}
|
||||
this.handle = h;
|
||||
this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_ADVANCE_BLOCK_FREE);
|
||||
}
|
||||
|
||||
/** Push one observation; returns the indicator value (NaN during warmup). */
|
||||
public double update(double open, double high, double low, double close, double volume, long timestamp) {
|
||||
try {
|
||||
return (double) NativeMethods.WICKRA_ADVANCE_BLOCK_UPDATE.invokeExact(handle, open, high, low, close, volume, timestamp);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Vectorized update over a whole series; NaN at warmup positions. */
|
||||
public double[] batch(double[] open, double[] high, double[] low, double[] close, double[] volume, double[] timestamp) {
|
||||
int n = open.length;
|
||||
if (high.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (low.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (close.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (volume.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (timestamp.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
try (Arena a = Arena.ofConfined()) {
|
||||
MemorySegment openSeg = a.allocateFrom(JAVA_DOUBLE, open);
|
||||
MemorySegment highSeg = a.allocateFrom(JAVA_DOUBLE, high);
|
||||
MemorySegment lowSeg = a.allocateFrom(JAVA_DOUBLE, low);
|
||||
MemorySegment closeSeg = a.allocateFrom(JAVA_DOUBLE, close);
|
||||
MemorySegment volumeSeg = a.allocateFrom(JAVA_DOUBLE, volume);
|
||||
MemorySegment timestampSeg = a.allocateFrom(JAVA_DOUBLE, timestamp);
|
||||
MemorySegment outSeg = a.allocate(JAVA_DOUBLE.byteSize() * n);
|
||||
NativeMethods.WICKRA_ADVANCE_BLOCK_BATCH.invokeExact(handle, openSeg, highSeg, lowSeg, closeSeg, volumeSeg, timestampSeg, outSeg, (long) n);
|
||||
double[] out = new double[n];
|
||||
MemorySegment.copy(outSeg, JAVA_DOUBLE, 0L, out, 0, n);
|
||||
return out;
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Reset to the just-constructed state. */
|
||||
public void reset() {
|
||||
try {
|
||||
NativeMethods.WICKRA_ADVANCE_BLOCK_RESET.invokeExact(handle);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
@Override public void close() {
|
||||
cleanable.clean();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,72 @@
|
||||
// Generated from bindings/c/include/wickra.h. Do not edit by hand.
|
||||
package org.wickra;
|
||||
|
||||
import org.wickra.internal.NativeMethods;
|
||||
import org.wickra.internal.WickraNative;
|
||||
import java.lang.foreign.Arena;
|
||||
import java.lang.foreign.MemorySegment;
|
||||
import java.lang.ref.Cleaner;
|
||||
import static java.lang.foreign.ValueLayout.*;
|
||||
|
||||
/** Streaming AdvanceDecline indicator over the Wickra C ABI. Not thread-safe; close when done. */
|
||||
public final class AdvanceDecline implements AutoCloseable {
|
||||
private final MemorySegment handle;
|
||||
private final Cleaner.Cleanable cleanable;
|
||||
|
||||
public AdvanceDecline() {
|
||||
MemorySegment h;
|
||||
try {
|
||||
h = (MemorySegment) NativeMethods.WICKRA_ADVANCE_DECLINE_NEW.invokeExact();
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
if (h.address() == 0L) {
|
||||
throw new IllegalArgumentException("invalid AdvanceDecline parameters");
|
||||
}
|
||||
this.handle = h;
|
||||
this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_ADVANCE_DECLINE_FREE);
|
||||
}
|
||||
|
||||
/** Push one observation; returns the indicator value (NaN during warmup). */
|
||||
public double update(double[] change, double[] volume, double[] newHigh, double[] newLow, double[] aboveMa, double[] onBuySignal, long timestamp) {
|
||||
if (volume.length != change.length) {
|
||||
throw new IllegalArgumentException("input arrays in the same group must have equal length");
|
||||
}
|
||||
if (newHigh.length != change.length) {
|
||||
throw new IllegalArgumentException("input arrays in the same group must have equal length");
|
||||
}
|
||||
if (newLow.length != change.length) {
|
||||
throw new IllegalArgumentException("input arrays in the same group must have equal length");
|
||||
}
|
||||
if (aboveMa.length != change.length) {
|
||||
throw new IllegalArgumentException("input arrays in the same group must have equal length");
|
||||
}
|
||||
if (onBuySignal.length != change.length) {
|
||||
throw new IllegalArgumentException("input arrays in the same group must have equal length");
|
||||
}
|
||||
try (Arena a = Arena.ofConfined()) {
|
||||
MemorySegment changeSeg = a.allocateFrom(JAVA_DOUBLE, change);
|
||||
MemorySegment volumeSeg = a.allocateFrom(JAVA_DOUBLE, volume);
|
||||
MemorySegment newHighSeg = a.allocateFrom(JAVA_DOUBLE, newHigh);
|
||||
MemorySegment newLowSeg = a.allocateFrom(JAVA_DOUBLE, newLow);
|
||||
MemorySegment aboveMaSeg = a.allocateFrom(JAVA_DOUBLE, aboveMa);
|
||||
MemorySegment onBuySignalSeg = a.allocateFrom(JAVA_DOUBLE, onBuySignal);
|
||||
return (double) NativeMethods.WICKRA_ADVANCE_DECLINE_UPDATE.invokeExact(handle, changeSeg, volumeSeg, newHighSeg, newLowSeg, aboveMaSeg, onBuySignalSeg, (long) change.length, timestamp);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Reset to the just-constructed state. */
|
||||
public void reset() {
|
||||
try {
|
||||
NativeMethods.WICKRA_ADVANCE_DECLINE_RESET.invokeExact(handle);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
@Override public void close() {
|
||||
cleanable.clean();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,72 @@
|
||||
// Generated from bindings/c/include/wickra.h. Do not edit by hand.
|
||||
package org.wickra;
|
||||
|
||||
import org.wickra.internal.NativeMethods;
|
||||
import org.wickra.internal.WickraNative;
|
||||
import java.lang.foreign.Arena;
|
||||
import java.lang.foreign.MemorySegment;
|
||||
import java.lang.ref.Cleaner;
|
||||
import static java.lang.foreign.ValueLayout.*;
|
||||
|
||||
/** Streaming AdvanceDeclineRatio indicator over the Wickra C ABI. Not thread-safe; close when done. */
|
||||
public final class AdvanceDeclineRatio implements AutoCloseable {
|
||||
private final MemorySegment handle;
|
||||
private final Cleaner.Cleanable cleanable;
|
||||
|
||||
public AdvanceDeclineRatio() {
|
||||
MemorySegment h;
|
||||
try {
|
||||
h = (MemorySegment) NativeMethods.WICKRA_ADVANCE_DECLINE_RATIO_NEW.invokeExact();
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
if (h.address() == 0L) {
|
||||
throw new IllegalArgumentException("invalid AdvanceDeclineRatio parameters");
|
||||
}
|
||||
this.handle = h;
|
||||
this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_ADVANCE_DECLINE_RATIO_FREE);
|
||||
}
|
||||
|
||||
/** Push one observation; returns the indicator value (NaN during warmup). */
|
||||
public double update(double[] change, double[] volume, double[] newHigh, double[] newLow, double[] aboveMa, double[] onBuySignal, long timestamp) {
|
||||
if (volume.length != change.length) {
|
||||
throw new IllegalArgumentException("input arrays in the same group must have equal length");
|
||||
}
|
||||
if (newHigh.length != change.length) {
|
||||
throw new IllegalArgumentException("input arrays in the same group must have equal length");
|
||||
}
|
||||
if (newLow.length != change.length) {
|
||||
throw new IllegalArgumentException("input arrays in the same group must have equal length");
|
||||
}
|
||||
if (aboveMa.length != change.length) {
|
||||
throw new IllegalArgumentException("input arrays in the same group must have equal length");
|
||||
}
|
||||
if (onBuySignal.length != change.length) {
|
||||
throw new IllegalArgumentException("input arrays in the same group must have equal length");
|
||||
}
|
||||
try (Arena a = Arena.ofConfined()) {
|
||||
MemorySegment changeSeg = a.allocateFrom(JAVA_DOUBLE, change);
|
||||
MemorySegment volumeSeg = a.allocateFrom(JAVA_DOUBLE, volume);
|
||||
MemorySegment newHighSeg = a.allocateFrom(JAVA_DOUBLE, newHigh);
|
||||
MemorySegment newLowSeg = a.allocateFrom(JAVA_DOUBLE, newLow);
|
||||
MemorySegment aboveMaSeg = a.allocateFrom(JAVA_DOUBLE, aboveMa);
|
||||
MemorySegment onBuySignalSeg = a.allocateFrom(JAVA_DOUBLE, onBuySignal);
|
||||
return (double) NativeMethods.WICKRA_ADVANCE_DECLINE_RATIO_UPDATE.invokeExact(handle, changeSeg, volumeSeg, newHighSeg, newLowSeg, aboveMaSeg, onBuySignalSeg, (long) change.length, timestamp);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Reset to the just-constructed state. */
|
||||
public void reset() {
|
||||
try {
|
||||
NativeMethods.WICKRA_ADVANCE_DECLINE_RATIO_RESET.invokeExact(handle);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
@Override public void close() {
|
||||
cleanable.clean();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,62 @@
|
||||
// Generated from bindings/c/include/wickra.h. Do not edit by hand.
|
||||
package org.wickra;
|
||||
|
||||
import org.wickra.internal.NativeMethods;
|
||||
import org.wickra.internal.WickraNative;
|
||||
import java.lang.foreign.Arena;
|
||||
import java.lang.foreign.MemorySegment;
|
||||
import java.lang.ref.Cleaner;
|
||||
import static java.lang.foreign.ValueLayout.*;
|
||||
|
||||
/** Streaming Adx indicator over the Wickra C ABI. Not thread-safe; close when done. */
|
||||
public final class Adx implements AutoCloseable {
|
||||
private final MemorySegment handle;
|
||||
private final Cleaner.Cleanable cleanable;
|
||||
|
||||
public Adx(int period) {
|
||||
if (period < 0) {
|
||||
throw new IllegalArgumentException("period must be non-negative");
|
||||
}
|
||||
MemorySegment h;
|
||||
try {
|
||||
h = (MemorySegment) NativeMethods.WICKRA_ADX_NEW.invokeExact((long) period);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
if (h.address() == 0L) {
|
||||
throw new IllegalArgumentException("invalid Adx parameters");
|
||||
}
|
||||
this.handle = h;
|
||||
this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_ADX_FREE);
|
||||
}
|
||||
|
||||
/** Push one observation; returns the result, or null during warmup. */
|
||||
public AdxOutput update(double open, double high, double low, double close, double volume, long timestamp) {
|
||||
try (Arena a = Arena.ofConfined()) {
|
||||
MemorySegment out = a.allocate(24L);
|
||||
byte ok = (byte) NativeMethods.WICKRA_ADX_UPDATE.invokeExact(handle, open, high, low, close, volume, timestamp, out);
|
||||
if (ok == 0) {
|
||||
return null;
|
||||
}
|
||||
return new AdxOutput(
|
||||
out.get(JAVA_DOUBLE, 0L),
|
||||
out.get(JAVA_DOUBLE, 8L),
|
||||
out.get(JAVA_DOUBLE, 16L));
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Reset to the just-constructed state. */
|
||||
public void reset() {
|
||||
try {
|
||||
NativeMethods.WICKRA_ADX_RESET.invokeExact(handle);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
@Override public void close() {
|
||||
cleanable.clean();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,5 @@
|
||||
// Generated from bindings/c/include/wickra.h. Do not edit by hand.
|
||||
package org.wickra;
|
||||
|
||||
/** Output record produced by the matching indicator. */
|
||||
public record AdxOutput(double plusDi, double minusDi, double adx) {}
|
||||
@@ -0,0 +1,89 @@
|
||||
// Generated from bindings/c/include/wickra.h. Do not edit by hand.
|
||||
package org.wickra;
|
||||
|
||||
import org.wickra.internal.NativeMethods;
|
||||
import org.wickra.internal.WickraNative;
|
||||
import java.lang.foreign.Arena;
|
||||
import java.lang.foreign.MemorySegment;
|
||||
import java.lang.ref.Cleaner;
|
||||
import static java.lang.foreign.ValueLayout.*;
|
||||
|
||||
/** Streaming Adxr indicator over the Wickra C ABI. Not thread-safe; close when done. */
|
||||
public final class Adxr implements AutoCloseable {
|
||||
private final MemorySegment handle;
|
||||
private final Cleaner.Cleanable cleanable;
|
||||
|
||||
public Adxr(int period) {
|
||||
if (period < 0) {
|
||||
throw new IllegalArgumentException("period must be non-negative");
|
||||
}
|
||||
MemorySegment h;
|
||||
try {
|
||||
h = (MemorySegment) NativeMethods.WICKRA_ADXR_NEW.invokeExact((long) period);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
if (h.address() == 0L) {
|
||||
throw new IllegalArgumentException("invalid Adxr parameters");
|
||||
}
|
||||
this.handle = h;
|
||||
this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_ADXR_FREE);
|
||||
}
|
||||
|
||||
/** Push one observation; returns the indicator value (NaN during warmup). */
|
||||
public double update(double open, double high, double low, double close, double volume, long timestamp) {
|
||||
try {
|
||||
return (double) NativeMethods.WICKRA_ADXR_UPDATE.invokeExact(handle, open, high, low, close, volume, timestamp);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Vectorized update over a whole series; NaN at warmup positions. */
|
||||
public double[] batch(double[] open, double[] high, double[] low, double[] close, double[] volume, double[] timestamp) {
|
||||
int n = open.length;
|
||||
if (high.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (low.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (close.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (volume.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (timestamp.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
try (Arena a = Arena.ofConfined()) {
|
||||
MemorySegment openSeg = a.allocateFrom(JAVA_DOUBLE, open);
|
||||
MemorySegment highSeg = a.allocateFrom(JAVA_DOUBLE, high);
|
||||
MemorySegment lowSeg = a.allocateFrom(JAVA_DOUBLE, low);
|
||||
MemorySegment closeSeg = a.allocateFrom(JAVA_DOUBLE, close);
|
||||
MemorySegment volumeSeg = a.allocateFrom(JAVA_DOUBLE, volume);
|
||||
MemorySegment timestampSeg = a.allocateFrom(JAVA_DOUBLE, timestamp);
|
||||
MemorySegment outSeg = a.allocate(JAVA_DOUBLE.byteSize() * n);
|
||||
NativeMethods.WICKRA_ADXR_BATCH.invokeExact(handle, openSeg, highSeg, lowSeg, closeSeg, volumeSeg, timestampSeg, outSeg, (long) n);
|
||||
double[] out = new double[n];
|
||||
MemorySegment.copy(outSeg, JAVA_DOUBLE, 0L, out, 0, n);
|
||||
return out;
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Reset to the just-constructed state. */
|
||||
public void reset() {
|
||||
try {
|
||||
NativeMethods.WICKRA_ADXR_RESET.invokeExact(handle);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
@Override public void close() {
|
||||
cleanable.clean();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,68 @@
|
||||
// Generated from bindings/c/include/wickra.h. Do not edit by hand.
|
||||
package org.wickra;
|
||||
|
||||
import org.wickra.internal.NativeMethods;
|
||||
import org.wickra.internal.WickraNative;
|
||||
import java.lang.foreign.Arena;
|
||||
import java.lang.foreign.MemorySegment;
|
||||
import java.lang.ref.Cleaner;
|
||||
import static java.lang.foreign.ValueLayout.*;
|
||||
|
||||
/** Streaming Alligator indicator over the Wickra C ABI. Not thread-safe; close when done. */
|
||||
public final class Alligator implements AutoCloseable {
|
||||
private final MemorySegment handle;
|
||||
private final Cleaner.Cleanable cleanable;
|
||||
|
||||
public Alligator(int jawPeriod, int teethPeriod, int lipsPeriod) {
|
||||
if (jawPeriod < 0) {
|
||||
throw new IllegalArgumentException("jawPeriod must be non-negative");
|
||||
}
|
||||
if (teethPeriod < 0) {
|
||||
throw new IllegalArgumentException("teethPeriod must be non-negative");
|
||||
}
|
||||
if (lipsPeriod < 0) {
|
||||
throw new IllegalArgumentException("lipsPeriod must be non-negative");
|
||||
}
|
||||
MemorySegment h;
|
||||
try {
|
||||
h = (MemorySegment) NativeMethods.WICKRA_ALLIGATOR_NEW.invokeExact((long) jawPeriod, (long) teethPeriod, (long) lipsPeriod);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
if (h.address() == 0L) {
|
||||
throw new IllegalArgumentException("invalid Alligator parameters");
|
||||
}
|
||||
this.handle = h;
|
||||
this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_ALLIGATOR_FREE);
|
||||
}
|
||||
|
||||
/** Push one observation; returns the result, or null during warmup. */
|
||||
public AlligatorOutput update(double open, double high, double low, double close, double volume, long timestamp) {
|
||||
try (Arena a = Arena.ofConfined()) {
|
||||
MemorySegment out = a.allocate(24L);
|
||||
byte ok = (byte) NativeMethods.WICKRA_ALLIGATOR_UPDATE.invokeExact(handle, open, high, low, close, volume, timestamp, out);
|
||||
if (ok == 0) {
|
||||
return null;
|
||||
}
|
||||
return new AlligatorOutput(
|
||||
out.get(JAVA_DOUBLE, 0L),
|
||||
out.get(JAVA_DOUBLE, 8L),
|
||||
out.get(JAVA_DOUBLE, 16L));
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Reset to the just-constructed state. */
|
||||
public void reset() {
|
||||
try {
|
||||
NativeMethods.WICKRA_ALLIGATOR_RESET.invokeExact(handle);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
@Override public void close() {
|
||||
cleanable.clean();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,5 @@
|
||||
// Generated from bindings/c/include/wickra.h. Do not edit by hand.
|
||||
package org.wickra;
|
||||
|
||||
/** Output record produced by the matching indicator. */
|
||||
public record AlligatorOutput(double jaw, double teeth, double lips) {}
|
||||
@@ -0,0 +1,69 @@
|
||||
// Generated from bindings/c/include/wickra.h. Do not edit by hand.
|
||||
package org.wickra;
|
||||
|
||||
import org.wickra.internal.NativeMethods;
|
||||
import org.wickra.internal.WickraNative;
|
||||
import java.lang.foreign.Arena;
|
||||
import java.lang.foreign.MemorySegment;
|
||||
import java.lang.ref.Cleaner;
|
||||
import static java.lang.foreign.ValueLayout.*;
|
||||
|
||||
/** Streaming Alma indicator over the Wickra C ABI. Not thread-safe; close when done. */
|
||||
public final class Alma implements AutoCloseable {
|
||||
private final MemorySegment handle;
|
||||
private final Cleaner.Cleanable cleanable;
|
||||
|
||||
public Alma(int period, double offset, double sigma) {
|
||||
if (period < 0) {
|
||||
throw new IllegalArgumentException("period must be non-negative");
|
||||
}
|
||||
MemorySegment h;
|
||||
try {
|
||||
h = (MemorySegment) NativeMethods.WICKRA_ALMA_NEW.invokeExact((long) period, offset, sigma);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
if (h.address() == 0L) {
|
||||
throw new IllegalArgumentException("invalid Alma parameters");
|
||||
}
|
||||
this.handle = h;
|
||||
this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_ALMA_FREE);
|
||||
}
|
||||
|
||||
/** Push one observation; returns the indicator value (NaN during warmup). */
|
||||
public double update(double value) {
|
||||
try {
|
||||
return (double) NativeMethods.WICKRA_ALMA_UPDATE.invokeExact(handle, value);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Vectorized update over a whole series; NaN at warmup positions. */
|
||||
public double[] batch(double[] input) {
|
||||
int n = input.length;
|
||||
try (Arena a = Arena.ofConfined()) {
|
||||
MemorySegment inputSeg = a.allocateFrom(JAVA_DOUBLE, input);
|
||||
MemorySegment outSeg = a.allocate(JAVA_DOUBLE.byteSize() * n);
|
||||
NativeMethods.WICKRA_ALMA_BATCH.invokeExact(handle, inputSeg, outSeg, (long) n);
|
||||
double[] out = new double[n];
|
||||
MemorySegment.copy(outSeg, JAVA_DOUBLE, 0L, out, 0, n);
|
||||
return out;
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Reset to the just-constructed state. */
|
||||
public void reset() {
|
||||
try {
|
||||
NativeMethods.WICKRA_ALMA_RESET.invokeExact(handle);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
@Override public void close() {
|
||||
cleanable.clean();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,73 @@
|
||||
// Generated from bindings/c/include/wickra.h. Do not edit by hand.
|
||||
package org.wickra;
|
||||
|
||||
import org.wickra.internal.NativeMethods;
|
||||
import org.wickra.internal.WickraNative;
|
||||
import java.lang.foreign.Arena;
|
||||
import java.lang.foreign.MemorySegment;
|
||||
import java.lang.ref.Cleaner;
|
||||
import static java.lang.foreign.ValueLayout.*;
|
||||
|
||||
/** Streaming Alpha indicator over the Wickra C ABI. Not thread-safe; close when done. */
|
||||
public final class Alpha implements AutoCloseable {
|
||||
private final MemorySegment handle;
|
||||
private final Cleaner.Cleanable cleanable;
|
||||
|
||||
public Alpha(int period, double riskFree) {
|
||||
if (period < 0) {
|
||||
throw new IllegalArgumentException("period must be non-negative");
|
||||
}
|
||||
MemorySegment h;
|
||||
try {
|
||||
h = (MemorySegment) NativeMethods.WICKRA_ALPHA_NEW.invokeExact((long) period, riskFree);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
if (h.address() == 0L) {
|
||||
throw new IllegalArgumentException("invalid Alpha parameters");
|
||||
}
|
||||
this.handle = h;
|
||||
this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_ALPHA_FREE);
|
||||
}
|
||||
|
||||
/** Push one observation; returns the indicator value (NaN during warmup). */
|
||||
public double update(double x, double y) {
|
||||
try {
|
||||
return (double) NativeMethods.WICKRA_ALPHA_UPDATE.invokeExact(handle, x, y);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Vectorized update over a whole series; NaN at warmup positions. */
|
||||
public double[] batch(double[] x, double[] y) {
|
||||
int n = x.length;
|
||||
if (y.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
try (Arena a = Arena.ofConfined()) {
|
||||
MemorySegment xSeg = a.allocateFrom(JAVA_DOUBLE, x);
|
||||
MemorySegment ySeg = a.allocateFrom(JAVA_DOUBLE, y);
|
||||
MemorySegment outSeg = a.allocate(JAVA_DOUBLE.byteSize() * n);
|
||||
NativeMethods.WICKRA_ALPHA_BATCH.invokeExact(handle, xSeg, ySeg, outSeg, (long) n);
|
||||
double[] out = new double[n];
|
||||
MemorySegment.copy(outSeg, JAVA_DOUBLE, 0L, out, 0, n);
|
||||
return out;
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Reset to the just-constructed state. */
|
||||
public void reset() {
|
||||
try {
|
||||
NativeMethods.WICKRA_ALPHA_RESET.invokeExact(handle);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
@Override public void close() {
|
||||
cleanable.clean();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,54 @@
|
||||
// Generated from bindings/c/include/wickra.h. Do not edit by hand.
|
||||
package org.wickra;
|
||||
|
||||
import org.wickra.internal.NativeMethods;
|
||||
import org.wickra.internal.WickraNative;
|
||||
import java.lang.foreign.Arena;
|
||||
import java.lang.foreign.MemorySegment;
|
||||
import java.lang.ref.Cleaner;
|
||||
import static java.lang.foreign.ValueLayout.*;
|
||||
|
||||
/** Streaming AmihudIlliquidity indicator over the Wickra C ABI. Not thread-safe; close when done. */
|
||||
public final class AmihudIlliquidity implements AutoCloseable {
|
||||
private final MemorySegment handle;
|
||||
private final Cleaner.Cleanable cleanable;
|
||||
|
||||
public AmihudIlliquidity(int period) {
|
||||
if (period < 0) {
|
||||
throw new IllegalArgumentException("period must be non-negative");
|
||||
}
|
||||
MemorySegment h;
|
||||
try {
|
||||
h = (MemorySegment) NativeMethods.WICKRA_AMIHUD_ILLIQUIDITY_NEW.invokeExact((long) period);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
if (h.address() == 0L) {
|
||||
throw new IllegalArgumentException("invalid AmihudIlliquidity parameters");
|
||||
}
|
||||
this.handle = h;
|
||||
this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_AMIHUD_ILLIQUIDITY_FREE);
|
||||
}
|
||||
|
||||
/** Push one observation; returns the indicator value (NaN during warmup). */
|
||||
public double update(double price, double size, boolean isBuy, long timestamp) {
|
||||
try {
|
||||
return (double) NativeMethods.WICKRA_AMIHUD_ILLIQUIDITY_UPDATE.invokeExact(handle, price, size, (byte) (isBuy ? 1 : 0), timestamp);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Reset to the just-constructed state. */
|
||||
public void reset() {
|
||||
try {
|
||||
NativeMethods.WICKRA_AMIHUD_ILLIQUIDITY_RESET.invokeExact(handle);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
@Override public void close() {
|
||||
cleanable.clean();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,66 @@
|
||||
// Generated from bindings/c/include/wickra.h. Do not edit by hand.
|
||||
package org.wickra;
|
||||
|
||||
import org.wickra.internal.NativeMethods;
|
||||
import org.wickra.internal.WickraNative;
|
||||
import java.lang.foreign.Arena;
|
||||
import java.lang.foreign.MemorySegment;
|
||||
import java.lang.ref.Cleaner;
|
||||
import static java.lang.foreign.ValueLayout.*;
|
||||
|
||||
/** Streaming AnchoredRsi indicator over the Wickra C ABI. Not thread-safe; close when done. */
|
||||
public final class AnchoredRsi implements AutoCloseable {
|
||||
private final MemorySegment handle;
|
||||
private final Cleaner.Cleanable cleanable;
|
||||
|
||||
public AnchoredRsi() {
|
||||
MemorySegment h;
|
||||
try {
|
||||
h = (MemorySegment) NativeMethods.WICKRA_ANCHORED_RSI_NEW.invokeExact();
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
if (h.address() == 0L) {
|
||||
throw new IllegalArgumentException("invalid AnchoredRsi parameters");
|
||||
}
|
||||
this.handle = h;
|
||||
this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_ANCHORED_RSI_FREE);
|
||||
}
|
||||
|
||||
/** Push one observation; returns the indicator value (NaN during warmup). */
|
||||
public double update(double value) {
|
||||
try {
|
||||
return (double) NativeMethods.WICKRA_ANCHORED_RSI_UPDATE.invokeExact(handle, value);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Vectorized update over a whole series; NaN at warmup positions. */
|
||||
public double[] batch(double[] input) {
|
||||
int n = input.length;
|
||||
try (Arena a = Arena.ofConfined()) {
|
||||
MemorySegment inputSeg = a.allocateFrom(JAVA_DOUBLE, input);
|
||||
MemorySegment outSeg = a.allocate(JAVA_DOUBLE.byteSize() * n);
|
||||
NativeMethods.WICKRA_ANCHORED_RSI_BATCH.invokeExact(handle, inputSeg, outSeg, (long) n);
|
||||
double[] out = new double[n];
|
||||
MemorySegment.copy(outSeg, JAVA_DOUBLE, 0L, out, 0, n);
|
||||
return out;
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Reset to the just-constructed state. */
|
||||
public void reset() {
|
||||
try {
|
||||
NativeMethods.WICKRA_ANCHORED_RSI_RESET.invokeExact(handle);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
@Override public void close() {
|
||||
cleanable.clean();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,86 @@
|
||||
// Generated from bindings/c/include/wickra.h. Do not edit by hand.
|
||||
package org.wickra;
|
||||
|
||||
import org.wickra.internal.NativeMethods;
|
||||
import org.wickra.internal.WickraNative;
|
||||
import java.lang.foreign.Arena;
|
||||
import java.lang.foreign.MemorySegment;
|
||||
import java.lang.ref.Cleaner;
|
||||
import static java.lang.foreign.ValueLayout.*;
|
||||
|
||||
/** Streaming AnchoredVwap indicator over the Wickra C ABI. Not thread-safe; close when done. */
|
||||
public final class AnchoredVwap implements AutoCloseable {
|
||||
private final MemorySegment handle;
|
||||
private final Cleaner.Cleanable cleanable;
|
||||
|
||||
public AnchoredVwap() {
|
||||
MemorySegment h;
|
||||
try {
|
||||
h = (MemorySegment) NativeMethods.WICKRA_ANCHORED_VWAP_NEW.invokeExact();
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
if (h.address() == 0L) {
|
||||
throw new IllegalArgumentException("invalid AnchoredVwap parameters");
|
||||
}
|
||||
this.handle = h;
|
||||
this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_ANCHORED_VWAP_FREE);
|
||||
}
|
||||
|
||||
/** Push one observation; returns the indicator value (NaN during warmup). */
|
||||
public double update(double open, double high, double low, double close, double volume, long timestamp) {
|
||||
try {
|
||||
return (double) NativeMethods.WICKRA_ANCHORED_VWAP_UPDATE.invokeExact(handle, open, high, low, close, volume, timestamp);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Vectorized update over a whole series; NaN at warmup positions. */
|
||||
public double[] batch(double[] open, double[] high, double[] low, double[] close, double[] volume, double[] timestamp) {
|
||||
int n = open.length;
|
||||
if (high.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (low.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (close.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (volume.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (timestamp.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
try (Arena a = Arena.ofConfined()) {
|
||||
MemorySegment openSeg = a.allocateFrom(JAVA_DOUBLE, open);
|
||||
MemorySegment highSeg = a.allocateFrom(JAVA_DOUBLE, high);
|
||||
MemorySegment lowSeg = a.allocateFrom(JAVA_DOUBLE, low);
|
||||
MemorySegment closeSeg = a.allocateFrom(JAVA_DOUBLE, close);
|
||||
MemorySegment volumeSeg = a.allocateFrom(JAVA_DOUBLE, volume);
|
||||
MemorySegment timestampSeg = a.allocateFrom(JAVA_DOUBLE, timestamp);
|
||||
MemorySegment outSeg = a.allocate(JAVA_DOUBLE.byteSize() * n);
|
||||
NativeMethods.WICKRA_ANCHORED_VWAP_BATCH.invokeExact(handle, openSeg, highSeg, lowSeg, closeSeg, volumeSeg, timestampSeg, outSeg, (long) n);
|
||||
double[] out = new double[n];
|
||||
MemorySegment.copy(outSeg, JAVA_DOUBLE, 0L, out, 0, n);
|
||||
return out;
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Reset to the just-constructed state. */
|
||||
public void reset() {
|
||||
try {
|
||||
NativeMethods.WICKRA_ANCHORED_VWAP_RESET.invokeExact(handle);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
@Override public void close() {
|
||||
cleanable.clean();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,62 @@
|
||||
// Generated from bindings/c/include/wickra.h. Do not edit by hand.
|
||||
package org.wickra;
|
||||
|
||||
import org.wickra.internal.NativeMethods;
|
||||
import org.wickra.internal.WickraNative;
|
||||
import java.lang.foreign.Arena;
|
||||
import java.lang.foreign.MemorySegment;
|
||||
import java.lang.ref.Cleaner;
|
||||
import static java.lang.foreign.ValueLayout.*;
|
||||
|
||||
/** Streaming AndrewsPitchfork indicator over the Wickra C ABI. Not thread-safe; close when done. */
|
||||
public final class AndrewsPitchfork implements AutoCloseable {
|
||||
private final MemorySegment handle;
|
||||
private final Cleaner.Cleanable cleanable;
|
||||
|
||||
public AndrewsPitchfork(int strength) {
|
||||
if (strength < 0) {
|
||||
throw new IllegalArgumentException("strength must be non-negative");
|
||||
}
|
||||
MemorySegment h;
|
||||
try {
|
||||
h = (MemorySegment) NativeMethods.WICKRA_ANDREWS_PITCHFORK_NEW.invokeExact((long) strength);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
if (h.address() == 0L) {
|
||||
throw new IllegalArgumentException("invalid AndrewsPitchfork parameters");
|
||||
}
|
||||
this.handle = h;
|
||||
this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_ANDREWS_PITCHFORK_FREE);
|
||||
}
|
||||
|
||||
/** Push one observation; returns the result, or null during warmup. */
|
||||
public AndrewsPitchforkOutput update(double open, double high, double low, double close, double volume, long timestamp) {
|
||||
try (Arena a = Arena.ofConfined()) {
|
||||
MemorySegment out = a.allocate(24L);
|
||||
byte ok = (byte) NativeMethods.WICKRA_ANDREWS_PITCHFORK_UPDATE.invokeExact(handle, open, high, low, close, volume, timestamp, out);
|
||||
if (ok == 0) {
|
||||
return null;
|
||||
}
|
||||
return new AndrewsPitchforkOutput(
|
||||
out.get(JAVA_DOUBLE, 0L),
|
||||
out.get(JAVA_DOUBLE, 8L),
|
||||
out.get(JAVA_DOUBLE, 16L));
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Reset to the just-constructed state. */
|
||||
public void reset() {
|
||||
try {
|
||||
NativeMethods.WICKRA_ANDREWS_PITCHFORK_RESET.invokeExact(handle);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
@Override public void close() {
|
||||
cleanable.clean();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,5 @@
|
||||
// Generated from bindings/c/include/wickra.h. Do not edit by hand.
|
||||
package org.wickra;
|
||||
|
||||
/** Output record produced by the matching indicator. */
|
||||
public record AndrewsPitchforkOutput(double median, double upper, double lower) {}
|
||||
@@ -0,0 +1,72 @@
|
||||
// Generated from bindings/c/include/wickra.h. Do not edit by hand.
|
||||
package org.wickra;
|
||||
|
||||
import org.wickra.internal.NativeMethods;
|
||||
import org.wickra.internal.WickraNative;
|
||||
import java.lang.foreign.Arena;
|
||||
import java.lang.foreign.MemorySegment;
|
||||
import java.lang.ref.Cleaner;
|
||||
import static java.lang.foreign.ValueLayout.*;
|
||||
|
||||
/** Streaming Apo indicator over the Wickra C ABI. Not thread-safe; close when done. */
|
||||
public final class Apo implements AutoCloseable {
|
||||
private final MemorySegment handle;
|
||||
private final Cleaner.Cleanable cleanable;
|
||||
|
||||
public Apo(int fast, int slow) {
|
||||
if (fast < 0) {
|
||||
throw new IllegalArgumentException("fast must be non-negative");
|
||||
}
|
||||
if (slow < 0) {
|
||||
throw new IllegalArgumentException("slow must be non-negative");
|
||||
}
|
||||
MemorySegment h;
|
||||
try {
|
||||
h = (MemorySegment) NativeMethods.WICKRA_APO_NEW.invokeExact((long) fast, (long) slow);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
if (h.address() == 0L) {
|
||||
throw new IllegalArgumentException("invalid Apo parameters");
|
||||
}
|
||||
this.handle = h;
|
||||
this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_APO_FREE);
|
||||
}
|
||||
|
||||
/** Push one observation; returns the indicator value (NaN during warmup). */
|
||||
public double update(double value) {
|
||||
try {
|
||||
return (double) NativeMethods.WICKRA_APO_UPDATE.invokeExact(handle, value);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Vectorized update over a whole series; NaN at warmup positions. */
|
||||
public double[] batch(double[] input) {
|
||||
int n = input.length;
|
||||
try (Arena a = Arena.ofConfined()) {
|
||||
MemorySegment inputSeg = a.allocateFrom(JAVA_DOUBLE, input);
|
||||
MemorySegment outSeg = a.allocate(JAVA_DOUBLE.byteSize() * n);
|
||||
NativeMethods.WICKRA_APO_BATCH.invokeExact(handle, inputSeg, outSeg, (long) n);
|
||||
double[] out = new double[n];
|
||||
MemorySegment.copy(outSeg, JAVA_DOUBLE, 0L, out, 0, n);
|
||||
return out;
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Reset to the just-constructed state. */
|
||||
public void reset() {
|
||||
try {
|
||||
NativeMethods.WICKRA_APO_RESET.invokeExact(handle);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
@Override public void close() {
|
||||
cleanable.clean();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,61 @@
|
||||
// Generated from bindings/c/include/wickra.h. Do not edit by hand.
|
||||
package org.wickra;
|
||||
|
||||
import org.wickra.internal.NativeMethods;
|
||||
import org.wickra.internal.WickraNative;
|
||||
import java.lang.foreign.Arena;
|
||||
import java.lang.foreign.MemorySegment;
|
||||
import java.lang.ref.Cleaner;
|
||||
import static java.lang.foreign.ValueLayout.*;
|
||||
|
||||
/** Streaming Aroon indicator over the Wickra C ABI. Not thread-safe; close when done. */
|
||||
public final class Aroon implements AutoCloseable {
|
||||
private final MemorySegment handle;
|
||||
private final Cleaner.Cleanable cleanable;
|
||||
|
||||
public Aroon(int period) {
|
||||
if (period < 0) {
|
||||
throw new IllegalArgumentException("period must be non-negative");
|
||||
}
|
||||
MemorySegment h;
|
||||
try {
|
||||
h = (MemorySegment) NativeMethods.WICKRA_AROON_NEW.invokeExact((long) period);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
if (h.address() == 0L) {
|
||||
throw new IllegalArgumentException("invalid Aroon parameters");
|
||||
}
|
||||
this.handle = h;
|
||||
this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_AROON_FREE);
|
||||
}
|
||||
|
||||
/** Push one observation; returns the result, or null during warmup. */
|
||||
public AroonOutput update(double open, double high, double low, double close, double volume, long timestamp) {
|
||||
try (Arena a = Arena.ofConfined()) {
|
||||
MemorySegment out = a.allocate(16L);
|
||||
byte ok = (byte) NativeMethods.WICKRA_AROON_UPDATE.invokeExact(handle, open, high, low, close, volume, timestamp, out);
|
||||
if (ok == 0) {
|
||||
return null;
|
||||
}
|
||||
return new AroonOutput(
|
||||
out.get(JAVA_DOUBLE, 0L),
|
||||
out.get(JAVA_DOUBLE, 8L));
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Reset to the just-constructed state. */
|
||||
public void reset() {
|
||||
try {
|
||||
NativeMethods.WICKRA_AROON_RESET.invokeExact(handle);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
@Override public void close() {
|
||||
cleanable.clean();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,89 @@
|
||||
// Generated from bindings/c/include/wickra.h. Do not edit by hand.
|
||||
package org.wickra;
|
||||
|
||||
import org.wickra.internal.NativeMethods;
|
||||
import org.wickra.internal.WickraNative;
|
||||
import java.lang.foreign.Arena;
|
||||
import java.lang.foreign.MemorySegment;
|
||||
import java.lang.ref.Cleaner;
|
||||
import static java.lang.foreign.ValueLayout.*;
|
||||
|
||||
/** Streaming AroonOscillator indicator over the Wickra C ABI. Not thread-safe; close when done. */
|
||||
public final class AroonOscillator implements AutoCloseable {
|
||||
private final MemorySegment handle;
|
||||
private final Cleaner.Cleanable cleanable;
|
||||
|
||||
public AroonOscillator(int period) {
|
||||
if (period < 0) {
|
||||
throw new IllegalArgumentException("period must be non-negative");
|
||||
}
|
||||
MemorySegment h;
|
||||
try {
|
||||
h = (MemorySegment) NativeMethods.WICKRA_AROON_OSCILLATOR_NEW.invokeExact((long) period);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
if (h.address() == 0L) {
|
||||
throw new IllegalArgumentException("invalid AroonOscillator parameters");
|
||||
}
|
||||
this.handle = h;
|
||||
this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_AROON_OSCILLATOR_FREE);
|
||||
}
|
||||
|
||||
/** Push one observation; returns the indicator value (NaN during warmup). */
|
||||
public double update(double open, double high, double low, double close, double volume, long timestamp) {
|
||||
try {
|
||||
return (double) NativeMethods.WICKRA_AROON_OSCILLATOR_UPDATE.invokeExact(handle, open, high, low, close, volume, timestamp);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Vectorized update over a whole series; NaN at warmup positions. */
|
||||
public double[] batch(double[] open, double[] high, double[] low, double[] close, double[] volume, double[] timestamp) {
|
||||
int n = open.length;
|
||||
if (high.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (low.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (close.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (volume.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (timestamp.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
try (Arena a = Arena.ofConfined()) {
|
||||
MemorySegment openSeg = a.allocateFrom(JAVA_DOUBLE, open);
|
||||
MemorySegment highSeg = a.allocateFrom(JAVA_DOUBLE, high);
|
||||
MemorySegment lowSeg = a.allocateFrom(JAVA_DOUBLE, low);
|
||||
MemorySegment closeSeg = a.allocateFrom(JAVA_DOUBLE, close);
|
||||
MemorySegment volumeSeg = a.allocateFrom(JAVA_DOUBLE, volume);
|
||||
MemorySegment timestampSeg = a.allocateFrom(JAVA_DOUBLE, timestamp);
|
||||
MemorySegment outSeg = a.allocate(JAVA_DOUBLE.byteSize() * n);
|
||||
NativeMethods.WICKRA_AROON_OSCILLATOR_BATCH.invokeExact(handle, openSeg, highSeg, lowSeg, closeSeg, volumeSeg, timestampSeg, outSeg, (long) n);
|
||||
double[] out = new double[n];
|
||||
MemorySegment.copy(outSeg, JAVA_DOUBLE, 0L, out, 0, n);
|
||||
return out;
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Reset to the just-constructed state. */
|
||||
public void reset() {
|
||||
try {
|
||||
NativeMethods.WICKRA_AROON_OSCILLATOR_RESET.invokeExact(handle);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
@Override public void close() {
|
||||
cleanable.clean();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,5 @@
|
||||
// Generated from bindings/c/include/wickra.h. Do not edit by hand.
|
||||
package org.wickra;
|
||||
|
||||
/** Output record produced by the matching indicator. */
|
||||
public record AroonOutput(double up, double down) {}
|
||||
@@ -0,0 +1,89 @@
|
||||
// Generated from bindings/c/include/wickra.h. Do not edit by hand.
|
||||
package org.wickra;
|
||||
|
||||
import org.wickra.internal.NativeMethods;
|
||||
import org.wickra.internal.WickraNative;
|
||||
import java.lang.foreign.Arena;
|
||||
import java.lang.foreign.MemorySegment;
|
||||
import java.lang.ref.Cleaner;
|
||||
import static java.lang.foreign.ValueLayout.*;
|
||||
|
||||
/** Streaming Atr indicator over the Wickra C ABI. Not thread-safe; close when done. */
|
||||
public final class Atr implements AutoCloseable {
|
||||
private final MemorySegment handle;
|
||||
private final Cleaner.Cleanable cleanable;
|
||||
|
||||
public Atr(int period) {
|
||||
if (period < 0) {
|
||||
throw new IllegalArgumentException("period must be non-negative");
|
||||
}
|
||||
MemorySegment h;
|
||||
try {
|
||||
h = (MemorySegment) NativeMethods.WICKRA_ATR_NEW.invokeExact((long) period);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
if (h.address() == 0L) {
|
||||
throw new IllegalArgumentException("invalid Atr parameters");
|
||||
}
|
||||
this.handle = h;
|
||||
this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_ATR_FREE);
|
||||
}
|
||||
|
||||
/** Push one observation; returns the indicator value (NaN during warmup). */
|
||||
public double update(double open, double high, double low, double close, double volume, long timestamp) {
|
||||
try {
|
||||
return (double) NativeMethods.WICKRA_ATR_UPDATE.invokeExact(handle, open, high, low, close, volume, timestamp);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Vectorized update over a whole series; NaN at warmup positions. */
|
||||
public double[] batch(double[] open, double[] high, double[] low, double[] close, double[] volume, double[] timestamp) {
|
||||
int n = open.length;
|
||||
if (high.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (low.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (close.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (volume.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (timestamp.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
try (Arena a = Arena.ofConfined()) {
|
||||
MemorySegment openSeg = a.allocateFrom(JAVA_DOUBLE, open);
|
||||
MemorySegment highSeg = a.allocateFrom(JAVA_DOUBLE, high);
|
||||
MemorySegment lowSeg = a.allocateFrom(JAVA_DOUBLE, low);
|
||||
MemorySegment closeSeg = a.allocateFrom(JAVA_DOUBLE, close);
|
||||
MemorySegment volumeSeg = a.allocateFrom(JAVA_DOUBLE, volume);
|
||||
MemorySegment timestampSeg = a.allocateFrom(JAVA_DOUBLE, timestamp);
|
||||
MemorySegment outSeg = a.allocate(JAVA_DOUBLE.byteSize() * n);
|
||||
NativeMethods.WICKRA_ATR_BATCH.invokeExact(handle, openSeg, highSeg, lowSeg, closeSeg, volumeSeg, timestampSeg, outSeg, (long) n);
|
||||
double[] out = new double[n];
|
||||
MemorySegment.copy(outSeg, JAVA_DOUBLE, 0L, out, 0, n);
|
||||
return out;
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Reset to the just-constructed state. */
|
||||
public void reset() {
|
||||
try {
|
||||
NativeMethods.WICKRA_ATR_RESET.invokeExact(handle);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
@Override public void close() {
|
||||
cleanable.clean();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,62 @@
|
||||
// Generated from bindings/c/include/wickra.h. Do not edit by hand.
|
||||
package org.wickra;
|
||||
|
||||
import org.wickra.internal.NativeMethods;
|
||||
import org.wickra.internal.WickraNative;
|
||||
import java.lang.foreign.Arena;
|
||||
import java.lang.foreign.MemorySegment;
|
||||
import java.lang.ref.Cleaner;
|
||||
import static java.lang.foreign.ValueLayout.*;
|
||||
|
||||
/** Streaming AtrBands indicator over the Wickra C ABI. Not thread-safe; close when done. */
|
||||
public final class AtrBands implements AutoCloseable {
|
||||
private final MemorySegment handle;
|
||||
private final Cleaner.Cleanable cleanable;
|
||||
|
||||
public AtrBands(int period, double multiplier) {
|
||||
if (period < 0) {
|
||||
throw new IllegalArgumentException("period must be non-negative");
|
||||
}
|
||||
MemorySegment h;
|
||||
try {
|
||||
h = (MemorySegment) NativeMethods.WICKRA_ATR_BANDS_NEW.invokeExact((long) period, multiplier);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
if (h.address() == 0L) {
|
||||
throw new IllegalArgumentException("invalid AtrBands parameters");
|
||||
}
|
||||
this.handle = h;
|
||||
this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_ATR_BANDS_FREE);
|
||||
}
|
||||
|
||||
/** Push one observation; returns the result, or null during warmup. */
|
||||
public AtrBandsOutput update(double open, double high, double low, double close, double volume, long timestamp) {
|
||||
try (Arena a = Arena.ofConfined()) {
|
||||
MemorySegment out = a.allocate(24L);
|
||||
byte ok = (byte) NativeMethods.WICKRA_ATR_BANDS_UPDATE.invokeExact(handle, open, high, low, close, volume, timestamp, out);
|
||||
if (ok == 0) {
|
||||
return null;
|
||||
}
|
||||
return new AtrBandsOutput(
|
||||
out.get(JAVA_DOUBLE, 0L),
|
||||
out.get(JAVA_DOUBLE, 8L),
|
||||
out.get(JAVA_DOUBLE, 16L));
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Reset to the just-constructed state. */
|
||||
public void reset() {
|
||||
try {
|
||||
NativeMethods.WICKRA_ATR_BANDS_RESET.invokeExact(handle);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
@Override public void close() {
|
||||
cleanable.clean();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,5 @@
|
||||
// Generated from bindings/c/include/wickra.h. Do not edit by hand.
|
||||
package org.wickra;
|
||||
|
||||
/** Output record produced by the matching indicator. */
|
||||
public record AtrBandsOutput(double upper, double middle, double lower) {}
|
||||
@@ -0,0 +1,61 @@
|
||||
// Generated from bindings/c/include/wickra.h. Do not edit by hand.
|
||||
package org.wickra;
|
||||
|
||||
import org.wickra.internal.NativeMethods;
|
||||
import org.wickra.internal.WickraNative;
|
||||
import java.lang.foreign.Arena;
|
||||
import java.lang.foreign.MemorySegment;
|
||||
import java.lang.ref.Cleaner;
|
||||
import static java.lang.foreign.ValueLayout.*;
|
||||
|
||||
/** Streaming AtrRatchet indicator over the Wickra C ABI. Not thread-safe; close when done. */
|
||||
public final class AtrRatchet implements AutoCloseable {
|
||||
private final MemorySegment handle;
|
||||
private final Cleaner.Cleanable cleanable;
|
||||
|
||||
public AtrRatchet(int atrPeriod, double startMult, double increment) {
|
||||
if (atrPeriod < 0) {
|
||||
throw new IllegalArgumentException("atrPeriod must be non-negative");
|
||||
}
|
||||
MemorySegment h;
|
||||
try {
|
||||
h = (MemorySegment) NativeMethods.WICKRA_ATR_RATCHET_NEW.invokeExact((long) atrPeriod, startMult, increment);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
if (h.address() == 0L) {
|
||||
throw new IllegalArgumentException("invalid AtrRatchet parameters");
|
||||
}
|
||||
this.handle = h;
|
||||
this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_ATR_RATCHET_FREE);
|
||||
}
|
||||
|
||||
/** Push one observation; returns the result, or null during warmup. */
|
||||
public AtrRatchetOutput update(double open, double high, double low, double close, double volume, long timestamp) {
|
||||
try (Arena a = Arena.ofConfined()) {
|
||||
MemorySegment out = a.allocate(16L);
|
||||
byte ok = (byte) NativeMethods.WICKRA_ATR_RATCHET_UPDATE.invokeExact(handle, open, high, low, close, volume, timestamp, out);
|
||||
if (ok == 0) {
|
||||
return null;
|
||||
}
|
||||
return new AtrRatchetOutput(
|
||||
out.get(JAVA_DOUBLE, 0L),
|
||||
out.get(JAVA_DOUBLE, 8L));
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Reset to the just-constructed state. */
|
||||
public void reset() {
|
||||
try {
|
||||
NativeMethods.WICKRA_ATR_RATCHET_RESET.invokeExact(handle);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
@Override public void close() {
|
||||
cleanable.clean();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,5 @@
|
||||
// Generated from bindings/c/include/wickra.h. Do not edit by hand.
|
||||
package org.wickra;
|
||||
|
||||
/** Output record produced by the matching indicator. */
|
||||
public record AtrRatchetOutput(double value, double direction) {}
|
||||
@@ -0,0 +1,89 @@
|
||||
// Generated from bindings/c/include/wickra.h. Do not edit by hand.
|
||||
package org.wickra;
|
||||
|
||||
import org.wickra.internal.NativeMethods;
|
||||
import org.wickra.internal.WickraNative;
|
||||
import java.lang.foreign.Arena;
|
||||
import java.lang.foreign.MemorySegment;
|
||||
import java.lang.ref.Cleaner;
|
||||
import static java.lang.foreign.ValueLayout.*;
|
||||
|
||||
/** Streaming AtrTrailingStop indicator over the Wickra C ABI. Not thread-safe; close when done. */
|
||||
public final class AtrTrailingStop implements AutoCloseable {
|
||||
private final MemorySegment handle;
|
||||
private final Cleaner.Cleanable cleanable;
|
||||
|
||||
public AtrTrailingStop(int atrPeriod, double multiplier) {
|
||||
if (atrPeriod < 0) {
|
||||
throw new IllegalArgumentException("atrPeriod must be non-negative");
|
||||
}
|
||||
MemorySegment h;
|
||||
try {
|
||||
h = (MemorySegment) NativeMethods.WICKRA_ATR_TRAILING_STOP_NEW.invokeExact((long) atrPeriod, multiplier);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
if (h.address() == 0L) {
|
||||
throw new IllegalArgumentException("invalid AtrTrailingStop parameters");
|
||||
}
|
||||
this.handle = h;
|
||||
this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_ATR_TRAILING_STOP_FREE);
|
||||
}
|
||||
|
||||
/** Push one observation; returns the indicator value (NaN during warmup). */
|
||||
public double update(double open, double high, double low, double close, double volume, long timestamp) {
|
||||
try {
|
||||
return (double) NativeMethods.WICKRA_ATR_TRAILING_STOP_UPDATE.invokeExact(handle, open, high, low, close, volume, timestamp);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Vectorized update over a whole series; NaN at warmup positions. */
|
||||
public double[] batch(double[] open, double[] high, double[] low, double[] close, double[] volume, double[] timestamp) {
|
||||
int n = open.length;
|
||||
if (high.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (low.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (close.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (volume.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (timestamp.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
try (Arena a = Arena.ofConfined()) {
|
||||
MemorySegment openSeg = a.allocateFrom(JAVA_DOUBLE, open);
|
||||
MemorySegment highSeg = a.allocateFrom(JAVA_DOUBLE, high);
|
||||
MemorySegment lowSeg = a.allocateFrom(JAVA_DOUBLE, low);
|
||||
MemorySegment closeSeg = a.allocateFrom(JAVA_DOUBLE, close);
|
||||
MemorySegment volumeSeg = a.allocateFrom(JAVA_DOUBLE, volume);
|
||||
MemorySegment timestampSeg = a.allocateFrom(JAVA_DOUBLE, timestamp);
|
||||
MemorySegment outSeg = a.allocate(JAVA_DOUBLE.byteSize() * n);
|
||||
NativeMethods.WICKRA_ATR_TRAILING_STOP_BATCH.invokeExact(handle, openSeg, highSeg, lowSeg, closeSeg, volumeSeg, timestampSeg, outSeg, (long) n);
|
||||
double[] out = new double[n];
|
||||
MemorySegment.copy(outSeg, JAVA_DOUBLE, 0L, out, 0, n);
|
||||
return out;
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Reset to the just-constructed state. */
|
||||
public void reset() {
|
||||
try {
|
||||
NativeMethods.WICKRA_ATR_TRAILING_STOP_RESET.invokeExact(handle);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
@Override public void close() {
|
||||
cleanable.clean();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,63 @@
|
||||
// Generated from bindings/c/include/wickra.h. Do not edit by hand.
|
||||
package org.wickra;
|
||||
|
||||
import org.wickra.internal.NativeMethods;
|
||||
import org.wickra.internal.WickraNative;
|
||||
import java.lang.foreign.Arena;
|
||||
import java.lang.foreign.MemorySegment;
|
||||
import java.lang.ref.Cleaner;
|
||||
import static java.lang.foreign.ValueLayout.*;
|
||||
|
||||
/** Streaming AutoFib indicator over the Wickra C ABI. Not thread-safe; close when done. */
|
||||
public final class AutoFib implements AutoCloseable {
|
||||
private final MemorySegment handle;
|
||||
private final Cleaner.Cleanable cleanable;
|
||||
|
||||
public AutoFib() {
|
||||
MemorySegment h;
|
||||
try {
|
||||
h = (MemorySegment) NativeMethods.WICKRA_AUTO_FIB_NEW.invokeExact();
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
if (h.address() == 0L) {
|
||||
throw new IllegalArgumentException("invalid AutoFib parameters");
|
||||
}
|
||||
this.handle = h;
|
||||
this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_AUTO_FIB_FREE);
|
||||
}
|
||||
|
||||
/** Push one observation; returns the result, or null during warmup. */
|
||||
public AutoFibOutput update(double open, double high, double low, double close, double volume, long timestamp) {
|
||||
try (Arena a = Arena.ofConfined()) {
|
||||
MemorySegment out = a.allocate(56L);
|
||||
byte ok = (byte) NativeMethods.WICKRA_AUTO_FIB_UPDATE.invokeExact(handle, open, high, low, close, volume, timestamp, out);
|
||||
if (ok == 0) {
|
||||
return null;
|
||||
}
|
||||
return new AutoFibOutput(
|
||||
out.get(JAVA_DOUBLE, 0L),
|
||||
out.get(JAVA_DOUBLE, 8L),
|
||||
out.get(JAVA_DOUBLE, 16L),
|
||||
out.get(JAVA_DOUBLE, 24L),
|
||||
out.get(JAVA_DOUBLE, 32L),
|
||||
out.get(JAVA_DOUBLE, 40L),
|
||||
out.get(JAVA_DOUBLE, 48L));
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Reset to the just-constructed state. */
|
||||
public void reset() {
|
||||
try {
|
||||
NativeMethods.WICKRA_AUTO_FIB_RESET.invokeExact(handle);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
@Override public void close() {
|
||||
cleanable.clean();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,5 @@
|
||||
// Generated from bindings/c/include/wickra.h. Do not edit by hand.
|
||||
package org.wickra;
|
||||
|
||||
/** Output record produced by the matching indicator. */
|
||||
public record AutoFibOutput(double level0, double level236, double level382, double level500, double level618, double level786, double level1000) {}
|
||||
@@ -0,0 +1,72 @@
|
||||
// Generated from bindings/c/include/wickra.h. Do not edit by hand.
|
||||
package org.wickra;
|
||||
|
||||
import org.wickra.internal.NativeMethods;
|
||||
import org.wickra.internal.WickraNative;
|
||||
import java.lang.foreign.Arena;
|
||||
import java.lang.foreign.MemorySegment;
|
||||
import java.lang.ref.Cleaner;
|
||||
import static java.lang.foreign.ValueLayout.*;
|
||||
|
||||
/** Streaming Autocorrelation indicator over the Wickra C ABI. Not thread-safe; close when done. */
|
||||
public final class Autocorrelation implements AutoCloseable {
|
||||
private final MemorySegment handle;
|
||||
private final Cleaner.Cleanable cleanable;
|
||||
|
||||
public Autocorrelation(int period, int lag) {
|
||||
if (period < 0) {
|
||||
throw new IllegalArgumentException("period must be non-negative");
|
||||
}
|
||||
if (lag < 0) {
|
||||
throw new IllegalArgumentException("lag must be non-negative");
|
||||
}
|
||||
MemorySegment h;
|
||||
try {
|
||||
h = (MemorySegment) NativeMethods.WICKRA_AUTOCORRELATION_NEW.invokeExact((long) period, (long) lag);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
if (h.address() == 0L) {
|
||||
throw new IllegalArgumentException("invalid Autocorrelation parameters");
|
||||
}
|
||||
this.handle = h;
|
||||
this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_AUTOCORRELATION_FREE);
|
||||
}
|
||||
|
||||
/** Push one observation; returns the indicator value (NaN during warmup). */
|
||||
public double update(double value) {
|
||||
try {
|
||||
return (double) NativeMethods.WICKRA_AUTOCORRELATION_UPDATE.invokeExact(handle, value);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Vectorized update over a whole series; NaN at warmup positions. */
|
||||
public double[] batch(double[] input) {
|
||||
int n = input.length;
|
||||
try (Arena a = Arena.ofConfined()) {
|
||||
MemorySegment inputSeg = a.allocateFrom(JAVA_DOUBLE, input);
|
||||
MemorySegment outSeg = a.allocate(JAVA_DOUBLE.byteSize() * n);
|
||||
NativeMethods.WICKRA_AUTOCORRELATION_BATCH.invokeExact(handle, inputSeg, outSeg, (long) n);
|
||||
double[] out = new double[n];
|
||||
MemorySegment.copy(outSeg, JAVA_DOUBLE, 0L, out, 0, n);
|
||||
return out;
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Reset to the just-constructed state. */
|
||||
public void reset() {
|
||||
try {
|
||||
NativeMethods.WICKRA_AUTOCORRELATION_RESET.invokeExact(handle);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
@Override public void close() {
|
||||
cleanable.clean();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,72 @@
|
||||
// Generated from bindings/c/include/wickra.h. Do not edit by hand.
|
||||
package org.wickra;
|
||||
|
||||
import org.wickra.internal.NativeMethods;
|
||||
import org.wickra.internal.WickraNative;
|
||||
import java.lang.foreign.Arena;
|
||||
import java.lang.foreign.MemorySegment;
|
||||
import java.lang.ref.Cleaner;
|
||||
import static java.lang.foreign.ValueLayout.*;
|
||||
|
||||
/** Streaming AutocorrelationPeriodogram indicator over the Wickra C ABI. Not thread-safe; close when done. */
|
||||
public final class AutocorrelationPeriodogram implements AutoCloseable {
|
||||
private final MemorySegment handle;
|
||||
private final Cleaner.Cleanable cleanable;
|
||||
|
||||
public AutocorrelationPeriodogram(int minPeriod, int maxPeriod) {
|
||||
if (minPeriod < 0) {
|
||||
throw new IllegalArgumentException("minPeriod must be non-negative");
|
||||
}
|
||||
if (maxPeriod < 0) {
|
||||
throw new IllegalArgumentException("maxPeriod must be non-negative");
|
||||
}
|
||||
MemorySegment h;
|
||||
try {
|
||||
h = (MemorySegment) NativeMethods.WICKRA_AUTOCORRELATION_PERIODOGRAM_NEW.invokeExact((long) minPeriod, (long) maxPeriod);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
if (h.address() == 0L) {
|
||||
throw new IllegalArgumentException("invalid AutocorrelationPeriodogram parameters");
|
||||
}
|
||||
this.handle = h;
|
||||
this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_AUTOCORRELATION_PERIODOGRAM_FREE);
|
||||
}
|
||||
|
||||
/** Push one observation; returns the indicator value (NaN during warmup). */
|
||||
public double update(double value) {
|
||||
try {
|
||||
return (double) NativeMethods.WICKRA_AUTOCORRELATION_PERIODOGRAM_UPDATE.invokeExact(handle, value);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Vectorized update over a whole series; NaN at warmup positions. */
|
||||
public double[] batch(double[] input) {
|
||||
int n = input.length;
|
||||
try (Arena a = Arena.ofConfined()) {
|
||||
MemorySegment inputSeg = a.allocateFrom(JAVA_DOUBLE, input);
|
||||
MemorySegment outSeg = a.allocate(JAVA_DOUBLE.byteSize() * n);
|
||||
NativeMethods.WICKRA_AUTOCORRELATION_PERIODOGRAM_BATCH.invokeExact(handle, inputSeg, outSeg, (long) n);
|
||||
double[] out = new double[n];
|
||||
MemorySegment.copy(outSeg, JAVA_DOUBLE, 0L, out, 0, n);
|
||||
return out;
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Reset to the just-constructed state. */
|
||||
public void reset() {
|
||||
try {
|
||||
NativeMethods.WICKRA_AUTOCORRELATION_PERIODOGRAM_RESET.invokeExact(handle);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
@Override public void close() {
|
||||
cleanable.clean();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,89 @@
|
||||
// Generated from bindings/c/include/wickra.h. Do not edit by hand.
|
||||
package org.wickra;
|
||||
|
||||
import org.wickra.internal.NativeMethods;
|
||||
import org.wickra.internal.WickraNative;
|
||||
import java.lang.foreign.Arena;
|
||||
import java.lang.foreign.MemorySegment;
|
||||
import java.lang.ref.Cleaner;
|
||||
import static java.lang.foreign.ValueLayout.*;
|
||||
|
||||
/** Streaming AverageDailyRange indicator over the Wickra C ABI. Not thread-safe; close when done. */
|
||||
public final class AverageDailyRange implements AutoCloseable {
|
||||
private final MemorySegment handle;
|
||||
private final Cleaner.Cleanable cleanable;
|
||||
|
||||
public AverageDailyRange(int period, int utcOffsetMinutes) {
|
||||
if (period < 0) {
|
||||
throw new IllegalArgumentException("period must be non-negative");
|
||||
}
|
||||
MemorySegment h;
|
||||
try {
|
||||
h = (MemorySegment) NativeMethods.WICKRA_AVERAGE_DAILY_RANGE_NEW.invokeExact((long) period, utcOffsetMinutes);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
if (h.address() == 0L) {
|
||||
throw new IllegalArgumentException("invalid AverageDailyRange parameters");
|
||||
}
|
||||
this.handle = h;
|
||||
this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_AVERAGE_DAILY_RANGE_FREE);
|
||||
}
|
||||
|
||||
/** Push one observation; returns the indicator value (NaN during warmup). */
|
||||
public double update(double open, double high, double low, double close, double volume, long timestamp) {
|
||||
try {
|
||||
return (double) NativeMethods.WICKRA_AVERAGE_DAILY_RANGE_UPDATE.invokeExact(handle, open, high, low, close, volume, timestamp);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Vectorized update over a whole series; NaN at warmup positions. */
|
||||
public double[] batch(double[] open, double[] high, double[] low, double[] close, double[] volume, double[] timestamp) {
|
||||
int n = open.length;
|
||||
if (high.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (low.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (close.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (volume.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (timestamp.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
try (Arena a = Arena.ofConfined()) {
|
||||
MemorySegment openSeg = a.allocateFrom(JAVA_DOUBLE, open);
|
||||
MemorySegment highSeg = a.allocateFrom(JAVA_DOUBLE, high);
|
||||
MemorySegment lowSeg = a.allocateFrom(JAVA_DOUBLE, low);
|
||||
MemorySegment closeSeg = a.allocateFrom(JAVA_DOUBLE, close);
|
||||
MemorySegment volumeSeg = a.allocateFrom(JAVA_DOUBLE, volume);
|
||||
MemorySegment timestampSeg = a.allocateFrom(JAVA_DOUBLE, timestamp);
|
||||
MemorySegment outSeg = a.allocate(JAVA_DOUBLE.byteSize() * n);
|
||||
NativeMethods.WICKRA_AVERAGE_DAILY_RANGE_BATCH.invokeExact(handle, openSeg, highSeg, lowSeg, closeSeg, volumeSeg, timestampSeg, outSeg, (long) n);
|
||||
double[] out = new double[n];
|
||||
MemorySegment.copy(outSeg, JAVA_DOUBLE, 0L, out, 0, n);
|
||||
return out;
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Reset to the just-constructed state. */
|
||||
public void reset() {
|
||||
try {
|
||||
NativeMethods.WICKRA_AVERAGE_DAILY_RANGE_RESET.invokeExact(handle);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
@Override public void close() {
|
||||
cleanable.clean();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,69 @@
|
||||
// Generated from bindings/c/include/wickra.h. Do not edit by hand.
|
||||
package org.wickra;
|
||||
|
||||
import org.wickra.internal.NativeMethods;
|
||||
import org.wickra.internal.WickraNative;
|
||||
import java.lang.foreign.Arena;
|
||||
import java.lang.foreign.MemorySegment;
|
||||
import java.lang.ref.Cleaner;
|
||||
import static java.lang.foreign.ValueLayout.*;
|
||||
|
||||
/** Streaming AverageDrawdown indicator over the Wickra C ABI. Not thread-safe; close when done. */
|
||||
public final class AverageDrawdown implements AutoCloseable {
|
||||
private final MemorySegment handle;
|
||||
private final Cleaner.Cleanable cleanable;
|
||||
|
||||
public AverageDrawdown(int period) {
|
||||
if (period < 0) {
|
||||
throw new IllegalArgumentException("period must be non-negative");
|
||||
}
|
||||
MemorySegment h;
|
||||
try {
|
||||
h = (MemorySegment) NativeMethods.WICKRA_AVERAGE_DRAWDOWN_NEW.invokeExact((long) period);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
if (h.address() == 0L) {
|
||||
throw new IllegalArgumentException("invalid AverageDrawdown parameters");
|
||||
}
|
||||
this.handle = h;
|
||||
this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_AVERAGE_DRAWDOWN_FREE);
|
||||
}
|
||||
|
||||
/** Push one observation; returns the indicator value (NaN during warmup). */
|
||||
public double update(double value) {
|
||||
try {
|
||||
return (double) NativeMethods.WICKRA_AVERAGE_DRAWDOWN_UPDATE.invokeExact(handle, value);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Vectorized update over a whole series; NaN at warmup positions. */
|
||||
public double[] batch(double[] input) {
|
||||
int n = input.length;
|
||||
try (Arena a = Arena.ofConfined()) {
|
||||
MemorySegment inputSeg = a.allocateFrom(JAVA_DOUBLE, input);
|
||||
MemorySegment outSeg = a.allocate(JAVA_DOUBLE.byteSize() * n);
|
||||
NativeMethods.WICKRA_AVERAGE_DRAWDOWN_BATCH.invokeExact(handle, inputSeg, outSeg, (long) n);
|
||||
double[] out = new double[n];
|
||||
MemorySegment.copy(outSeg, JAVA_DOUBLE, 0L, out, 0, n);
|
||||
return out;
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Reset to the just-constructed state. */
|
||||
public void reset() {
|
||||
try {
|
||||
NativeMethods.WICKRA_AVERAGE_DRAWDOWN_RESET.invokeExact(handle);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
@Override public void close() {
|
||||
cleanable.clean();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,86 @@
|
||||
// Generated from bindings/c/include/wickra.h. Do not edit by hand.
|
||||
package org.wickra;
|
||||
|
||||
import org.wickra.internal.NativeMethods;
|
||||
import org.wickra.internal.WickraNative;
|
||||
import java.lang.foreign.Arena;
|
||||
import java.lang.foreign.MemorySegment;
|
||||
import java.lang.ref.Cleaner;
|
||||
import static java.lang.foreign.ValueLayout.*;
|
||||
|
||||
/** Streaming AvgPrice indicator over the Wickra C ABI. Not thread-safe; close when done. */
|
||||
public final class AvgPrice implements AutoCloseable {
|
||||
private final MemorySegment handle;
|
||||
private final Cleaner.Cleanable cleanable;
|
||||
|
||||
public AvgPrice() {
|
||||
MemorySegment h;
|
||||
try {
|
||||
h = (MemorySegment) NativeMethods.WICKRA_AVG_PRICE_NEW.invokeExact();
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
if (h.address() == 0L) {
|
||||
throw new IllegalArgumentException("invalid AvgPrice parameters");
|
||||
}
|
||||
this.handle = h;
|
||||
this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_AVG_PRICE_FREE);
|
||||
}
|
||||
|
||||
/** Push one observation; returns the indicator value (NaN during warmup). */
|
||||
public double update(double open, double high, double low, double close, double volume, long timestamp) {
|
||||
try {
|
||||
return (double) NativeMethods.WICKRA_AVG_PRICE_UPDATE.invokeExact(handle, open, high, low, close, volume, timestamp);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Vectorized update over a whole series; NaN at warmup positions. */
|
||||
public double[] batch(double[] open, double[] high, double[] low, double[] close, double[] volume, double[] timestamp) {
|
||||
int n = open.length;
|
||||
if (high.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (low.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (close.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (volume.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (timestamp.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
try (Arena a = Arena.ofConfined()) {
|
||||
MemorySegment openSeg = a.allocateFrom(JAVA_DOUBLE, open);
|
||||
MemorySegment highSeg = a.allocateFrom(JAVA_DOUBLE, high);
|
||||
MemorySegment lowSeg = a.allocateFrom(JAVA_DOUBLE, low);
|
||||
MemorySegment closeSeg = a.allocateFrom(JAVA_DOUBLE, close);
|
||||
MemorySegment volumeSeg = a.allocateFrom(JAVA_DOUBLE, volume);
|
||||
MemorySegment timestampSeg = a.allocateFrom(JAVA_DOUBLE, timestamp);
|
||||
MemorySegment outSeg = a.allocate(JAVA_DOUBLE.byteSize() * n);
|
||||
NativeMethods.WICKRA_AVG_PRICE_BATCH.invokeExact(handle, openSeg, highSeg, lowSeg, closeSeg, volumeSeg, timestampSeg, outSeg, (long) n);
|
||||
double[] out = new double[n];
|
||||
MemorySegment.copy(outSeg, JAVA_DOUBLE, 0L, out, 0, n);
|
||||
return out;
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Reset to the just-constructed state. */
|
||||
public void reset() {
|
||||
try {
|
||||
NativeMethods.WICKRA_AVG_PRICE_RESET.invokeExact(handle);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
@Override public void close() {
|
||||
cleanable.clean();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,92 @@
|
||||
// Generated from bindings/c/include/wickra.h. Do not edit by hand.
|
||||
package org.wickra;
|
||||
|
||||
import org.wickra.internal.NativeMethods;
|
||||
import org.wickra.internal.WickraNative;
|
||||
import java.lang.foreign.Arena;
|
||||
import java.lang.foreign.MemorySegment;
|
||||
import java.lang.ref.Cleaner;
|
||||
import static java.lang.foreign.ValueLayout.*;
|
||||
|
||||
/** Streaming AwesomeOscillator indicator over the Wickra C ABI. Not thread-safe; close when done. */
|
||||
public final class AwesomeOscillator implements AutoCloseable {
|
||||
private final MemorySegment handle;
|
||||
private final Cleaner.Cleanable cleanable;
|
||||
|
||||
public AwesomeOscillator(int fast, int slow) {
|
||||
if (fast < 0) {
|
||||
throw new IllegalArgumentException("fast must be non-negative");
|
||||
}
|
||||
if (slow < 0) {
|
||||
throw new IllegalArgumentException("slow must be non-negative");
|
||||
}
|
||||
MemorySegment h;
|
||||
try {
|
||||
h = (MemorySegment) NativeMethods.WICKRA_AWESOME_OSCILLATOR_NEW.invokeExact((long) fast, (long) slow);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
if (h.address() == 0L) {
|
||||
throw new IllegalArgumentException("invalid AwesomeOscillator parameters");
|
||||
}
|
||||
this.handle = h;
|
||||
this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_AWESOME_OSCILLATOR_FREE);
|
||||
}
|
||||
|
||||
/** Push one observation; returns the indicator value (NaN during warmup). */
|
||||
public double update(double open, double high, double low, double close, double volume, long timestamp) {
|
||||
try {
|
||||
return (double) NativeMethods.WICKRA_AWESOME_OSCILLATOR_UPDATE.invokeExact(handle, open, high, low, close, volume, timestamp);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Vectorized update over a whole series; NaN at warmup positions. */
|
||||
public double[] batch(double[] open, double[] high, double[] low, double[] close, double[] volume, double[] timestamp) {
|
||||
int n = open.length;
|
||||
if (high.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (low.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (close.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (volume.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (timestamp.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
try (Arena a = Arena.ofConfined()) {
|
||||
MemorySegment openSeg = a.allocateFrom(JAVA_DOUBLE, open);
|
||||
MemorySegment highSeg = a.allocateFrom(JAVA_DOUBLE, high);
|
||||
MemorySegment lowSeg = a.allocateFrom(JAVA_DOUBLE, low);
|
||||
MemorySegment closeSeg = a.allocateFrom(JAVA_DOUBLE, close);
|
||||
MemorySegment volumeSeg = a.allocateFrom(JAVA_DOUBLE, volume);
|
||||
MemorySegment timestampSeg = a.allocateFrom(JAVA_DOUBLE, timestamp);
|
||||
MemorySegment outSeg = a.allocate(JAVA_DOUBLE.byteSize() * n);
|
||||
NativeMethods.WICKRA_AWESOME_OSCILLATOR_BATCH.invokeExact(handle, openSeg, highSeg, lowSeg, closeSeg, volumeSeg, timestampSeg, outSeg, (long) n);
|
||||
double[] out = new double[n];
|
||||
MemorySegment.copy(outSeg, JAVA_DOUBLE, 0L, out, 0, n);
|
||||
return out;
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Reset to the just-constructed state. */
|
||||
public void reset() {
|
||||
try {
|
||||
NativeMethods.WICKRA_AWESOME_OSCILLATOR_RESET.invokeExact(handle);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
@Override public void close() {
|
||||
cleanable.clean();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,95 @@
|
||||
// Generated from bindings/c/include/wickra.h. Do not edit by hand.
|
||||
package org.wickra;
|
||||
|
||||
import org.wickra.internal.NativeMethods;
|
||||
import org.wickra.internal.WickraNative;
|
||||
import java.lang.foreign.Arena;
|
||||
import java.lang.foreign.MemorySegment;
|
||||
import java.lang.ref.Cleaner;
|
||||
import static java.lang.foreign.ValueLayout.*;
|
||||
|
||||
/** Streaming AwesomeOscillatorHistogram indicator over the Wickra C ABI. Not thread-safe; close when done. */
|
||||
public final class AwesomeOscillatorHistogram implements AutoCloseable {
|
||||
private final MemorySegment handle;
|
||||
private final Cleaner.Cleanable cleanable;
|
||||
|
||||
public AwesomeOscillatorHistogram(int fast, int slow, int smaPeriod) {
|
||||
if (fast < 0) {
|
||||
throw new IllegalArgumentException("fast must be non-negative");
|
||||
}
|
||||
if (slow < 0) {
|
||||
throw new IllegalArgumentException("slow must be non-negative");
|
||||
}
|
||||
if (smaPeriod < 0) {
|
||||
throw new IllegalArgumentException("smaPeriod must be non-negative");
|
||||
}
|
||||
MemorySegment h;
|
||||
try {
|
||||
h = (MemorySegment) NativeMethods.WICKRA_AWESOME_OSCILLATOR_HISTOGRAM_NEW.invokeExact((long) fast, (long) slow, (long) smaPeriod);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
if (h.address() == 0L) {
|
||||
throw new IllegalArgumentException("invalid AwesomeOscillatorHistogram parameters");
|
||||
}
|
||||
this.handle = h;
|
||||
this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_AWESOME_OSCILLATOR_HISTOGRAM_FREE);
|
||||
}
|
||||
|
||||
/** Push one observation; returns the indicator value (NaN during warmup). */
|
||||
public double update(double open, double high, double low, double close, double volume, long timestamp) {
|
||||
try {
|
||||
return (double) NativeMethods.WICKRA_AWESOME_OSCILLATOR_HISTOGRAM_UPDATE.invokeExact(handle, open, high, low, close, volume, timestamp);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Vectorized update over a whole series; NaN at warmup positions. */
|
||||
public double[] batch(double[] open, double[] high, double[] low, double[] close, double[] volume, double[] timestamp) {
|
||||
int n = open.length;
|
||||
if (high.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (low.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (close.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (volume.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (timestamp.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
try (Arena a = Arena.ofConfined()) {
|
||||
MemorySegment openSeg = a.allocateFrom(JAVA_DOUBLE, open);
|
||||
MemorySegment highSeg = a.allocateFrom(JAVA_DOUBLE, high);
|
||||
MemorySegment lowSeg = a.allocateFrom(JAVA_DOUBLE, low);
|
||||
MemorySegment closeSeg = a.allocateFrom(JAVA_DOUBLE, close);
|
||||
MemorySegment volumeSeg = a.allocateFrom(JAVA_DOUBLE, volume);
|
||||
MemorySegment timestampSeg = a.allocateFrom(JAVA_DOUBLE, timestamp);
|
||||
MemorySegment outSeg = a.allocate(JAVA_DOUBLE.byteSize() * n);
|
||||
NativeMethods.WICKRA_AWESOME_OSCILLATOR_HISTOGRAM_BATCH.invokeExact(handle, openSeg, highSeg, lowSeg, closeSeg, volumeSeg, timestampSeg, outSeg, (long) n);
|
||||
double[] out = new double[n];
|
||||
MemorySegment.copy(outSeg, JAVA_DOUBLE, 0L, out, 0, n);
|
||||
return out;
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Reset to the just-constructed state. */
|
||||
public void reset() {
|
||||
try {
|
||||
NativeMethods.WICKRA_AWESOME_OSCILLATOR_HISTOGRAM_RESET.invokeExact(handle);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
@Override public void close() {
|
||||
cleanable.clean();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,86 @@
|
||||
// Generated from bindings/c/include/wickra.h. Do not edit by hand.
|
||||
package org.wickra;
|
||||
|
||||
import org.wickra.internal.NativeMethods;
|
||||
import org.wickra.internal.WickraNative;
|
||||
import java.lang.foreign.Arena;
|
||||
import java.lang.foreign.MemorySegment;
|
||||
import java.lang.ref.Cleaner;
|
||||
import static java.lang.foreign.ValueLayout.*;
|
||||
|
||||
/** Streaming BalanceOfPower indicator over the Wickra C ABI. Not thread-safe; close when done. */
|
||||
public final class BalanceOfPower implements AutoCloseable {
|
||||
private final MemorySegment handle;
|
||||
private final Cleaner.Cleanable cleanable;
|
||||
|
||||
public BalanceOfPower() {
|
||||
MemorySegment h;
|
||||
try {
|
||||
h = (MemorySegment) NativeMethods.WICKRA_BALANCE_OF_POWER_NEW.invokeExact();
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
if (h.address() == 0L) {
|
||||
throw new IllegalArgumentException("invalid BalanceOfPower parameters");
|
||||
}
|
||||
this.handle = h;
|
||||
this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_BALANCE_OF_POWER_FREE);
|
||||
}
|
||||
|
||||
/** Push one observation; returns the indicator value (NaN during warmup). */
|
||||
public double update(double open, double high, double low, double close, double volume, long timestamp) {
|
||||
try {
|
||||
return (double) NativeMethods.WICKRA_BALANCE_OF_POWER_UPDATE.invokeExact(handle, open, high, low, close, volume, timestamp);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Vectorized update over a whole series; NaN at warmup positions. */
|
||||
public double[] batch(double[] open, double[] high, double[] low, double[] close, double[] volume, double[] timestamp) {
|
||||
int n = open.length;
|
||||
if (high.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (low.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (close.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (volume.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (timestamp.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
try (Arena a = Arena.ofConfined()) {
|
||||
MemorySegment openSeg = a.allocateFrom(JAVA_DOUBLE, open);
|
||||
MemorySegment highSeg = a.allocateFrom(JAVA_DOUBLE, high);
|
||||
MemorySegment lowSeg = a.allocateFrom(JAVA_DOUBLE, low);
|
||||
MemorySegment closeSeg = a.allocateFrom(JAVA_DOUBLE, close);
|
||||
MemorySegment volumeSeg = a.allocateFrom(JAVA_DOUBLE, volume);
|
||||
MemorySegment timestampSeg = a.allocateFrom(JAVA_DOUBLE, timestamp);
|
||||
MemorySegment outSeg = a.allocate(JAVA_DOUBLE.byteSize() * n);
|
||||
NativeMethods.WICKRA_BALANCE_OF_POWER_BATCH.invokeExact(handle, openSeg, highSeg, lowSeg, closeSeg, volumeSeg, timestampSeg, outSeg, (long) n);
|
||||
double[] out = new double[n];
|
||||
MemorySegment.copy(outSeg, JAVA_DOUBLE, 0L, out, 0, n);
|
||||
return out;
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Reset to the just-constructed state. */
|
||||
public void reset() {
|
||||
try {
|
||||
NativeMethods.WICKRA_BALANCE_OF_POWER_RESET.invokeExact(handle);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
@Override public void close() {
|
||||
cleanable.clean();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,69 @@
|
||||
// Generated from bindings/c/include/wickra.h. Do not edit by hand.
|
||||
package org.wickra;
|
||||
|
||||
import org.wickra.internal.NativeMethods;
|
||||
import org.wickra.internal.WickraNative;
|
||||
import java.lang.foreign.Arena;
|
||||
import java.lang.foreign.MemorySegment;
|
||||
import java.lang.ref.Cleaner;
|
||||
import static java.lang.foreign.ValueLayout.*;
|
||||
|
||||
/** Streaming BandpassFilter indicator over the Wickra C ABI. Not thread-safe; close when done. */
|
||||
public final class BandpassFilter implements AutoCloseable {
|
||||
private final MemorySegment handle;
|
||||
private final Cleaner.Cleanable cleanable;
|
||||
|
||||
public BandpassFilter(int period, double bandwidth) {
|
||||
if (period < 0) {
|
||||
throw new IllegalArgumentException("period must be non-negative");
|
||||
}
|
||||
MemorySegment h;
|
||||
try {
|
||||
h = (MemorySegment) NativeMethods.WICKRA_BANDPASS_FILTER_NEW.invokeExact((long) period, bandwidth);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
if (h.address() == 0L) {
|
||||
throw new IllegalArgumentException("invalid BandpassFilter parameters");
|
||||
}
|
||||
this.handle = h;
|
||||
this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_BANDPASS_FILTER_FREE);
|
||||
}
|
||||
|
||||
/** Push one observation; returns the indicator value (NaN during warmup). */
|
||||
public double update(double value) {
|
||||
try {
|
||||
return (double) NativeMethods.WICKRA_BANDPASS_FILTER_UPDATE.invokeExact(handle, value);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Vectorized update over a whole series; NaN at warmup positions. */
|
||||
public double[] batch(double[] input) {
|
||||
int n = input.length;
|
||||
try (Arena a = Arena.ofConfined()) {
|
||||
MemorySegment inputSeg = a.allocateFrom(JAVA_DOUBLE, input);
|
||||
MemorySegment outSeg = a.allocate(JAVA_DOUBLE.byteSize() * n);
|
||||
NativeMethods.WICKRA_BANDPASS_FILTER_BATCH.invokeExact(handle, inputSeg, outSeg, (long) n);
|
||||
double[] out = new double[n];
|
||||
MemorySegment.copy(outSeg, JAVA_DOUBLE, 0L, out, 0, n);
|
||||
return out;
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Reset to the just-constructed state. */
|
||||
public void reset() {
|
||||
try {
|
||||
NativeMethods.WICKRA_BANDPASS_FILTER_RESET.invokeExact(handle);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
@Override public void close() {
|
||||
cleanable.clean();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,86 @@
|
||||
// Generated from bindings/c/include/wickra.h. Do not edit by hand.
|
||||
package org.wickra;
|
||||
|
||||
import org.wickra.internal.NativeMethods;
|
||||
import org.wickra.internal.WickraNative;
|
||||
import java.lang.foreign.Arena;
|
||||
import java.lang.foreign.MemorySegment;
|
||||
import java.lang.ref.Cleaner;
|
||||
import static java.lang.foreign.ValueLayout.*;
|
||||
|
||||
/** Streaming Bat indicator over the Wickra C ABI. Not thread-safe; close when done. */
|
||||
public final class Bat implements AutoCloseable {
|
||||
private final MemorySegment handle;
|
||||
private final Cleaner.Cleanable cleanable;
|
||||
|
||||
public Bat() {
|
||||
MemorySegment h;
|
||||
try {
|
||||
h = (MemorySegment) NativeMethods.WICKRA_BAT_NEW.invokeExact();
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
if (h.address() == 0L) {
|
||||
throw new IllegalArgumentException("invalid Bat parameters");
|
||||
}
|
||||
this.handle = h;
|
||||
this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_BAT_FREE);
|
||||
}
|
||||
|
||||
/** Push one observation; returns the indicator value (NaN during warmup). */
|
||||
public double update(double open, double high, double low, double close, double volume, long timestamp) {
|
||||
try {
|
||||
return (double) NativeMethods.WICKRA_BAT_UPDATE.invokeExact(handle, open, high, low, close, volume, timestamp);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Vectorized update over a whole series; NaN at warmup positions. */
|
||||
public double[] batch(double[] open, double[] high, double[] low, double[] close, double[] volume, double[] timestamp) {
|
||||
int n = open.length;
|
||||
if (high.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (low.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (close.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (volume.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (timestamp.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
try (Arena a = Arena.ofConfined()) {
|
||||
MemorySegment openSeg = a.allocateFrom(JAVA_DOUBLE, open);
|
||||
MemorySegment highSeg = a.allocateFrom(JAVA_DOUBLE, high);
|
||||
MemorySegment lowSeg = a.allocateFrom(JAVA_DOUBLE, low);
|
||||
MemorySegment closeSeg = a.allocateFrom(JAVA_DOUBLE, close);
|
||||
MemorySegment volumeSeg = a.allocateFrom(JAVA_DOUBLE, volume);
|
||||
MemorySegment timestampSeg = a.allocateFrom(JAVA_DOUBLE, timestamp);
|
||||
MemorySegment outSeg = a.allocate(JAVA_DOUBLE.byteSize() * n);
|
||||
NativeMethods.WICKRA_BAT_BATCH.invokeExact(handle, openSeg, highSeg, lowSeg, closeSeg, volumeSeg, timestampSeg, outSeg, (long) n);
|
||||
double[] out = new double[n];
|
||||
MemorySegment.copy(outSeg, JAVA_DOUBLE, 0L, out, 0, n);
|
||||
return out;
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Reset to the just-constructed state. */
|
||||
public void reset() {
|
||||
try {
|
||||
NativeMethods.WICKRA_BAT_RESET.invokeExact(handle);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
@Override public void close() {
|
||||
cleanable.clean();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,86 @@
|
||||
// Generated from bindings/c/include/wickra.h. Do not edit by hand.
|
||||
package org.wickra;
|
||||
|
||||
import org.wickra.internal.NativeMethods;
|
||||
import org.wickra.internal.WickraNative;
|
||||
import java.lang.foreign.Arena;
|
||||
import java.lang.foreign.MemorySegment;
|
||||
import java.lang.ref.Cleaner;
|
||||
import static java.lang.foreign.ValueLayout.*;
|
||||
|
||||
/** Streaming BeltHold indicator over the Wickra C ABI. Not thread-safe; close when done. */
|
||||
public final class BeltHold implements AutoCloseable {
|
||||
private final MemorySegment handle;
|
||||
private final Cleaner.Cleanable cleanable;
|
||||
|
||||
public BeltHold() {
|
||||
MemorySegment h;
|
||||
try {
|
||||
h = (MemorySegment) NativeMethods.WICKRA_BELT_HOLD_NEW.invokeExact();
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
if (h.address() == 0L) {
|
||||
throw new IllegalArgumentException("invalid BeltHold parameters");
|
||||
}
|
||||
this.handle = h;
|
||||
this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_BELT_HOLD_FREE);
|
||||
}
|
||||
|
||||
/** Push one observation; returns the indicator value (NaN during warmup). */
|
||||
public double update(double open, double high, double low, double close, double volume, long timestamp) {
|
||||
try {
|
||||
return (double) NativeMethods.WICKRA_BELT_HOLD_UPDATE.invokeExact(handle, open, high, low, close, volume, timestamp);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Vectorized update over a whole series; NaN at warmup positions. */
|
||||
public double[] batch(double[] open, double[] high, double[] low, double[] close, double[] volume, double[] timestamp) {
|
||||
int n = open.length;
|
||||
if (high.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (low.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (close.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (volume.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (timestamp.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
try (Arena a = Arena.ofConfined()) {
|
||||
MemorySegment openSeg = a.allocateFrom(JAVA_DOUBLE, open);
|
||||
MemorySegment highSeg = a.allocateFrom(JAVA_DOUBLE, high);
|
||||
MemorySegment lowSeg = a.allocateFrom(JAVA_DOUBLE, low);
|
||||
MemorySegment closeSeg = a.allocateFrom(JAVA_DOUBLE, close);
|
||||
MemorySegment volumeSeg = a.allocateFrom(JAVA_DOUBLE, volume);
|
||||
MemorySegment timestampSeg = a.allocateFrom(JAVA_DOUBLE, timestamp);
|
||||
MemorySegment outSeg = a.allocate(JAVA_DOUBLE.byteSize() * n);
|
||||
NativeMethods.WICKRA_BELT_HOLD_BATCH.invokeExact(handle, openSeg, highSeg, lowSeg, closeSeg, volumeSeg, timestampSeg, outSeg, (long) n);
|
||||
double[] out = new double[n];
|
||||
MemorySegment.copy(outSeg, JAVA_DOUBLE, 0L, out, 0, n);
|
||||
return out;
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Reset to the just-constructed state. */
|
||||
public void reset() {
|
||||
try {
|
||||
NativeMethods.WICKRA_BELT_HOLD_RESET.invokeExact(handle);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
@Override public void close() {
|
||||
cleanable.clean();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,73 @@
|
||||
// Generated from bindings/c/include/wickra.h. Do not edit by hand.
|
||||
package org.wickra;
|
||||
|
||||
import org.wickra.internal.NativeMethods;
|
||||
import org.wickra.internal.WickraNative;
|
||||
import java.lang.foreign.Arena;
|
||||
import java.lang.foreign.MemorySegment;
|
||||
import java.lang.ref.Cleaner;
|
||||
import static java.lang.foreign.ValueLayout.*;
|
||||
|
||||
/** Streaming Beta indicator over the Wickra C ABI. Not thread-safe; close when done. */
|
||||
public final class Beta implements AutoCloseable {
|
||||
private final MemorySegment handle;
|
||||
private final Cleaner.Cleanable cleanable;
|
||||
|
||||
public Beta(int period) {
|
||||
if (period < 0) {
|
||||
throw new IllegalArgumentException("period must be non-negative");
|
||||
}
|
||||
MemorySegment h;
|
||||
try {
|
||||
h = (MemorySegment) NativeMethods.WICKRA_BETA_NEW.invokeExact((long) period);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
if (h.address() == 0L) {
|
||||
throw new IllegalArgumentException("invalid Beta parameters");
|
||||
}
|
||||
this.handle = h;
|
||||
this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_BETA_FREE);
|
||||
}
|
||||
|
||||
/** Push one observation; returns the indicator value (NaN during warmup). */
|
||||
public double update(double x, double y) {
|
||||
try {
|
||||
return (double) NativeMethods.WICKRA_BETA_UPDATE.invokeExact(handle, x, y);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Vectorized update over a whole series; NaN at warmup positions. */
|
||||
public double[] batch(double[] x, double[] y) {
|
||||
int n = x.length;
|
||||
if (y.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
try (Arena a = Arena.ofConfined()) {
|
||||
MemorySegment xSeg = a.allocateFrom(JAVA_DOUBLE, x);
|
||||
MemorySegment ySeg = a.allocateFrom(JAVA_DOUBLE, y);
|
||||
MemorySegment outSeg = a.allocate(JAVA_DOUBLE.byteSize() * n);
|
||||
NativeMethods.WICKRA_BETA_BATCH.invokeExact(handle, xSeg, ySeg, outSeg, (long) n);
|
||||
double[] out = new double[n];
|
||||
MemorySegment.copy(outSeg, JAVA_DOUBLE, 0L, out, 0, n);
|
||||
return out;
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Reset to the just-constructed state. */
|
||||
public void reset() {
|
||||
try {
|
||||
NativeMethods.WICKRA_BETA_RESET.invokeExact(handle);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
@Override public void close() {
|
||||
cleanable.clean();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,73 @@
|
||||
// Generated from bindings/c/include/wickra.h. Do not edit by hand.
|
||||
package org.wickra;
|
||||
|
||||
import org.wickra.internal.NativeMethods;
|
||||
import org.wickra.internal.WickraNative;
|
||||
import java.lang.foreign.Arena;
|
||||
import java.lang.foreign.MemorySegment;
|
||||
import java.lang.ref.Cleaner;
|
||||
import static java.lang.foreign.ValueLayout.*;
|
||||
|
||||
/** Streaming BetaNeutralSpread indicator over the Wickra C ABI. Not thread-safe; close when done. */
|
||||
public final class BetaNeutralSpread implements AutoCloseable {
|
||||
private final MemorySegment handle;
|
||||
private final Cleaner.Cleanable cleanable;
|
||||
|
||||
public BetaNeutralSpread(int period) {
|
||||
if (period < 0) {
|
||||
throw new IllegalArgumentException("period must be non-negative");
|
||||
}
|
||||
MemorySegment h;
|
||||
try {
|
||||
h = (MemorySegment) NativeMethods.WICKRA_BETA_NEUTRAL_SPREAD_NEW.invokeExact((long) period);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
if (h.address() == 0L) {
|
||||
throw new IllegalArgumentException("invalid BetaNeutralSpread parameters");
|
||||
}
|
||||
this.handle = h;
|
||||
this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_BETA_NEUTRAL_SPREAD_FREE);
|
||||
}
|
||||
|
||||
/** Push one observation; returns the indicator value (NaN during warmup). */
|
||||
public double update(double x, double y) {
|
||||
try {
|
||||
return (double) NativeMethods.WICKRA_BETA_NEUTRAL_SPREAD_UPDATE.invokeExact(handle, x, y);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Vectorized update over a whole series; NaN at warmup positions. */
|
||||
public double[] batch(double[] x, double[] y) {
|
||||
int n = x.length;
|
||||
if (y.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
try (Arena a = Arena.ofConfined()) {
|
||||
MemorySegment xSeg = a.allocateFrom(JAVA_DOUBLE, x);
|
||||
MemorySegment ySeg = a.allocateFrom(JAVA_DOUBLE, y);
|
||||
MemorySegment outSeg = a.allocate(JAVA_DOUBLE.byteSize() * n);
|
||||
NativeMethods.WICKRA_BETA_NEUTRAL_SPREAD_BATCH.invokeExact(handle, xSeg, ySeg, outSeg, (long) n);
|
||||
double[] out = new double[n];
|
||||
MemorySegment.copy(outSeg, JAVA_DOUBLE, 0L, out, 0, n);
|
||||
return out;
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Reset to the just-constructed state. */
|
||||
public void reset() {
|
||||
try {
|
||||
NativeMethods.WICKRA_BETA_NEUTRAL_SPREAD_RESET.invokeExact(handle);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
@Override public void close() {
|
||||
cleanable.clean();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,89 @@
|
||||
// Generated from bindings/c/include/wickra.h. Do not edit by hand.
|
||||
package org.wickra;
|
||||
|
||||
import org.wickra.internal.NativeMethods;
|
||||
import org.wickra.internal.WickraNative;
|
||||
import java.lang.foreign.Arena;
|
||||
import java.lang.foreign.MemorySegment;
|
||||
import java.lang.ref.Cleaner;
|
||||
import static java.lang.foreign.ValueLayout.*;
|
||||
|
||||
/** Streaming BetterVolume indicator over the Wickra C ABI. Not thread-safe; close when done. */
|
||||
public final class BetterVolume implements AutoCloseable {
|
||||
private final MemorySegment handle;
|
||||
private final Cleaner.Cleanable cleanable;
|
||||
|
||||
public BetterVolume(int period) {
|
||||
if (period < 0) {
|
||||
throw new IllegalArgumentException("period must be non-negative");
|
||||
}
|
||||
MemorySegment h;
|
||||
try {
|
||||
h = (MemorySegment) NativeMethods.WICKRA_BETTER_VOLUME_NEW.invokeExact((long) period);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
if (h.address() == 0L) {
|
||||
throw new IllegalArgumentException("invalid BetterVolume parameters");
|
||||
}
|
||||
this.handle = h;
|
||||
this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_BETTER_VOLUME_FREE);
|
||||
}
|
||||
|
||||
/** Push one observation; returns the indicator value (NaN during warmup). */
|
||||
public double update(double open, double high, double low, double close, double volume, long timestamp) {
|
||||
try {
|
||||
return (double) NativeMethods.WICKRA_BETTER_VOLUME_UPDATE.invokeExact(handle, open, high, low, close, volume, timestamp);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Vectorized update over a whole series; NaN at warmup positions. */
|
||||
public double[] batch(double[] open, double[] high, double[] low, double[] close, double[] volume, double[] timestamp) {
|
||||
int n = open.length;
|
||||
if (high.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (low.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (close.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (volume.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (timestamp.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
try (Arena a = Arena.ofConfined()) {
|
||||
MemorySegment openSeg = a.allocateFrom(JAVA_DOUBLE, open);
|
||||
MemorySegment highSeg = a.allocateFrom(JAVA_DOUBLE, high);
|
||||
MemorySegment lowSeg = a.allocateFrom(JAVA_DOUBLE, low);
|
||||
MemorySegment closeSeg = a.allocateFrom(JAVA_DOUBLE, close);
|
||||
MemorySegment volumeSeg = a.allocateFrom(JAVA_DOUBLE, volume);
|
||||
MemorySegment timestampSeg = a.allocateFrom(JAVA_DOUBLE, timestamp);
|
||||
MemorySegment outSeg = a.allocate(JAVA_DOUBLE.byteSize() * n);
|
||||
NativeMethods.WICKRA_BETTER_VOLUME_BATCH.invokeExact(handle, openSeg, highSeg, lowSeg, closeSeg, volumeSeg, timestampSeg, outSeg, (long) n);
|
||||
double[] out = new double[n];
|
||||
MemorySegment.copy(outSeg, JAVA_DOUBLE, 0L, out, 0, n);
|
||||
return out;
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Reset to the just-constructed state. */
|
||||
public void reset() {
|
||||
try {
|
||||
NativeMethods.WICKRA_BETTER_VOLUME_RESET.invokeExact(handle);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
@Override public void close() {
|
||||
cleanable.clean();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,69 @@
|
||||
// Generated from bindings/c/include/wickra.h. Do not edit by hand.
|
||||
package org.wickra;
|
||||
|
||||
import org.wickra.internal.NativeMethods;
|
||||
import org.wickra.internal.WickraNative;
|
||||
import java.lang.foreign.Arena;
|
||||
import java.lang.foreign.MemorySegment;
|
||||
import java.lang.ref.Cleaner;
|
||||
import static java.lang.foreign.ValueLayout.*;
|
||||
|
||||
/** Streaming BipowerVariation indicator over the Wickra C ABI. Not thread-safe; close when done. */
|
||||
public final class BipowerVariation implements AutoCloseable {
|
||||
private final MemorySegment handle;
|
||||
private final Cleaner.Cleanable cleanable;
|
||||
|
||||
public BipowerVariation(int period) {
|
||||
if (period < 0) {
|
||||
throw new IllegalArgumentException("period must be non-negative");
|
||||
}
|
||||
MemorySegment h;
|
||||
try {
|
||||
h = (MemorySegment) NativeMethods.WICKRA_BIPOWER_VARIATION_NEW.invokeExact((long) period);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
if (h.address() == 0L) {
|
||||
throw new IllegalArgumentException("invalid BipowerVariation parameters");
|
||||
}
|
||||
this.handle = h;
|
||||
this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_BIPOWER_VARIATION_FREE);
|
||||
}
|
||||
|
||||
/** Push one observation; returns the indicator value (NaN during warmup). */
|
||||
public double update(double value) {
|
||||
try {
|
||||
return (double) NativeMethods.WICKRA_BIPOWER_VARIATION_UPDATE.invokeExact(handle, value);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Vectorized update over a whole series; NaN at warmup positions. */
|
||||
public double[] batch(double[] input) {
|
||||
int n = input.length;
|
||||
try (Arena a = Arena.ofConfined()) {
|
||||
MemorySegment inputSeg = a.allocateFrom(JAVA_DOUBLE, input);
|
||||
MemorySegment outSeg = a.allocate(JAVA_DOUBLE.byteSize() * n);
|
||||
NativeMethods.WICKRA_BIPOWER_VARIATION_BATCH.invokeExact(handle, inputSeg, outSeg, (long) n);
|
||||
double[] out = new double[n];
|
||||
MemorySegment.copy(outSeg, JAVA_DOUBLE, 0L, out, 0, n);
|
||||
return out;
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Reset to the just-constructed state. */
|
||||
public void reset() {
|
||||
try {
|
||||
NativeMethods.WICKRA_BIPOWER_VARIATION_RESET.invokeExact(handle);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
@Override public void close() {
|
||||
cleanable.clean();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,86 @@
|
||||
// Generated from bindings/c/include/wickra.h. Do not edit by hand.
|
||||
package org.wickra;
|
||||
|
||||
import org.wickra.internal.NativeMethods;
|
||||
import org.wickra.internal.WickraNative;
|
||||
import java.lang.foreign.Arena;
|
||||
import java.lang.foreign.MemorySegment;
|
||||
import java.lang.ref.Cleaner;
|
||||
import static java.lang.foreign.ValueLayout.*;
|
||||
|
||||
/** Streaming BodySizePct indicator over the Wickra C ABI. Not thread-safe; close when done. */
|
||||
public final class BodySizePct implements AutoCloseable {
|
||||
private final MemorySegment handle;
|
||||
private final Cleaner.Cleanable cleanable;
|
||||
|
||||
public BodySizePct() {
|
||||
MemorySegment h;
|
||||
try {
|
||||
h = (MemorySegment) NativeMethods.WICKRA_BODY_SIZE_PCT_NEW.invokeExact();
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
if (h.address() == 0L) {
|
||||
throw new IllegalArgumentException("invalid BodySizePct parameters");
|
||||
}
|
||||
this.handle = h;
|
||||
this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_BODY_SIZE_PCT_FREE);
|
||||
}
|
||||
|
||||
/** Push one observation; returns the indicator value (NaN during warmup). */
|
||||
public double update(double open, double high, double low, double close, double volume, long timestamp) {
|
||||
try {
|
||||
return (double) NativeMethods.WICKRA_BODY_SIZE_PCT_UPDATE.invokeExact(handle, open, high, low, close, volume, timestamp);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Vectorized update over a whole series; NaN at warmup positions. */
|
||||
public double[] batch(double[] open, double[] high, double[] low, double[] close, double[] volume, double[] timestamp) {
|
||||
int n = open.length;
|
||||
if (high.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (low.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (close.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (volume.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (timestamp.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
try (Arena a = Arena.ofConfined()) {
|
||||
MemorySegment openSeg = a.allocateFrom(JAVA_DOUBLE, open);
|
||||
MemorySegment highSeg = a.allocateFrom(JAVA_DOUBLE, high);
|
||||
MemorySegment lowSeg = a.allocateFrom(JAVA_DOUBLE, low);
|
||||
MemorySegment closeSeg = a.allocateFrom(JAVA_DOUBLE, close);
|
||||
MemorySegment volumeSeg = a.allocateFrom(JAVA_DOUBLE, volume);
|
||||
MemorySegment timestampSeg = a.allocateFrom(JAVA_DOUBLE, timestamp);
|
||||
MemorySegment outSeg = a.allocate(JAVA_DOUBLE.byteSize() * n);
|
||||
NativeMethods.WICKRA_BODY_SIZE_PCT_BATCH.invokeExact(handle, openSeg, highSeg, lowSeg, closeSeg, volumeSeg, timestampSeg, outSeg, (long) n);
|
||||
double[] out = new double[n];
|
||||
MemorySegment.copy(outSeg, JAVA_DOUBLE, 0L, out, 0, n);
|
||||
return out;
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Reset to the just-constructed state. */
|
||||
public void reset() {
|
||||
try {
|
||||
NativeMethods.WICKRA_BODY_SIZE_PCT_RESET.invokeExact(handle);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
@Override public void close() {
|
||||
cleanable.clean();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,63 @@
|
||||
// Generated from bindings/c/include/wickra.h. Do not edit by hand.
|
||||
package org.wickra;
|
||||
|
||||
import org.wickra.internal.NativeMethods;
|
||||
import org.wickra.internal.WickraNative;
|
||||
import java.lang.foreign.Arena;
|
||||
import java.lang.foreign.MemorySegment;
|
||||
import java.lang.ref.Cleaner;
|
||||
import static java.lang.foreign.ValueLayout.*;
|
||||
|
||||
/** Streaming BollingerBands indicator over the Wickra C ABI. Not thread-safe; close when done. */
|
||||
public final class BollingerBands implements AutoCloseable {
|
||||
private final MemorySegment handle;
|
||||
private final Cleaner.Cleanable cleanable;
|
||||
|
||||
public BollingerBands(int period, double multiplier) {
|
||||
if (period < 0) {
|
||||
throw new IllegalArgumentException("period must be non-negative");
|
||||
}
|
||||
MemorySegment h;
|
||||
try {
|
||||
h = (MemorySegment) NativeMethods.WICKRA_BOLLINGER_BANDS_NEW.invokeExact((long) period, multiplier);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
if (h.address() == 0L) {
|
||||
throw new IllegalArgumentException("invalid BollingerBands parameters");
|
||||
}
|
||||
this.handle = h;
|
||||
this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_BOLLINGER_BANDS_FREE);
|
||||
}
|
||||
|
||||
/** Push one observation; returns the result, or null during warmup. */
|
||||
public BollingerOutput update(double value) {
|
||||
try (Arena a = Arena.ofConfined()) {
|
||||
MemorySegment out = a.allocate(32L);
|
||||
byte ok = (byte) NativeMethods.WICKRA_BOLLINGER_BANDS_UPDATE.invokeExact(handle, value, out);
|
||||
if (ok == 0) {
|
||||
return null;
|
||||
}
|
||||
return new BollingerOutput(
|
||||
out.get(JAVA_DOUBLE, 0L),
|
||||
out.get(JAVA_DOUBLE, 8L),
|
||||
out.get(JAVA_DOUBLE, 16L),
|
||||
out.get(JAVA_DOUBLE, 24L));
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Reset to the just-constructed state. */
|
||||
public void reset() {
|
||||
try {
|
||||
NativeMethods.WICKRA_BOLLINGER_BANDS_RESET.invokeExact(handle);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
@Override public void close() {
|
||||
cleanable.clean();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,69 @@
|
||||
// Generated from bindings/c/include/wickra.h. Do not edit by hand.
|
||||
package org.wickra;
|
||||
|
||||
import org.wickra.internal.NativeMethods;
|
||||
import org.wickra.internal.WickraNative;
|
||||
import java.lang.foreign.Arena;
|
||||
import java.lang.foreign.MemorySegment;
|
||||
import java.lang.ref.Cleaner;
|
||||
import static java.lang.foreign.ValueLayout.*;
|
||||
|
||||
/** Streaming BollingerBandwidth indicator over the Wickra C ABI. Not thread-safe; close when done. */
|
||||
public final class BollingerBandwidth implements AutoCloseable {
|
||||
private final MemorySegment handle;
|
||||
private final Cleaner.Cleanable cleanable;
|
||||
|
||||
public BollingerBandwidth(int period, double multiplier) {
|
||||
if (period < 0) {
|
||||
throw new IllegalArgumentException("period must be non-negative");
|
||||
}
|
||||
MemorySegment h;
|
||||
try {
|
||||
h = (MemorySegment) NativeMethods.WICKRA_BOLLINGER_BANDWIDTH_NEW.invokeExact((long) period, multiplier);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
if (h.address() == 0L) {
|
||||
throw new IllegalArgumentException("invalid BollingerBandwidth parameters");
|
||||
}
|
||||
this.handle = h;
|
||||
this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_BOLLINGER_BANDWIDTH_FREE);
|
||||
}
|
||||
|
||||
/** Push one observation; returns the indicator value (NaN during warmup). */
|
||||
public double update(double value) {
|
||||
try {
|
||||
return (double) NativeMethods.WICKRA_BOLLINGER_BANDWIDTH_UPDATE.invokeExact(handle, value);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Vectorized update over a whole series; NaN at warmup positions. */
|
||||
public double[] batch(double[] input) {
|
||||
int n = input.length;
|
||||
try (Arena a = Arena.ofConfined()) {
|
||||
MemorySegment inputSeg = a.allocateFrom(JAVA_DOUBLE, input);
|
||||
MemorySegment outSeg = a.allocate(JAVA_DOUBLE.byteSize() * n);
|
||||
NativeMethods.WICKRA_BOLLINGER_BANDWIDTH_BATCH.invokeExact(handle, inputSeg, outSeg, (long) n);
|
||||
double[] out = new double[n];
|
||||
MemorySegment.copy(outSeg, JAVA_DOUBLE, 0L, out, 0, n);
|
||||
return out;
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Reset to the just-constructed state. */
|
||||
public void reset() {
|
||||
try {
|
||||
NativeMethods.WICKRA_BOLLINGER_BANDWIDTH_RESET.invokeExact(handle);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
@Override public void close() {
|
||||
cleanable.clean();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,5 @@
|
||||
// Generated from bindings/c/include/wickra.h. Do not edit by hand.
|
||||
package org.wickra;
|
||||
|
||||
/** Output record produced by the matching indicator. */
|
||||
public record BollingerOutput(double upper, double middle, double lower, double stddev) {}
|
||||
@@ -0,0 +1,62 @@
|
||||
// Generated from bindings/c/include/wickra.h. Do not edit by hand.
|
||||
package org.wickra;
|
||||
|
||||
import org.wickra.internal.NativeMethods;
|
||||
import org.wickra.internal.WickraNative;
|
||||
import java.lang.foreign.Arena;
|
||||
import java.lang.foreign.MemorySegment;
|
||||
import java.lang.ref.Cleaner;
|
||||
import static java.lang.foreign.ValueLayout.*;
|
||||
|
||||
/** Streaming BomarBands indicator over the Wickra C ABI. Not thread-safe; close when done. */
|
||||
public final class BomarBands implements AutoCloseable {
|
||||
private final MemorySegment handle;
|
||||
private final Cleaner.Cleanable cleanable;
|
||||
|
||||
public BomarBands(int period, double coverage) {
|
||||
if (period < 0) {
|
||||
throw new IllegalArgumentException("period must be non-negative");
|
||||
}
|
||||
MemorySegment h;
|
||||
try {
|
||||
h = (MemorySegment) NativeMethods.WICKRA_BOMAR_BANDS_NEW.invokeExact((long) period, coverage);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
if (h.address() == 0L) {
|
||||
throw new IllegalArgumentException("invalid BomarBands parameters");
|
||||
}
|
||||
this.handle = h;
|
||||
this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_BOMAR_BANDS_FREE);
|
||||
}
|
||||
|
||||
/** Push one observation; returns the result, or null during warmup. */
|
||||
public BomarBandsOutput update(double value) {
|
||||
try (Arena a = Arena.ofConfined()) {
|
||||
MemorySegment out = a.allocate(24L);
|
||||
byte ok = (byte) NativeMethods.WICKRA_BOMAR_BANDS_UPDATE.invokeExact(handle, value, out);
|
||||
if (ok == 0) {
|
||||
return null;
|
||||
}
|
||||
return new BomarBandsOutput(
|
||||
out.get(JAVA_DOUBLE, 0L),
|
||||
out.get(JAVA_DOUBLE, 8L),
|
||||
out.get(JAVA_DOUBLE, 16L));
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Reset to the just-constructed state. */
|
||||
public void reset() {
|
||||
try {
|
||||
NativeMethods.WICKRA_BOMAR_BANDS_RESET.invokeExact(handle);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
@Override public void close() {
|
||||
cleanable.clean();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,5 @@
|
||||
// Generated from bindings/c/include/wickra.h. Do not edit by hand.
|
||||
package org.wickra;
|
||||
|
||||
/** Output record produced by the matching indicator. */
|
||||
public record BomarBandsOutput(double upper, double middle, double lower) {}
|
||||
@@ -0,0 +1,75 @@
|
||||
// Generated from bindings/c/include/wickra.h. Do not edit by hand.
|
||||
package org.wickra;
|
||||
|
||||
import org.wickra.internal.NativeMethods;
|
||||
import org.wickra.internal.WickraNative;
|
||||
import java.lang.foreign.Arena;
|
||||
import java.lang.foreign.MemorySegment;
|
||||
import java.lang.ref.Cleaner;
|
||||
import static java.lang.foreign.ValueLayout.*;
|
||||
|
||||
/** Streaming BreadthThrust indicator over the Wickra C ABI. Not thread-safe; close when done. */
|
||||
public final class BreadthThrust implements AutoCloseable {
|
||||
private final MemorySegment handle;
|
||||
private final Cleaner.Cleanable cleanable;
|
||||
|
||||
public BreadthThrust(int period) {
|
||||
if (period < 0) {
|
||||
throw new IllegalArgumentException("period must be non-negative");
|
||||
}
|
||||
MemorySegment h;
|
||||
try {
|
||||
h = (MemorySegment) NativeMethods.WICKRA_BREADTH_THRUST_NEW.invokeExact((long) period);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
if (h.address() == 0L) {
|
||||
throw new IllegalArgumentException("invalid BreadthThrust parameters");
|
||||
}
|
||||
this.handle = h;
|
||||
this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_BREADTH_THRUST_FREE);
|
||||
}
|
||||
|
||||
/** Push one observation; returns the indicator value (NaN during warmup). */
|
||||
public double update(double[] change, double[] volume, double[] newHigh, double[] newLow, double[] aboveMa, double[] onBuySignal, long timestamp) {
|
||||
if (volume.length != change.length) {
|
||||
throw new IllegalArgumentException("input arrays in the same group must have equal length");
|
||||
}
|
||||
if (newHigh.length != change.length) {
|
||||
throw new IllegalArgumentException("input arrays in the same group must have equal length");
|
||||
}
|
||||
if (newLow.length != change.length) {
|
||||
throw new IllegalArgumentException("input arrays in the same group must have equal length");
|
||||
}
|
||||
if (aboveMa.length != change.length) {
|
||||
throw new IllegalArgumentException("input arrays in the same group must have equal length");
|
||||
}
|
||||
if (onBuySignal.length != change.length) {
|
||||
throw new IllegalArgumentException("input arrays in the same group must have equal length");
|
||||
}
|
||||
try (Arena a = Arena.ofConfined()) {
|
||||
MemorySegment changeSeg = a.allocateFrom(JAVA_DOUBLE, change);
|
||||
MemorySegment volumeSeg = a.allocateFrom(JAVA_DOUBLE, volume);
|
||||
MemorySegment newHighSeg = a.allocateFrom(JAVA_DOUBLE, newHigh);
|
||||
MemorySegment newLowSeg = a.allocateFrom(JAVA_DOUBLE, newLow);
|
||||
MemorySegment aboveMaSeg = a.allocateFrom(JAVA_DOUBLE, aboveMa);
|
||||
MemorySegment onBuySignalSeg = a.allocateFrom(JAVA_DOUBLE, onBuySignal);
|
||||
return (double) NativeMethods.WICKRA_BREADTH_THRUST_UPDATE.invokeExact(handle, changeSeg, volumeSeg, newHighSeg, newLowSeg, aboveMaSeg, onBuySignalSeg, (long) change.length, timestamp);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Reset to the just-constructed state. */
|
||||
public void reset() {
|
||||
try {
|
||||
NativeMethods.WICKRA_BREADTH_THRUST_RESET.invokeExact(handle);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
@Override public void close() {
|
||||
cleanable.clean();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,86 @@
|
||||
// Generated from bindings/c/include/wickra.h. Do not edit by hand.
|
||||
package org.wickra;
|
||||
|
||||
import org.wickra.internal.NativeMethods;
|
||||
import org.wickra.internal.WickraNative;
|
||||
import java.lang.foreign.Arena;
|
||||
import java.lang.foreign.MemorySegment;
|
||||
import java.lang.ref.Cleaner;
|
||||
import static java.lang.foreign.ValueLayout.*;
|
||||
|
||||
/** Streaming Breakaway indicator over the Wickra C ABI. Not thread-safe; close when done. */
|
||||
public final class Breakaway implements AutoCloseable {
|
||||
private final MemorySegment handle;
|
||||
private final Cleaner.Cleanable cleanable;
|
||||
|
||||
public Breakaway() {
|
||||
MemorySegment h;
|
||||
try {
|
||||
h = (MemorySegment) NativeMethods.WICKRA_BREAKAWAY_NEW.invokeExact();
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
if (h.address() == 0L) {
|
||||
throw new IllegalArgumentException("invalid Breakaway parameters");
|
||||
}
|
||||
this.handle = h;
|
||||
this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_BREAKAWAY_FREE);
|
||||
}
|
||||
|
||||
/** Push one observation; returns the indicator value (NaN during warmup). */
|
||||
public double update(double open, double high, double low, double close, double volume, long timestamp) {
|
||||
try {
|
||||
return (double) NativeMethods.WICKRA_BREAKAWAY_UPDATE.invokeExact(handle, open, high, low, close, volume, timestamp);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Vectorized update over a whole series; NaN at warmup positions. */
|
||||
public double[] batch(double[] open, double[] high, double[] low, double[] close, double[] volume, double[] timestamp) {
|
||||
int n = open.length;
|
||||
if (high.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (low.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (close.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (volume.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (timestamp.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
try (Arena a = Arena.ofConfined()) {
|
||||
MemorySegment openSeg = a.allocateFrom(JAVA_DOUBLE, open);
|
||||
MemorySegment highSeg = a.allocateFrom(JAVA_DOUBLE, high);
|
||||
MemorySegment lowSeg = a.allocateFrom(JAVA_DOUBLE, low);
|
||||
MemorySegment closeSeg = a.allocateFrom(JAVA_DOUBLE, close);
|
||||
MemorySegment volumeSeg = a.allocateFrom(JAVA_DOUBLE, volume);
|
||||
MemorySegment timestampSeg = a.allocateFrom(JAVA_DOUBLE, timestamp);
|
||||
MemorySegment outSeg = a.allocate(JAVA_DOUBLE.byteSize() * n);
|
||||
NativeMethods.WICKRA_BREAKAWAY_BATCH.invokeExact(handle, openSeg, highSeg, lowSeg, closeSeg, volumeSeg, timestampSeg, outSeg, (long) n);
|
||||
double[] out = new double[n];
|
||||
MemorySegment.copy(outSeg, JAVA_DOUBLE, 0L, out, 0, n);
|
||||
return out;
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Reset to the just-constructed state. */
|
||||
public void reset() {
|
||||
try {
|
||||
NativeMethods.WICKRA_BREAKAWAY_RESET.invokeExact(handle);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
@Override public void close() {
|
||||
cleanable.clean();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,72 @@
|
||||
// Generated from bindings/c/include/wickra.h. Do not edit by hand.
|
||||
package org.wickra;
|
||||
|
||||
import org.wickra.internal.NativeMethods;
|
||||
import org.wickra.internal.WickraNative;
|
||||
import java.lang.foreign.Arena;
|
||||
import java.lang.foreign.MemorySegment;
|
||||
import java.lang.ref.Cleaner;
|
||||
import static java.lang.foreign.ValueLayout.*;
|
||||
|
||||
/** Streaming BullishPercentIndex indicator over the Wickra C ABI. Not thread-safe; close when done. */
|
||||
public final class BullishPercentIndex implements AutoCloseable {
|
||||
private final MemorySegment handle;
|
||||
private final Cleaner.Cleanable cleanable;
|
||||
|
||||
public BullishPercentIndex() {
|
||||
MemorySegment h;
|
||||
try {
|
||||
h = (MemorySegment) NativeMethods.WICKRA_BULLISH_PERCENT_INDEX_NEW.invokeExact();
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
if (h.address() == 0L) {
|
||||
throw new IllegalArgumentException("invalid BullishPercentIndex parameters");
|
||||
}
|
||||
this.handle = h;
|
||||
this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_BULLISH_PERCENT_INDEX_FREE);
|
||||
}
|
||||
|
||||
/** Push one observation; returns the indicator value (NaN during warmup). */
|
||||
public double update(double[] change, double[] volume, double[] newHigh, double[] newLow, double[] aboveMa, double[] onBuySignal, long timestamp) {
|
||||
if (volume.length != change.length) {
|
||||
throw new IllegalArgumentException("input arrays in the same group must have equal length");
|
||||
}
|
||||
if (newHigh.length != change.length) {
|
||||
throw new IllegalArgumentException("input arrays in the same group must have equal length");
|
||||
}
|
||||
if (newLow.length != change.length) {
|
||||
throw new IllegalArgumentException("input arrays in the same group must have equal length");
|
||||
}
|
||||
if (aboveMa.length != change.length) {
|
||||
throw new IllegalArgumentException("input arrays in the same group must have equal length");
|
||||
}
|
||||
if (onBuySignal.length != change.length) {
|
||||
throw new IllegalArgumentException("input arrays in the same group must have equal length");
|
||||
}
|
||||
try (Arena a = Arena.ofConfined()) {
|
||||
MemorySegment changeSeg = a.allocateFrom(JAVA_DOUBLE, change);
|
||||
MemorySegment volumeSeg = a.allocateFrom(JAVA_DOUBLE, volume);
|
||||
MemorySegment newHighSeg = a.allocateFrom(JAVA_DOUBLE, newHigh);
|
||||
MemorySegment newLowSeg = a.allocateFrom(JAVA_DOUBLE, newLow);
|
||||
MemorySegment aboveMaSeg = a.allocateFrom(JAVA_DOUBLE, aboveMa);
|
||||
MemorySegment onBuySignalSeg = a.allocateFrom(JAVA_DOUBLE, onBuySignal);
|
||||
return (double) NativeMethods.WICKRA_BULLISH_PERCENT_INDEX_UPDATE.invokeExact(handle, changeSeg, volumeSeg, newHighSeg, newLowSeg, aboveMaSeg, onBuySignalSeg, (long) change.length, timestamp);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Reset to the just-constructed state. */
|
||||
public void reset() {
|
||||
try {
|
||||
NativeMethods.WICKRA_BULLISH_PERCENT_INDEX_RESET.invokeExact(handle);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
@Override public void close() {
|
||||
cleanable.clean();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,69 @@
|
||||
// Generated from bindings/c/include/wickra.h. Do not edit by hand.
|
||||
package org.wickra;
|
||||
|
||||
import org.wickra.internal.NativeMethods;
|
||||
import org.wickra.internal.WickraNative;
|
||||
import java.lang.foreign.Arena;
|
||||
import java.lang.foreign.MemorySegment;
|
||||
import java.lang.ref.Cleaner;
|
||||
import static java.lang.foreign.ValueLayout.*;
|
||||
|
||||
/** Streaming BurkeRatio indicator over the Wickra C ABI. Not thread-safe; close when done. */
|
||||
public final class BurkeRatio implements AutoCloseable {
|
||||
private final MemorySegment handle;
|
||||
private final Cleaner.Cleanable cleanable;
|
||||
|
||||
public BurkeRatio(int period) {
|
||||
if (period < 0) {
|
||||
throw new IllegalArgumentException("period must be non-negative");
|
||||
}
|
||||
MemorySegment h;
|
||||
try {
|
||||
h = (MemorySegment) NativeMethods.WICKRA_BURKE_RATIO_NEW.invokeExact((long) period);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
if (h.address() == 0L) {
|
||||
throw new IllegalArgumentException("invalid BurkeRatio parameters");
|
||||
}
|
||||
this.handle = h;
|
||||
this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_BURKE_RATIO_FREE);
|
||||
}
|
||||
|
||||
/** Push one observation; returns the indicator value (NaN during warmup). */
|
||||
public double update(double value) {
|
||||
try {
|
||||
return (double) NativeMethods.WICKRA_BURKE_RATIO_UPDATE.invokeExact(handle, value);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Vectorized update over a whole series; NaN at warmup positions. */
|
||||
public double[] batch(double[] input) {
|
||||
int n = input.length;
|
||||
try (Arena a = Arena.ofConfined()) {
|
||||
MemorySegment inputSeg = a.allocateFrom(JAVA_DOUBLE, input);
|
||||
MemorySegment outSeg = a.allocate(JAVA_DOUBLE.byteSize() * n);
|
||||
NativeMethods.WICKRA_BURKE_RATIO_BATCH.invokeExact(handle, inputSeg, outSeg, (long) n);
|
||||
double[] out = new double[n];
|
||||
MemorySegment.copy(outSeg, JAVA_DOUBLE, 0L, out, 0, n);
|
||||
return out;
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Reset to the just-constructed state. */
|
||||
public void reset() {
|
||||
try {
|
||||
NativeMethods.WICKRA_BURKE_RATIO_RESET.invokeExact(handle);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
@Override public void close() {
|
||||
cleanable.clean();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,86 @@
|
||||
// Generated from bindings/c/include/wickra.h. Do not edit by hand.
|
||||
package org.wickra;
|
||||
|
||||
import org.wickra.internal.NativeMethods;
|
||||
import org.wickra.internal.WickraNative;
|
||||
import java.lang.foreign.Arena;
|
||||
import java.lang.foreign.MemorySegment;
|
||||
import java.lang.ref.Cleaner;
|
||||
import static java.lang.foreign.ValueLayout.*;
|
||||
|
||||
/** Streaming Butterfly indicator over the Wickra C ABI. Not thread-safe; close when done. */
|
||||
public final class Butterfly implements AutoCloseable {
|
||||
private final MemorySegment handle;
|
||||
private final Cleaner.Cleanable cleanable;
|
||||
|
||||
public Butterfly() {
|
||||
MemorySegment h;
|
||||
try {
|
||||
h = (MemorySegment) NativeMethods.WICKRA_BUTTERFLY_NEW.invokeExact();
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
if (h.address() == 0L) {
|
||||
throw new IllegalArgumentException("invalid Butterfly parameters");
|
||||
}
|
||||
this.handle = h;
|
||||
this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_BUTTERFLY_FREE);
|
||||
}
|
||||
|
||||
/** Push one observation; returns the indicator value (NaN during warmup). */
|
||||
public double update(double open, double high, double low, double close, double volume, long timestamp) {
|
||||
try {
|
||||
return (double) NativeMethods.WICKRA_BUTTERFLY_UPDATE.invokeExact(handle, open, high, low, close, volume, timestamp);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Vectorized update over a whole series; NaN at warmup positions. */
|
||||
public double[] batch(double[] open, double[] high, double[] low, double[] close, double[] volume, double[] timestamp) {
|
||||
int n = open.length;
|
||||
if (high.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (low.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (close.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (volume.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (timestamp.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
try (Arena a = Arena.ofConfined()) {
|
||||
MemorySegment openSeg = a.allocateFrom(JAVA_DOUBLE, open);
|
||||
MemorySegment highSeg = a.allocateFrom(JAVA_DOUBLE, high);
|
||||
MemorySegment lowSeg = a.allocateFrom(JAVA_DOUBLE, low);
|
||||
MemorySegment closeSeg = a.allocateFrom(JAVA_DOUBLE, close);
|
||||
MemorySegment volumeSeg = a.allocateFrom(JAVA_DOUBLE, volume);
|
||||
MemorySegment timestampSeg = a.allocateFrom(JAVA_DOUBLE, timestamp);
|
||||
MemorySegment outSeg = a.allocate(JAVA_DOUBLE.byteSize() * n);
|
||||
NativeMethods.WICKRA_BUTTERFLY_BATCH.invokeExact(handle, openSeg, highSeg, lowSeg, closeSeg, volumeSeg, timestampSeg, outSeg, (long) n);
|
||||
double[] out = new double[n];
|
||||
MemorySegment.copy(outSeg, JAVA_DOUBLE, 0L, out, 0, n);
|
||||
return out;
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Reset to the just-constructed state. */
|
||||
public void reset() {
|
||||
try {
|
||||
NativeMethods.WICKRA_BUTTERFLY_RESET.invokeExact(handle);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
@Override public void close() {
|
||||
cleanable.clean();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,51 @@
|
||||
// Generated from bindings/c/include/wickra.h. Do not edit by hand.
|
||||
package org.wickra;
|
||||
|
||||
import org.wickra.internal.NativeMethods;
|
||||
import org.wickra.internal.WickraNative;
|
||||
import java.lang.foreign.Arena;
|
||||
import java.lang.foreign.MemorySegment;
|
||||
import java.lang.ref.Cleaner;
|
||||
import static java.lang.foreign.ValueLayout.*;
|
||||
|
||||
/** Streaming CalendarSpread indicator over the Wickra C ABI. Not thread-safe; close when done. */
|
||||
public final class CalendarSpread implements AutoCloseable {
|
||||
private final MemorySegment handle;
|
||||
private final Cleaner.Cleanable cleanable;
|
||||
|
||||
public CalendarSpread() {
|
||||
MemorySegment h;
|
||||
try {
|
||||
h = (MemorySegment) NativeMethods.WICKRA_CALENDAR_SPREAD_NEW.invokeExact();
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
if (h.address() == 0L) {
|
||||
throw new IllegalArgumentException("invalid CalendarSpread parameters");
|
||||
}
|
||||
this.handle = h;
|
||||
this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_CALENDAR_SPREAD_FREE);
|
||||
}
|
||||
|
||||
/** Push one observation; returns the indicator value (NaN during warmup). */
|
||||
public double update(double fundingRate, double markPrice, double indexPrice, double futuresPrice, double openInterest, double longSize, double shortSize, double takerBuyVolume, double takerSellVolume, double longLiquidation, double shortLiquidation, long timestamp) {
|
||||
try {
|
||||
return (double) NativeMethods.WICKRA_CALENDAR_SPREAD_UPDATE.invokeExact(handle, fundingRate, markPrice, indexPrice, futuresPrice, openInterest, longSize, shortSize, takerBuyVolume, takerSellVolume, longLiquidation, shortLiquidation, timestamp);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Reset to the just-constructed state. */
|
||||
public void reset() {
|
||||
try {
|
||||
NativeMethods.WICKRA_CALENDAR_SPREAD_RESET.invokeExact(handle);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
@Override public void close() {
|
||||
cleanable.clean();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,69 @@
|
||||
// Generated from bindings/c/include/wickra.h. Do not edit by hand.
|
||||
package org.wickra;
|
||||
|
||||
import org.wickra.internal.NativeMethods;
|
||||
import org.wickra.internal.WickraNative;
|
||||
import java.lang.foreign.Arena;
|
||||
import java.lang.foreign.MemorySegment;
|
||||
import java.lang.ref.Cleaner;
|
||||
import static java.lang.foreign.ValueLayout.*;
|
||||
|
||||
/** Streaming CalmarRatio indicator over the Wickra C ABI. Not thread-safe; close when done. */
|
||||
public final class CalmarRatio implements AutoCloseable {
|
||||
private final MemorySegment handle;
|
||||
private final Cleaner.Cleanable cleanable;
|
||||
|
||||
public CalmarRatio(int period) {
|
||||
if (period < 0) {
|
||||
throw new IllegalArgumentException("period must be non-negative");
|
||||
}
|
||||
MemorySegment h;
|
||||
try {
|
||||
h = (MemorySegment) NativeMethods.WICKRA_CALMAR_RATIO_NEW.invokeExact((long) period);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
if (h.address() == 0L) {
|
||||
throw new IllegalArgumentException("invalid CalmarRatio parameters");
|
||||
}
|
||||
this.handle = h;
|
||||
this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_CALMAR_RATIO_FREE);
|
||||
}
|
||||
|
||||
/** Push one observation; returns the indicator value (NaN during warmup). */
|
||||
public double update(double value) {
|
||||
try {
|
||||
return (double) NativeMethods.WICKRA_CALMAR_RATIO_UPDATE.invokeExact(handle, value);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Vectorized update over a whole series; NaN at warmup positions. */
|
||||
public double[] batch(double[] input) {
|
||||
int n = input.length;
|
||||
try (Arena a = Arena.ofConfined()) {
|
||||
MemorySegment inputSeg = a.allocateFrom(JAVA_DOUBLE, input);
|
||||
MemorySegment outSeg = a.allocate(JAVA_DOUBLE.byteSize() * n);
|
||||
NativeMethods.WICKRA_CALMAR_RATIO_BATCH.invokeExact(handle, inputSeg, outSeg, (long) n);
|
||||
double[] out = new double[n];
|
||||
MemorySegment.copy(outSeg, JAVA_DOUBLE, 0L, out, 0, n);
|
||||
return out;
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Reset to the just-constructed state. */
|
||||
public void reset() {
|
||||
try {
|
||||
NativeMethods.WICKRA_CALMAR_RATIO_RESET.invokeExact(handle);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
@Override public void close() {
|
||||
cleanable.clean();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,65 @@
|
||||
// Generated from bindings/c/include/wickra.h. Do not edit by hand.
|
||||
package org.wickra;
|
||||
|
||||
import org.wickra.internal.NativeMethods;
|
||||
import org.wickra.internal.WickraNative;
|
||||
import java.lang.foreign.Arena;
|
||||
import java.lang.foreign.MemorySegment;
|
||||
import java.lang.ref.Cleaner;
|
||||
import static java.lang.foreign.ValueLayout.*;
|
||||
|
||||
/** Streaming Camarilla indicator over the Wickra C ABI. Not thread-safe; close when done. */
|
||||
public final class Camarilla implements AutoCloseable {
|
||||
private final MemorySegment handle;
|
||||
private final Cleaner.Cleanable cleanable;
|
||||
|
||||
public Camarilla() {
|
||||
MemorySegment h;
|
||||
try {
|
||||
h = (MemorySegment) NativeMethods.WICKRA_CAMARILLA_NEW.invokeExact();
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
if (h.address() == 0L) {
|
||||
throw new IllegalArgumentException("invalid Camarilla parameters");
|
||||
}
|
||||
this.handle = h;
|
||||
this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_CAMARILLA_FREE);
|
||||
}
|
||||
|
||||
/** Push one observation; returns the result, or null during warmup. */
|
||||
public CamarillaPivotsOutput update(double open, double high, double low, double close, double volume, long timestamp) {
|
||||
try (Arena a = Arena.ofConfined()) {
|
||||
MemorySegment out = a.allocate(72L);
|
||||
byte ok = (byte) NativeMethods.WICKRA_CAMARILLA_UPDATE.invokeExact(handle, open, high, low, close, volume, timestamp, out);
|
||||
if (ok == 0) {
|
||||
return null;
|
||||
}
|
||||
return new CamarillaPivotsOutput(
|
||||
out.get(JAVA_DOUBLE, 0L),
|
||||
out.get(JAVA_DOUBLE, 8L),
|
||||
out.get(JAVA_DOUBLE, 16L),
|
||||
out.get(JAVA_DOUBLE, 24L),
|
||||
out.get(JAVA_DOUBLE, 32L),
|
||||
out.get(JAVA_DOUBLE, 40L),
|
||||
out.get(JAVA_DOUBLE, 48L),
|
||||
out.get(JAVA_DOUBLE, 56L),
|
||||
out.get(JAVA_DOUBLE, 64L));
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Reset to the just-constructed state. */
|
||||
public void reset() {
|
||||
try {
|
||||
NativeMethods.WICKRA_CAMARILLA_RESET.invokeExact(handle);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
@Override public void close() {
|
||||
cleanable.clean();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,5 @@
|
||||
// Generated from bindings/c/include/wickra.h. Do not edit by hand.
|
||||
package org.wickra;
|
||||
|
||||
/** Output record produced by the matching indicator. */
|
||||
public record CamarillaPivotsOutput(double pp, double r1, double r2, double r3, double r4, double s1, double s2, double s3, double s4) {}
|
||||
@@ -0,0 +1,61 @@
|
||||
// Generated from bindings/c/include/wickra.h. Do not edit by hand.
|
||||
package org.wickra;
|
||||
|
||||
import org.wickra.internal.NativeMethods;
|
||||
import org.wickra.internal.WickraNative;
|
||||
import java.lang.foreign.Arena;
|
||||
import java.lang.foreign.MemorySegment;
|
||||
import java.lang.ref.Cleaner;
|
||||
import static java.lang.foreign.ValueLayout.*;
|
||||
|
||||
/** Streaming CandleVolume indicator over the Wickra C ABI. Not thread-safe; close when done. */
|
||||
public final class CandleVolume implements AutoCloseable {
|
||||
private final MemorySegment handle;
|
||||
private final Cleaner.Cleanable cleanable;
|
||||
|
||||
public CandleVolume(int period) {
|
||||
if (period < 0) {
|
||||
throw new IllegalArgumentException("period must be non-negative");
|
||||
}
|
||||
MemorySegment h;
|
||||
try {
|
||||
h = (MemorySegment) NativeMethods.WICKRA_CANDLE_VOLUME_NEW.invokeExact((long) period);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
if (h.address() == 0L) {
|
||||
throw new IllegalArgumentException("invalid CandleVolume parameters");
|
||||
}
|
||||
this.handle = h;
|
||||
this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_CANDLE_VOLUME_FREE);
|
||||
}
|
||||
|
||||
/** Push one observation; returns the result, or null during warmup. */
|
||||
public CandleVolumeOutput update(double open, double high, double low, double close, double volume, long timestamp) {
|
||||
try (Arena a = Arena.ofConfined()) {
|
||||
MemorySegment out = a.allocate(16L);
|
||||
byte ok = (byte) NativeMethods.WICKRA_CANDLE_VOLUME_UPDATE.invokeExact(handle, open, high, low, close, volume, timestamp, out);
|
||||
if (ok == 0) {
|
||||
return null;
|
||||
}
|
||||
return new CandleVolumeOutput(
|
||||
out.get(JAVA_DOUBLE, 0L),
|
||||
out.get(JAVA_DOUBLE, 8L));
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Reset to the just-constructed state. */
|
||||
public void reset() {
|
||||
try {
|
||||
NativeMethods.WICKRA_CANDLE_VOLUME_RESET.invokeExact(handle);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
@Override public void close() {
|
||||
cleanable.clean();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,5 @@
|
||||
// Generated from bindings/c/include/wickra.h. Do not edit by hand.
|
||||
package org.wickra;
|
||||
|
||||
/** Output record produced by the matching indicator. */
|
||||
public record CandleVolumeOutput(double body, double width) {}
|
||||
@@ -0,0 +1,89 @@
|
||||
// Generated from bindings/c/include/wickra.h. Do not edit by hand.
|
||||
package org.wickra;
|
||||
|
||||
import org.wickra.internal.NativeMethods;
|
||||
import org.wickra.internal.WickraNative;
|
||||
import java.lang.foreign.Arena;
|
||||
import java.lang.foreign.MemorySegment;
|
||||
import java.lang.ref.Cleaner;
|
||||
import static java.lang.foreign.ValueLayout.*;
|
||||
|
||||
/** Streaming Cci indicator over the Wickra C ABI. Not thread-safe; close when done. */
|
||||
public final class Cci implements AutoCloseable {
|
||||
private final MemorySegment handle;
|
||||
private final Cleaner.Cleanable cleanable;
|
||||
|
||||
public Cci(int period) {
|
||||
if (period < 0) {
|
||||
throw new IllegalArgumentException("period must be non-negative");
|
||||
}
|
||||
MemorySegment h;
|
||||
try {
|
||||
h = (MemorySegment) NativeMethods.WICKRA_CCI_NEW.invokeExact((long) period);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
if (h.address() == 0L) {
|
||||
throw new IllegalArgumentException("invalid Cci parameters");
|
||||
}
|
||||
this.handle = h;
|
||||
this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_CCI_FREE);
|
||||
}
|
||||
|
||||
/** Push one observation; returns the indicator value (NaN during warmup). */
|
||||
public double update(double open, double high, double low, double close, double volume, long timestamp) {
|
||||
try {
|
||||
return (double) NativeMethods.WICKRA_CCI_UPDATE.invokeExact(handle, open, high, low, close, volume, timestamp);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Vectorized update over a whole series; NaN at warmup positions. */
|
||||
public double[] batch(double[] open, double[] high, double[] low, double[] close, double[] volume, double[] timestamp) {
|
||||
int n = open.length;
|
||||
if (high.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (low.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (close.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (volume.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (timestamp.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
try (Arena a = Arena.ofConfined()) {
|
||||
MemorySegment openSeg = a.allocateFrom(JAVA_DOUBLE, open);
|
||||
MemorySegment highSeg = a.allocateFrom(JAVA_DOUBLE, high);
|
||||
MemorySegment lowSeg = a.allocateFrom(JAVA_DOUBLE, low);
|
||||
MemorySegment closeSeg = a.allocateFrom(JAVA_DOUBLE, close);
|
||||
MemorySegment volumeSeg = a.allocateFrom(JAVA_DOUBLE, volume);
|
||||
MemorySegment timestampSeg = a.allocateFrom(JAVA_DOUBLE, timestamp);
|
||||
MemorySegment outSeg = a.allocate(JAVA_DOUBLE.byteSize() * n);
|
||||
NativeMethods.WICKRA_CCI_BATCH.invokeExact(handle, openSeg, highSeg, lowSeg, closeSeg, volumeSeg, timestampSeg, outSeg, (long) n);
|
||||
double[] out = new double[n];
|
||||
MemorySegment.copy(outSeg, JAVA_DOUBLE, 0L, out, 0, n);
|
||||
return out;
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Reset to the just-constructed state. */
|
||||
public void reset() {
|
||||
try {
|
||||
NativeMethods.WICKRA_CCI_RESET.invokeExact(handle);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
@Override public void close() {
|
||||
cleanable.clean();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,69 @@
|
||||
// Generated from bindings/c/include/wickra.h. Do not edit by hand.
|
||||
package org.wickra;
|
||||
|
||||
import org.wickra.internal.NativeMethods;
|
||||
import org.wickra.internal.WickraNative;
|
||||
import java.lang.foreign.Arena;
|
||||
import java.lang.foreign.MemorySegment;
|
||||
import java.lang.ref.Cleaner;
|
||||
import static java.lang.foreign.ValueLayout.*;
|
||||
|
||||
/** Streaming CenterOfGravity indicator over the Wickra C ABI. Not thread-safe; close when done. */
|
||||
public final class CenterOfGravity implements AutoCloseable {
|
||||
private final MemorySegment handle;
|
||||
private final Cleaner.Cleanable cleanable;
|
||||
|
||||
public CenterOfGravity(int period) {
|
||||
if (period < 0) {
|
||||
throw new IllegalArgumentException("period must be non-negative");
|
||||
}
|
||||
MemorySegment h;
|
||||
try {
|
||||
h = (MemorySegment) NativeMethods.WICKRA_CENTER_OF_GRAVITY_NEW.invokeExact((long) period);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
if (h.address() == 0L) {
|
||||
throw new IllegalArgumentException("invalid CenterOfGravity parameters");
|
||||
}
|
||||
this.handle = h;
|
||||
this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_CENTER_OF_GRAVITY_FREE);
|
||||
}
|
||||
|
||||
/** Push one observation; returns the indicator value (NaN during warmup). */
|
||||
public double update(double value) {
|
||||
try {
|
||||
return (double) NativeMethods.WICKRA_CENTER_OF_GRAVITY_UPDATE.invokeExact(handle, value);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Vectorized update over a whole series; NaN at warmup positions. */
|
||||
public double[] batch(double[] input) {
|
||||
int n = input.length;
|
||||
try (Arena a = Arena.ofConfined()) {
|
||||
MemorySegment inputSeg = a.allocateFrom(JAVA_DOUBLE, input);
|
||||
MemorySegment outSeg = a.allocate(JAVA_DOUBLE.byteSize() * n);
|
||||
NativeMethods.WICKRA_CENTER_OF_GRAVITY_BATCH.invokeExact(handle, inputSeg, outSeg, (long) n);
|
||||
double[] out = new double[n];
|
||||
MemorySegment.copy(outSeg, JAVA_DOUBLE, 0L, out, 0, n);
|
||||
return out;
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Reset to the just-constructed state. */
|
||||
public void reset() {
|
||||
try {
|
||||
NativeMethods.WICKRA_CENTER_OF_GRAVITY_RESET.invokeExact(handle);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
@Override public void close() {
|
||||
cleanable.clean();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,59 @@
|
||||
// Generated from bindings/c/include/wickra.h. Do not edit by hand.
|
||||
package org.wickra;
|
||||
|
||||
import org.wickra.internal.NativeMethods;
|
||||
import org.wickra.internal.WickraNative;
|
||||
import java.lang.foreign.Arena;
|
||||
import java.lang.foreign.MemorySegment;
|
||||
import java.lang.ref.Cleaner;
|
||||
import static java.lang.foreign.ValueLayout.*;
|
||||
|
||||
/** Streaming CentralPivotRange indicator over the Wickra C ABI. Not thread-safe; close when done. */
|
||||
public final class CentralPivotRange implements AutoCloseable {
|
||||
private final MemorySegment handle;
|
||||
private final Cleaner.Cleanable cleanable;
|
||||
|
||||
public CentralPivotRange() {
|
||||
MemorySegment h;
|
||||
try {
|
||||
h = (MemorySegment) NativeMethods.WICKRA_CENTRAL_PIVOT_RANGE_NEW.invokeExact();
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
if (h.address() == 0L) {
|
||||
throw new IllegalArgumentException("invalid CentralPivotRange parameters");
|
||||
}
|
||||
this.handle = h;
|
||||
this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_CENTRAL_PIVOT_RANGE_FREE);
|
||||
}
|
||||
|
||||
/** Push one observation; returns the result, or null during warmup. */
|
||||
public CentralPivotRangeOutput update(double open, double high, double low, double close, double volume, long timestamp) {
|
||||
try (Arena a = Arena.ofConfined()) {
|
||||
MemorySegment out = a.allocate(24L);
|
||||
byte ok = (byte) NativeMethods.WICKRA_CENTRAL_PIVOT_RANGE_UPDATE.invokeExact(handle, open, high, low, close, volume, timestamp, out);
|
||||
if (ok == 0) {
|
||||
return null;
|
||||
}
|
||||
return new CentralPivotRangeOutput(
|
||||
out.get(JAVA_DOUBLE, 0L),
|
||||
out.get(JAVA_DOUBLE, 8L),
|
||||
out.get(JAVA_DOUBLE, 16L));
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Reset to the just-constructed state. */
|
||||
public void reset() {
|
||||
try {
|
||||
NativeMethods.WICKRA_CENTRAL_PIVOT_RANGE_RESET.invokeExact(handle);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
@Override public void close() {
|
||||
cleanable.clean();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,5 @@
|
||||
// Generated from bindings/c/include/wickra.h. Do not edit by hand.
|
||||
package org.wickra;
|
||||
|
||||
/** Output record produced by the matching indicator. */
|
||||
public record CentralPivotRangeOutput(double pivot, double tc, double bc) {}
|
||||
@@ -0,0 +1,69 @@
|
||||
// Generated from bindings/c/include/wickra.h. Do not edit by hand.
|
||||
package org.wickra;
|
||||
|
||||
import org.wickra.internal.NativeMethods;
|
||||
import org.wickra.internal.WickraNative;
|
||||
import java.lang.foreign.Arena;
|
||||
import java.lang.foreign.MemorySegment;
|
||||
import java.lang.ref.Cleaner;
|
||||
import static java.lang.foreign.ValueLayout.*;
|
||||
|
||||
/** Streaming Cfo indicator over the Wickra C ABI. Not thread-safe; close when done. */
|
||||
public final class Cfo implements AutoCloseable {
|
||||
private final MemorySegment handle;
|
||||
private final Cleaner.Cleanable cleanable;
|
||||
|
||||
public Cfo(int period) {
|
||||
if (period < 0) {
|
||||
throw new IllegalArgumentException("period must be non-negative");
|
||||
}
|
||||
MemorySegment h;
|
||||
try {
|
||||
h = (MemorySegment) NativeMethods.WICKRA_CFO_NEW.invokeExact((long) period);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
if (h.address() == 0L) {
|
||||
throw new IllegalArgumentException("invalid Cfo parameters");
|
||||
}
|
||||
this.handle = h;
|
||||
this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_CFO_FREE);
|
||||
}
|
||||
|
||||
/** Push one observation; returns the indicator value (NaN during warmup). */
|
||||
public double update(double value) {
|
||||
try {
|
||||
return (double) NativeMethods.WICKRA_CFO_UPDATE.invokeExact(handle, value);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Vectorized update over a whole series; NaN at warmup positions. */
|
||||
public double[] batch(double[] input) {
|
||||
int n = input.length;
|
||||
try (Arena a = Arena.ofConfined()) {
|
||||
MemorySegment inputSeg = a.allocateFrom(JAVA_DOUBLE, input);
|
||||
MemorySegment outSeg = a.allocate(JAVA_DOUBLE.byteSize() * n);
|
||||
NativeMethods.WICKRA_CFO_BATCH.invokeExact(handle, inputSeg, outSeg, (long) n);
|
||||
double[] out = new double[n];
|
||||
MemorySegment.copy(outSeg, JAVA_DOUBLE, 0L, out, 0, n);
|
||||
return out;
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Reset to the just-constructed state. */
|
||||
public void reset() {
|
||||
try {
|
||||
NativeMethods.WICKRA_CFO_RESET.invokeExact(handle);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
@Override public void close() {
|
||||
cleanable.clean();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,89 @@
|
||||
// Generated from bindings/c/include/wickra.h. Do not edit by hand.
|
||||
package org.wickra;
|
||||
|
||||
import org.wickra.internal.NativeMethods;
|
||||
import org.wickra.internal.WickraNative;
|
||||
import java.lang.foreign.Arena;
|
||||
import java.lang.foreign.MemorySegment;
|
||||
import java.lang.ref.Cleaner;
|
||||
import static java.lang.foreign.ValueLayout.*;
|
||||
|
||||
/** Streaming ChaikinMoneyFlow indicator over the Wickra C ABI. Not thread-safe; close when done. */
|
||||
public final class ChaikinMoneyFlow implements AutoCloseable {
|
||||
private final MemorySegment handle;
|
||||
private final Cleaner.Cleanable cleanable;
|
||||
|
||||
public ChaikinMoneyFlow(int period) {
|
||||
if (period < 0) {
|
||||
throw new IllegalArgumentException("period must be non-negative");
|
||||
}
|
||||
MemorySegment h;
|
||||
try {
|
||||
h = (MemorySegment) NativeMethods.WICKRA_CHAIKIN_MONEY_FLOW_NEW.invokeExact((long) period);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
if (h.address() == 0L) {
|
||||
throw new IllegalArgumentException("invalid ChaikinMoneyFlow parameters");
|
||||
}
|
||||
this.handle = h;
|
||||
this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_CHAIKIN_MONEY_FLOW_FREE);
|
||||
}
|
||||
|
||||
/** Push one observation; returns the indicator value (NaN during warmup). */
|
||||
public double update(double open, double high, double low, double close, double volume, long timestamp) {
|
||||
try {
|
||||
return (double) NativeMethods.WICKRA_CHAIKIN_MONEY_FLOW_UPDATE.invokeExact(handle, open, high, low, close, volume, timestamp);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Vectorized update over a whole series; NaN at warmup positions. */
|
||||
public double[] batch(double[] open, double[] high, double[] low, double[] close, double[] volume, double[] timestamp) {
|
||||
int n = open.length;
|
||||
if (high.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (low.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (close.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (volume.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (timestamp.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
try (Arena a = Arena.ofConfined()) {
|
||||
MemorySegment openSeg = a.allocateFrom(JAVA_DOUBLE, open);
|
||||
MemorySegment highSeg = a.allocateFrom(JAVA_DOUBLE, high);
|
||||
MemorySegment lowSeg = a.allocateFrom(JAVA_DOUBLE, low);
|
||||
MemorySegment closeSeg = a.allocateFrom(JAVA_DOUBLE, close);
|
||||
MemorySegment volumeSeg = a.allocateFrom(JAVA_DOUBLE, volume);
|
||||
MemorySegment timestampSeg = a.allocateFrom(JAVA_DOUBLE, timestamp);
|
||||
MemorySegment outSeg = a.allocate(JAVA_DOUBLE.byteSize() * n);
|
||||
NativeMethods.WICKRA_CHAIKIN_MONEY_FLOW_BATCH.invokeExact(handle, openSeg, highSeg, lowSeg, closeSeg, volumeSeg, timestampSeg, outSeg, (long) n);
|
||||
double[] out = new double[n];
|
||||
MemorySegment.copy(outSeg, JAVA_DOUBLE, 0L, out, 0, n);
|
||||
return out;
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Reset to the just-constructed state. */
|
||||
public void reset() {
|
||||
try {
|
||||
NativeMethods.WICKRA_CHAIKIN_MONEY_FLOW_RESET.invokeExact(handle);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
@Override public void close() {
|
||||
cleanable.clean();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,92 @@
|
||||
// Generated from bindings/c/include/wickra.h. Do not edit by hand.
|
||||
package org.wickra;
|
||||
|
||||
import org.wickra.internal.NativeMethods;
|
||||
import org.wickra.internal.WickraNative;
|
||||
import java.lang.foreign.Arena;
|
||||
import java.lang.foreign.MemorySegment;
|
||||
import java.lang.ref.Cleaner;
|
||||
import static java.lang.foreign.ValueLayout.*;
|
||||
|
||||
/** Streaming ChaikinOscillator indicator over the Wickra C ABI. Not thread-safe; close when done. */
|
||||
public final class ChaikinOscillator implements AutoCloseable {
|
||||
private final MemorySegment handle;
|
||||
private final Cleaner.Cleanable cleanable;
|
||||
|
||||
public ChaikinOscillator(int fast, int slow) {
|
||||
if (fast < 0) {
|
||||
throw new IllegalArgumentException("fast must be non-negative");
|
||||
}
|
||||
if (slow < 0) {
|
||||
throw new IllegalArgumentException("slow must be non-negative");
|
||||
}
|
||||
MemorySegment h;
|
||||
try {
|
||||
h = (MemorySegment) NativeMethods.WICKRA_CHAIKIN_OSCILLATOR_NEW.invokeExact((long) fast, (long) slow);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
if (h.address() == 0L) {
|
||||
throw new IllegalArgumentException("invalid ChaikinOscillator parameters");
|
||||
}
|
||||
this.handle = h;
|
||||
this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_CHAIKIN_OSCILLATOR_FREE);
|
||||
}
|
||||
|
||||
/** Push one observation; returns the indicator value (NaN during warmup). */
|
||||
public double update(double open, double high, double low, double close, double volume, long timestamp) {
|
||||
try {
|
||||
return (double) NativeMethods.WICKRA_CHAIKIN_OSCILLATOR_UPDATE.invokeExact(handle, open, high, low, close, volume, timestamp);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Vectorized update over a whole series; NaN at warmup positions. */
|
||||
public double[] batch(double[] open, double[] high, double[] low, double[] close, double[] volume, double[] timestamp) {
|
||||
int n = open.length;
|
||||
if (high.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (low.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (close.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (volume.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (timestamp.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
try (Arena a = Arena.ofConfined()) {
|
||||
MemorySegment openSeg = a.allocateFrom(JAVA_DOUBLE, open);
|
||||
MemorySegment highSeg = a.allocateFrom(JAVA_DOUBLE, high);
|
||||
MemorySegment lowSeg = a.allocateFrom(JAVA_DOUBLE, low);
|
||||
MemorySegment closeSeg = a.allocateFrom(JAVA_DOUBLE, close);
|
||||
MemorySegment volumeSeg = a.allocateFrom(JAVA_DOUBLE, volume);
|
||||
MemorySegment timestampSeg = a.allocateFrom(JAVA_DOUBLE, timestamp);
|
||||
MemorySegment outSeg = a.allocate(JAVA_DOUBLE.byteSize() * n);
|
||||
NativeMethods.WICKRA_CHAIKIN_OSCILLATOR_BATCH.invokeExact(handle, openSeg, highSeg, lowSeg, closeSeg, volumeSeg, timestampSeg, outSeg, (long) n);
|
||||
double[] out = new double[n];
|
||||
MemorySegment.copy(outSeg, JAVA_DOUBLE, 0L, out, 0, n);
|
||||
return out;
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Reset to the just-constructed state. */
|
||||
public void reset() {
|
||||
try {
|
||||
NativeMethods.WICKRA_CHAIKIN_OSCILLATOR_RESET.invokeExact(handle);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
@Override public void close() {
|
||||
cleanable.clean();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,92 @@
|
||||
// Generated from bindings/c/include/wickra.h. Do not edit by hand.
|
||||
package org.wickra;
|
||||
|
||||
import org.wickra.internal.NativeMethods;
|
||||
import org.wickra.internal.WickraNative;
|
||||
import java.lang.foreign.Arena;
|
||||
import java.lang.foreign.MemorySegment;
|
||||
import java.lang.ref.Cleaner;
|
||||
import static java.lang.foreign.ValueLayout.*;
|
||||
|
||||
/** Streaming ChaikinVolatility indicator over the Wickra C ABI. Not thread-safe; close when done. */
|
||||
public final class ChaikinVolatility implements AutoCloseable {
|
||||
private final MemorySegment handle;
|
||||
private final Cleaner.Cleanable cleanable;
|
||||
|
||||
public ChaikinVolatility(int emaPeriod, int rocPeriod) {
|
||||
if (emaPeriod < 0) {
|
||||
throw new IllegalArgumentException("emaPeriod must be non-negative");
|
||||
}
|
||||
if (rocPeriod < 0) {
|
||||
throw new IllegalArgumentException("rocPeriod must be non-negative");
|
||||
}
|
||||
MemorySegment h;
|
||||
try {
|
||||
h = (MemorySegment) NativeMethods.WICKRA_CHAIKIN_VOLATILITY_NEW.invokeExact((long) emaPeriod, (long) rocPeriod);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
if (h.address() == 0L) {
|
||||
throw new IllegalArgumentException("invalid ChaikinVolatility parameters");
|
||||
}
|
||||
this.handle = h;
|
||||
this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_CHAIKIN_VOLATILITY_FREE);
|
||||
}
|
||||
|
||||
/** Push one observation; returns the indicator value (NaN during warmup). */
|
||||
public double update(double open, double high, double low, double close, double volume, long timestamp) {
|
||||
try {
|
||||
return (double) NativeMethods.WICKRA_CHAIKIN_VOLATILITY_UPDATE.invokeExact(handle, open, high, low, close, volume, timestamp);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Vectorized update over a whole series; NaN at warmup positions. */
|
||||
public double[] batch(double[] open, double[] high, double[] low, double[] close, double[] volume, double[] timestamp) {
|
||||
int n = open.length;
|
||||
if (high.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (low.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (close.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (volume.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (timestamp.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
try (Arena a = Arena.ofConfined()) {
|
||||
MemorySegment openSeg = a.allocateFrom(JAVA_DOUBLE, open);
|
||||
MemorySegment highSeg = a.allocateFrom(JAVA_DOUBLE, high);
|
||||
MemorySegment lowSeg = a.allocateFrom(JAVA_DOUBLE, low);
|
||||
MemorySegment closeSeg = a.allocateFrom(JAVA_DOUBLE, close);
|
||||
MemorySegment volumeSeg = a.allocateFrom(JAVA_DOUBLE, volume);
|
||||
MemorySegment timestampSeg = a.allocateFrom(JAVA_DOUBLE, timestamp);
|
||||
MemorySegment outSeg = a.allocate(JAVA_DOUBLE.byteSize() * n);
|
||||
NativeMethods.WICKRA_CHAIKIN_VOLATILITY_BATCH.invokeExact(handle, openSeg, highSeg, lowSeg, closeSeg, volumeSeg, timestampSeg, outSeg, (long) n);
|
||||
double[] out = new double[n];
|
||||
MemorySegment.copy(outSeg, JAVA_DOUBLE, 0L, out, 0, n);
|
||||
return out;
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Reset to the just-constructed state. */
|
||||
public void reset() {
|
||||
try {
|
||||
NativeMethods.WICKRA_CHAIKIN_VOLATILITY_RESET.invokeExact(handle);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
@Override public void close() {
|
||||
cleanable.clean();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,64 @@
|
||||
// Generated from bindings/c/include/wickra.h. Do not edit by hand.
|
||||
package org.wickra;
|
||||
|
||||
import org.wickra.internal.NativeMethods;
|
||||
import org.wickra.internal.WickraNative;
|
||||
import java.lang.foreign.Arena;
|
||||
import java.lang.foreign.MemorySegment;
|
||||
import java.lang.ref.Cleaner;
|
||||
import static java.lang.foreign.ValueLayout.*;
|
||||
|
||||
/** Streaming ChandeKrollStop indicator over the Wickra C ABI. Not thread-safe; close when done. */
|
||||
public final class ChandeKrollStop implements AutoCloseable {
|
||||
private final MemorySegment handle;
|
||||
private final Cleaner.Cleanable cleanable;
|
||||
|
||||
public ChandeKrollStop(int atrPeriod, double atrMultiplier, int stopPeriod) {
|
||||
if (atrPeriod < 0) {
|
||||
throw new IllegalArgumentException("atrPeriod must be non-negative");
|
||||
}
|
||||
if (stopPeriod < 0) {
|
||||
throw new IllegalArgumentException("stopPeriod must be non-negative");
|
||||
}
|
||||
MemorySegment h;
|
||||
try {
|
||||
h = (MemorySegment) NativeMethods.WICKRA_CHANDE_KROLL_STOP_NEW.invokeExact((long) atrPeriod, atrMultiplier, (long) stopPeriod);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
if (h.address() == 0L) {
|
||||
throw new IllegalArgumentException("invalid ChandeKrollStop parameters");
|
||||
}
|
||||
this.handle = h;
|
||||
this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_CHANDE_KROLL_STOP_FREE);
|
||||
}
|
||||
|
||||
/** Push one observation; returns the result, or null during warmup. */
|
||||
public ChandeKrollStopOutput update(double open, double high, double low, double close, double volume, long timestamp) {
|
||||
try (Arena a = Arena.ofConfined()) {
|
||||
MemorySegment out = a.allocate(16L);
|
||||
byte ok = (byte) NativeMethods.WICKRA_CHANDE_KROLL_STOP_UPDATE.invokeExact(handle, open, high, low, close, volume, timestamp, out);
|
||||
if (ok == 0) {
|
||||
return null;
|
||||
}
|
||||
return new ChandeKrollStopOutput(
|
||||
out.get(JAVA_DOUBLE, 0L),
|
||||
out.get(JAVA_DOUBLE, 8L));
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Reset to the just-constructed state. */
|
||||
public void reset() {
|
||||
try {
|
||||
NativeMethods.WICKRA_CHANDE_KROLL_STOP_RESET.invokeExact(handle);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
@Override public void close() {
|
||||
cleanable.clean();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,5 @@
|
||||
// Generated from bindings/c/include/wickra.h. Do not edit by hand.
|
||||
package org.wickra;
|
||||
|
||||
/** Output record produced by the matching indicator. */
|
||||
public record ChandeKrollStopOutput(double stopLong, double stopShort) {}
|
||||
@@ -0,0 +1,61 @@
|
||||
// Generated from bindings/c/include/wickra.h. Do not edit by hand.
|
||||
package org.wickra;
|
||||
|
||||
import org.wickra.internal.NativeMethods;
|
||||
import org.wickra.internal.WickraNative;
|
||||
import java.lang.foreign.Arena;
|
||||
import java.lang.foreign.MemorySegment;
|
||||
import java.lang.ref.Cleaner;
|
||||
import static java.lang.foreign.ValueLayout.*;
|
||||
|
||||
/** Streaming ChandelierExit indicator over the Wickra C ABI. Not thread-safe; close when done. */
|
||||
public final class ChandelierExit implements AutoCloseable {
|
||||
private final MemorySegment handle;
|
||||
private final Cleaner.Cleanable cleanable;
|
||||
|
||||
public ChandelierExit(int period, double multiplier) {
|
||||
if (period < 0) {
|
||||
throw new IllegalArgumentException("period must be non-negative");
|
||||
}
|
||||
MemorySegment h;
|
||||
try {
|
||||
h = (MemorySegment) NativeMethods.WICKRA_CHANDELIER_EXIT_NEW.invokeExact((long) period, multiplier);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
if (h.address() == 0L) {
|
||||
throw new IllegalArgumentException("invalid ChandelierExit parameters");
|
||||
}
|
||||
this.handle = h;
|
||||
this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_CHANDELIER_EXIT_FREE);
|
||||
}
|
||||
|
||||
/** Push one observation; returns the result, or null during warmup. */
|
||||
public ChandelierExitOutput update(double open, double high, double low, double close, double volume, long timestamp) {
|
||||
try (Arena a = Arena.ofConfined()) {
|
||||
MemorySegment out = a.allocate(16L);
|
||||
byte ok = (byte) NativeMethods.WICKRA_CHANDELIER_EXIT_UPDATE.invokeExact(handle, open, high, low, close, volume, timestamp, out);
|
||||
if (ok == 0) {
|
||||
return null;
|
||||
}
|
||||
return new ChandelierExitOutput(
|
||||
out.get(JAVA_DOUBLE, 0L),
|
||||
out.get(JAVA_DOUBLE, 8L));
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Reset to the just-constructed state. */
|
||||
public void reset() {
|
||||
try {
|
||||
NativeMethods.WICKRA_CHANDELIER_EXIT_RESET.invokeExact(handle);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
@Override public void close() {
|
||||
cleanable.clean();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,5 @@
|
||||
// Generated from bindings/c/include/wickra.h. Do not edit by hand.
|
||||
package org.wickra;
|
||||
|
||||
/** Output record produced by the matching indicator. */
|
||||
public record ChandelierExitOutput(double longStop, double shortStop) {}
|
||||
@@ -0,0 +1,89 @@
|
||||
// Generated from bindings/c/include/wickra.h. Do not edit by hand.
|
||||
package org.wickra;
|
||||
|
||||
import org.wickra.internal.NativeMethods;
|
||||
import org.wickra.internal.WickraNative;
|
||||
import java.lang.foreign.Arena;
|
||||
import java.lang.foreign.MemorySegment;
|
||||
import java.lang.ref.Cleaner;
|
||||
import static java.lang.foreign.ValueLayout.*;
|
||||
|
||||
/** Streaming ChoppinessIndex indicator over the Wickra C ABI. Not thread-safe; close when done. */
|
||||
public final class ChoppinessIndex implements AutoCloseable {
|
||||
private final MemorySegment handle;
|
||||
private final Cleaner.Cleanable cleanable;
|
||||
|
||||
public ChoppinessIndex(int period) {
|
||||
if (period < 0) {
|
||||
throw new IllegalArgumentException("period must be non-negative");
|
||||
}
|
||||
MemorySegment h;
|
||||
try {
|
||||
h = (MemorySegment) NativeMethods.WICKRA_CHOPPINESS_INDEX_NEW.invokeExact((long) period);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
if (h.address() == 0L) {
|
||||
throw new IllegalArgumentException("invalid ChoppinessIndex parameters");
|
||||
}
|
||||
this.handle = h;
|
||||
this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_CHOPPINESS_INDEX_FREE);
|
||||
}
|
||||
|
||||
/** Push one observation; returns the indicator value (NaN during warmup). */
|
||||
public double update(double open, double high, double low, double close, double volume, long timestamp) {
|
||||
try {
|
||||
return (double) NativeMethods.WICKRA_CHOPPINESS_INDEX_UPDATE.invokeExact(handle, open, high, low, close, volume, timestamp);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Vectorized update over a whole series; NaN at warmup positions. */
|
||||
public double[] batch(double[] open, double[] high, double[] low, double[] close, double[] volume, double[] timestamp) {
|
||||
int n = open.length;
|
||||
if (high.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (low.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (close.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (volume.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (timestamp.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
try (Arena a = Arena.ofConfined()) {
|
||||
MemorySegment openSeg = a.allocateFrom(JAVA_DOUBLE, open);
|
||||
MemorySegment highSeg = a.allocateFrom(JAVA_DOUBLE, high);
|
||||
MemorySegment lowSeg = a.allocateFrom(JAVA_DOUBLE, low);
|
||||
MemorySegment closeSeg = a.allocateFrom(JAVA_DOUBLE, close);
|
||||
MemorySegment volumeSeg = a.allocateFrom(JAVA_DOUBLE, volume);
|
||||
MemorySegment timestampSeg = a.allocateFrom(JAVA_DOUBLE, timestamp);
|
||||
MemorySegment outSeg = a.allocate(JAVA_DOUBLE.byteSize() * n);
|
||||
NativeMethods.WICKRA_CHOPPINESS_INDEX_BATCH.invokeExact(handle, openSeg, highSeg, lowSeg, closeSeg, volumeSeg, timestampSeg, outSeg, (long) n);
|
||||
double[] out = new double[n];
|
||||
MemorySegment.copy(outSeg, JAVA_DOUBLE, 0L, out, 0, n);
|
||||
return out;
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Reset to the just-constructed state. */
|
||||
public void reset() {
|
||||
try {
|
||||
NativeMethods.WICKRA_CHOPPINESS_INDEX_RESET.invokeExact(handle);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
@Override public void close() {
|
||||
cleanable.clean();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,63 @@
|
||||
// Generated from bindings/c/include/wickra.h. Do not edit by hand.
|
||||
package org.wickra;
|
||||
|
||||
import org.wickra.internal.NativeMethods;
|
||||
import org.wickra.internal.WickraNative;
|
||||
import java.lang.foreign.Arena;
|
||||
import java.lang.foreign.MemorySegment;
|
||||
import java.lang.ref.Cleaner;
|
||||
import static java.lang.foreign.ValueLayout.*;
|
||||
|
||||
/** Streaming ClassicPivots indicator over the Wickra C ABI. Not thread-safe; close when done. */
|
||||
public final class ClassicPivots implements AutoCloseable {
|
||||
private final MemorySegment handle;
|
||||
private final Cleaner.Cleanable cleanable;
|
||||
|
||||
public ClassicPivots() {
|
||||
MemorySegment h;
|
||||
try {
|
||||
h = (MemorySegment) NativeMethods.WICKRA_CLASSIC_PIVOTS_NEW.invokeExact();
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
if (h.address() == 0L) {
|
||||
throw new IllegalArgumentException("invalid ClassicPivots parameters");
|
||||
}
|
||||
this.handle = h;
|
||||
this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_CLASSIC_PIVOTS_FREE);
|
||||
}
|
||||
|
||||
/** Push one observation; returns the result, or null during warmup. */
|
||||
public ClassicPivotsOutput update(double open, double high, double low, double close, double volume, long timestamp) {
|
||||
try (Arena a = Arena.ofConfined()) {
|
||||
MemorySegment out = a.allocate(56L);
|
||||
byte ok = (byte) NativeMethods.WICKRA_CLASSIC_PIVOTS_UPDATE.invokeExact(handle, open, high, low, close, volume, timestamp, out);
|
||||
if (ok == 0) {
|
||||
return null;
|
||||
}
|
||||
return new ClassicPivotsOutput(
|
||||
out.get(JAVA_DOUBLE, 0L),
|
||||
out.get(JAVA_DOUBLE, 8L),
|
||||
out.get(JAVA_DOUBLE, 16L),
|
||||
out.get(JAVA_DOUBLE, 24L),
|
||||
out.get(JAVA_DOUBLE, 32L),
|
||||
out.get(JAVA_DOUBLE, 40L),
|
||||
out.get(JAVA_DOUBLE, 48L));
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Reset to the just-constructed state. */
|
||||
public void reset() {
|
||||
try {
|
||||
NativeMethods.WICKRA_CLASSIC_PIVOTS_RESET.invokeExact(handle);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
@Override public void close() {
|
||||
cleanable.clean();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,5 @@
|
||||
// Generated from bindings/c/include/wickra.h. Do not edit by hand.
|
||||
package org.wickra;
|
||||
|
||||
/** Output record produced by the matching indicator. */
|
||||
public record ClassicPivotsOutput(double pp, double r1, double r2, double r3, double s1, double s2, double s3) {}
|
||||
@@ -0,0 +1,86 @@
|
||||
// Generated from bindings/c/include/wickra.h. Do not edit by hand.
|
||||
package org.wickra;
|
||||
|
||||
import org.wickra.internal.NativeMethods;
|
||||
import org.wickra.internal.WickraNative;
|
||||
import java.lang.foreign.Arena;
|
||||
import java.lang.foreign.MemorySegment;
|
||||
import java.lang.ref.Cleaner;
|
||||
import static java.lang.foreign.ValueLayout.*;
|
||||
|
||||
/** Streaming CloseVsOpen indicator over the Wickra C ABI. Not thread-safe; close when done. */
|
||||
public final class CloseVsOpen implements AutoCloseable {
|
||||
private final MemorySegment handle;
|
||||
private final Cleaner.Cleanable cleanable;
|
||||
|
||||
public CloseVsOpen() {
|
||||
MemorySegment h;
|
||||
try {
|
||||
h = (MemorySegment) NativeMethods.WICKRA_CLOSE_VS_OPEN_NEW.invokeExact();
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
if (h.address() == 0L) {
|
||||
throw new IllegalArgumentException("invalid CloseVsOpen parameters");
|
||||
}
|
||||
this.handle = h;
|
||||
this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_CLOSE_VS_OPEN_FREE);
|
||||
}
|
||||
|
||||
/** Push one observation; returns the indicator value (NaN during warmup). */
|
||||
public double update(double open, double high, double low, double close, double volume, long timestamp) {
|
||||
try {
|
||||
return (double) NativeMethods.WICKRA_CLOSE_VS_OPEN_UPDATE.invokeExact(handle, open, high, low, close, volume, timestamp);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Vectorized update over a whole series; NaN at warmup positions. */
|
||||
public double[] batch(double[] open, double[] high, double[] low, double[] close, double[] volume, double[] timestamp) {
|
||||
int n = open.length;
|
||||
if (high.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (low.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (close.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (volume.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (timestamp.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
try (Arena a = Arena.ofConfined()) {
|
||||
MemorySegment openSeg = a.allocateFrom(JAVA_DOUBLE, open);
|
||||
MemorySegment highSeg = a.allocateFrom(JAVA_DOUBLE, high);
|
||||
MemorySegment lowSeg = a.allocateFrom(JAVA_DOUBLE, low);
|
||||
MemorySegment closeSeg = a.allocateFrom(JAVA_DOUBLE, close);
|
||||
MemorySegment volumeSeg = a.allocateFrom(JAVA_DOUBLE, volume);
|
||||
MemorySegment timestampSeg = a.allocateFrom(JAVA_DOUBLE, timestamp);
|
||||
MemorySegment outSeg = a.allocate(JAVA_DOUBLE.byteSize() * n);
|
||||
NativeMethods.WICKRA_CLOSE_VS_OPEN_BATCH.invokeExact(handle, openSeg, highSeg, lowSeg, closeSeg, volumeSeg, timestampSeg, outSeg, (long) n);
|
||||
double[] out = new double[n];
|
||||
MemorySegment.copy(outSeg, JAVA_DOUBLE, 0L, out, 0, n);
|
||||
return out;
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Reset to the just-constructed state. */
|
||||
public void reset() {
|
||||
try {
|
||||
NativeMethods.WICKRA_CLOSE_VS_OPEN_RESET.invokeExact(handle);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
@Override public void close() {
|
||||
cleanable.clean();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,86 @@
|
||||
// Generated from bindings/c/include/wickra.h. Do not edit by hand.
|
||||
package org.wickra;
|
||||
|
||||
import org.wickra.internal.NativeMethods;
|
||||
import org.wickra.internal.WickraNative;
|
||||
import java.lang.foreign.Arena;
|
||||
import java.lang.foreign.MemorySegment;
|
||||
import java.lang.ref.Cleaner;
|
||||
import static java.lang.foreign.ValueLayout.*;
|
||||
|
||||
/** Streaming ClosingMarubozu indicator over the Wickra C ABI. Not thread-safe; close when done. */
|
||||
public final class ClosingMarubozu implements AutoCloseable {
|
||||
private final MemorySegment handle;
|
||||
private final Cleaner.Cleanable cleanable;
|
||||
|
||||
public ClosingMarubozu() {
|
||||
MemorySegment h;
|
||||
try {
|
||||
h = (MemorySegment) NativeMethods.WICKRA_CLOSING_MARUBOZU_NEW.invokeExact();
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
if (h.address() == 0L) {
|
||||
throw new IllegalArgumentException("invalid ClosingMarubozu parameters");
|
||||
}
|
||||
this.handle = h;
|
||||
this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_CLOSING_MARUBOZU_FREE);
|
||||
}
|
||||
|
||||
/** Push one observation; returns the indicator value (NaN during warmup). */
|
||||
public double update(double open, double high, double low, double close, double volume, long timestamp) {
|
||||
try {
|
||||
return (double) NativeMethods.WICKRA_CLOSING_MARUBOZU_UPDATE.invokeExact(handle, open, high, low, close, volume, timestamp);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Vectorized update over a whole series; NaN at warmup positions. */
|
||||
public double[] batch(double[] open, double[] high, double[] low, double[] close, double[] volume, double[] timestamp) {
|
||||
int n = open.length;
|
||||
if (high.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (low.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (close.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (volume.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (timestamp.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
try (Arena a = Arena.ofConfined()) {
|
||||
MemorySegment openSeg = a.allocateFrom(JAVA_DOUBLE, open);
|
||||
MemorySegment highSeg = a.allocateFrom(JAVA_DOUBLE, high);
|
||||
MemorySegment lowSeg = a.allocateFrom(JAVA_DOUBLE, low);
|
||||
MemorySegment closeSeg = a.allocateFrom(JAVA_DOUBLE, close);
|
||||
MemorySegment volumeSeg = a.allocateFrom(JAVA_DOUBLE, volume);
|
||||
MemorySegment timestampSeg = a.allocateFrom(JAVA_DOUBLE, timestamp);
|
||||
MemorySegment outSeg = a.allocate(JAVA_DOUBLE.byteSize() * n);
|
||||
NativeMethods.WICKRA_CLOSING_MARUBOZU_BATCH.invokeExact(handle, openSeg, highSeg, lowSeg, closeSeg, volumeSeg, timestampSeg, outSeg, (long) n);
|
||||
double[] out = new double[n];
|
||||
MemorySegment.copy(outSeg, JAVA_DOUBLE, 0L, out, 0, n);
|
||||
return out;
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Reset to the just-constructed state. */
|
||||
public void reset() {
|
||||
try {
|
||||
NativeMethods.WICKRA_CLOSING_MARUBOZU_RESET.invokeExact(handle);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
@Override public void close() {
|
||||
cleanable.clean();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,69 @@
|
||||
// Generated from bindings/c/include/wickra.h. Do not edit by hand.
|
||||
package org.wickra;
|
||||
|
||||
import org.wickra.internal.NativeMethods;
|
||||
import org.wickra.internal.WickraNative;
|
||||
import java.lang.foreign.Arena;
|
||||
import java.lang.foreign.MemorySegment;
|
||||
import java.lang.ref.Cleaner;
|
||||
import static java.lang.foreign.ValueLayout.*;
|
||||
|
||||
/** Streaming Cmo indicator over the Wickra C ABI. Not thread-safe; close when done. */
|
||||
public final class Cmo implements AutoCloseable {
|
||||
private final MemorySegment handle;
|
||||
private final Cleaner.Cleanable cleanable;
|
||||
|
||||
public Cmo(int period) {
|
||||
if (period < 0) {
|
||||
throw new IllegalArgumentException("period must be non-negative");
|
||||
}
|
||||
MemorySegment h;
|
||||
try {
|
||||
h = (MemorySegment) NativeMethods.WICKRA_CMO_NEW.invokeExact((long) period);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
if (h.address() == 0L) {
|
||||
throw new IllegalArgumentException("invalid Cmo parameters");
|
||||
}
|
||||
this.handle = h;
|
||||
this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_CMO_FREE);
|
||||
}
|
||||
|
||||
/** Push one observation; returns the indicator value (NaN during warmup). */
|
||||
public double update(double value) {
|
||||
try {
|
||||
return (double) NativeMethods.WICKRA_CMO_UPDATE.invokeExact(handle, value);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Vectorized update over a whole series; NaN at warmup positions. */
|
||||
public double[] batch(double[] input) {
|
||||
int n = input.length;
|
||||
try (Arena a = Arena.ofConfined()) {
|
||||
MemorySegment inputSeg = a.allocateFrom(JAVA_DOUBLE, input);
|
||||
MemorySegment outSeg = a.allocate(JAVA_DOUBLE.byteSize() * n);
|
||||
NativeMethods.WICKRA_CMO_BATCH.invokeExact(handle, inputSeg, outSeg, (long) n);
|
||||
double[] out = new double[n];
|
||||
MemorySegment.copy(outSeg, JAVA_DOUBLE, 0L, out, 0, n);
|
||||
return out;
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Reset to the just-constructed state. */
|
||||
public void reset() {
|
||||
try {
|
||||
NativeMethods.WICKRA_CMO_RESET.invokeExact(handle);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
@Override public void close() {
|
||||
cleanable.clean();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,69 @@
|
||||
// Generated from bindings/c/include/wickra.h. Do not edit by hand.
|
||||
package org.wickra;
|
||||
|
||||
import org.wickra.internal.NativeMethods;
|
||||
import org.wickra.internal.WickraNative;
|
||||
import java.lang.foreign.Arena;
|
||||
import java.lang.foreign.MemorySegment;
|
||||
import java.lang.ref.Cleaner;
|
||||
import static java.lang.foreign.ValueLayout.*;
|
||||
|
||||
/** Streaming CoefficientOfVariation indicator over the Wickra C ABI. Not thread-safe; close when done. */
|
||||
public final class CoefficientOfVariation implements AutoCloseable {
|
||||
private final MemorySegment handle;
|
||||
private final Cleaner.Cleanable cleanable;
|
||||
|
||||
public CoefficientOfVariation(int period) {
|
||||
if (period < 0) {
|
||||
throw new IllegalArgumentException("period must be non-negative");
|
||||
}
|
||||
MemorySegment h;
|
||||
try {
|
||||
h = (MemorySegment) NativeMethods.WICKRA_COEFFICIENT_OF_VARIATION_NEW.invokeExact((long) period);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
if (h.address() == 0L) {
|
||||
throw new IllegalArgumentException("invalid CoefficientOfVariation parameters");
|
||||
}
|
||||
this.handle = h;
|
||||
this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_COEFFICIENT_OF_VARIATION_FREE);
|
||||
}
|
||||
|
||||
/** Push one observation; returns the indicator value (NaN during warmup). */
|
||||
public double update(double value) {
|
||||
try {
|
||||
return (double) NativeMethods.WICKRA_COEFFICIENT_OF_VARIATION_UPDATE.invokeExact(handle, value);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Vectorized update over a whole series; NaN at warmup positions. */
|
||||
public double[] batch(double[] input) {
|
||||
int n = input.length;
|
||||
try (Arena a = Arena.ofConfined()) {
|
||||
MemorySegment inputSeg = a.allocateFrom(JAVA_DOUBLE, input);
|
||||
MemorySegment outSeg = a.allocate(JAVA_DOUBLE.byteSize() * n);
|
||||
NativeMethods.WICKRA_COEFFICIENT_OF_VARIATION_BATCH.invokeExact(handle, inputSeg, outSeg, (long) n);
|
||||
double[] out = new double[n];
|
||||
MemorySegment.copy(outSeg, JAVA_DOUBLE, 0L, out, 0, n);
|
||||
return out;
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Reset to the just-constructed state. */
|
||||
public void reset() {
|
||||
try {
|
||||
NativeMethods.WICKRA_COEFFICIENT_OF_VARIATION_RESET.invokeExact(handle);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
@Override public void close() {
|
||||
cleanable.clean();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,65 @@
|
||||
// Generated from bindings/c/include/wickra.h. Do not edit by hand.
|
||||
package org.wickra;
|
||||
|
||||
import org.wickra.internal.NativeMethods;
|
||||
import org.wickra.internal.WickraNative;
|
||||
import java.lang.foreign.Arena;
|
||||
import java.lang.foreign.MemorySegment;
|
||||
import java.lang.ref.Cleaner;
|
||||
import static java.lang.foreign.ValueLayout.*;
|
||||
|
||||
/** Streaming Cointegration indicator over the Wickra C ABI. Not thread-safe; close when done. */
|
||||
public final class Cointegration implements AutoCloseable {
|
||||
private final MemorySegment handle;
|
||||
private final Cleaner.Cleanable cleanable;
|
||||
|
||||
public Cointegration(int period, int adfLags) {
|
||||
if (period < 0) {
|
||||
throw new IllegalArgumentException("period must be non-negative");
|
||||
}
|
||||
if (adfLags < 0) {
|
||||
throw new IllegalArgumentException("adfLags must be non-negative");
|
||||
}
|
||||
MemorySegment h;
|
||||
try {
|
||||
h = (MemorySegment) NativeMethods.WICKRA_COINTEGRATION_NEW.invokeExact((long) period, (long) adfLags);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
if (h.address() == 0L) {
|
||||
throw new IllegalArgumentException("invalid Cointegration parameters");
|
||||
}
|
||||
this.handle = h;
|
||||
this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_COINTEGRATION_FREE);
|
||||
}
|
||||
|
||||
/** Push one observation; returns the result, or null during warmup. */
|
||||
public CointegrationOutput update(double x, double y) {
|
||||
try (Arena a = Arena.ofConfined()) {
|
||||
MemorySegment out = a.allocate(24L);
|
||||
byte ok = (byte) NativeMethods.WICKRA_COINTEGRATION_UPDATE.invokeExact(handle, x, y, out);
|
||||
if (ok == 0) {
|
||||
return null;
|
||||
}
|
||||
return new CointegrationOutput(
|
||||
out.get(JAVA_DOUBLE, 0L),
|
||||
out.get(JAVA_DOUBLE, 8L),
|
||||
out.get(JAVA_DOUBLE, 16L));
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Reset to the just-constructed state. */
|
||||
public void reset() {
|
||||
try {
|
||||
NativeMethods.WICKRA_COINTEGRATION_RESET.invokeExact(handle);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
@Override public void close() {
|
||||
cleanable.clean();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,5 @@
|
||||
// Generated from bindings/c/include/wickra.h. Do not edit by hand.
|
||||
package org.wickra;
|
||||
|
||||
/** Output record produced by the matching indicator. */
|
||||
public record CointegrationOutput(double hedgeRatio, double spread, double adfStat) {}
|
||||
@@ -0,0 +1,69 @@
|
||||
// Generated from bindings/c/include/wickra.h. Do not edit by hand.
|
||||
package org.wickra;
|
||||
|
||||
import org.wickra.internal.NativeMethods;
|
||||
import org.wickra.internal.WickraNative;
|
||||
import java.lang.foreign.Arena;
|
||||
import java.lang.foreign.MemorySegment;
|
||||
import java.lang.ref.Cleaner;
|
||||
import static java.lang.foreign.ValueLayout.*;
|
||||
|
||||
/** Streaming CommonSenseRatio indicator over the Wickra C ABI. Not thread-safe; close when done. */
|
||||
public final class CommonSenseRatio implements AutoCloseable {
|
||||
private final MemorySegment handle;
|
||||
private final Cleaner.Cleanable cleanable;
|
||||
|
||||
public CommonSenseRatio(int period) {
|
||||
if (period < 0) {
|
||||
throw new IllegalArgumentException("period must be non-negative");
|
||||
}
|
||||
MemorySegment h;
|
||||
try {
|
||||
h = (MemorySegment) NativeMethods.WICKRA_COMMON_SENSE_RATIO_NEW.invokeExact((long) period);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
if (h.address() == 0L) {
|
||||
throw new IllegalArgumentException("invalid CommonSenseRatio parameters");
|
||||
}
|
||||
this.handle = h;
|
||||
this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_COMMON_SENSE_RATIO_FREE);
|
||||
}
|
||||
|
||||
/** Push one observation; returns the indicator value (NaN during warmup). */
|
||||
public double update(double value) {
|
||||
try {
|
||||
return (double) NativeMethods.WICKRA_COMMON_SENSE_RATIO_UPDATE.invokeExact(handle, value);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Vectorized update over a whole series; NaN at warmup positions. */
|
||||
public double[] batch(double[] input) {
|
||||
int n = input.length;
|
||||
try (Arena a = Arena.ofConfined()) {
|
||||
MemorySegment inputSeg = a.allocateFrom(JAVA_DOUBLE, input);
|
||||
MemorySegment outSeg = a.allocate(JAVA_DOUBLE.byteSize() * n);
|
||||
NativeMethods.WICKRA_COMMON_SENSE_RATIO_BATCH.invokeExact(handle, inputSeg, outSeg, (long) n);
|
||||
double[] out = new double[n];
|
||||
MemorySegment.copy(outSeg, JAVA_DOUBLE, 0L, out, 0, n);
|
||||
return out;
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Reset to the just-constructed state. */
|
||||
public void reset() {
|
||||
try {
|
||||
NativeMethods.WICKRA_COMMON_SENSE_RATIO_RESET.invokeExact(handle);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
@Override public void close() {
|
||||
cleanable.clean();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,65 @@
|
||||
// Generated from bindings/c/include/wickra.h. Do not edit by hand.
|
||||
package org.wickra;
|
||||
|
||||
import org.wickra.internal.NativeMethods;
|
||||
import org.wickra.internal.WickraNative;
|
||||
import java.lang.foreign.Arena;
|
||||
import java.lang.foreign.MemorySegment;
|
||||
import java.lang.ref.Cleaner;
|
||||
import static java.lang.foreign.ValueLayout.*;
|
||||
|
||||
/** Streaming CompositeProfile indicator over the Wickra C ABI. Not thread-safe; close when done. */
|
||||
public final class CompositeProfile implements AutoCloseable {
|
||||
private final MemorySegment handle;
|
||||
private final Cleaner.Cleanable cleanable;
|
||||
|
||||
public CompositeProfile(int period, int bins, double valueAreaPct) {
|
||||
if (period < 0) {
|
||||
throw new IllegalArgumentException("period must be non-negative");
|
||||
}
|
||||
if (bins < 0) {
|
||||
throw new IllegalArgumentException("bins must be non-negative");
|
||||
}
|
||||
MemorySegment h;
|
||||
try {
|
||||
h = (MemorySegment) NativeMethods.WICKRA_COMPOSITE_PROFILE_NEW.invokeExact((long) period, (long) bins, valueAreaPct);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
if (h.address() == 0L) {
|
||||
throw new IllegalArgumentException("invalid CompositeProfile parameters");
|
||||
}
|
||||
this.handle = h;
|
||||
this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_COMPOSITE_PROFILE_FREE);
|
||||
}
|
||||
|
||||
/** Push one observation; returns the result, or null during warmup. */
|
||||
public CompositeProfileOutput update(double open, double high, double low, double close, double volume, long timestamp) {
|
||||
try (Arena a = Arena.ofConfined()) {
|
||||
MemorySegment out = a.allocate(24L);
|
||||
byte ok = (byte) NativeMethods.WICKRA_COMPOSITE_PROFILE_UPDATE.invokeExact(handle, open, high, low, close, volume, timestamp, out);
|
||||
if (ok == 0) {
|
||||
return null;
|
||||
}
|
||||
return new CompositeProfileOutput(
|
||||
out.get(JAVA_DOUBLE, 0L),
|
||||
out.get(JAVA_DOUBLE, 8L),
|
||||
out.get(JAVA_DOUBLE, 16L));
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Reset to the just-constructed state. */
|
||||
public void reset() {
|
||||
try {
|
||||
NativeMethods.WICKRA_COMPOSITE_PROFILE_RESET.invokeExact(handle);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
@Override public void close() {
|
||||
cleanable.clean();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,5 @@
|
||||
// Generated from bindings/c/include/wickra.h. Do not edit by hand.
|
||||
package org.wickra;
|
||||
|
||||
/** Output record produced by the matching indicator. */
|
||||
public record CompositeProfileOutput(double poc, double vah, double val) {}
|
||||
@@ -0,0 +1,86 @@
|
||||
// Generated from bindings/c/include/wickra.h. Do not edit by hand.
|
||||
package org.wickra;
|
||||
|
||||
import org.wickra.internal.NativeMethods;
|
||||
import org.wickra.internal.WickraNative;
|
||||
import java.lang.foreign.Arena;
|
||||
import java.lang.foreign.MemorySegment;
|
||||
import java.lang.ref.Cleaner;
|
||||
import static java.lang.foreign.ValueLayout.*;
|
||||
|
||||
/** Streaming ConcealingBabySwallow indicator over the Wickra C ABI. Not thread-safe; close when done. */
|
||||
public final class ConcealingBabySwallow implements AutoCloseable {
|
||||
private final MemorySegment handle;
|
||||
private final Cleaner.Cleanable cleanable;
|
||||
|
||||
public ConcealingBabySwallow() {
|
||||
MemorySegment h;
|
||||
try {
|
||||
h = (MemorySegment) NativeMethods.WICKRA_CONCEALING_BABY_SWALLOW_NEW.invokeExact();
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
if (h.address() == 0L) {
|
||||
throw new IllegalArgumentException("invalid ConcealingBabySwallow parameters");
|
||||
}
|
||||
this.handle = h;
|
||||
this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_CONCEALING_BABY_SWALLOW_FREE);
|
||||
}
|
||||
|
||||
/** Push one observation; returns the indicator value (NaN during warmup). */
|
||||
public double update(double open, double high, double low, double close, double volume, long timestamp) {
|
||||
try {
|
||||
return (double) NativeMethods.WICKRA_CONCEALING_BABY_SWALLOW_UPDATE.invokeExact(handle, open, high, low, close, volume, timestamp);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Vectorized update over a whole series; NaN at warmup positions. */
|
||||
public double[] batch(double[] open, double[] high, double[] low, double[] close, double[] volume, double[] timestamp) {
|
||||
int n = open.length;
|
||||
if (high.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (low.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (close.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (volume.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
if (timestamp.length != n) {
|
||||
throw new IllegalArgumentException("all input arrays must have the same length");
|
||||
}
|
||||
try (Arena a = Arena.ofConfined()) {
|
||||
MemorySegment openSeg = a.allocateFrom(JAVA_DOUBLE, open);
|
||||
MemorySegment highSeg = a.allocateFrom(JAVA_DOUBLE, high);
|
||||
MemorySegment lowSeg = a.allocateFrom(JAVA_DOUBLE, low);
|
||||
MemorySegment closeSeg = a.allocateFrom(JAVA_DOUBLE, close);
|
||||
MemorySegment volumeSeg = a.allocateFrom(JAVA_DOUBLE, volume);
|
||||
MemorySegment timestampSeg = a.allocateFrom(JAVA_DOUBLE, timestamp);
|
||||
MemorySegment outSeg = a.allocate(JAVA_DOUBLE.byteSize() * n);
|
||||
NativeMethods.WICKRA_CONCEALING_BABY_SWALLOW_BATCH.invokeExact(handle, openSeg, highSeg, lowSeg, closeSeg, volumeSeg, timestampSeg, outSeg, (long) n);
|
||||
double[] out = new double[n];
|
||||
MemorySegment.copy(outSeg, JAVA_DOUBLE, 0L, out, 0, n);
|
||||
return out;
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
/** Reset to the just-constructed state. */
|
||||
public void reset() {
|
||||
try {
|
||||
NativeMethods.WICKRA_CONCEALING_BABY_SWALLOW_RESET.invokeExact(handle);
|
||||
} catch (Throwable t) {
|
||||
throw WickraNative.rethrow(t);
|
||||
}
|
||||
}
|
||||
|
||||
@Override public void close() {
|
||||
cleanable.clean();
|
||||
}
|
||||
}
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user