@Override
public void mutablePairwiseDivide(Vec b) {
if (this.length() != b.length())
throw new ArithmeticException("Vectors must have the same length");
clearCaches();
for (int i = 0; i < used; i++) values[i] /= b.get(indexes[i]); // zeros stay zero
}
@Override
public void mutableMultiply(double c) {
clearCaches();
if (c == 0.0) {
zeroOut();
return;
}
for (int i = 0; i < used; i++) values[i] *= c;
}
@Override
public void mutableAdd(double c) {
if (c == 0.0) return;
clearCaches();
/* This NOT the most efficient way to implement this.
* But adding a constant to every value in a sparce
* vector defeats its purpos.
*/
for (int i = 0; i < length(); i++) this.set(i, get(i) + c);
}
@Override
public void set(int index, double val) {
if (index > length() - 1 || index < 0)
throw new IndexOutOfBoundsException(index + " does not fit in [0," + length + ")");
clearCaches();
int insertLocation = Arrays.binarySearch(indexes, 0, used, index);
if (insertLocation >= 0) {
if (val != 0) // set it
values[insertLocation] = val;
else // shift used count and everyone over
{
removeNonZero(insertLocation);
}
} else if (val != 0) // dont insert 0s, that is stupid
insertValue(insertLocation, index, val);
}
@Override
public void mutableDivide(double c) {
clearCaches();
if (c == 0 && used != length) throw new ArithmeticException("Division by zero would occur");
for (int i = 0; i < used; i++) values[i] /= c;
}
@Override
public void mutableAdd(double c, Vec v) {
clearCaches();
if (c == 0.0) return;
if (v instanceof SparseVector) {
SparseVector b = (SparseVector) v;
int p1 = 0, p2 = 0;
while (p1 < used && p2 < b.used) {
int a1 = indexes[p1], a2 = b.indexes[p2];
if (a1 == a2) {
values[p1] += c * b.values[p2];
p1++;
p2++;
} else if (a1 > a2) {
// 0 + some value is that value, set it
this.set(a2, c * b.values[p2]);
/*
* p2 must be increment becase were moving to the next value
*
* p1 must be be incremented becase a2 was less thenn the current index.
* So the inseration occured before p1, so for indexes[p1] to == a1,
* p1 must be incremented
*
*/
p1++;
p2++;
} else // a1 < a2, thats adding 0 to this vector, nothing to do.
{
p1++;
}
}
// One of them is now empty.
// If b is not empty, we must add b to this. If b is empty, we would be adding zeros to this
// [so we do nothing]
while (p2 < b.used)
this.set(b.indexes[p2], c * b.values[p2++]); // TODO Can be done more efficently
} else if (v.isSparse()) {
if (v.nnz() == 0) return;
int p1 = 0;
Iterator<IndexValue> iter = v.getNonZeroIterator();
IndexValue iv = iter.next();
while (p1 < used && iv != null) {
int a1 = indexes[p1];
int a2 = iv.getIndex();
if (a1 == a2) {
values[p1++] += c * iv.getValue();
if (iter.hasNext()) iv = iter.next();
else break;
} else if (a1 > a2) {
this.set(a2, c * iv.getValue());
p1++;
if (iter.hasNext()) iv = iter.next();
else break;
} else p1++;
}
} else {
// Else it is dense
for (int i = 0; i < length(); i++) this.set(i, this.get(i) + c * v.get(i));
}
}
