Class SparseArray<N extends java.lang.Comparable<N>>

    • Field Detail

      • myActualLength

        private int myActualLength
        The actual number of nonzwero elements
      • myCount

        private final long myCount
      • myDenseFactory

        private final DenseArray.Factory<N extends java.lang.Comparable<N>> myDenseFactory
      • myIndices

        private long[] myIndices
      • myValues

        private DenseArray<N extends java.lang.Comparable<N>> myValues
      • myZeroNumber

        private final N extends java.lang.Comparable<N> myZeroNumber
      • myZeroScalar

        private final Scalar<N extends java.lang.Comparable<N>> myZeroScalar
      • myZeroValue

        private final double myZeroValue
    • Method Detail

      • add

        public void add​(long index,
                        java.lang.Comparable<?> addend)
      • add

        public void add​(long index,
                        double addend)
      • add

        public void add​(long index,
                        float addend)
      • axpy

        public void axpy​(double a,
                         Mutate1D.Modifiable<?> y)
        Description copied from interface: Access1D
        Will calculate y = y + a x, will add "a" times "this" to "y"
        Parameters:
        a - The scale
        y - The "vector" to update
      • count

        public long count()
        Description copied from interface: Structure1D
        The total number of elements in this structure.

        You only need to implement this method if the structure can contain more than Integer.MAX_VALUE elements.

      • countNonzeros

        public int countNonzeros()
      • countZeros

        public long countZeros()
      • dot

        public double dot​(Access1D<?> vector)
        Description copied from interface: Access1D
        Will calculate and return the dot product of this 1D-structure and another input 1D-vector.
        Parameters:
        vector - Another 1D-structure
        Returns:
        The dot product
      • doubleValue

        public double doubleValue​(int index)
      • doubleValue

        public double doubleValue​(long index)
      • fillAll

        public void fillAll​(N value)
      • fillRange

        public void fillRange​(long first,
                              long limit,
                              N value)
      • fillRange

        public void fillRange​(long first,
                              long limit,
                              NullaryFunction<?> supplier)
      • firstInRange

        public long firstInRange​(long rangeFirst,
                                 long rangeLimit)
      • get

        public N get​(long index)
      • limitOfRange

        public long limitOfRange​(long rangeFirst,
                                 long rangeLimit)
      • modifyOne

        public void modifyOne​(long index,
                              UnaryFunction<N> modifier)
      • nonzeros

        public SparseArray.NonzeroView<N> nonzeros()
        Description copied from interface: Access1D
        Similar to Access1D.elements() but avoids elements that are structurally known to be zero. (That does not eliminate all zero-values from this view.) With an arbitrary (dense) unstructured implementation the Access1D.nonzeros() and Access1D.elements() methods do the same thing! Only some specific implementations are able to actually exploit structure/sparsity to view fewer elements.
      • reset

        public void reset()
        Description copied from interface: Mutate1D
        Reset this mutable structure to some standard (all zeros) initial state. It must still be usuable after this call, and the structure/size/shape must not change.
      • set

        public void set​(int index,
                        double value)
      • set

        public void set​(long index,
                        java.lang.Comparable<?> value)
      • set

        public void set​(long index,
                        double value)
      • set

        public void set​(long index,
                        float value)
      • size

        public int size()
        Description copied from interface: Structure1D
        The total number of elements in this structure.
      • supplyNonZerosTo

        public void supplyNonZerosTo​(Mutate1D consumer)
      • visitOne

        public void visitOne​(long index,
                             VoidFunction<N> visitor)
      • update

        private void update​(long externalIndex,
                            int internalIndex,
                            java.lang.Comparable<?> value,
                            boolean shouldStoreZero)
        Will never remove anything - just insert or update
      • update

        private void update​(long externalIndex,
                            int internalIndex,
                            double value,
                            boolean shouldStoreZero)
        Will never remove anything - just insert or update
      • exchange

        protected void exchange​(long firstA,
                                long firstB,
                                long step,
                                long count)
        Overrides:
        exchange in class BasicArray<N extends java.lang.Comparable<N>>
      • fill

        protected void fill​(long first,
                            long limit,
                            long step,
                            N value)
        Overrides:
        fill in class BasicArray<N extends java.lang.Comparable<N>>
      • fill

        protected void fill​(long first,
                            long limit,
                            long step,
                            NullaryFunction<?> supplier)
        Overrides:
        fill in class BasicArray<N extends java.lang.Comparable<N>>
      • indexOfLargest

        protected long indexOfLargest​(long first,
                                      long limit,
                                      long step)
        Overrides:
        indexOfLargest in class BasicArray<N extends java.lang.Comparable<N>>
      • modify

        protected void modify​(long first,
                              long limit,
                              long step,
                              UnaryFunction<N> function)
        Overrides:
        modify in class BasicArray<N extends java.lang.Comparable<N>>
      • visit

        protected void visit​(long first,
                             long limit,
                             long step,
                             VoidFunction<N> visitor)
        Overrides:
        visit in class BasicArray<N extends java.lang.Comparable<N>>
      • capacity

        long capacity()
      • doubleValueInternally

        double doubleValueInternally​(int internalIndex)
      • firstIndex

        long firstIndex()
      • getActualLength

        int getActualLength()
      • getInternally

        N getInternally​(int internalIndex)
      • getValues

        Access1D<N> getValues​(long fromIncl,
                              long toExcl)
      • index

        int index​(long index)
      • indices

        java.util.stream.LongStream indices()
      • lastIndex

        long lastIndex()
      • put

        void put​(long key,
                 int index,
                 double value)
      • put

        void put​(long key,
                 int index,
                 N value)
      • remove

        void remove​(long externalIndex,
                    int internalIndex)