/**
* Returns a list of the sample values in the contained averaged record list.
*
* @return
*/
public TDoubleList getSamples() {
TDoubleList retVal = new TDoubleArrayList();
for (Sample s : averagedRecords) {
retVal.add(s.value);
}
return retVal;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((averagedRecords == null) ? 0 : averagedRecords.hashCode());
result = prime * result + ((historicalValues == null) ? 0 : historicalValues.hashCode());
long temp;
temp = Double.doubleToLongBits(total);
result = prime * result + (int) (temp ^ (temp >>> 32));
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj) return true;
if (obj == null) return false;
if (getClass() != obj.getClass()) return false;
AveragedAnomalyRecordList other = (AveragedAnomalyRecordList) obj;
if (averagedRecords == null) {
if (other.averagedRecords != null) return false;
} else if (!averagedRecords.equals(other.averagedRecords)) return false;
if (historicalValues == null) {
if (other.historicalValues != null) return false;
} else if (!historicalValues.equals(other.historicalValues)) return false;
if (Double.doubleToLongBits(total) != Double.doubleToLongBits(other.total)) return false;
return true;
}
public void set(int offset, double[] values) {
synchronized (mutex) {
list.set(offset, values);
}
}
public double get(int index) {
synchronized (mutex) {
return list.get(index);
}
}
public boolean equals(Object o) {
synchronized (mutex) {
return list.equals(o);
}
}
public boolean forEachDescending(TDoubleProcedure procedure) {
synchronized (mutex) {
return list.forEachDescending(procedure);
}
}
public TDoubleList inverseGrep(TDoubleProcedure condition) {
synchronized (mutex) {
return list.inverseGrep(condition);
}
}
public int binarySearch(double value) {
synchronized (mutex) {
return list.binarySearch(value);
}
}
public double[] toArray(double[] dest, int offset, int len) {
synchronized (mutex) {
return list.toArray(dest, offset, len);
}
}
public TDoubleList subList(int fromIndex, int toIndex) {
synchronized (mutex) {
return new TSynchronizedDoubleList(list.subList(fromIndex, toIndex), mutex);
}
}
public int lastIndexOf(double o) {
synchronized (mutex) {
return list.lastIndexOf(o);
}
}
public void insert(int offset, double[] values, int valOffset, int len) {
synchronized (mutex) {
list.insert(offset, values, valOffset, len);
}
}
public void insert(int offset, double value) {
synchronized (mutex) {
list.insert(offset, value);
}
}
public void add(double[] vals, int offset, int length) {
synchronized (mutex) {
list.add(vals, offset, length);
}
}
public void sort() {
synchronized (mutex) {
list.sort();
}
}
public void sort(int fromIndex, int toIndex) {
synchronized (mutex) {
list.sort(fromIndex, toIndex);
}
}
public double[] toArray(double[] dest, int source_pos, int dest_pos, int len) {
synchronized (mutex) {
return list.toArray(dest, source_pos, dest_pos, len);
}
}
public int binarySearch(double value, int fromIndex, int toIndex) {
synchronized (mutex) {
return list.binarySearch(value, fromIndex, toIndex);
}
}
public int lastIndexOf(int offset, double value) {
synchronized (mutex) {
return list.lastIndexOf(offset, value);
}
}
public double min() {
synchronized (mutex) {
return list.min();
}
}
public void fill(double val) {
synchronized (mutex) {
list.fill(val);
}
}
public void transformValues(TDoubleFunction function) {
synchronized (mutex) {
list.transformValues(function);
}
}
public void fill(int fromIndex, int toIndex, double val) {
synchronized (mutex) {
list.fill(fromIndex, toIndex, val);
}
}
public int hashCode() {
synchronized (mutex) {
return list.hashCode();
}
}
public void reverse() {
synchronized (mutex) {
list.reverse();
}
}
public double set(int index, double element) {
synchronized (mutex) {
return list.set(index, element);
}
}
public void reverse(int from, int to) {
synchronized (mutex) {
list.reverse(from, to);
}
}
public void set(int offset, double[] values, int valOffset, int length) {
synchronized (mutex) {
list.set(offset, values, valOffset, length);
}
}
public void shuffle(Random rand) {
synchronized (mutex) {
list.shuffle(rand);
}
}