Addressed comments

Author: Pulkit Gupta

lucene/core/src/java/org/apache/lucene/codecs/lucene104/OffHeapScalarQuantizedFloatVectorValues.java

@@ -70,7 +70,6 @@ abstract class OffHeapScalarQuantizedFloatVectorValues extends FloatVectorValues
   int quantizedComponentSum;
   final Lucene104ScalarQuantizedVectorsFormat.ScalarEncoding encoding;
   final float[] centroid;
-  final boolean isQuerySide;
 
   OffHeapScalarQuantizedFloatVectorValues(
       int dimension,
@@ -80,20 +79,6 @@ abstract class OffHeapScalarQuantizedFloatVectorValues extends FloatVectorValues
       VectorSimilarityFunction similarityFunction,
       FlatVectorsScorer vectorsScorer,
       IndexInput slice) {
-    this(false, dimension, size, centroid, encoding, similarityFunction, vectorsScorer, slice);
-  }
-
-  OffHeapScalarQuantizedFloatVectorValues(
-      boolean isQuerySide,
-      int dimension,
-      int size,
-      float[] centroid,
-      Lucene104ScalarQuantizedVectorsFormat.ScalarEncoding encoding,
-      VectorSimilarityFunction similarityFunction,
-      FlatVectorsScorer vectorsScorer,
-      IndexInput slice) {
-    assert isQuerySide == false || encoding.isAsymmetric();
-    this.isQuerySide = isQuerySide;
     this.dimension = dimension;
     this.size = size;
     this.similarityFunction = similarityFunction;
@@ -102,10 +87,7 @@ abstract class OffHeapScalarQuantizedFloatVectorValues extends FloatVectorValues
     this.centroid = centroid;
     this.correctiveValues = new float[3];
     this.encoding = encoding;
-    int docPackedLength =
-        isQuerySide
-            ? encoding.getQueryPackedLength(dimension)
-            : encoding.getDocPackedLength(dimension);
+    int docPackedLength = encoding.getDocPackedLength(dimension);
     this.byteSize = docPackedLength + (Float.BYTES * 3) + Integer.BYTES;
     this.byteBuffer = ByteBuffer.allocate(docPackedLength);
     this.vectorValue = new float[dimension];
@@ -142,15 +124,26 @@ public float[] vectorValue(int targetOrd) throws IOException {
       case SINGLE_BIT_QUERY_NIBBLE ->
           OptimizedScalarQuantizer.unpackBinary(byteValue, unpackedByteVectorValue);
       case UNSIGNED_BYTE, SEVEN_BIT -> {
-        deQuantize(byteValue, vectorValue, encoding.getBits(), correctiveValues, centroid);
+        deQuantize(
+            byteValue,
+            vectorValue,
+            encoding.getBits(),
+            correctiveValues[0],
+            correctiveValues[1],
+            centroid);
         lastOrd = targetOrd;
         return vectorValue;
       }
     }
 
     // dequantize
     deQuantize(
-        unpackedByteVectorValue, vectorValue, encoding.getBits(), correctiveValues, centroid);
+        unpackedByteVectorValue,
+        vectorValue,
+        encoding.getBits(),
+        correctiveValues[0],
+        correctiveValues[1],
+        centroid);
 
     lastOrd = targetOrd;
     return vectorValue;
@@ -219,7 +212,7 @@ static OffHeapScalarQuantizedFloatVectorValues load(
   }
 
   /** Dense off-heap scalar quantized vector values */
-  static class DenseOffHeapVectorValues extends OffHeapScalarQuantizedFloatVectorValues {
+  private static class DenseOffHeapVectorValues extends OffHeapScalarQuantizedFloatVectorValues {
     DenseOffHeapVectorValues(
         int dimension,
         int size,
@@ -231,38 +224,11 @@ static class DenseOffHeapVectorValues extends OffHeapScalarQuantizedFloatVectorV
       super(dimension, size, centroid, encoding, similarityFunction, vectorsScorer, slice);
     }
 
-    DenseOffHeapVectorValues(
-        boolean isQuerySide,
-        int dimension,
-        int size,
-        float[] centroid,
-        Lucene104ScalarQuantizedVectorsFormat.ScalarEncoding encoding,
-        VectorSimilarityFunction similarityFunction,
-        FlatVectorsScorer vectorsScorer,
-        IndexInput slice) {
-      super(
-          isQuerySide,
-          dimension,
-          size,
-          centroid,
-          encoding,
-          similarityFunction,
-          vectorsScorer,
-          slice);
-    }
-
     @Override
     public OffHeapScalarQuantizedFloatVectorValues.DenseOffHeapVectorValues copy()
         throws IOException {
       return new OffHeapScalarQuantizedFloatVectorValues.DenseOffHeapVectorValues(
-          isQuerySide,
-          dimension,
-          size,
-          centroid,
-          encoding,
-          similarityFunction,
-          vectorsScorer,
-          slice.clone());
+          dimension, size, centroid, encoding, similarityFunction, vectorsScorer, slice.clone());
     }
 
     @Override
@@ -272,7 +238,6 @@ public Bits getAcceptOrds(Bits acceptDocs) {
 
     @Override
     public VectorScorer scorer(float[] target) throws IOException {
-      assert isQuerySide == false;
       OffHeapScalarQuantizedFloatVectorValues.DenseOffHeapVectorValues copy = copy();
       DocIndexIterator iterator = copy.iterator();
       RandomVectorScorer scorer =
@@ -316,7 +281,6 @@ private static class SparseOffHeapVectorValues extends OffHeapScalarQuantizedFlo
         IndexInput slice)
         throws IOException {
       super(dimension, size, centroid, encoding, similarityFunction, vectorsScorer, slice);
-      assert isQuerySide == false;
       this.configuration = configuration;
       this.dataIn = dataIn;
       this.ordToDoc = configuration.getDirectMonotonicReader(dataIn);
@@ -326,7 +290,6 @@ private static class SparseOffHeapVectorValues extends OffHeapScalarQuantizedFlo
     @Override
     public OffHeapScalarQuantizedFloatVectorValues.SparseOffHeapVectorValues copy()
         throws IOException {
-      assert isQuerySide == false;
       return new OffHeapScalarQuantizedFloatVectorValues.SparseOffHeapVectorValues(
           configuration,
           dimension,
@@ -369,7 +332,6 @@ public DocIndexIterator iterator() {
 
     @Override
     public VectorScorer scorer(float[] target) throws IOException {
-      assert isQuerySide == false;
       OffHeapScalarQuantizedFloatVectorValues.SparseOffHeapVectorValues copy = copy();
       DocIndexIterator iterator = copy.iterator();
       RandomVectorScorer scorer =
@@ -388,6 +350,7 @@ public DocIdSetIterator iterator() {
     }
   }
 
+  /** Empty vector values */
   private static class EmptyOffHeapVectorValues extends OffHeapScalarQuantizedFloatVectorValues {
     EmptyOffHeapVectorValues(
         int dimension,
@@ -401,7 +364,6 @@ private static class EmptyOffHeapVectorValues extends OffHeapScalarQuantizedFloa
           similarityFunction,
           vectorsScorer,
           null);
-      assert isQuerySide == false;
     }
 
     @Override

lucene/core/src/java/org/apache/lucene/util/quantization/OptimizedScalarQuantizer.java

@@ -245,23 +245,22 @@ public QuantizationResult scalarQuantize(
    * @param quantized the quantized byte vector to dequantize
    * @param dequantized the output array to store dequantized float values
    * @param bits the number of bits used for quantization
-   * @param correctiveValues array containing [a, b, unused] where a=min, b=max of quantization
-   *     range
+   * @param lowerCorrectiveValue min value of quantization range
+   * @param upperCorrectiveValue max value of quantization range
    * @param centroid the centroid vector that was subtracted during quantization
    * @return the dequantized float array (same as dequantized parameter)
    */
   public static float[] deQuantize(
       byte[] quantized,
       float[] dequantized,
       byte bits,
-      float[] correctiveValues,
+      float lowerCorrectiveValue,
+      float upperCorrectiveValue,
       float[] centroid) {
-    float a = correctiveValues[0];
-    float b = correctiveValues[1];
     int nSteps = (1 << bits) - 1;
-    double step = (b - a) / nSteps;
+    double step = (upperCorrectiveValue - lowerCorrectiveValue) / nSteps;
     for (int h = 0; h < quantized.length; h++) {
-      double xi = (double) (quantized[h] & 0xFF) * step + a;
+      double xi = (double) (quantized[h] & 0xFF) * step + lowerCorrectiveValue;
       dequantized[h] = (float) (xi + centroid[h]);
     }
     return dequantized;

lucene/core/src/test/org/apache/lucene/util/quantization/TestOptimizedScalarQuantizer.java

@@ -66,7 +66,8 @@ public void testQuantizationQuality() {
             destination,
             dequantized,
             bit,
-            new float[] {result.lowerInterval(), result.upperInterval()},
+            result.lowerInterval(),
+            result.upperInterval(),
             centroid);
         float mae = 0;
         for (int k = 0; k < dims; ++k) {