[CI] Auto commit changes from spotless

Author: elasticsearchmachine

benchmarks/src/main/java/org/elasticsearch/benchmark/exponentialhistogram/ExponentialHistogramGenerationBench.java

@@ -43,7 +43,7 @@
 @State(Scope.Thread)
 public class ExponentialHistogramGenerationBench {
 
-    @Param({ "100", "500", "1000", "5000" , "10000", "20000"})
+    @Param({ "100", "500", "1000", "5000", "10000", "20000" })
     int bucketCount;
 
     @Param({ "NORMAL", "GAUSSIAN" })

libs/exponential-histogram/src/main/java/org/elasticsearch/exponentialhistogram/ExponentialHistogram.java

@@ -30,8 +30,8 @@
  */
 public interface ExponentialHistogram {
 
-    //TODO: support min/max/sum/count storage and merging
-    //TODO: Add special positive and negative infinity buckets to allow representation of explicit bucket histograms with open boundaries
+    // TODO: support min/max/sum/count storage and merging
+    // TODO: Add special positive and negative infinity buckets to allow representation of explicit bucket histograms with open boundaries
 
     // scale of 38 is the largest scale where at the borders we don't run into problems due to floating point precision when computing
     // indices for double values

libs/exponential-histogram/src/main/java/org/elasticsearch/exponentialhistogram/ExponentialHistogramGenerator.java

@@ -73,6 +73,7 @@ public ExponentialHistogram get() {
     public static ExponentialHistogram createFor(double... values) {
         return createFor(values.length, Arrays.stream(values));
     }
+
     /**
      * Create a histogram representing the distribution of the given values with at most the given number of buckets.
      * If the given bucketCount is greater or equal to the number of values, the resulting histogram will have a

libs/exponential-histogram/src/main/java/org/elasticsearch/exponentialhistogram/ExponentialHistogramMerger.java

@@ -9,9 +9,7 @@
 
 package org.elasticsearch.exponentialhistogram;
 
-import java.util.Arrays;
 import java.util.OptionalLong;
-import java.util.stream.Stream;
 
 import static org.elasticsearch.exponentialhistogram.ExponentialScaleUtils.getMaximumScaleIncrease;
 
@@ -64,7 +62,8 @@ public ExponentialHistogram get() {
 
     // TODO: this algorithm is very efficient if b has roughly as many buckets as a
     // However, if b is much smaller we still have to iterate over all buckets of a which is very wasteful
-    // This can be optimized by buffering multiple histograms to accumulate first, then in O(log(b)) turn them into a single, merged histogram
+    // This can be optimized by buffering multiple histograms to accumulate first, then in O(log(b)) turn them into a single, merged
+    // histogram
     // (b is the number of buffered buckets)
 
     private void merge(FixedCapacityExponentialHistogram output, ExponentialHistogram a, ExponentialHistogram b) {

libs/exponential-histogram/src/main/java/org/elasticsearch/exponentialhistogram/ExponentialHistogramQuantile.java

@@ -45,8 +45,12 @@ public static double getQuantile(ExponentialHistogram histo, double quantile) {
         double upperFactor = exactRank - lowerRank;
 
         // TODO: if we want more performance here, we could iterate the buckets once instead of twice
-        return getElementAtRank(histo, lowerRank, negCount, zeroCount) * ( 1 - upperFactor)
-            +getElementAtRank(histo, upperRank, negCount, zeroCount) * upperFactor;
+        return getElementAtRank(histo, lowerRank, negCount, zeroCount) * (1 - upperFactor) + getElementAtRank(
+            histo,
+            upperRank,
+            negCount,
+            zeroCount
+        ) * upperFactor;
     }
 
     private static double getElementAtRank(ExponentialHistogram histo, long rank, long negCount, long zeroCount) {

libs/exponential-histogram/src/main/java/org/elasticsearch/exponentialhistogram/ExponentialScaleUtils.java

@@ -11,7 +11,6 @@
 
 import static org.elasticsearch.exponentialhistogram.ExponentialHistogram.MAX_INDEX;
 import static org.elasticsearch.exponentialhistogram.ExponentialHistogram.MAX_INDEX_BITS;
-import static org.elasticsearch.exponentialhistogram.ExponentialHistogram.MAX_SCALE;
 import static org.elasticsearch.exponentialhistogram.ExponentialHistogram.MIN_INDEX;
 import static org.elasticsearch.exponentialhistogram.ExponentialHistogram.MIN_SCALE;
 
@@ -30,58 +29,57 @@ public class ExponentialScaleUtils {
      * The constant is computed using the following formula:
      * <code>(1 + 2^scale * ( 1 - log2(1 + 2^(2^-scale))))</code>
      */
-   static final double[] SCALE_UP_CONSTANT_TABLE = new double[]{
-       4.8828125E-4,
-       9.765625E-4,
-       0.001953125,
-       0.00390625,
-       0.0078125,
-       0.015625,
-       0.03124999998950301,
-       0.06249862414928998,
-       0.12429693135076524,
-       0.22813428968741514,
-       0.33903595255631885,
-       0.4150374992788438,
-       0.45689339367277604,
-       0.47836619809201575,
-       0.4891729613112115,
-       0.49458521106164327,
-       0.497292446757125,
-       0.4986462035295225,
-       0.4993230992835585,
-       0.4996615493316266,
-       0.49983077462704417,
-       0.49991538730867596,
-       0.4999576936537322,
-       0.4999788468267904,
-       0.4999894234133857,
-       0.4999947117066917,
-       0.4999973558533457,
-       0.49999867792667285,
-       0.4999993389633364,
-       0.4999996694816682,
-       0.4999998347408341,
-       0.49999991737041705,
-       0.4999999586852085,
-       0.49999997934260426,
-       0.49999998967130216,
-       0.49999999483565105,
-       0.4999999974178255,
-       0.49999999870891276,
-       0.4999999993544564,
-       0.4999999996772282,
-       0.4999999998386141,
-       0.49999999991930705,
-       0.49999999995965355,
-       0.49999999997982675,
-       0.4999999999899134,
-       0.4999999999949567,
-       0.49999999999747835,
-       0.4999999999987392,
-       0.49999999999936956,
-       0.4999999999996848
-   };
+    static final double[] SCALE_UP_CONSTANT_TABLE = new double[] {
+        4.8828125E-4,
+        9.765625E-4,
+        0.001953125,
+        0.00390625,
+        0.0078125,
+        0.015625,
+        0.03124999998950301,
+        0.06249862414928998,
+        0.12429693135076524,
+        0.22813428968741514,
+        0.33903595255631885,
+        0.4150374992788438,
+        0.45689339367277604,
+        0.47836619809201575,
+        0.4891729613112115,
+        0.49458521106164327,
+        0.497292446757125,
+        0.4986462035295225,
+        0.4993230992835585,
+        0.4996615493316266,
+        0.49983077462704417,
+        0.49991538730867596,
+        0.4999576936537322,
+        0.4999788468267904,
+        0.4999894234133857,
+        0.4999947117066917,
+        0.4999973558533457,
+        0.49999867792667285,
+        0.4999993389633364,
+        0.4999996694816682,
+        0.4999998347408341,
+        0.49999991737041705,
+        0.4999999586852085,
+        0.49999997934260426,
+        0.49999998967130216,
+        0.49999999483565105,
+        0.4999999974178255,
+        0.49999999870891276,
+        0.4999999993544564,
+        0.4999999996772282,
+        0.4999999998386141,
+        0.49999999991930705,
+        0.49999999995965355,
+        0.49999999997982675,
+        0.4999999999899134,
+        0.4999999999949567,
+        0.49999999999747835,
+        0.4999999999987392,
+        0.49999999999936956,
+        0.4999999999996848 };
 
     /**
      * Computes the new index for a bucket when adjusting the scale of the histogram by the given amount.
@@ -110,7 +108,6 @@ static long adjustScale(long index, int currentScale, int scaleAdjustment) {
         }
     }
 
-
     /**
      * Equivalent to mathematically correct comparison of the lower bucket boundaries of the given buckets
      */

libs/exponential-histogram/src/main/java/org/elasticsearch/exponentialhistogram/FixedCapacityExponentialHistogram.java

@@ -57,7 +57,7 @@ public void reset() {
      */
     public void resetBuckets(int scale) {
         if (scale > MAX_SCALE || scale < MIN_SCALE) {
-            throw new IllegalArgumentException("scale must be in range ["+MIN_SCALE+".."+MAX_SCALE+"]");
+            throw new IllegalArgumentException("scale must be in range [" + MIN_SCALE + ".." + MAX_SCALE + "]");
         }
         negativeBucketCount = 0;
         positiveBucketCount = 0;

libs/exponential-histogram/src/main/java/org/elasticsearch/exponentialhistogram/ZeroBucket.java

@@ -9,11 +9,11 @@
 
 package org.elasticsearch.exponentialhistogram;
 
+import static org.elasticsearch.exponentialhistogram.ExponentialHistogram.MAX_SCALE;
 import static org.elasticsearch.exponentialhistogram.ExponentialHistogram.MIN_INDEX;
 import static org.elasticsearch.exponentialhistogram.ExponentialScaleUtils.compareLowerBoundaries;
 import static org.elasticsearch.exponentialhistogram.ExponentialScaleUtils.computeIndex;
 import static org.elasticsearch.exponentialhistogram.ExponentialScaleUtils.getLowerBucketBoundary;
-import static org.elasticsearch.exponentialhistogram.ExponentialHistogram.MAX_SCALE;
 
 public record ZeroBucket(long index, int scale, long count) {
 

libs/exponential-histogram/src/test/java/org/elasticsearch/exponentialhistogram/ExponentialHistogramGeneratorTests.java

@@ -17,7 +17,7 @@
 public class ExponentialHistogramGeneratorTests extends ESTestCase {
 
     public void testVeryLargeValue() {
-        double value =  Double.MAX_VALUE/10;
+        double value = Double.MAX_VALUE / 10;
         ExponentialHistogram histo = ExponentialHistogramGenerator.createFor(value);
 
         long index = histo.positiveBuckets().peekIndex();

libs/exponential-histogram/src/test/java/org/elasticsearch/exponentialhistogram/ExponentialScaleUtilsTests.java

@@ -71,7 +71,7 @@ public void testRandomValueIndexing() {
             // generate values in the range 10^-100 to 10^100
             double exponent = rnd.nextDouble() * 200 - 100;
             double testValue = Math.pow(10, exponent);
-            int scale = rnd.nextInt(MIN_SCALE/2, MAX_SCALE/2);
+            int scale = rnd.nextInt(MIN_SCALE / 2, MAX_SCALE / 2);
             long index = computeIndex(testValue, scale);
 
             double lowerBound = getLowerBucketBoundary(index, scale);
@@ -160,13 +160,12 @@ public void testUpscalingAccuracy() {
         for (int i = 0; i < 10_000; i++) {
 
             int startScale = rnd.nextInt(minScale, maxScale);
-            int scaleIncrease =  rnd.nextInt(1, maxScale-startScale + 1);
+            int scaleIncrease = rnd.nextInt(1, maxScale - startScale + 1);
 
             long index = MAX_INDEX >> scaleIncrease >> (int) (rnd.nextDouble() * (MAX_INDEX_BITS - scaleIncrease));
             index = Math.max(1, index);
             index = (long) (rnd.nextDouble() * index) * (rnd.nextBoolean() ? 1 : -1);
 
-
             double midPoint = getPointOfLeastRelativeError(index, startScale);
             // limit the numeric range, otherwise we get rounding errors causing the test to fail
             while (midPoint > Math.pow(10, 10) || midPoint < Math.pow(10, -10)) {