DoubleVectorData.java
package org.djunits.value.vdouble.vector;
import java.util.Arrays;
import java.util.List;
import java.util.SortedMap;
import java.util.stream.IntStream;
import org.djunits.unit.scale.Scale;
import org.djunits.value.StorageType;
import org.djunits.value.ValueException;
import org.djunits.value.vdouble.scalar.DoubleScalarInterface;
/**
* Stores the data for a DoubleVector and carries out basic operations.
* <p>
* Copyright (c) 2013-2019 Delft University of Technology, PO Box 5, 2600 AA, Delft, the Netherlands. All rights reserved. <br>
* BSD-style license. See <a href="http://opentrafficsim.org/docs/license.html">OpenTrafficSim License</a>.
* </p>
* $LastChangedDate: 2015-07-24 02:58:59 +0200 (Fri, 24 Jul 2015) $, @version $Revision: 1147 $, by $Author: averbraeck $,
* initial version Oct 3, 2015 <br>
* @author <a href="http://www.tbm.tudelft.nl/averbraeck">Alexander Verbraeck</a>
* @author <a href="http://www.tudelft.nl/pknoppers">Peter Knoppers</a>
*/
abstract class DoubleVectorData
{
/** the internal storage of the Vector; can be sparse or dense. */
@SuppressWarnings("checkstyle:visibilitymodifier")
protected double[] vectorSI;
/** the data type. */
private final StorageType storageType;
/** threshold to do parallel execution. */
protected static final int PARALLEL_THRESHOLD = 1000;
/**
* @param storageType StorageType; the data type.
*/
DoubleVectorData(final StorageType storageType)
{
super();
this.storageType = storageType;
}
/* ============================================================================================ */
/* ====================================== INSTANTIATION ======================================= */
/* ============================================================================================ */
/**
* Instantiate a DoubleVectorData with the right data type.
* @param values double[]; the (SI) values to store
* @param scale Scale; the scale of the unit to use for conversion to SI
* @param storageType StorageType; the data type to use
* @return the DoubleVectorData with the right data type
* @throws ValueException when values are null, or storageType is null
*/
public static DoubleVectorData instantiate(final double[] values, final Scale scale, final StorageType storageType)
throws ValueException
{
if (values == null)
{
throw new ValueException("DoubleVectorData.instantiate: double[] values is null");
}
double[] valuesSI = scale.isBaseSIScale() ? values : new double[values.length];
if (!scale.isBaseSIScale())
{
if (values.length > PARALLEL_THRESHOLD)
{
IntStream.range(0, values.length).parallel().forEach(i -> valuesSI[i] = scale.toStandardUnit(values[i]));
}
else
{
IntStream.range(0, values.length).forEach(i -> valuesSI[i] = scale.toStandardUnit(values[i]));
}
}
switch (storageType)
{
case DENSE:
return new DoubleVectorDataDense(valuesSI);
case SPARSE:
return DoubleVectorDataSparse.instantiate(valuesSI);
default:
throw new ValueException("Unknown data type in DoubleVectorData.instantiate: " + storageType);
}
}
/**
* Instantiate a DoubleVectorData with the right data type.
* @param values List<Double>; the values to store
* @param scale Scale; the scale of the unit to use for conversion to SI
* @param storageType StorageType; the data type to use
* @return the DoubleVectorData with the right data type
* @throws ValueException when list is null, or storageType is null
*/
public static DoubleVectorData instantiate(final List<Double> values, final Scale scale, final StorageType storageType)
throws ValueException
{
if (values == null)
{
throw new ValueException("DoubleVectorData.instantiate: List<Double> values is null");
}
double[] valuesSI;
if (values.size() > PARALLEL_THRESHOLD)
{
if (scale.isBaseSIScale())
{
valuesSI = values.parallelStream().mapToDouble(d -> d).toArray();
}
else
{
valuesSI = values.parallelStream().mapToDouble(d -> scale.toStandardUnit(d)).toArray();
}
}
else
{
if (scale.isBaseSIScale())
{
valuesSI = values.stream().mapToDouble(d -> d).toArray();
}
else
{
valuesSI = values.stream().mapToDouble(d -> scale.toStandardUnit(d)).toArray();
}
}
switch (storageType)
{
case DENSE:
return new DoubleVectorDataDense(valuesSI);
case SPARSE:
return DoubleVectorDataSparse.instantiate(valuesSI);
default:
throw new ValueException("Unknown data type in DoubleVectorData.instantiate: " + storageType);
}
}
/**
* Instantiate a DoubleVectorData with the right data type.
* @param values DoubleScalarInterface[]; the values to store
* @param storageType StorageType; the data type to use
* @return the DoubleVectorData with the right data type
* @throws ValueException when values is null, or storageType is null
*/
public static DoubleVectorData instantiate(final DoubleScalarInterface[] values, final StorageType storageType)
throws ValueException
{
if (values == null)
{
throw new ValueException("DoubleVectorData.instantiate: DoubleScalar[] values is null");
}
double[] valuesSI;
if (values.length > PARALLEL_THRESHOLD)
{
valuesSI = Arrays.stream(values).parallel().mapToDouble(s -> s.getSI()).toArray();
}
else
{
valuesSI = Arrays.stream(values).mapToDouble(s -> s.getSI()).toArray();
}
switch (storageType)
{
case DENSE:
return new DoubleVectorDataDense(valuesSI);
case SPARSE:
return DoubleVectorDataSparse.instantiate(valuesSI);
default:
throw new ValueException("Unknown data type in DoubleVectorData.instantiate: " + storageType);
}
}
/**
* Instantiate a DoubleVectorData with the right data type.
* @param values List<? extends DoubleScalarInterface>; the DoubleScalar values to store
* @param storageType StorageType; the data type to use
* @return the DoubleVectorData with the right data type
* @throws ValueException when values is null, or storageType is null
*/
public static DoubleVectorData instantiateLD(final List<? extends DoubleScalarInterface> values,
final StorageType storageType) throws ValueException
{
if (values == null)
{
throw new ValueException("DoubleVectorData.instantiate: values list is null");
}
double[] valuesSI = values.parallelStream().mapToDouble(s -> s.getSI()).toArray();
switch (storageType)
{
case DENSE:
return new DoubleVectorDataDense(valuesSI);
case SPARSE:
return DoubleVectorDataSparse.instantiate(valuesSI);
default:
throw new ValueException("Unknown data type in DoubleVectorData.instantiate: " + storageType);
}
}
/**
* Instantiate a DoubleVectorData with the right data type.
* @param values SortedMap<Integer,S>; the DoubleScalar values to store
* @param length int; the length of the vector to pad with 0 after last entry in map
* @param storageType StorageType; the data type to use
* @param <S> the scalar type to use
* @return the DoubleVectorData with the right data type
* @throws ValueException when values is null, or storageType is null
*/
public static <S extends DoubleScalarInterface> DoubleVectorData instantiateMD(final SortedMap<Integer, S> values,
final int length, final StorageType storageType) throws ValueException
{
if (values == null)
{
throw new ValueException("DoubleVectorData.instantiate: values map is null");
}
switch (storageType)
{
case DENSE:
{
double[] valuesSI = values.keySet().parallelStream().mapToDouble(index -> values.get(index).getSI()).toArray();
return new DoubleVectorDataDense(valuesSI);
}
case SPARSE:
{
int[] indices = values.keySet().parallelStream().mapToInt(i -> i).toArray();
double[] valuesSI = values.values().parallelStream().mapToDouble(s -> s.getSI()).toArray();
return new DoubleVectorDataSparse(valuesSI, indices, length);
}
default:
throw new ValueException("Unknown data type in DoubleVectorData.instantiate: " + storageType);
}
}
/**
* Instantiate a DoubleVectorData with the right data type.
* @param values SortedMap<Integer,Double>; the DoubleScalar values to store
* @param length int; the length of the vector to pad with 0 after last entry in map
* @param scale Scale; the scale of the unit to use for conversion to SI
* @param storageType StorageType; the data type to use
* @return the DoubleVectorData with the right data type
* @throws ValueException when values is null, or storageType is null
*/
public static DoubleVectorData instantiate(final SortedMap<Integer, Double> values, final int length, final Scale scale,
final StorageType storageType) throws ValueException
{
if (values == null)
{
throw new ValueException("DoubleVectorData.instantiate: values map is null");
}
switch (storageType)
{
case DENSE:
{
double[] valuesSI = values.keySet().parallelStream()
.mapToDouble(index -> scale.toStandardUnit(values.get(index))).toArray();
return new DoubleVectorDataDense(valuesSI);
}
case SPARSE:
{
int[] indices = values.keySet().parallelStream().mapToInt(i -> i).toArray();
double[] valuesSI = values.values().parallelStream().mapToDouble(d -> scale.toStandardUnit(d)).toArray();
return new DoubleVectorDataSparse(valuesSI, indices, length);
}
default:
throw new ValueException("Unknown data type in DoubleVectorData.instantiate: " + storageType);
}
}
/* ============================================================================================ */
/* ==================================== UTILITY FUNCTIONS ===================================== */
/* ============================================================================================ */
/**
* Return the StorageType (DENSE, SPARSE, etc.) for the stored Vector.
* @return the StorageType (DENSE, SPARSE, etc.) for the stored Vector
*/
public final StorageType getStorageType()
{
return this.storageType;
}
/**
* @return the size of the vector
*/
public abstract int size();
/**
* @return whether data type is sparse.
*/
public boolean isSparse()
{
return this.storageType.equals(StorageType.SPARSE);
}
/**
* @return the sparse transformation of this data
*/
public DoubleVectorDataSparse toSparse()
{
return isSparse() ? (DoubleVectorDataSparse) this : ((DoubleVectorDataDense) this).toSparse();
}
/**
* @return whether data type is dense.
*/
public boolean isDense()
{
return this.storageType.equals(StorageType.DENSE);
}
/**
* @return the dense transformation of this data
*/
public DoubleVectorDataDense toDense()
{
return isDense() ? (DoubleVectorDataDense) this : ((DoubleVectorDataSparse) this).toDense();
}
/**
* @param index int; the index to get the value for
* @return the value at the index
*/
public abstract double getSI(int index);
/**
* Sets a value at the index in the vector.
* @param index int; the index to set the value for
* @param valueSI double; the value at the index
*/
public abstract void setSI(int index, double valueSI);
/**
* @return the number of non-zero cells.
*/
public final int cardinality()
{
return (int) Arrays.stream(this.vectorSI).parallel().filter(d -> d != 0.0).count();
}
/**
* @return the sum of the values of all cells.
*/
public final double zSum()
{
return Arrays.stream(this.vectorSI).parallel().sum();
}
/**
* @return a deep copy of the data.
*/
public abstract DoubleVectorData copy();
/**
* @return a safe copy of VectorSI
*/
public abstract double[] getDenseVectorSI();
/**
* Check the sizes of this data object and the other data object.
* @param other DoubleVectorData; the other data object
* @throws ValueException if vectors have different lengths
*/
private void checkSizes(final DoubleVectorData other) throws ValueException
{
if (this.size() != other.size())
{
throw new ValueException("Two data objects used in a DoubleVector operation do not have the same size");
}
}
/* ============================================================================================ */
/* ================================== CALCULATION FUNCTIONS =================================== */
/* ============================================================================================ */
/**
* Add two vectors on a cell-by-cell basis. If both vectors are sparse, a sparse vector is returned, otherwise a dense
* vector is returned.
* @param right DoubleVectorData; the other data object to add
* @return the sum of this data object and the other data object
* @throws ValueException if vectors have different lengths
*/
public DoubleVectorData plus(final DoubleVectorData right) throws ValueException
{
checkSizes(right);
double[] dv = IntStream.range(0, size()).parallel().mapToDouble(i -> getSI(i) + right.getSI(i)).toArray();
if (this instanceof DoubleVectorDataSparse && right instanceof DoubleVectorDataSparse)
{
return new DoubleVectorDataDense(dv).toSparse();
}
return new DoubleVectorDataDense(dv);
}
/**
* Add a vector to this vector on a cell-by-cell basis. The type of vector (sparse, dense) stays the same.
* @param right DoubleVectorData; the other data object to add
* @throws ValueException if vectors have different lengths
*/
public abstract void incrementBy(DoubleVectorData right) throws ValueException;
/**
* Add a number to this vector on a cell-by-cell basis.
* @param valueSI double; the value to add
*/
public void incrementBy(final double valueSI)
{
IntStream.range(0, this.vectorSI.length).parallel().forEach(i -> this.vectorSI[i] += valueSI);
}
/**
* Subtract two vectors on a cell-by-cell basis. If both vectors are sparse, a sparse vector is returned, otherwise a dense
* vector is returned.
* @param right DoubleVectorData; the other data object to subtract
* @return the sum of this data object and the other data object
* @throws ValueException if vectors have different lengths
*/
public DoubleVectorData minus(final DoubleVectorData right) throws ValueException
{
checkSizes(right);
double[] dv = IntStream.range(0, size()).parallel().mapToDouble(i -> getSI(i) - right.getSI(i)).toArray();
if (this instanceof DoubleVectorDataSparse && right instanceof DoubleVectorDataSparse)
{
return new DoubleVectorDataDense(dv).toSparse();
}
return new DoubleVectorDataDense(dv);
}
/**
* Subtract a vector from this vector on a cell-by-cell basis. The type of vector (sparse, dense) stays the same.
* @param right DoubleVectorData; the other data object to subtract
* @throws ValueException if vectors have different lengths
*/
public abstract void decrementBy(DoubleVectorData right) throws ValueException;
/**
* Subtract a number from this vector on a cell-by-cell basis.
* @param valueSI double; the value to subtract
*/
public void decrementBy(final double valueSI)
{
IntStream.range(0, this.vectorSI.length).parallel().forEach(i -> this.vectorSI[i] -= valueSI);
}
/**
* Multiply two vector on a cell-by-cell basis. If both vectors are dense, a dense vector is returned, otherwise a sparse
* vector is returned.
* @param right DoubleVectorData; the other data object to multiply with
* @return the sum of this data object and the other data object
* @throws ValueException if vectors have different lengths
*/
public DoubleVectorData times(final DoubleVectorData right) throws ValueException
{
checkSizes(right);
double[] dv = IntStream.range(0, size()).parallel().mapToDouble(i -> getSI(i) * right.getSI(i)).toArray();
if (this instanceof DoubleVectorDataDense && right instanceof DoubleVectorDataDense)
{
return new DoubleVectorDataDense(dv);
}
return new DoubleVectorDataDense(dv).toSparse();
}
/**
* Multiply a vector with the values of another vector on a cell-by-cell basis. The type of vector (sparse, dense) stays the
* same.
* @param right DoubleVectorData; the other data object to multiply with
* @throws ValueException if vectors have different lengths
*/
public abstract void multiplyBy(DoubleVectorData right) throws ValueException;
/**
* Multiply the values of this vector with a number on a cell-by-cell basis.
* @param valueSI double; the value to multiply with
*/
public void multiplyBy(final double valueSI)
{
IntStream.range(0, this.vectorSI.length).parallel().forEach(i -> this.vectorSI[i] *= valueSI);
}
/**
* Divide two vectors on a cell-by-cell basis. If both vectors are dense, a dense vector is returned, otherwise a sparse
* vector is returned.
* @param right DoubleVectorData; the other data object to divide by
* @return the sum of this data object and the other data object
* @throws ValueException if vectors have different lengths
*/
public DoubleVectorData divide(final DoubleVectorData right) throws ValueException
{
checkSizes(right);
double[] dv = IntStream.range(0, size()).parallel().mapToDouble(i -> getSI(i) / right.getSI(i)).toArray();
if (this instanceof DoubleVectorDataDense && right instanceof DoubleVectorDataDense)
{
return new DoubleVectorDataDense(dv);
}
return new DoubleVectorDataDense(dv).toSparse();
}
/**
* Divide the values of a vector by the values of another vector on a cell-by-cell basis. The type of vector (sparse, dense)
* stays the same.
* @param right DoubleVectorData; the other data object to divide by
* @throws ValueException if vectors have different lengths
*/
public abstract void divideBy(DoubleVectorData right) throws ValueException;
/**
* Divide the values of this vector by a number on a cell-by-cell basis.
* @param valueSI double; the value to multiply with
*/
public void divideBy(final double valueSI)
{
IntStream.range(0, this.vectorSI.length).parallel().forEach(i -> this.vectorSI[i] /= valueSI);
}
/* ============================================================================================ */
/* =============================== EQUALS, HASHCODE, TOSTRING ================================= */
/* ============================================================================================ */
/** {@inheritDoc} */
@Override
public int hashCode()
{
final int prime = 31;
int result = 1;
result = prime * result + Arrays.hashCode(this.vectorSI);
return result;
}
/** {@inheritDoc} */
@Override
@SuppressWarnings("checkstyle:needbraces")
public boolean equals(final Object obj)
{
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
DoubleVectorData other = (DoubleVectorData) obj;
if (!Arrays.equals(this.vectorSI, other.vectorSI))
return false;
return true;
}
/** {@inheritDoc} */
@Override
public String toString()
{
return "DoubleVectorData [storageType=" + this.storageType + ", vectorSI=" + Arrays.toString(this.vectorSI) + "]";
}
}