package jsat.linear;
import java.util.Iterator;
/**
* A wrapper for a vector that allows for transparent tracking of the 2-norm of
* the base vector. This class is meant primarily for use when most updates are
* done by sparse vectors accumulated to a single dense vector. If there are
* only O(s) non zero values, updating the norm can be done in O(s) time. If
* most updates will be done by dense vectors, this wrapper may not give any
* performance improvements.
* The norm is obtained by calling {@link #pNorm(double) }. The original vector
* can be obtained by calling {@link #getBase() }. The exact values returned for
* the norm may differ slightly due to numerical issues.
*
* @author Edward Raff
*/
public class VecWithNorm extends Vec
{
private static final long serialVersionUID = 3888178071694466561L;
final private Vec base;
private double normSqrd;
/**
* Creates a wrapper around the base vector that will update the norm of the
* vector
* @param base the vector to use as the base value
* @param norm the initial value of the norm
*/
public VecWithNorm(Vec base, double norm)
{
this.base = base;
this.normSqrd = norm*norm;
}
/**
* Creates a wrapper around the base vector that will update the norm of the
* vector
* @param base the vector to use as the base value
*/
public VecWithNorm(Vec base)
{
this(base, base.pNorm(2));
}
/**
* Return the base vector that is having its norm tracked
* @return the base vector that is having its norm tracked
*/
public Vec getBase()
{
return base;
}
@Override
public double pNorm(double p)
{
if(p == 2)
return Math.sqrt(normSqrd);
return base.pNorm(p);
}
@Override
public int length()
{
return base.length();
}
@Override
public double get(int index)
{
return base.get(index);
}
@Override
public void set(int index, double val)
{
double old = base.get(index);
normSqrd += -(old*old)+(val*val);
base.set(index, val);
}
@Override
public boolean isSparse()
{
return base.isSparse();
}
@Override
public VecWithNorm clone()
{
return new VecWithNorm(this.base.clone(), Math.sqrt(normSqrd));
}
@Override
public void mutableAdd(double c)
{
//TODO this can be improved for scenarios where the base vector is sparse, but that should be uncommon
for(int i = 0; i < base.length(); i++)
{
double old = base.get(i);
double toAdd = c;
normSqrd += toAdd*(toAdd+2*old);
}
base.mutableAdd(c);
}
@Override
public void mutableAdd(double c, Vec b)
{
for(IndexValue iv : b)
{
double old = base.get(iv.getIndex());
double toAdd = c*iv.getValue();
normSqrd += toAdd*(toAdd+2*old);
}
base.mutableAdd(c, b);
}
@Override
public void mutablePairwiseMultiply(Vec b)
{
//if b is sparse or dense its going to need updates to every value.
//migth as well jsut refresh
base.mutablePairwiseMultiply(b);
normSqrd = Math.pow(base.pNorm(2), 2);
}
@Override
public void mutableMultiply(double c)
{
normSqrd *= c*c;
base.mutableMultiply(c);
}
@Override
public void mutablePairwiseDivide(Vec b)
{
//if b is sparse or dense its going to need updates to every value.
//migth as well just refresh
base.mutablePairwiseDivide(b);
normSqrd = Math.pow(base.pNorm(2), 2);
}
@Override
public void mutableDivide(double c)
{
normSqrd /= c*c;
}
@Override
public void zeroOut()
{
normSqrd = 0;
base.zeroOut();
}
@Override
public int nnz()
{
return base.nnz();
}
@Override
public Iterator getNonZeroIterator()
{
return base.getNonZeroIterator();
}
@Override
public Iterator getNonZeroIterator(int start)
{
return base.getNonZeroIterator(start);
}
}
Ads help maintain this website.