Releasing version 1.0.19 (bugfix release)

MyTracks/src/com/google/android/apps/mytracks/stats/DoubleBuffer.java

@@ -0,0 +1,143 @@
+/*
+ * Copyright 2009 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package com.google.android.apps.mytracks.stats;
+
+/**
+ * This class maintains a buffer of doubles. This buffer is a convenient class
+ * for storing a series of doubles and calculating information about them. This
+ * is a FIFO buffer.
+ *
+ * @author Sandor Dornbush
+ */
+public class DoubleBuffer {
+
+  /**
+   * The location that the next write will occur at.
+   */
+  private int index;
+
+  /**
+   * The sliding buffer of doubles.
+   */
+  private final double[] buffer;
+
+  /**
+   * Have all of the slots in the buffer been filled?
+   */
+  private boolean isFull;
+
+  /**
+   * Creates a buffer with size elements.
+   *
+   * @param size the number of elements in the buffer
+   * @throws IllegalArgumentException if the size is not a positive value
+   */
+  public DoubleBuffer(int size) {
+    if (size < 1) {
+      throw new IllegalArgumentException("The buffer size must be positive.");
+    }
+    buffer = new double[size];
+    reset();
+  }
+
+  /**
+   * Adds a double to the buffer. If the buffer is full the oldest element is
+   * overwritten.
+   *
+   * @param d the double to add
+   */
+  public void setNext(double d) {
+    if (index == buffer.length) {
+      index = 0;
+    }
+    buffer[index] = d;
+    index++;
+    if (index == buffer.length) {
+      isFull = true;
+    }
+  }
+
+  /**
+   * Are all of the entries in the buffer used?
+   */
+  public boolean isFull() {
+    return isFull;
+  }
+
+  /**
+   * Resets the buffer to the initial state.
+   */
+  public void reset() {
+    index = 0;
+    isFull = false;
+  }
+
+  /**
+   * Gets the average of values from the buffer.
+   *
+   * @return The average of the buffer
+   */
+  public double getAverage() {
+    int numberOfEntries = isFull ? buffer.length : index;
+    if (numberOfEntries == 0) {
+      return 0;
+    }
+
+    double sum = 0;
+    for (int i = 0; i < numberOfEntries; i++) {
+      sum += buffer[i];
+    }
+    return sum / numberOfEntries;
+  }
+
+  /**
+   * Gets the average and standard deviation of the buffer.
+   *
+   * @return An array of two elements - the first is the average, and the second
+   *         is the variance
+   */
+  public double[] getAverageAndVariance() {
+    int numberOfEntries = isFull ? buffer.length : index;
+    if (numberOfEntries == 0) {
+      return new double[]{0, 0};
+    }
+
+    double sum = 0;
+    double sumSquares = 0;
+    for (int i = 0; i < numberOfEntries; i++) {
+      sum += buffer[i];
+      sumSquares += Math.pow(buffer[i], 2);
+    }
+
+    double average = sum / numberOfEntries;
+    return new double[]{average,
+      sumSquares / numberOfEntries  - Math.pow(average, 2)};
+  }
+
+  @Override
+  public String toString() {
+    StringBuffer stringBuffer = new StringBuffer("Full: ");
+    stringBuffer.append(isFull);
+    stringBuffer.append("\n");
+    for (int i = 0; i < buffer.length; i++) {
+      stringBuffer.append((i == index) ? "<<" : "[");
+      stringBuffer.append(buffer[i]);
+      stringBuffer.append((i == index) ? ">> " : "] ");
+    }
+    return stringBuffer.toString();
+  }
+}