Package org.djunits.value.vfloat.vector.base

Class AbstractFloatVectorRel<U extends Unit<U>,​S extends AbstractFloatScalarRel<U,​S>,​RV extends AbstractFloatVectorRel<U,​S,​RV>>

    • Constructor Detail

      • AbstractFloatVectorRel

        protected AbstractFloatVectorRel​(FloatVectorData data,
                                 U unit)
        Construct a new Relative Mutable FloatVector.
        Parameters:
        data - FloatVectorData; an internal data object
        unit - U; the unit

    • Method Detail

      • zSum

        public final S zSum()
        Compute the sum of all SI values of this vector.
        Returns:
        S; the sum of all values of this vector with the same display unit as this vector

      • plus

        public final RV plus​(RV rel)
              throws ValueRuntimeException
        Add a relative vector to this relative mutable vector. A new vector is returned. When the vector itself needs to be changed, use the increaseBy(V) method instead. The addition is done value by value and the result is stored in a new vector. If both operands are sparse, the result is a sparse vector, otherwise the result is a dense vector.
        Specified by:
        plus in interface Vector.Rel<U extends Unit<U>,​S extends AbstractFloatScalarRel<U,​S>,​RV extends AbstractFloatVectorRel<U,​S,​RV>>
        Parameters:
        rel - RV; the relative vector (mutable or immutable, sparse or dense) to add
        Returns:
        RMV; the sum of this vector and the operand as a new relative, mutable vector
        Throws:
        ValueRuntimeException - in case this vector and the operand have a different size

      • minus

        public final RV minus​(RV rel)
               throws ValueRuntimeException
        Subtract a relative vector from this relative mutable vector. The display unit of the result is the display unit of this absolute vector. The subtraction is done value by value and the result is stored in a new vector. If both operands are sparse, the result is a sparse vector, otherwise the result is a dense vector.
        Specified by:
        minus in interface Vector.Rel<U extends Unit<U>,​S extends AbstractFloatScalarRel<U,​S>,​RV extends AbstractFloatVectorRel<U,​S,​RV>>
        Parameters:
        rel - RV; the value to subtract
        Returns:
        RMV; the difference of this vector and the operand as a new relative, mutable vector
        Throws:
        ValueRuntimeException - in case this vector and the operand have a different size

      • incrementBy

        public RV incrementBy​(S increment)
        Increment all values of this vector by the increment. This only works if the vector is mutable.
        Parameters:
        increment - S; the scalar by which to increment all values
        Returns:
        RV; this modified vector
        Throws:
        ValueRuntimeException - in case this vector is immutable

      • incrementBy

        public RV incrementBy​(RV increment)
        Increment all values of this vector by the increment on a value by value basis. This only works if this vector is mutable.
        Parameters:
        increment - RV; the vector that contains the values by which to increment the corresponding values
        Returns:
        RV; this modified vector
        Throws:
        ValueRuntimeException - in case this vector is immutable or when the sizes of the vectors differ

      • decrementBy

        public RV decrementBy​(S decrement)
        Decrement all values of this vector by the decrement. This only works if the vector is mutable.
        Parameters:
        decrement - S; the scalar by which to decrement all values
        Returns:
        RV; this modified vector
        Throws:
        ValueRuntimeException - in case this vector is immutable

      • decrementBy

        public RV decrementBy​(RV decrement)
        Decrement all values of this vector by the decrement on a value by value basis. This only works if this vector is mutable.
        Parameters:
        decrement - RV; the vector that contains the values by which to decrement the corresponding values
        Returns:
        RV; this modified vector
        Throws:
        ValueRuntimeException - in case this vector is immutable or when the sizes of the vectors differ

      • multiplyBy

        public final RV multiplyBy​(double multiplier)
        Multiply all values of this vector by the multiplier. This only works if the vector is mutable.
        Specified by:
        multiplyBy in interface Vector.Rel<U extends Unit<U>,​S extends AbstractFloatScalarRel<U,​S>,​RV extends AbstractFloatVectorRel<U,​S,​RV>>
        Parameters:
        multiplier - double; the factor by which to multiply all values
        Returns:
        V; this modified vector

      • divideBy

        public RV divideBy​(double divisor)
        Divide all values of this vector by the divisor. This only works if the vector is mutable.
        Specified by:
        divideBy in interface Vector.Rel<U extends Unit<U>,​S extends AbstractFloatScalarRel<U,​S>,​RV extends AbstractFloatVectorRel<U,​S,​RV>>
        Parameters:
        divisor - double; the value by which to divide all values
        Returns:
        V; this modified vector

      • times

        public final <UT extends Unit<UT>,​ST extends AbstractFloatScalarRel<UT,​ST>,​VT extends AbstractFloatVectorRel<UT,​ST,​VT> & Relative<UT,​VT>> FloatSIVector times​(VT rel)
                                                                                                                                                                                           throws ValueRuntimeException,
                                                                                                                                                                                                  UnitException
        Multiply a Relative value with this Relative value for a vector or matrix. The multiplication is done value by value and store the result in a new Relative value. If both operands are dense, the result is a dense vector or matrix, otherwise the result is a sparse vector or matrix.
        Type Parameters:
        UT - the unit type of the multiplier
        ST - the scalar type of the multiplier
        VT - the vector type of the multiplier
        Parameters:
        rel - VT; the right operand, which can be any vector type
        Returns:
        FloatSIVector; the multiplication of this vector and the operand
        Throws:
        ValueRuntimeException - in case this vector or matrix and the operand have a different size
        UnitException - on unit error

      • divide

        public final <UT extends Unit<UT>,​ST extends AbstractFloatScalarRel<UT,​ST>,​VT extends AbstractFloatVectorRel<UT,​ST,​VT> & Relative<UT,​VT>> FloatSIVector divide​(VT rel)
                                                                                                                                                                                            throws ValueRuntimeException,
                                                                                                                                                                                                   UnitException
        Divide this Relative value by a Relative value for a vector or matrix. The division is done value by value and store the result in a new Relative value. If both operands are dense, the result is a dense vector or matrix, otherwise the result is a sparse vector or matrix.
        Type Parameters:
        UT - the unit type of the multiplier
        ST - the scalar type of the multiplier
        VT - the vector type of the multiplier
        Parameters:
        rel - VT; the right operand, which can be any vector type
        Returns:
        FloatSIVector; the division of this vector and the operand
        Throws:
        ValueRuntimeException - in case this vector or matrix and the operand have a different size
        UnitException - on unit error

      • times

        public RV times​(double multiplier)
        Returns a new scalar/vector/matrix with value(s) multiplied by a factor.
        Specified by:
        times in interface Relative<U extends Unit<U>,​S extends AbstractFloatScalarRel<U,​S>>
        Parameters:
        multiplier - double; the multiplier
        Returns:
        T; a new scalar/vector/matrix

      • divide

        public RV divide​(double divisor)
        Returns a new scalar/vector/matrix with value(s) divided by a factor.
        Specified by:
        divide in interface Relative<U extends Unit<U>,​S extends AbstractFloatScalarRel<U,​S>>
        Parameters:
        divisor - double; the divisor
        Returns:
        T; the modified T

      • times

        public RV times​(float multiplier)
        Returns a new scalar/vector/matrix with value(s) multiplied by a factor.
        Specified by:
        times in interface Relative<U extends Unit<U>,​S extends AbstractFloatScalarRel<U,​S>>
        Parameters:
        multiplier - float; the multiplier
        Returns:
        T; a new scalar/vector/matrix

      • divide

        public RV divide​(float divisor)
        Returns a new scalar/vector/matrix with value(s) divided by a factor.
        Specified by:
        divide in interface Relative<U extends Unit<U>,​S extends AbstractFloatScalarRel<U,​S>>
        Parameters:
        divisor - float; the divisor
        Returns:
        T; the modified T