Class SparseArray<N extends Comparable<N>>

java.lang.Object
org.ojalgo.array.BasicArray<N>
org.ojalgo.array.SparseArray<N>
All Implemented Interfaces:
Access1D<N>, Access1D.Aggregatable<N>, Access1D.Collectable<N,Mutate1D>, Access1D.Visitable<N>, Mutate1D, Mutate1D.Fillable<N>, Mutate1D.Modifiable<N>, Structure1D

public final class SparseArray<N extends Comparable<N>> extends BasicArray<N>

Only stores nonzero elements and/or elements specifically set by the user. The nonzero elements are stored internally in a DenseArray.

  • Field Details

    • MATH_CONTEXT

      private static final NumberContext MATH_CONTEXT
    • myActualLength

      private int myActualLength
      The actual number of nonzwero elements
    • myCount

      private final long myCount
    • myDenseFactory

      private final DenseArray.Factory<N extends Comparable<N>> myDenseFactory
    • myGrowthStrategy

      private final GrowthStrategy myGrowthStrategy
    • myIndices

      private long[] myIndices
    • myValues

      private DenseArray<N extends Comparable<N>> myValues
    • myZeroNumber

      private final N extends Comparable<N> myZeroNumber
    • myZeroScalar

      private final Scalar<N extends Comparable<N>> myZeroScalar
    • myZeroValue

      private final double myZeroValue
  • Constructor Details

  • Method Details

    • factory

      public static <N extends Comparable<N>> SparseArray.SparseFactory<N> factory(DenseArray.Factory<N> denseFactory)
    • add

      public void add(long index, 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)
    • fillAll

      public void fillAll(NullaryFunction<?> supplier)
    • 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)
    • indexOfLargest

      public long indexOfLargest()
      Specified by:
      indexOfLargest in interface Access1D.Aggregatable<N extends Comparable<N>>
      Overrides:
      indexOfLargest in class BasicArray<N extends Comparable<N>>
    • limitOfRange

      public long limitOfRange(long rangeFirst, long rangeLimit)
    • modifyAll

      public void modifyAll(UnaryFunction<N> modifier)
      Specified by:
      modifyAll in interface Mutate1D.Modifiable<N extends Comparable<N>>
      Overrides:
      modifyAll in class BasicArray<N extends Comparable<N>>
    • 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, 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)
    • visitPrimitiveNonzerosInRange

      public void visitPrimitiveNonzerosInRange(long first, long limit, SparseArray.NonzeroPrimitiveCallback visitor)
    • visitRange

      public void visitRange(long first, long limit, VoidFunction<N> visitor)
      Specified by:
      visitRange in interface Access1D.Visitable<N extends Comparable<N>>
      Overrides:
      visitRange in class BasicArray<N extends Comparable<N>>
    • visitReferenceTypeNonzerosInRange

      public void visitReferenceTypeNonzerosInRange(long first, long limit, SparseArray.NonzeroReferenceTypeCallback<N> visitor)
    • update

      private void update(long externalIndex, int internalIndex, 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 Comparable<N>>
    • fill

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

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

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

      protected void modify(long first, long limit, long step, Access1D<N> left, BinaryFunction<N> function)
      Overrides:
      modify in class BasicArray<N extends Comparable<N>>
    • modify

      protected void modify(long first, long limit, long step, BinaryFunction<N> function, Access1D<N> right)
      Overrides:
      modify in class BasicArray<N extends Comparable<N>>
    • modify

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

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

      long capacity()
    • densify

      DenseArray<N> densify()
    • doubleValueInternally

      double doubleValueInternally(int internalIndex)
    • firstIndex

      long firstIndex()
    • getActualLength

      int getActualLength()
    • getInternally

      N getInternally(int internalIndex)
    • getValues

      DenseArray<N> getValues()
    • getValues

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

      int index(long index)
    • indices

      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)