Cover toString()

Author: mbok

src/main/java/org/scaleborn/elasticsearch/linreg/aggregation/stats/StatsAggregator.java

@@ -100,6 +100,8 @@ public void collect(int doc, long bucket) throws IOException {
           }
           LOGGER.info("Sampling for bucket={}, fields={}", bucket, fieldVals);
           sampling.sample(fieldVals, fieldVals[fieldVals.length - 1]);
+        } else {
+          LOGGER.warn("Skipped bucket={}, fields={}", bucket, fieldVals);
         }
       }
 

src/main/java/org/scaleborn/linereg/evaluation/SlopeCoefficientsSampling.java

@@ -48,51 +48,60 @@ public SlopeCoefficientsSamplingProxy(final SamplingContext<?> samplingContext,
 
     @Override
     public void saveState(final StateOutputStream destination) throws IOException {
-      samplingContext.saveState(destination);
-      coefficientLinearTermSampling.saveState(destination);
-      coefficientSquareTermSampling.saveState(destination);
+      this.samplingContext.saveState(destination);
+      this.coefficientLinearTermSampling.saveState(destination);
+      this.coefficientSquareTermSampling.saveState(destination);
     }
 
     @Override
     public void sample(final double[] featureValues, final double responseValue) {
-      samplingContext.sample(featureValues, responseValue);
-      coefficientLinearTermSampling.sample(featureValues, responseValue);
-      coefficientSquareTermSampling.sample(featureValues, responseValue);
+      this.samplingContext.sample(featureValues, responseValue);
+      this.coefficientLinearTermSampling.sample(featureValues, responseValue);
+      this.coefficientSquareTermSampling.sample(featureValues, responseValue);
     }
 
     @Override
     public void loadState(final StateInputStream source) throws IOException {
-      samplingContext.loadState(source);
-      coefficientLinearTermSampling.loadState(source);
-      coefficientSquareTermSampling.loadState(source);
+      this.samplingContext.loadState(source);
+      this.coefficientLinearTermSampling.loadState(source);
+      this.coefficientSquareTermSampling.loadState(source);
     }
 
     @SuppressWarnings("unchecked")
     @Override
     public void merge(final SlopeCoefficientsSamplingProxy fromSample) {
-      samplingContext.merge(fromSample.samplingContext);
-      coefficientLinearTermSampling.merge(fromSample.coefficientLinearTermSampling);
-      coefficientSquareTermSampling.merge(fromSample.coefficientSquareTermSampling);
+      this.samplingContext.merge(fromSample.samplingContext);
+      this.coefficientLinearTermSampling.merge(fromSample.coefficientLinearTermSampling);
+      this.coefficientSquareTermSampling.merge(fromSample.coefficientSquareTermSampling);
     }
 
     @Override
     public double[] getFeaturesResponseCovariance() {
-      return coefficientLinearTermSampling.getFeaturesResponseCovariance();
+      return this.coefficientLinearTermSampling.getFeaturesResponseCovariance();
     }
 
     @Override
     public double[][] getCovarianceLowerTriangularMatrix() {
-      return coefficientSquareTermSampling.getCovarianceLowerTriangularMatrix();
+      return this.coefficientSquareTermSampling.getCovarianceLowerTriangularMatrix();
     }
 
     @Override
     public long getCount() {
-      return samplingContext.getCount();
+      return this.samplingContext.getCount();
     }
 
     @Override
     public int getFeaturesCount() {
-      return samplingContext.getFeaturesCount();
+      return this.samplingContext.getFeaturesCount();
+    }
+
+    @Override
+    public String toString() {
+      return "SlopeCoefficientsSamplingProxy{" +
+          "samplingContext=" + this.samplingContext +
+          ", coefficientLinearTermSampling=" + this.coefficientLinearTermSampling +
+          ", coefficientSquareTermSampling=" + this.coefficientSquareTermSampling +
+          '}';
     }
   }
 

src/main/java/org/scaleborn/linereg/sampling/exact/ExactCoefficientSquareTermSampling.java

@@ -17,6 +17,7 @@
 package org.scaleborn.linereg.sampling.exact;
 
 import java.io.IOException;
+import java.util.Arrays;
 import org.scaleborn.linereg.sampling.Sampling.CoefficientSquareTermSampling;
 import org.scaleborn.linereg.sampling.io.StateInputStream;
 import org.scaleborn.linereg.sampling.io.StateOutputStream;
@@ -40,61 +41,69 @@ public class ExactCoefficientSquareTermSampling implements
   public ExactCoefficientSquareTermSampling(ExactSamplingContext context) {
     this.context = context;
     int featuresCount = context.getFeaturesCount();
-    featuresProductSums = new double[featuresCount][];
+    this.featuresProductSums = new double[featuresCount][];
     for (int i = 0; i < featuresCount; i++) {
-      featuresProductSums[i] = new double[featuresCount];
+      this.featuresProductSums[i] = new double[featuresCount];
     }
   }
 
   @Override
   public double[][] getCovarianceLowerTriangularMatrix() {
-    int featuresCount = context.getFeaturesCount();
-    long count = context.getCount();
+    int featuresCount = this.context.getFeaturesCount();
+    long count = this.context.getCount();
     double[][] covMatrix = new double[featuresCount][];
-    double[] averages = context.getFeaturesMean();
-    double[] featureSums = context.featureSums;
+    double[] averages = this.context.getFeaturesMean();
+    double[] featureSums = this.context.featureSums;
     for (int i = 0; i < featuresCount; i++) {
       double avgI = averages[i];
       covMatrix[i] = new double[featuresCount];
       // Iterate until "i" due to the covariance matrix is symmetric and
       // build only the lower triangle
       for (int j = 0; j <= i; j++) {
         double avgJ = averages[j];
-        covMatrix[i][j] = featuresProductSums[i][j] - avgI * featureSums[j] - avgJ * featureSums[i]
-            + count * avgI * avgJ;
+        covMatrix[i][j] =
+            this.featuresProductSums[i][j] - avgI * featureSums[j] - avgJ * featureSums[i]
+                + count * avgI * avgJ;
       }
     }
     return covMatrix;
   }
 
   @Override
   public void sample(final double[] featureValues, final double responseValue) {
-    int featuresCount = context.getFeaturesCount();
+    int featuresCount = this.context.getFeaturesCount();
     for (int i = 0; i < featuresCount; i++) {
       double vi = featureValues[i];
       for (int j = 0; j < featuresCount; j++) {
-        featuresProductSums[i][j] += vi * featureValues[j];
+        this.featuresProductSums[i][j] += vi * featureValues[j];
       }
     }
   }
 
   @Override
   public void merge(final ExactCoefficientSquareTermSampling fromSample) {
-    int featuresCount = context.getFeaturesCount();
+    int featuresCount = this.context.getFeaturesCount();
     for (int i = 0; i < featuresCount; i++) {
       for (int j = 0; j < featuresCount; j++) {
-        featuresProductSums[i][j] += fromSample.featuresProductSums[i][j];
+        this.featuresProductSums[i][j] += fromSample.featuresProductSums[i][j];
       }
     }
   }
 
   @Override
   public void saveState(final StateOutputStream stream) throws IOException {
-    stream.writeDoubleMatrix(featuresProductSums);
+    stream.writeDoubleMatrix(this.featuresProductSums);
   }
 
   @Override
   public void loadState(final StateInputStream stream) throws IOException {
-    featuresProductSums = stream.readDoubleMatrix();
+    this.featuresProductSums = stream.readDoubleMatrix();
+  }
+
+  @Override
+  public String toString() {
+    return "ExactCoefficientSquareTermSampling{" +
+        "featuresProductSums=" + Arrays.deepToString(this.featuresProductSums) +
+        '}';
   }
 }

src/main/java/org/scaleborn/linereg/sampling/exact/ExactSamplingContext.java

@@ -17,6 +17,7 @@
 package org.scaleborn.linereg.sampling.exact;
 
 import java.io.IOException;
+import java.util.Arrays;
 import org.scaleborn.linereg.sampling.io.StateInputStream;
 import org.scaleborn.linereg.sampling.io.StateOutputStream;
 import org.scaleborn.linereg.sampling.support.BaseSamplingContext;
@@ -35,63 +36,75 @@ public class ExactSamplingContext extends BaseSamplingContext<ExactSamplingConte
 
   public ExactSamplingContext(final int featuresCount) {
     super(featuresCount);
-    featureSums = new double[featuresCount];
-    featuresResponseProductSum = new double[featuresCount];
+    this.featureSums = new double[featuresCount];
+    this.featuresResponseProductSum = new double[featuresCount];
   }
 
   @Override
   public void sample(double[] featureValues, double targetValue) {
     super.sample(featureValues, targetValue);
     for (int i = 0; i < featuresCount; i++) {
       double v = featureValues[i];
-      featureSums[i] += v;
-      featuresResponseProductSum[i] += v * targetValue;
+      this.featureSums[i] += v;
+      this.featuresResponseProductSum[i] += v * targetValue;
     }
-    responseSum += targetValue;
-    responseSquareSum += targetValue * targetValue;
+    this.responseSum += targetValue;
+    this.responseSquareSum += targetValue * targetValue;
   }
 
   @Override
   public void merge(ExactSamplingContext from) {
     super.merge(from);
     for (int i = 0; i < featuresCount; i++) {
-      featureSums[i] += from.featureSums[i];
-      featuresResponseProductSum[i] += from.featuresResponseProductSum[i];
+      this.featureSums[i] += from.featureSums[i];
+      this.featuresResponseProductSum[i] += from.featuresResponseProductSum[i];
     }
-    responseSum += from.responseSum;
-    responseSquareSum += from.responseSquareSum;
+    this.responseSum += from.responseSum;
+    this.responseSquareSum += from.responseSquareSum;
   }
 
   double[] getFeaturesMean() {
     double[] avgs = new double[featuresCount];
     if (count > 0) {
       for (int i = 0; i < featuresCount; i++) {
-        avgs[i] = featureSums[i] / count;
+        avgs[i] = this.featureSums[i] / count;
       }
     }
     return avgs;
   }
 
   double getResponseMean() {
     if (count > 0) {
-      return responseSum / count;
+      return this.responseSum / count;
     }
     return 0;
   }
 
   @Override
   public void saveState(final StateOutputStream stream) throws IOException {
-    stream.writeDouble(responseSum);
-    stream.writeDouble(responseSquareSum);
-    stream.writeDoubleArray(featureSums);
-    stream.writeDoubleArray(featuresResponseProductSum);
+    super.saveState(stream);
+    stream.writeDouble(this.responseSum);
+    stream.writeDouble(this.responseSquareSum);
+    stream.writeDoubleArray(this.featureSums);
+    stream.writeDoubleArray(this.featuresResponseProductSum);
   }
 
   @Override
   public void loadState(final StateInputStream stream) throws IOException {
-    responseSum = stream.readDouble();
-    responseSquareSum = stream.readDouble();
-    featureSums = stream.readDoubleArray();
-    featuresResponseProductSum = stream.readDoubleArray();
+    super.loadState(stream);
+    this.responseSum = stream.readDouble();
+    this.responseSquareSum = stream.readDouble();
+    this.featureSums = stream.readDoubleArray();
+    this.featuresResponseProductSum = stream.readDoubleArray();
+  }
+
+  @Override
+  public String toString() {
+    return "ExactSamplingContext{" +
+        "featureSums=" + Arrays.toString(this.featureSums) +
+        ", responseSum=" + this.responseSum +
+        ", featuresResponseProductSum=" + Arrays.toString(this.featuresResponseProductSum) +
+        ", responseSquareSum=" + this.responseSquareSum +
+        "} " + super.toString();
   }
 }

src/main/java/org/scaleborn/linereg/statistics/StatsSampling.java

@@ -71,5 +71,12 @@ public void merge(final StatsSamplingProxy fromSample) {
     public double getResponseVariance() {
       return responseVarianceTermSampling.getResponseVariance();
     }
+
+    @Override
+    public String toString() {
+      return "StatsSamplingProxy{" +
+          "responseVarianceTermSampling=" + responseVarianceTermSampling +
+          "} " + super.toString();
+    }
   }
 }