Class SegmentedArray<N extends Comparable<N>>

java.lang.Object

org.ojalgo.array.BasicArray<N>

org.ojalgo.array.SegmentedArray<N>

All Implemented Interfaces:

Access1D<N>, Access1D.Aggregatable<N>, Access1D.Collectable<N,Mutate1D>, Access1D.Visitable<N>, Mutate1D, Mutate1D.Fillable<N>, Mutate1D.Modifiable<N>, Structure1D

final class SegmentedArray<N extends Comparable<N>>
extends BasicArray<N>

An array implemented as a sequence of segments that together make up the data structure. Any BasicArray subclass can be used for segments. A BasicArray.Factory is used to create sparse segments (they're not guaranteed to actually be sparse) and a DenseArray.Factory is used to create dense segments (guaranteed to be dense).

Nested Class Summary

Nested classes/interfaces inherited from class BasicArray

BasicArray.BaseFactory<N,A>, BasicArray.Factory<N>

Nested classes/interfaces inherited from interface Access1D

Access1D.Aggregatable<N>, Access1D.Collectable<N,R>, Access1D.ElementView<N>, Access1D.SelectionView<N>, Access1D.Sliceable<N>, Access1D.Visitable<N>

Nested classes/interfaces inherited from interface Mutate1D

Mutate1D.Fillable<N>, Mutate1D.Mixable<N>, Mutate1D.Modifiable<N>, Mutate1D.ModifiableReceiver<N>, Mutate1D.Receiver<N>, Mutate1D.Sortable

Nested classes/interfaces inherited from interface Structure1D

Structure1D.BasicMapper<T>, Structure1D.IndexMapper<T>, Structure1D.IntIndex, Structure1D.Logical<S,B>, Structure1D.LongIndex, Structure1D.LoopCallback

Field Summary

Fields

Modifier and Type	Field	Description
private final int	myIndexBits
private final long	myIndexMask
private final BasicArray.BaseFactory<N,?>	mySegmentFactory
private final BasicArray<N>[]	mySegments
private final long	mySegmentSize	All segments except the last one are assumed to (must) be of equal length.

Constructor Summary

Constructors

Constructor	Description
SegmentedArray(BasicArray<N>[] segments, BasicArray.BaseFactory<N,?> segmentFactory)

Method Summary

Modifier and Type	Method	Description
void	add(int index, double addend)
void	add(long index, double addend)
void	add(long index, float addend)
void	add(long index, Comparable<?> addend)
long	count()	The total number of elements in this structure.
double	doubleValue(int index)
double	doubleValue(long index)
protected void	exchange(long firstA, long firstB, long step, long count)
protected void	fill(long first, long limit, long step, N value)
protected void	fill(long first, long limit, long step, NullaryFunction<?> supplier)
void	fillAll(N value)
void	fillAll(NullaryFunction<?> supplier)
void	fillRange(long first, long limit, N value)
void	fillRange(long first, long limit, NullaryFunction<?> supplier)
N	get(long index)
(package private) SegmentedArray<N>	grow()	Will either grow the last segment to be the same size as all the others, or add another segment (with the same size).
protected void	modify(long first, long limit, long step, BinaryFunction<N> function, Access1D<N> right)
protected void	modify(long first, long limit, long step, UnaryFunction<N> function)
protected void	modify(long first, long limit, long step, Access1D<N> left, BinaryFunction<N> function)
void	modifyOne(long index, UnaryFunction<N> modifier)
(package private) static <N extends Comparable<N>> SegmentedArray<N>	newInstance(BasicArray.BaseFactory<N,?> segmentFactory, long... structure)
void	reset()	Reset this mutable structure to some standard (all zeros) initial state.
void	set(int index, double value)
void	set(long index, double value)
void	set(long index, float value)
void	set(long index, Comparable<?> value)
int	size()	The total number of elements in this structure.
protected void	visit(long first, long limit, long step, VoidFunction<N> visitor)
void	visitOne(long index, VoidFunction<N> visitor)

Methods inherited from class BasicArray

aggregateRange, equals, factory, getMathType, hashCode, indexOfLargest, indexOfLargest, isPrimitive, modifyAll, modifyMatching, modifyMatching, modifyRange, supplyTo, toString, visitAll, visitRange, wrapInArray1D, wrapInArray2D, wrapInArrayAnyD

Methods inherited from class Object

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface Access1D

asCollectable1D, asKeyed1D, asList, axpy, byteValue, byteValue, dot, elements, floatValue, floatValue, intValue, intValue, longValue, longValue, nonzeros, select, shortValue, shortValue, supplyTo, toList, toRawCopy1D

Methods inherited from interface Access1D.Aggregatable

aggregateAll

Methods inherited from interface Access1D.Collectable

collect

Methods inherited from interface Mutate1D

set, set, set, set, set, set, set, set, set

Methods inherited from interface Mutate1D.Fillable

fillCompatible, fillMatching, fillMatching, fillMatching, fillMatching

Methods inherited from interface Mutate1D.Modifiable

add, add, add, add, add, add, add, add, add

Field Details

myIndexBits

private final int myIndexBits

myIndexMask

private final long myIndexMask

mySegmentFactory

private final BasicArray.BaseFactory<N extends Comparable<N>, ?> mySegmentFactory

mySegments

private final BasicArray<N extends Comparable<N>>[] mySegments

mySegmentSize

private final long mySegmentSize

All segments except the last one are assumed to (must) be of equal length. The last segment cannot be longer than the others.

Constructor Details

SegmentedArray

SegmentedArray(BasicArray<N>[] segments,
 BasicArray.BaseFactory<N,?> segmentFactory)

Method Details

newInstance

static <N extends Comparable<N>> SegmentedArray<N> newInstance(BasicArray.BaseFactory<N,?> segmentFactory,
 long... structure)

add

public void add(int index,
 double addend)

add

public void add(long index,
 Comparable<?> addend)

add

public void add(long index,
 double addend)

add

public void add(long index,
 float addend)

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.

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)

get

public N get(long index)

modifyOne

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

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.

visitOne

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

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>>

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>>

grow

SegmentedArray<N> grow()

Will either grow the last segment to be the same size as all the others, or add another segment (with the same size). The returned (could be the same) instance is guaranteed to have a last segment of the same size as the others and at least one more "space" in that segment.