package jsat.linear;
import java.util.Collections;
import java.util.Iterator;
/**
* A wrapper for a vector that represents the vector multiplied by a scalar
* constant. This allows for using and altering the value multiplied by a
* constant factor quickly, especially when the multiplicative factor must be
* changed often. Mutable operations will alter the underling vector, and all
* operations will automatically be scaled on a per element basis as needed.
*
* If a point is reached where the multiplicative constant will be infrequently
* modified relative to the use of the vector, it may be more efficient to use
* the original vector scaled appropriately. This can be done by first calling
* {@link #embedScale() } and then calling {@link #getBase() } .
*
* When the multiplicative constant is set to zero, the underlying base vector
* is {@link Vec#zeroOut() zeroed out} and the constant reset to 1.
*
* @author Edward Raff
*/
public class ScaledVector extends Vec
{
private static final long serialVersionUID = 7357893957632067299L;
private double scale;
private Vec base;
/**
* Creates a new scaled vector
* @param scale the initial scaling constant
* @param base the vector to implicitly scale
*/
public ScaledVector(double scale, Vec base)
{
this.scale = scale;
this.base = base;
}
/**
* Creates a new scaled vector with a default scale of 1.
* @param vec the vector to implicitly scale
*/
public ScaledVector(Vec vec)
{
this(1.0, vec);
}
/**
* Returns the current scale in use
* @return the current scale in use
*/
public double getScale()
{
return scale;
}
/**
* Explicitly sets the current scale to the given value
* NOTE: If the scale is set to zero, the underlying base vector will be
* zeroed out, and the scale set to 1.
* @param scale the new multiplicative constant to set for the scale
*/
public void setScale(double scale)
{
if(scale == 0.0)
zeroOut();
else
this.scale = scale;
}
/**
* Returns the base vector that is being scaled
* @return the base vector that is being scaled
*/
public Vec getBase()
{
return base;
}
/**
* Embeds the current scale factor into the base vector, so that the current
* scale factor can be set to 1.
*/
public void embedScale()
{
base.mutableMultiply(scale);
scale = 1;
}
@Override
public int length()
{
return base.length();
}
@Override
public double get(int index)
{
return base.get(index)*scale;
}
@Override
public void set(int index, double val)
{
base.set(index, val/scale);
}
@Override
public void multiply(double c, Matrix A, Vec b)
{
base.multiply(c/scale, A, b);
}
@Override
public void mutableAdd(double c)
{
base.mutableAdd(c/scale);
}
@Override
public void mutableAdd(double c, Vec b)
{
base.mutableAdd(c/scale, b);
}
@Override
public void mutablePairwiseMultiply(Vec b)
{
base.mutablePairwiseMultiply(b);
}
@Override
public void mutableMultiply(double c)
{
scale *= c;
if(scale == 0.0)
this.zeroOut();
else if(Math.abs(scale) < 1e-10 || Math.abs(scale) > 1e10)
embedScale();
}
@Override
public void mutablePairwiseDivide(Vec b)
{
base.mutablePairwiseDivide(b);
}
@Override
public void mutableDivide(double c)
{
scale /= c;
if(scale == 0.0)
this.zeroOut();
}
@Override
public Vec sortedCopy()
{
return new ScaledVector(scale, base.sortedCopy());
}
@Override
public double min()
{
if(scale >= 0)
return base.min()*scale;
else
return base.max()*scale;
}
@Override
public double max()
{
if(scale >= 0)
return base.max()*scale;
else
return base.min()*scale;
}
@Override
public double sum()
{
return scale*base.sum();
}
@Override
public double mean()
{
return scale*base.mean();
}
@Override
public double standardDeviation()
{
return scale*base.standardDeviation();
}
@Override
public double median()
{
return scale*base.median();
}
@Override
public double skewness()
{
return base.skewness();//skew is scale invariant
}
@Override
public double kurtosis()
{
return base.kurtosis(); //kurtosis is scale invariant
}
@Override
public boolean isSparse()
{
return base.isSparse();
}
@Override
public Vec clone()
{
return new ScaledVector(scale, base.clone());
}
@Override
public double pNorm(double p)
{
return scale*base.pNorm(p);
}
@Override
public double dot(Vec v)
{
return scale*base.dot(v);
}
@Override
public double[] arrayCopy()
{
double[] copy = base.arrayCopy();
for(int i = 0; i < copy.length; i++)
copy[i] *= scale;
return copy;
}
@Override
public void zeroOut()
{
scale = 1.0;
base.zeroOut();
}
@Override
public int nnz()
{
return base.nnz();
}
@Override
public Iterator getNonZeroIterator(int start)
{
if(scale == 0)
return Collections.EMPTY_LIST.iterator();
final Iterator origIter = base.getNonZeroIterator(start);
Iterator wrapedIter = new Iterator()
{
@Override
public boolean hasNext()
{
return origIter.hasNext();
}
@Override
public IndexValue next()
{
IndexValue iv = origIter.next();
if( iv != null)
iv.setValue(scale*iv.getValue());
return iv;
}
@Override
public void remove()
{
origIter.remove();
}
};
return wrapedIter;
}
}
Ads help maintain this website.