Colt 1.2.0

## Uses of Class
cern.colt.PersistentObject

Packages that use PersistentObject
cern.colt: Core base classes; Operations on primitive arrays such as sorting, partitioning and permuting.
cern.colt.bitvector: Bit vectors and bit matrices.
cern.colt.buffer: Fixed sized (non resizable) streaming buffers connected to a target objects to which data is automatically flushed upon buffer overflow.
cern.colt.list: Resizable lists holding objects or primitive data types such as `int`, `double`, etc.
cern.colt.map: Automatically growing and shrinking maps holding objects or primitive data types such as `int`, `double`, etc.
cern.colt.matrix: Matrix interfaces and factories; efficient and flexible dense and sparse 1, 2, 3 and d-dimensional matrices holding objects or primitive data types such as `int`, `double`, etc; Templated, fixed sized (not dynamically resizable); Also known as multi-dimensional arrays or Data Cubes.
cern.colt.matrix.doublealgo: Double matrix algorithms such as print formatting, sorting, partitioning and statistics.
cern.colt.matrix.impl: Matrix implementations; You normally need not look at this package, because all concrete classes implement the abstract interfaces of `cern.colt.matrix`, without subsetting or supersetting.
cern.colt.matrix.linalg: Linear Algebraic matrix computations operating on `DoubleMatrix2D` and `DoubleMatrix1D`.
cern.jet.random: Large variety of probability distributions featuring high performance generation of random numbers, CDF's and PDF's.
cern.jet.random.engine: Engines generating strong uniformly distributed pseudo-random numbers; Needed by all JET probability distributions since they rely on uniform random numbers to generate random numbers from their own distribution.
cern.jet.random.sampling: Samples (picks) random subsets of data sequences.
cern.jet.stat.quantile: Scalable algorithms and data structures to compute approximate quantiles over very large data sequences.
hep.aida.bin: Multisets (bags) with efficient statistics operations defined upon; This package requires the Colt distribution.

Uses of PersistentObject in cern.colt

Subclasses of PersistentObject in cern.colt
`class` `Timer` A handy stopwatch for benchmarking.

Uses of PersistentObject in cern.colt.bitvector

Subclasses of PersistentObject in cern.colt.bitvector
`class` `BitMatrix` Fixed sized (non resizable) n*m bit matrix.
`class` `BitVector` Fixed sized (non resizable) bitvector.

Uses of PersistentObject in cern.colt.buffer

Subclasses of PersistentObject in cern.colt.buffer
`class` `DoubleBuffer` Fixed sized (non resizable) streaming buffer connected to a target `DoubleBufferConsumer` to which data is automatically flushed upon buffer overflow.
`class` `DoubleBuffer2D` Fixed sized (non resizable) streaming buffer connected to a target `DoubleBuffer2DConsumer` to which data is automatically flushed upon buffer overflow.
`class` `DoubleBuffer3D` Fixed sized (non resizable) streaming buffer connected to a target `DoubleBuffer3DConsumer` to which data is automatically flushed upon buffer overflow.
`class` `IntBuffer` Fixed sized (non resizable) streaming buffer connected to a target `IntBufferConsumer` to which data is automatically flushed upon buffer overflow.
`class` `IntBuffer2D` Fixed sized (non resizable) streaming buffer connected to a target `IntBuffer2DConsumer` to which data is automatically flushed upon buffer overflow.
`class` `IntBuffer3D` Fixed sized (non resizable) streaming buffer connected to a target `IntBuffer3DConsumer` to which data is automatically flushed upon buffer overflow.
`class` `ObjectBuffer` Fixed sized (non resizable) streaming buffer connected to a target `ObjectBufferConsumer` to which data is automatically flushed upon buffer overflow.

Uses of PersistentObject in cern.colt.list

Subclasses of PersistentObject in cern.colt.list
`class` `AbstractBooleanList` Abstract base class for resizable lists holding `boolean` elements; abstract.
`class` `AbstractByteList` Abstract base class for resizable lists holding `byte` elements; abstract.
`class` `AbstractCharList` Abstract base class for resizable lists holding `char` elements; abstract.
`class` `AbstractCollection` Abstract base class for resizable collections holding objects or primitive data types such as `int`, `float`, etc.
`class` `AbstractDoubleList` Abstract base class for resizable lists holding `double` elements; abstract.
`class` `AbstractFloatList` Abstract base class for resizable lists holding `float` elements; abstract.
`class` `AbstractIntList` Abstract base class for resizable lists holding `int` elements; abstract.
`class` `AbstractList` Abstract base class for resizable lists holding objects or primitive data types such as `int`, `float`, etc.
`class` `AbstractLongList` Abstract base class for resizable lists holding `long` elements; abstract.
`class` `AbstractShortList` Abstract base class for resizable lists holding `short` elements; abstract.
`class` `BooleanArrayList` Resizable list holding `boolean` elements; implemented with arrays.
`class` `ByteArrayList` Resizable list holding `byte` elements; implemented with arrays.
`class` `CharArrayList` Resizable list holding `char` elements; implemented with arrays.
`class` `DistinctNumberList` Resizable compressed list holding numbers; based on the fact that a number from a large list with few distinct values need not take more than `log(distinctValues)` bits; implemented with a `MinMaxNumberList`.
`class` `DoubleArrayList` Resizable list holding `double` elements; implemented with arrays.
`class` `FloatArrayList` Resizable list holding `float` elements; implemented with arrays.
`class` `IntArrayList` Resizable list holding `int` elements; implemented with arrays.
`class` `LongArrayList` Resizable list holding `long` elements; implemented with arrays.
`class` `MinMaxNumberList` Resizable compressed list holding numbers; based on the fact that a value in a given interval need not take more than `log(max-min+1)` bits; implemented with a `cern.colt.bitvector.BitVector`.
`class` `ObjectArrayList` Resizable list holding `Object` elements; implemented with arrays.
`class` `ShortArrayList` Resizable list holding `short` elements; implemented with arrays.
`class` `SimpleLongArrayList` Resizable list holding `long` elements; implemented with arrays; not efficient; just to demonstrate which methods you must override to implement a fully functional list.

Uses of PersistentObject in cern.colt.map

Subclasses of PersistentObject in cern.colt.map
`class` `AbstractDoubleIntMap` Abstract base class for hash maps holding (key,value) associations of type `(double-->int)`.
`class` `AbstractIntDoubleMap` Abstract base class for hash maps holding (key,value) associations of type `(int-->double)`.
`class` `AbstractIntIntMap` Abstract base class for hash maps holding (key,value) associations of type `(int-->int)`.
`class` `AbstractIntObjectMap` Abstract base class for hash maps holding (key,value) associations of type `(int-->Object)`.
`class` `AbstractLongObjectMap` Abstract base class for hash maps holding (key,value) associations of type `(long-->Object)`.
`class` `AbstractMap` Abstract base class for hash maps holding objects or primitive data types such as `int`, `float`, etc.
`class` `OpenDoubleIntHashMap` Hash map holding (key,value) associations of type `(double-->int)`; Automatically grows and shrinks as needed; Implemented using open addressing with double hashing.
`class` `OpenIntDoubleHashMap` Hash map holding (key,value) associations of type `(int-->double)`; Automatically grows and shrinks as needed; Implemented using open addressing with double hashing.
`class` `OpenIntIntHashMap` Hash map holding (key,value) associations of type `(int-->int)`; Automatically grows and shrinks as needed; Implemented using open addressing with double hashing.
`class` `OpenIntObjectHashMap` Hash map holding (key,value) associations of type `(int-->Object)`; Automatically grows and shrinks as needed; Implemented using open addressing with double hashing.
`class` `OpenLongObjectHashMap` Hash map holding (key,value) associations of type `(long-->Object)`; Automatically grows and shrinks as needed; Implemented using open addressing with double hashing.

Uses of PersistentObject in cern.colt.matrix

Subclasses of PersistentObject in cern.colt.matrix
`class` `DoubleFactory1D` Factory for convenient construction of 1-d matrices holding `double` cells.
`class` `DoubleFactory2D` Factory for convenient construction of 2-d matrices holding `double` cells.
`class` `DoubleFactory3D` Factory for convenient construction of 3-d matrices holding `double` cells.
`class` `DoubleMatrix1D` Abstract base class for 1-d matrices (aka vectors) holding `double` elements.
`class` `DoubleMatrix2D` Abstract base class for 2-d matrices holding `double` elements.
`class` `DoubleMatrix3D` Abstract base class for 3-d matrices holding `double` elements.
`class` `ObjectFactory1D` Factory for convenient construction of 1-d matrices holding `Object` cells.
`class` `ObjectFactory2D` Factory for convenient construction of 2-d matrices holding `Object` cells.
`class` `ObjectFactory3D` Factory for convenient construction of 3-d matrices holding `Object` cells.
`class` `ObjectMatrix1D` Abstract base class for 1-d matrices (aka vectors) holding `Object` elements.
`class` `ObjectMatrix2D` Abstract base class for 2-d matrices holding `Object` elements.
`class` `ObjectMatrix3D` Abstract base class for 3-d matrices holding `Object` elements.

Uses of PersistentObject in cern.colt.matrix.doublealgo

Subclasses of PersistentObject in cern.colt.matrix.doublealgo
`class` `Formatter` Flexible, well human readable matrix print formatting; By default decimal point aligned.
`class` `Sorting` Matrix quicksorts and mergesorts.
`class` `Transform` Deprecated.

Uses of PersistentObject in cern.colt.matrix.impl

Subclasses of PersistentObject in cern.colt.matrix.impl
`class` `AbstractFormatter` Abstract base class for flexible, well human readable matrix print formatting.
`class` `AbstractMatrix` Abstract base class for arbitrary-dimensional matrices holding objects or primitive data types such as `int`, `float`, etc.
`class` `AbstractMatrix1D` Abstract base class for 1-d matrices (aka vectors) holding objects or primitive data types such as `int`, `double`, etc.
`class` `AbstractMatrix2D` Abstract base class for 2-d matrices holding objects or primitive data types such as `int`, `double`, etc.
`class` `AbstractMatrix3D` Abstract base class for 3-d matrices holding objects or primitive data types such as `int`, `double`, etc.
`class` `DenseDoubleMatrix1D` Dense 1-d matrix (aka vector) holding `double` elements.
`class` `DenseDoubleMatrix2D` Dense 2-d matrix holding `double` elements.
`class` `DenseDoubleMatrix3D` Dense 3-d matrix holding `double` elements.
`class` `DenseObjectMatrix1D` Dense 1-d matrix (aka vector) holding `Object` elements.
`class` `DenseObjectMatrix2D` Dense 2-d matrix holding `Object` elements.
`class` `DenseObjectMatrix3D` Dense 3-d matrix holding `Object` elements.
`class` `RCDoubleMatrix2D` Sparse row-compressed 2-d matrix holding `double` elements.
`class` `SparseDoubleMatrix1D` Sparse hashed 1-d matrix (aka vector) holding `double` elements.
`class` `SparseDoubleMatrix2D` Sparse hashed 2-d matrix holding `double` elements.
`class` `SparseDoubleMatrix3D` Sparse hashed 3-d matrix holding `double` elements.
`class` `SparseObjectMatrix1D` Sparse hashed 1-d matrix (aka vector) holding `Object` elements.
`class` `SparseObjectMatrix2D` Sparse hashed 2-d matrix holding `Object` elements.
`class` `SparseObjectMatrix3D` Sparse hashed 3-d matrix holding `Object` elements.

Uses of PersistentObject in cern.colt.matrix.linalg

Subclasses of PersistentObject in cern.colt.matrix.linalg
`class` `Algebra` Linear algebraic matrix operations operating on `DoubleMatrix2D`; concentrates most functionality of this package.
`class` `Property` Tests matrices for linear algebraic properties (equality, tridiagonality, symmetry, singularity, etc).

Uses of PersistentObject in cern.jet.random

Subclasses of PersistentObject in cern.jet.random
`class` `AbstractContinousDistribution` Abstract base class for all continous distributions.
`class` `AbstractDiscreteDistribution` Abstract base class for all discrete distributions.
`class` `AbstractDistribution` Abstract base class for all random distributions.
`class` `Benchmark` Benchmarks random number generation from various distributions as well as PDF and CDF lookups.
`class` `Beta` Beta distribution; math definition and animated definition.
`class` `Binomial` Binomial distribution; See the math definition and animated definition.
`class` `BreitWigner` BreitWigner (aka Lorentz) distribution; See the math definition.
`class` `BreitWignerMeanSquare` Mean-square BreitWigner distribution; See the math definition.
`class` `ChiSquare` ChiSquare distribution; See the math definition and animated definition.
`class` `Empirical` Empirical distribution.
`class` `EmpiricalWalker` Discrete Empirical distribution (pdf's can be specified).
`class` `Exponential` Exponential Distribution (aka Negative Exponential Distribution); See the math definition animated definition.
`class` `ExponentialPower` Exponential Power distribution.
`class` `Gamma` Gamma distribution; math definition, definition of gamma function and animated definition.
`class` `Hyperbolic` Hyperbolic distribution.
`class` `HyperGeometric` HyperGeometric distribution; See the math definition The hypergeometric distribution with parameters `N`, `n` and `s` is the probability distribution of the random variable X, whose value is the number of successes in a sample of `n` items from a population of size `N` that has `s` 'success' items and `N - s` 'failure' items.
`class` `Logarithmic` Logarithmic distribution.
`class` `NegativeBinomial` Negative Binomial distribution; See the math definition.
`class` `Normal` Normal (aka Gaussian) distribution; See the math definition and animated definition.
`class` `Poisson` Poisson distribution (quick); See the math definition and animated definition.
`class` `PoissonSlow` Poisson distribution; See the math definition and animated definition.
`class` `StudentT` StudentT distribution (aka T-distribution); See the math definition and animated definition.
`class` `Uniform` Uniform distribution; Math definition and animated definition.
`class` `VonMises` Von Mises distribution.
`class` `Zeta` Zeta distribution.

Uses of PersistentObject in cern.jet.random.engine

Subclasses of PersistentObject in cern.jet.random.engine
`class` `DRand` Quick medium quality uniform pseudo-random number generator.
`class` `MersenneTwister` MersenneTwister (MT19937) is one of the strongest uniform pseudo-random number generators known so far; at the same time it is quick.
`class` `MersenneTwister64` Same as `MersenneTwister` except that method `raw()` returns 64 bit random numbers instead of 32 bit random numbers.
`class` `RandomEngine` Abstract base class for uniform pseudo-random number generating engines.
`class` `RandomSeedGenerator` Deterministic seed generator for pseudo-random number generators.

Uses of PersistentObject in cern.jet.random.sampling

Subclasses of PersistentObject in cern.jet.random.sampling
`class` `RandomSampler` Space and time efficiently computes a sorted Simple Random Sample Without Replacement (SRSWOR), that is, a sorted set of `n` random numbers from an interval of `N` numbers; Example: Computing `n=3` random numbers from the interval `[1,50]` may yield the sorted random set `(7,13,47)`.
`class` `RandomSamplingAssistant` Conveniently computes a stable Simple Random Sample Without Replacement (SRSWOR) subsequence of `n` elements from a given input sequence of `N` elements; Example: Computing a sublist of `n=3` random elements from a list `(1,...,50)` may yield the sublist `(7,13,47)`.
`class` `WeightedRandomSampler` Conveniently computes a stable subsequence of elements from a given input sequence; Picks (samples) exactly one random element from successive blocks of `weight` input elements each.

Uses of PersistentObject in cern.jet.stat.quantile

Subclasses of PersistentObject in cern.jet.stat.quantile
`class` `EquiDepthHistogram` Read-only equi-depth histogram for selectivity estimation.

Uses of PersistentObject in hep.aida.bin

Subclasses of PersistentObject in hep.aida.bin
`class` `AbstractBin` Abstract base class for all arbitrary-dimensional bins consumes `double` elements.
`class` `AbstractBin1D` Abstract base class for all 1-dimensional bins consumes `double` elements.
`class` `DynamicBin1D` 1-dimensional rebinnable bin holding `double` elements; Efficiently computes advanced statistics of data sequences.
`class` `MightyStaticBin1D` Static and the same as its superclass, except that it can do more: Additionally computes moments of arbitrary integer order, harmonic mean, geometric mean, etc.

`class`

`QuantileBin1D`
1-dimensional non-rebinnable bin holding `double` elements with scalable quantile operations defined upon; Using little main memory, quickly computes approximate quantiles over very large data sequences with and even without a-priori knowledge of the number of elements to be filled; Conceptually a strongly lossily compressed multiset (or bag); Guarantees to respect the worst case approximation error specified upon instance construction.

`class` `StaticBin1D` 1-dimensional non-rebinnable bin consuming `double` elements; Efficiently computes basic statistics of data sequences.

Colt 1.2.0

Jump to the Colt Homepage