New: VolatilitySqueeze, UltimateStrengthIndex, DoubleSeries.cross

Author: didalgolab

chartsy-core/src/main/java/one/chartsy/base/DoubleDataset.java

@@ -9,6 +9,7 @@
 import one.chartsy.base.dataset.AbstractIntDataset;
 import one.chartsy.base.dataset.AbstractLongDataset;
 import one.chartsy.base.dataset.ImmutableDoubleDataset;
+import one.chartsy.base.function.DoubleBiPredicate;
 
 import java.util.Objects;
 import java.util.Spliterator;
@@ -38,6 +39,34 @@ public interface DoubleDataset extends PrimitiveDataset<Double, DoubleDataset, S
 	 */
 	double get(int index);
 
+    /**
+     * Returns a dataset indicating where the series crosses over the specified value.
+     *
+     * @param value the value to check crossings against
+     * @return a {@code Dataset} of {@code Boolean} indicating crossings over the value
+     */
+    default Dataset<Boolean> crossesOver(double value) {
+        return crosses((prev, curr) -> prev <= value && curr > value);
+    }
+
+    /**
+     * Returns a dataset indicating where the series crosses under the specified value.
+     *
+     * @param value the value to check crossings against
+     * @return a {@code Dataset} of {@code Boolean} indicating crossings over the value
+     */
+    default Dataset<Boolean> crossesUnder(double value) {
+        return crosses((prev, curr) -> prev >= value && curr < value);
+    }
+
+    /**
+     * Determines the dataset's crossings based on the provided crossing condition.
+     *
+     * @param crossingCondition a {@code DoubleBiPredicate} that defines the crossing condition
+     * @return a {@code Dataset} of {@code Boolean} indicating crossings based on the condition
+     */
+    Dataset<Boolean> crosses(DoubleBiPredicate crossingCondition);
+
 	default DoubleStream stream() {
 		return StreamSupport.doubleStream(spliterator(), false);
 	}

chartsy-core/src/main/java/one/chartsy/base/SequenceAlike.java

@@ -49,6 +49,15 @@ public boolean isDescending() {
 			return this == INDEX_DESC;
 		}
 
+		public int previousIndex(SequenceAlike seq, int index) {
+            return switch (this) {
+                case INDEX_ASC -> (index > 0) ? index - 1 : -1;
+                case INDEX_DESC -> (index < seq.length() - 1) ? index + 1 : -1;
+                default ->
+						throw new UnsupportedOperationException("Operation `previousIndex` not implemented for order " + this);
+            };
+		}
+
 		public static void reverse(Object[] arr) {
 			int start = 0;
 			int end = arr.length - 1;

chartsy-core/src/main/java/one/chartsy/base/dataset/AbstractDoubleDataset.java

@@ -4,10 +4,13 @@
  */
 package one.chartsy.base.dataset;
 
+import one.chartsy.base.Dataset;
 import one.chartsy.base.DoubleDataset;
 import one.chartsy.base.SequenceAlike;
+import one.chartsy.base.function.DoubleBiPredicate;
 import one.chartsy.base.function.IndexedToDoubleFunction;
 
+import java.util.Objects;
 import java.util.PrimitiveIterator;
 import java.util.Spliterator;
 import java.util.function.Function;
@@ -42,6 +45,20 @@ public Spliterator.OfDouble spliterator() {
         return stream().spliterator();
     }
 
+    @Override
+    public Dataset<Boolean> crosses(DoubleBiPredicate crossingCondition) {
+        Objects.requireNonNull(crossingCondition);
+        return AbstractDataset.from(this, (dataset, index) -> {
+            int prevIndex = dataset.getOrder().previousIndex(dataset, index);
+            if (prevIndex == -1)
+                return false;
+
+            double prevValue = dataset.get(prevIndex);
+            double currValue = dataset.get(index);
+            return crossingCondition.test(prevValue, currValue);
+        });
+    }
+
     public static <T extends SequenceAlike>
     AbstractDoubleDataset from(T origin, IndexedToDoubleFunction<T> getter) {
         return new From<>(origin) {

chartsy-core/src/main/java/one/chartsy/base/function/DoubleBiPredicate.java

@@ -0,0 +1,26 @@
+/*
+ * Copyright 2024 Mariusz Bernacki <[email protected]>
+ * SPDX-License-Identifier: Apache-2.0
+ */
+package one.chartsy.base.function;
+
+import java.util.function.BiPredicate;
+
+/**
+ * Represents a predicate (boolean-valued function) of two {@code double}-valued arguments.
+ * This is the {@code double}-consuming primitive type specialization of {@link BiPredicate}.
+ *
+ * <p>This is a functional interface whose functional method is {@link #test(double, double)}.
+ */
+@FunctionalInterface
+public interface DoubleBiPredicate {
+
+    /**
+     * Evaluates this predicate on the given arguments.
+     *
+     * @param left the first input argument
+     * @param right the second input argument
+     * @return {@code true} if the input arguments match the predicate, otherwise {@code false}
+     */
+    boolean test(double left, double right);
+}

chartsy-core/src/main/java/one/chartsy/core/NamedPlugin.java

@@ -19,6 +19,8 @@ public String getName() {
         return name;
     }
 
+    public abstract String getLabel();
+
     public <R> R query(NamedPluginQuery<R, T> query) {
         return query.queryFrom(this);
     }

chartsy-core/src/main/java/one/chartsy/data/Series.java

@@ -40,6 +40,8 @@ default Iterator<E> iterator() {
         return chronologicalIterator(iteratorContext());
     }
 
+    Dataset<E> getData();
+
     private static ChronologicalIteratorContext iteratorContext() {
         class Holder {
             private static final ChronologicalIteratorContext INSTANCE = new ChronologicalIteratorContext(-1);

chartsy-core/src/main/java/one/chartsy/financial/ValueIndicatorSupport.java

@@ -7,6 +7,7 @@
 import one.chartsy.data.Series;
 import one.chartsy.data.packed.PackedDoubleSeries;
 import one.chartsy.time.Chronological;
+import one.chartsy.time.Timeline;
 
 import java.util.Arrays;
 import java.util.List;
@@ -29,6 +30,12 @@ PackedDoubleSeries calculate(DoubleSeries data, VI indicator) {
         return calculate(data, indicator, ValueIndicator.OfDouble::getLast);
     }
 
+    private static PackedDoubleSeries createSeries(double[] values, Timeline timeline) {
+        return (values == null)
+                ? DoubleSeries.empty(timeline)
+                : DoubleSeries.of(values, timeline);
+    }
+
     public static <V extends ValueIndicator & DoubleConsumer>
     PackedDoubleSeries calculate(DoubleSeries data, V indicator, ToDoubleFunction<V> output) {
         double[] values = null;
@@ -41,7 +48,7 @@ PackedDoubleSeries calculate(DoubleSeries data, V indicator, ToDoubleFunction<V>
             if (values != null)
                 values[index] = output.applyAsDouble(indicator);
         }
-        return DoubleSeries.of(values, data.getTimeline());
+        return createSeries(values, data.getTimeline());
     }
 
     public static <E extends Chronological, V extends ValueIndicator.OfDouble & Consumer<E>>
@@ -61,7 +68,7 @@ PackedDoubleSeries calculate(Series<E> data, V indicator, ToDoubleFunction<V> ou
             if (values != null)
                 values[index] = output.applyAsDouble(indicator);
         }
-        return (values == null) ? DoubleSeries.empty(data.getTimeline()) : DoubleSeries.of(values, data.getTimeline());
+        return createSeries(values, data.getTimeline());
     }
 
     public static <E extends Chronological, V extends ValueIndicator & Consumer<E>>

chartsy-core/src/main/java/one/chartsy/financial/indicators/UltimateSmoother.java

@@ -0,0 +1,47 @@
+/*
+ * Copyright 2024 Mariusz Bernacki <[email protected]>
+ * SPDX-License-Identifier: Apache-2.0
+ */
+package one.chartsy.financial.indicators;
+
+import lombok.Getter;
+import one.chartsy.data.structures.RingBuffer;
+
+public class UltimateSmoother {
+    private final double a1, b1, c1, c2, c3;
+    private final RingBuffer.OfDouble prices;
+    private final RingBuffer.OfDouble values;
+    @Getter
+    private double last = Double.NaN;
+
+    public UltimateSmoother(int period) {
+        this.prices = new RingBuffer.OfDouble(2);
+        this.values = new RingBuffer.OfDouble(2);
+        double sqrt2 = Math.sqrt(2);
+        this.a1 = Math.exp(-sqrt2 * Math.PI / period);
+        this.b1 = 2 * a1 * Math.cos(sqrt2 * Math.PI / period);
+        this.c2 = b1;
+        this.c3 = -a1 * a1;
+        this.c1 = (1 + c2 - c3) / 4;
+    }
+
+    public double smooth(double price) {
+        if (!values.isFull()) {
+            prices.add(price);
+            values.add(price);
+            last = price;
+            return price;
+        }
+
+        double value = (1 - c1) * price
+                + (2 * c1 - c2) * prices.get(0)
+                - (c1 + c3) * prices.get(1)
+                + c2 * values.get(0)
+                + c3 * values.get(1);
+
+        prices.add(price);
+        values.add(value);
+        last = value;
+        return value;
+    }
+}

chartsy-core/src/main/java/one/chartsy/financial/indicators/UltimateStrengthIndex.java

@@ -0,0 +1,64 @@
+/*
+ * Copyright 2024 Mariusz Bernacki <[email protected]>
+ * SPDX-License-Identifier: Apache-2.0
+ */
+package one.chartsy.financial.indicators;
+
+import one.chartsy.data.structures.DoubleWindowSummaryStatistics;
+import one.chartsy.financial.AbstractDoubleIndicator;
+
+public class UltimateStrengthIndex extends AbstractDoubleIndicator {
+    private final int length;
+    private final DoubleWindowSummaryStatistics strengthUp;
+    private final DoubleWindowSummaryStatistics strengthDown;
+    private final UltimateSmoother usuSmoother;
+    private final UltimateSmoother usdSmoother;
+    private double lastClose = Double.NaN;
+    private double last = Double.NaN;
+    private int count;
+
+    public UltimateStrengthIndex(int length) {
+        this.length = length;
+        this.strengthUp = new DoubleWindowSummaryStatistics(4);
+        this.strengthDown = new DoubleWindowSummaryStatistics(4);
+        this.usuSmoother = new UltimateSmoother(length);
+        this.usdSmoother = new UltimateSmoother(length);
+    }
+
+    @Override
+    public void accept(double close) {
+        if (!Double.isNaN(lastClose)) {
+            // Calculate strength up and down
+            double diff = close - lastClose;
+            strengthUp.add(diff > 0 ? diff : 0);
+            strengthDown.add(diff < 0 ? -diff : 0);
+
+            if (count >= 3) {
+                // Calculate 4-bar averages using DoubleWindowSummaryStatistics's capabilities
+                double suAvg = strengthUp.getAverage();
+                double sdAvg = strengthDown.getAverage();
+
+                // Apply Ultimate Smoother to the averages
+                double usu = usuSmoother.smooth(suAvg);
+                double usd = usdSmoother.smooth(sdAvg);
+
+                // Calculate USI
+                if (usu + usd != 0.0 && usu > 0.0001 && usd > 0.0001)
+                    last = (usu - usd) / (usu + usd);
+            }
+            count++;
+        }
+        lastClose = close;
+    }
+
+    @Override
+    public double getLast() {
+        return last;
+    }
+
+    @Override
+    public boolean isReady() {
+        return count >= length;
+    }
+
+}

chartsy-samples/src/main/java/one/chartsy/data/provider/file/stooq/pl/VolatilityBasedSelectionFromStooqFlatFileDataProvider.java

@@ -15,15 +15,16 @@
 
 import java.io.IOException;
 import java.nio.file.Path;
-import java.util.DoubleSummaryStatistics;
+import java.util.ArrayList;
+import java.util.Comparator;
 import java.util.List;
 import java.util.concurrent.atomic.AtomicReference;
 import java.util.stream.IntStream;
 
 public class VolatilityBasedSelectionFromStooqFlatFileDataProvider {
 
-    private static final Path PATH_TO_STOOQ_FILE = Path.of("C:/Downloads/d_pl_txt(3).zip");
-//    private static final Path PATH_TO_STOOQ_FILE = Path.of("C:/Downloads/d_us_txt(1).zip");
+    private static final Path PATH_TO_STOOQ_FILE = Path.of("C:/Downloads/d_pl_txt(20).zip");
+    //    private static final Path PATH_TO_STOOQ_FILE = Path.of("C:/Downloads/d_us_txt(1).zip");
     private static final Logger log = LogManager.getLogger(VolatilityBasedSelectionFromStooqFlatFileDataProvider.class);
 
     public static void main(String[] args) throws IOException {
@@ -34,26 +35,33 @@ public static void main(String[] args) throws IOException {
         // list all stocks contained in a file
         List<? extends SymbolIdentity> stocks = dataProvider.listSymbols(new SymbolGroup("/data/daily/pl/wse stocks"));
         int stockCount = stocks.size();
-        log.info("Found {} stock(s)".replace("(s)", stockCount==1?"":"s"), stockCount);
+        log.info("Found {} stock(s)".replace("(s)", stockCount == 1 ? "" : "s"), stockCount);
         log.info("");
 
         // list summary of each stock data series
-        int candleCount = 0;
+        List<ExtremaResult> extremaResults = new ArrayList<>();
         for (SymbolIdentity stock : stocks) {
             var resource = SymbolResource.of(stock, TimeFrame.Period.DAILY);
             var candles = dataProvider.queryForCandles(
                             DataQuery.of(resource))
                     .collectSortedList()
                     .as(CandleSeries.of(resource));
-            detectDecreasingVolatility(candles);
-            //log.info(candles);
+            extremaResults.add(detectDecreasingVolatility(candles));
         }
-        log.info("Total {} candle(s)".replace("(s)", candleCount==1?"":"s"), candleCount);
+
+        // Sort and print results by largest correlation coefficient
+        extremaResults.stream()
+                .sorted(Comparator.comparingDouble(ExtremaResult::coefficient).reversed())
+                .forEach(result -> {
+                    System.out.println(result.candleSeries().getSymbol() + ":");
+                    System.out.println("\tHighest correlation coefficient: " + result.coefficient());
+                    System.out.println("\tOffset for highest correlation coefficient: " + result.offset());
+                    System.out.println("\tBarCount for highest correlation coefficient: " + result.barCount());
+                });
     }
 
-    public static void detectDecreasingVolatility(CandleSeries candleSeries) {
-        PearsonsCorrelation pearsonsCorrelation = new PearsonsCorrelation();
-        AtomicReference<ExtremaParams> minParams = new AtomicReference<>(new ExtremaParams(0, -1, -1));
+    public static ExtremaResult detectDecreasingVolatility(CandleSeries candleSeries) {
+        AtomicReference<ExtremaParams> maxParams = new AtomicReference<>(new ExtremaParams(0, -1, -1));
 
         // Iterate from 3 to 90 for barCount
         IntStream.rangeClosed(3, 90).forEach(barCount -> {
@@ -72,18 +80,19 @@ public static void detectDecreasingVolatility(CandleSeries candleSeries) {
                     // Calculate correlation coefficient
                     double correlationCoefficient = regression.getR();
                     // Update stats if needed
-                    if (correlationCoefficient > minParams.get().coefficient()) {
-                        minParams.set(new ExtremaParams(correlationCoefficient, offset, barCount));
+                    if (correlationCoefficient > maxParams.get().coefficient()) {
+                        maxParams.set(new ExtremaParams(correlationCoefficient, offset, barCount));
                     }
                 }
             });
         });
 
-        System.out.println(candleSeries.getSymbol() + ":");
-        System.out.println("\tLowest correlation coefficient: " + minParams.get().coefficient());
-        System.out.println("\tOffset for lowest correlation coefficient: " + minParams.get().offset());
-        System.out.println("\tBarCount for lowest correlation coefficient: " + minParams.get().barCount());
+        return new ExtremaResult(candleSeries, maxParams.get().coefficient(), maxParams.get().offset(), maxParams.get().barCount());
+    }
+
+    record ExtremaParams(double coefficient, int offset, int barCount) {
     }
 
-    record ExtremaParams(double coefficient, int offset, int barCount) { }
+    record ExtremaResult(CandleSeries candleSeries, double coefficient, int offset, int barCount) {
+    }
 }