in commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/linear/RealVector.java [1211:1628]
public static RealVector unmodifiableRealVector(final RealVector v) {
/*
* This anonymous class is an implementation of {@link RealVector}
* with read-only access.
* It wraps any {@link RealVector}, and exposes all methods which
* do not modify it. Invoking methods which should normally result
* in the modification of the calling {@link RealVector} results in
* a {@link MathUnsupportedOperationException}. It should be noted
* that {@link UnmodifiableVector} is <em>not</em> immutable.
*/
return new RealVector() {
/**
* {@inheritDoc}
*
* @throws MathUnsupportedOperationException in all circumstances.
*/
@Override
public RealVector mapToSelf(UnivariateFunction function)
throws MathUnsupportedOperationException {
throw new MathUnsupportedOperationException();
}
/** {@inheritDoc} */
@Override
public RealVector map(UnivariateFunction function) {
return v.map(function);
}
/** {@inheritDoc} */
@Override
public Iterator<Entry> iterator() {
final Iterator<Entry> i = v.iterator();
return new Iterator<Entry>() {
/** The current entry. */
private final UnmodifiableEntry e = new UnmodifiableEntry();
/** {@inheritDoc} */
@Override
public boolean hasNext() {
return i.hasNext();
}
/** {@inheritDoc} */
@Override
public Entry next() {
e.setIndex(i.next().getIndex());
return e;
}
/**
* {@inheritDoc}
*
* @throws MathUnsupportedOperationException in all
* circumstances.
*/
@Override
public void remove() throws MathUnsupportedOperationException {
throw new MathUnsupportedOperationException();
}
};
}
/** {@inheritDoc} */
@Override
public Iterator<Entry> sparseIterator() {
final Iterator<Entry> i = v.sparseIterator();
return new Iterator<Entry>() {
/** The current entry. */
private final UnmodifiableEntry e = new UnmodifiableEntry();
/** {@inheritDoc} */
@Override
public boolean hasNext() {
return i.hasNext();
}
/** {@inheritDoc} */
@Override
public Entry next() {
e.setIndex(i.next().getIndex());
return e;
}
/**
* {@inheritDoc}
*
* @throws MathUnsupportedOperationException in all
* circumstances.
*/
@Override
public void remove()
throws MathUnsupportedOperationException {
throw new MathUnsupportedOperationException();
}
};
}
/** {@inheritDoc} */
@Override
public RealVector copy() {
return v.copy();
}
/** {@inheritDoc} */
@Override
public RealVector add(RealVector w)
throws DimensionMismatchException {
return v.add(w);
}
/** {@inheritDoc} */
@Override
public RealVector subtract(RealVector w)
throws DimensionMismatchException {
return v.subtract(w);
}
/** {@inheritDoc} */
@Override
public RealVector mapAdd(double d) {
return v.mapAdd(d);
}
/**
* {@inheritDoc}
*
* @throws MathUnsupportedOperationException in all
* circumstances.
*/
@Override
public RealVector mapAddToSelf(double d)
throws MathUnsupportedOperationException {
throw new MathUnsupportedOperationException();
}
/** {@inheritDoc} */
@Override
public RealVector mapSubtract(double d) {
return v.mapSubtract(d);
}
/**
* {@inheritDoc}
*
* @throws MathUnsupportedOperationException in all
* circumstances.
*/
@Override
public RealVector mapSubtractToSelf(double d)
throws MathUnsupportedOperationException {
throw new MathUnsupportedOperationException();
}
/** {@inheritDoc} */
@Override
public RealVector mapMultiply(double d) {
return v.mapMultiply(d);
}
/**
* {@inheritDoc}
*
* @throws MathUnsupportedOperationException in all
* circumstances.
*/
@Override
public RealVector mapMultiplyToSelf(double d)
throws MathUnsupportedOperationException {
throw new MathUnsupportedOperationException();
}
/** {@inheritDoc} */
@Override
public RealVector mapDivide(double d) {
return v.mapDivide(d);
}
/**
* {@inheritDoc}
*
* @throws MathUnsupportedOperationException in all
* circumstances.
*/
@Override
public RealVector mapDivideToSelf(double d)
throws MathUnsupportedOperationException {
throw new MathUnsupportedOperationException();
}
/** {@inheritDoc} */
@Override
public RealVector ebeMultiply(RealVector w)
throws DimensionMismatchException {
return v.ebeMultiply(w);
}
/** {@inheritDoc} */
@Override
public RealVector ebeDivide(RealVector w)
throws DimensionMismatchException {
return v.ebeDivide(w);
}
/** {@inheritDoc} */
@Override
public double dotProduct(RealVector w)
throws DimensionMismatchException {
return v.dotProduct(w);
}
/** {@inheritDoc} */
@Override
public double cosine(RealVector w)
throws DimensionMismatchException, MathArithmeticException {
return v.cosine(w);
}
/** {@inheritDoc} */
@Override
public double getNorm() {
return v.getNorm();
}
/** {@inheritDoc} */
@Override
public double getL1Norm() {
return v.getL1Norm();
}
/** {@inheritDoc} */
@Override
public double getLInfNorm() {
return v.getLInfNorm();
}
/** {@inheritDoc} */
@Override
public double getDistance(RealVector w)
throws DimensionMismatchException {
return v.getDistance(w);
}
/** {@inheritDoc} */
@Override
public double getL1Distance(RealVector w)
throws DimensionMismatchException {
return v.getL1Distance(w);
}
/** {@inheritDoc} */
@Override
public double getLInfDistance(RealVector w)
throws DimensionMismatchException {
return v.getLInfDistance(w);
}
/** {@inheritDoc} */
@Override
public RealVector unitVector() throws MathArithmeticException {
return v.unitVector();
}
/**
* {@inheritDoc}
*
* @throws MathUnsupportedOperationException in all
* circumstances.
*/
@Override
public void unitize() throws MathUnsupportedOperationException {
throw new MathUnsupportedOperationException();
}
/** {@inheritDoc} */
@Override
public RealMatrix outerProduct(RealVector w) {
return v.outerProduct(w);
}
/** {@inheritDoc} */
@Override
public double getEntry(int index) throws OutOfRangeException {
return v.getEntry(index);
}
/**
* {@inheritDoc}
*
* @throws MathUnsupportedOperationException in all
* circumstances.
*/
@Override
public void setEntry(int index, double value)
throws MathUnsupportedOperationException {
throw new MathUnsupportedOperationException();
}
/**
* {@inheritDoc}
*
* @throws MathUnsupportedOperationException in all
* circumstances.
*/
@Override
public void addToEntry(int index, double value)
throws MathUnsupportedOperationException {
throw new MathUnsupportedOperationException();
}
/** {@inheritDoc} */
@Override
public int getDimension() {
return v.getDimension();
}
/** {@inheritDoc} */
@Override
public RealVector append(RealVector w) {
return v.append(w);
}
/** {@inheritDoc} */
@Override
public RealVector append(double d) {
return v.append(d);
}
/** {@inheritDoc} */
@Override
public RealVector getSubVector(int index, int n)
throws OutOfRangeException, NotPositiveException {
return v.getSubVector(index, n);
}
/**
* {@inheritDoc}
*
* @throws MathUnsupportedOperationException in all
* circumstances.
*/
@Override
public void setSubVector(int index, RealVector w)
throws MathUnsupportedOperationException {
throw new MathUnsupportedOperationException();
}
/**
* {@inheritDoc}
*
* @throws MathUnsupportedOperationException in all
* circumstances.
*/
@Override
public void set(double value)
throws MathUnsupportedOperationException {
throw new MathUnsupportedOperationException();
}
/** {@inheritDoc} */
@Override
public double[] toArray() {
return v.toArray();
}
/** {@inheritDoc} */
@Override
public boolean isNaN() {
return v.isNaN();
}
/** {@inheritDoc} */
@Override
public boolean isInfinite() {
return v.isInfinite();
}
/** {@inheritDoc} */
@Override
public RealVector combine(double a, double b, RealVector y)
throws DimensionMismatchException {
return v.combine(a, b, y);
}
/**
* {@inheritDoc}
*
* @throws MathUnsupportedOperationException in all
* circumstances.
*/
@Override
public RealVector combineToSelf(double a, double b, RealVector y)
throws MathUnsupportedOperationException {
throw new MathUnsupportedOperationException();
}
/** An entry in the vector. */
class UnmodifiableEntry extends Entry {
/** {@inheritDoc} */
@Override
public double getValue() {
return v.getEntry(getIndex());
}
/**
* {@inheritDoc}
*
* @throws MathUnsupportedOperationException in all
* circumstances.
*/
@Override
public void setValue(double value)
throws MathUnsupportedOperationException {
throw new MathUnsupportedOperationException();
}
}
};
}