Class SparseFieldVector<T extends FieldElement<T>>

    • Constructor Detail

      • SparseFieldVector

        public SparseFieldVector​(Field<T> field,
                                 int dimension)
        Construct a (dimension)-length vector of zeros.
        Parameters:
        field - field to which the elements belong
        dimension - Size of the vector
      • SparseFieldVector

        public SparseFieldVector​(Field<T> field,
                                 int dimension,
                                 int expectedSize)
        Build a vector with known the sparseness (for advanced use only).
        Parameters:
        field - field to which the elements belong
        dimension - The size of the vector
        expectedSize - The expected number of non-zero entries
      • SparseFieldVector

        public SparseFieldVector​(Field<T> field,
                                 T[] values)
        Create from a Field array. Only non-zero entries will be stored
        Parameters:
        field - field to which the elements belong
        values - The set of values to create from
      • SparseFieldVector

        public SparseFieldVector​(SparseFieldVector<T> v)
        Copy constructor.
        Parameters:
        v - The instance to copy from
    • Method Detail

      • add

        public FieldVector<T> add​(SparseFieldVector<T> v)
                           throws java.lang.IllegalArgumentException
        Optimized method to add sparse vectors.
        Parameters:
        v - vector to add
        Returns:
        The sum of this and v
        Throws:
        java.lang.IllegalArgumentException - If the dimensions don't match
      • add

        public FieldVector<T> add​(T[] v)
                           throws java.lang.IllegalArgumentException
        Compute the sum of this and v.
        Specified by:
        add in interface FieldVector<T extends FieldElement<T>>
        Parameters:
        v - vector to be added
        Returns:
        this + v
        Throws:
        java.lang.IllegalArgumentException - if v is not the same size as this
      • append

        public FieldVector<T> append​(SparseFieldVector<T> v)
        Construct a vector by appending a vector to this vector.
        Parameters:
        v - vector to append to this one.
        Returns:
        a new vector
      • append

        public FieldVector<T> append​(T d)
        Construct a vector by appending a T to this vector.
        Specified by:
        append in interface FieldVector<T extends FieldElement<T>>
        Parameters:
        d - T to append.
        Returns:
        a new vector
      • append

        public FieldVector<T> append​(T[] a)
        Construct a vector by appending a T array to this vector.
        Specified by:
        append in interface FieldVector<T extends FieldElement<T>>
        Parameters:
        a - T array to append.
        Returns:
        a new vector
      • dotProduct

        public T dotProduct​(FieldVector<T> v)
                     throws java.lang.IllegalArgumentException
        Compute the dot product.
        Specified by:
        dotProduct in interface FieldVector<T extends FieldElement<T>>
        Parameters:
        v - vector with which dot product should be computed
        Returns:
        the scalar dot product between instance and v
        Throws:
        java.lang.IllegalArgumentException - if v is not the same size as this
      • dotProduct

        public T dotProduct​(T[] v)
                     throws java.lang.IllegalArgumentException
        Compute the dot product.
        Specified by:
        dotProduct in interface FieldVector<T extends FieldElement<T>>
        Parameters:
        v - vector with which dot product should be computed
        Returns:
        the scalar dot product between instance and v
        Throws:
        java.lang.IllegalArgumentException - if v is not the same size as this
      • ebeDivide

        public FieldVector<T> ebeDivide​(FieldVector<T> v)
                                 throws java.lang.IllegalArgumentException
        Element-by-element division.
        Specified by:
        ebeDivide in interface FieldVector<T extends FieldElement<T>>
        Parameters:
        v - vector by which instance elements must be divided
        Returns:
        a vector containing this[i] / v[i] for all i
        Throws:
        java.lang.IllegalArgumentException - if v is not the same size as this
      • ebeDivide

        public FieldVector<T> ebeDivide​(T[] v)
                                 throws java.lang.IllegalArgumentException
        Element-by-element division.
        Specified by:
        ebeDivide in interface FieldVector<T extends FieldElement<T>>
        Parameters:
        v - vector by which instance elements must be divided
        Returns:
        a vector containing this[i] / v[i] for all i
        Throws:
        java.lang.IllegalArgumentException - if v is not the same size as this
      • ebeMultiply

        public FieldVector<T> ebeMultiply​(FieldVector<T> v)
                                   throws java.lang.IllegalArgumentException
        Element-by-element multiplication.
        Specified by:
        ebeMultiply in interface FieldVector<T extends FieldElement<T>>
        Parameters:
        v - vector by which instance elements must be multiplied
        Returns:
        a vector containing this[i] * v[i] for all i
        Throws:
        java.lang.IllegalArgumentException - if v is not the same size as this
      • ebeMultiply

        public FieldVector<T> ebeMultiply​(T[] v)
                                   throws java.lang.IllegalArgumentException
        Element-by-element multiplication.
        Specified by:
        ebeMultiply in interface FieldVector<T extends FieldElement<T>>
        Parameters:
        v - vector by which instance elements must be multiplied
        Returns:
        a vector containing this[i] * v[i] for all i
        Throws:
        java.lang.IllegalArgumentException - if v is not the same size as this
      • getData

        public T[] getData()
        Returns vector entries as a T array.
        Specified by:
        getData in interface FieldVector<T extends FieldElement<T>>
        Returns:
        T array of entries
      • getField

        public Field<T> getField()
        Get the type of field elements of the vector.
        Specified by:
        getField in interface FieldVector<T extends FieldElement<T>>
        Returns:
        type of field elements of the vector
      • mapAdd

        public FieldVector<T> mapAdd​(T d)
        Map an addition operation to each entry.
        Specified by:
        mapAdd in interface FieldVector<T extends FieldElement<T>>
        Parameters:
        d - value to be added to each entry
        Returns:
        this + d
      • mapAddToSelf

        public FieldVector<T> mapAddToSelf​(T d)
        Map an addition operation to each entry.

        The instance is changed by this method.

        Specified by:
        mapAddToSelf in interface FieldVector<T extends FieldElement<T>>
        Parameters:
        d - value to be added to each entry
        Returns:
        for convenience, return this
      • mapDivide

        public FieldVector<T> mapDivide​(T d)
        Map a division operation to each entry.
        Specified by:
        mapDivide in interface FieldVector<T extends FieldElement<T>>
        Parameters:
        d - value to divide all entries by
        Returns:
        this / d
      • mapDivideToSelf

        public FieldVector<T> mapDivideToSelf​(T d)
        Map a division operation to each entry.

        The instance is changed by this method.

        Specified by:
        mapDivideToSelf in interface FieldVector<T extends FieldElement<T>>
        Parameters:
        d - value to divide all entries by
        Returns:
        for convenience, return this
      • mapInv

        public FieldVector<T> mapInv()
        Map the 1/x function to each entry.
        Specified by:
        mapInv in interface FieldVector<T extends FieldElement<T>>
        Returns:
        a vector containing the result of applying the function to each entry
      • mapInvToSelf

        public FieldVector<T> mapInvToSelf()
        Map the 1/x function to each entry.

        The instance is changed by this method.

        Specified by:
        mapInvToSelf in interface FieldVector<T extends FieldElement<T>>
        Returns:
        for convenience, return this
      • mapMultiply

        public FieldVector<T> mapMultiply​(T d)
        Map a multiplication operation to each entry.
        Specified by:
        mapMultiply in interface FieldVector<T extends FieldElement<T>>
        Parameters:
        d - value to multiply all entries by
        Returns:
        this * d
      • mapMultiplyToSelf

        public FieldVector<T> mapMultiplyToSelf​(T d)
        Map a multiplication operation to each entry.

        The instance is changed by this method.

        Specified by:
        mapMultiplyToSelf in interface FieldVector<T extends FieldElement<T>>
        Parameters:
        d - value to multiply all entries by
        Returns:
        for convenience, return this
      • mapSubtract

        public FieldVector<T> mapSubtract​(T d)
        Map a subtraction operation to each entry.
        Specified by:
        mapSubtract in interface FieldVector<T extends FieldElement<T>>
        Parameters:
        d - value to be subtracted to each entry
        Returns:
        this - d
      • mapSubtractToSelf

        public FieldVector<T> mapSubtractToSelf​(T d)
        Map a subtraction operation to each entry.

        The instance is changed by this method.

        Specified by:
        mapSubtractToSelf in interface FieldVector<T extends FieldElement<T>>
        Parameters:
        d - value to be subtracted to each entry
        Returns:
        for convenience, return this
      • outerProduct

        public FieldMatrix<T> outerProduct​(SparseFieldVector<T> v)
                                    throws java.lang.IllegalArgumentException
        Optimized method to compute outer product when both vectors are sparse.
        Parameters:
        v - vector with which outer product should be computed
        Returns:
        the square matrix outer product between instance and v
        Throws:
        java.lang.IllegalArgumentException - if v is not the same size as this
      • outerProduct

        public FieldMatrix<T> outerProduct​(T[] v)
                                    throws java.lang.IllegalArgumentException
        Compute the outer product.
        Specified by:
        outerProduct in interface FieldVector<T extends FieldElement<T>>
        Parameters:
        v - vector with which outer product should be computed
        Returns:
        the square matrix outer product between instance and v
        Throws:
        java.lang.IllegalArgumentException - if v is not the same size as this
      • outerProduct

        public FieldMatrix<T> outerProduct​(FieldVector<T> v)
                                    throws java.lang.IllegalArgumentException
        Compute the outer product.
        Specified by:
        outerProduct in interface FieldVector<T extends FieldElement<T>>
        Parameters:
        v - vector with which outer product should be computed
        Returns:
        the square matrix outer product between instance and v
        Throws:
        java.lang.IllegalArgumentException - if v is not the same size as this
      • projection

        public FieldVector<T> projection​(FieldVector<T> v)
                                  throws java.lang.IllegalArgumentException
        Find the orthogonal projection of this vector onto another vector.
        Specified by:
        projection in interface FieldVector<T extends FieldElement<T>>
        Parameters:
        v - vector onto which instance must be projected
        Returns:
        projection of the instance onto v
        Throws:
        java.lang.IllegalArgumentException - if v is not the same size as this
      • projection

        public FieldVector<T> projection​(T[] v)
                                  throws java.lang.IllegalArgumentException
        Find the orthogonal projection of this vector onto another vector.
        Specified by:
        projection in interface FieldVector<T extends FieldElement<T>>
        Parameters:
        v - vector onto which instance must be projected
        Returns:
        projection of the instance onto v
        Throws:
        java.lang.IllegalArgumentException - if v is not the same size as this
      • set

        public void set​(T value)
        Set all elements to a single value.
        Specified by:
        set in interface FieldVector<T extends FieldElement<T>>
        Parameters:
        value - single value to set for all elements
      • subtract

        public SparseFieldVector<T> subtract​(SparseFieldVector<T> v)
                                      throws java.lang.IllegalArgumentException
        Optimized method to subtract SparseRealVectors.
        Parameters:
        v - The vector to subtract from this
        Returns:
        The difference of this and v
        Throws:
        java.lang.IllegalArgumentException - If the dimensions don't match
      • subtract

        public FieldVector<T> subtract​(FieldVector<T> v)
                                throws java.lang.IllegalArgumentException
        Compute this minus v.
        Specified by:
        subtract in interface FieldVector<T extends FieldElement<T>>
        Parameters:
        v - vector to be subtracted
        Returns:
        this + v
        Throws:
        java.lang.IllegalArgumentException - if v is not the same size as this
      • subtract

        public FieldVector<T> subtract​(T[] v)
                                throws java.lang.IllegalArgumentException
        Compute this minus v.
        Specified by:
        subtract in interface FieldVector<T extends FieldElement<T>>
        Parameters:
        v - vector to be subtracted
        Returns:
        this + v
        Throws:
        java.lang.IllegalArgumentException - if v is not the same size as this
      • toArray

        public T[] toArray()
        Convert the vector to a T array.

        The array is independent from vector data, it's elements are copied.

        Specified by:
        toArray in interface FieldVector<T extends FieldElement<T>>
        Returns:
        array containing a copy of vector elements
      • add

        public FieldVector<T> add​(FieldVector<T> v)
                           throws java.lang.IllegalArgumentException
        Compute the sum of this and v.
        Specified by:
        add in interface FieldVector<T extends FieldElement<T>>
        Parameters:
        v - vector to be added
        Returns:
        this + v
        Throws:
        java.lang.IllegalArgumentException - if v is not the same size as this
      • hashCode

        public int hashCode()
        Overrides:
        hashCode in class java.lang.Object
      • equals

        public boolean equals​(java.lang.Object obj)
        Overrides:
        equals in class java.lang.Object