package jsat.linear;
import static java.lang.Math.abs;
import static java.lang.Math.pow;
import java.util.Iterator;
/**
* A wrapper for a vector that represents the vector added with a scalar value.
* This allows for using and altering the value added by a
* constant factor quickly. Mutable operations will alter the underling vector,
* and all operations will automatically be adjusted on a per element basis as
* needed. The most significant performance difference is in representing a
* sparse input sifted by a constant factor. Note, that when using a sparse base
* vector - the ShiftedVec will always return {@code true} for
* {@link #isSparse() }, even if shifting makes all values non-zero
*
*
* @author Edward Raff
*/
public class ShiftedVec extends Vec
{
private static final long serialVersionUID = -8318033099234181766L;
private Vec base;
private double shift;
/**
* Creates a new vector represented as base+shift
* @param base the base vector to represent
* @param shift the scalar shift to add to the base vector
*/
public ShiftedVec(Vec base, double shift)
{
this.base = base;
this.shift = shift;
}
/**
* @return the base vector used by this object
*/
public Vec getBase()
{
return base;
}
/**
* Directly alters the shift value used for this vector. The old sift is
* "forgotten" immediately.
* @param shift the new value to use for the additive scalar
*/
public void setShift(double shift)
{
this.shift = shift;
}
/**
*
* @return the additive scalar used to shift over the {@link #getBase()
* base} value
*/
public double getShift()
{
return shift;
}
/**
* Embeds the current shift scalar into the base vector, modifying it and
* then setting the new shit to zero. This makes the base vector have the
* value represented by this ShiftedVec
*/
public void embedShift()
{
base.mutableAdd(shift);
shift = 0;
}
@Override
public int length()
{
return base.length();
}
@Override
public double get(int index)
{
return base.get(index)+shift;
}
@Override
public void set(int index, double val)
{
base.set(index, val-shift);
}
@Override
public void increment(int index, double val)
{
base.increment(index, val);
}
@Override
public void mutableAdd(Vec b)
{
if(b instanceof ShiftedVec)
{
ShiftedVec other = (ShiftedVec) b;
base.mutableAdd(other.base);
shift += other.shift;
}
else
base.mutableAdd(b);
}
@Override
public void mutableAdd(double c)
{
shift += c;
}
@Override
public void mutableAdd(double c, Vec b)
{
if(b instanceof ShiftedVec)
{
ShiftedVec other = (ShiftedVec) b;
base.mutableAdd(c, other.base);
shift += other.shift*c;
}
else
base.mutableAdd(c, b);
}
@Override
public void mutableDivide(double c)
{
base.mutableDivide(c);
shift /= c;
if(Double.isNaN(shift))
shift = 0;
}
@Override
public void mutableMultiply(double c)
{
base.mutableMultiply(c);
shift*=c;
}
@Override
public void mutablePairwiseDivide(Vec b)
{
//this would require multiple different shifts, so we have to fold it back into the base vector
base.mutableAdd(shift);
shift = 0;
base.mutablePairwiseDivide(b);
}
@Override
public void mutablePairwiseMultiply(Vec b)
{
//this would require multiple different shifts, so we have to fold it back into the base vector
base.mutableAdd(shift);
shift = 0;
base.mutablePairwiseMultiply(b);
}
// No real performance to gain by re-implementing matrix mul ops
// @Override
// public void multiply(double c, Matrix A, Vec b)
@Override
public double dot(Vec v)
{
if(v instanceof ShiftedVec)
{
ShiftedVec other = (ShiftedVec) v;
return this.base.dot(other.base) + other.base.sum()*this.shift + this.base.sum()*other.shift + this.length()*this.shift*other.shift;
}
return base.dot(v) + v.sum()*shift;
}
@Override
public void zeroOut()
{
base.zeroOut();
shift = 0;
}
@Override
public double pNorm(double p)
{
if(!isSparse())
return super.pNorm(p);
//else sparse base, we can save some work
//contributes of zero values
double baseZeroContribs = pow(abs(shift), p)*(length()-base.nnz());
//+ contribution of non zero values
double baseNonZeroContribs = 0;
for(IndexValue iv : base)
baseNonZeroContribs += pow(abs(iv.getValue()+shift), p);
return pow(baseNonZeroContribs+baseZeroContribs, 1/p);
}
// TODO: In the case of the y also being a ShiftedVec and sparse some significant performance could be saved.
// public double pNormDist(double p, Vec y)
@Override
public double mean()
{
return base.mean()+ shift;
}
@Override
public double variance()
{
return base.variance();
}
@Override
public double standardDeviation()
{
return base.standardDeviation();
}
@Override
public double kurtosis()
{
return base.kurtosis();
}
@Override
public double max()
{
return base.max()+shift;
}
@Override
public double min()
{
return base.min()+shift;
}
@Override
public double median()
{
return base.median()+shift;
}
@Override
public Iterator getNonZeroIterator(final int start)
{
if(!isSparse())//dense case, just add the shift and use the base implemenaton since its going to do the exact same thing I would
return super.getNonZeroIterator(start);
final Iterator baseIter = base.getNonZeroIterator(start);
if(shift == 0)//easy case, just use the base's iterator
return baseIter;
//ugly case, sparse vec with shifted values iterating over non zeros (which should generally be all of them)
final int lastIndx = length()-1;
return new Iterator()
{
IndexValue nextBaseVal;
IndexValue nextVal;
IndexValue toRet = null;
//init
{
for(int effectiveStart = start; effectiveStart <= lastIndx; effectiveStart++)
{
nextBaseVal = baseIter.hasNext() ? baseIter.next() : null;
if (nextBaseVal != null && nextBaseVal.getIndex() == effectiveStart)
{
if (nextBaseVal.getValue() + shift == 0)
continue;//no starting on zero!
else
nextVal = new IndexValue(effectiveStart, nextBaseVal.getValue() + shift);
nextBaseVal = baseIter.hasNext() ? baseIter.next() : null;
}
else//was zero + shift
nextVal = new IndexValue(effectiveStart, shift);
toRet = new IndexValue(effectiveStart, shift);
break;
}
}
@Override
public boolean hasNext()
{
return nextVal != null;
}
@Override
public IndexValue next()
{
toRet.setIndex(nextVal.getIndex());
toRet.setValue(nextVal.getValue());
//loop to get next value b/c we may have to skip over zeros
do
{
nextVal.setIndex(nextVal.getIndex()+1);//pre-bump index
//prep next value
if(nextVal.getIndex() == lastIndx+1)
nextVal = null;//done
else
{
if(nextBaseVal != null && nextBaseVal.getIndex() == nextVal.getIndex())//there is a base non-zero next
{
nextVal.setValue(nextBaseVal.getValue()+shift);
nextBaseVal = baseIter.hasNext() ? baseIter.next() : null;
}
else//a base non-zero in our imediate future
{
nextVal.setValue(shift);
}
}
}
while(nextVal != null && nextVal.getValue() == 0);
return toRet;
}
@Override
public void remove()
{
throw new UnsupportedOperationException("Not supported.");
}
};
}
@Override
public boolean isSparse()
{
return base.isSparse();
}
@Override
public ShiftedVec clone()
{
return new ShiftedVec(base.clone(), shift);
}
}
Ads help maintain this website.