Working with arrays

In the org.ojalgo.array package there are classes supporting 1, 2 or “any” dimensional arrays of double, BigDecimal, ComplexNumber, Quaternion and RationalNumber. The arrays can be sparse or dense and arbitrarily large.

Further the array package contain List and Map implementations backed by the array classes.

Example code

import java.math.BigDecimal;

import org.ojalgo.OjAlgoUtils;
import org.ojalgo.array.*;
import org.ojalgo.netio.BasicLogger;
import org.ojalgo.random.Exponential;
import org.ojalgo.random.Normal;
import org.ojalgo.random.Uniform;
import org.ojalgo.scalar.ComplexNumber;
import org.ojalgo.scalar.Quaternion;
import org.ojalgo.scalar.RationalNumber;

/**
 * Demonstrate some basic array functionality.
 *
 * @author apete
 */
public class WorkingWithArrays {

    public static void main(final String[] args) {

        BasicLogger.debug();
        BasicLogger.debug(WorkingWithArrays.class.getSimpleName());
        BasicLogger.debug(OjAlgoUtils.getTitle());
        BasicLogger.debug(OjAlgoUtils.getDate());
        BasicLogger.debug();

        // There are (currently) 8 dense array factories available in ojAlgo
        final DenseArray.Factory<BigDecimal> bigFactory = BigArray.FACTORY;
        final DenseArray.Factory<ComplexNumber> complexFactory = ComplexArray.FACTORY;
        final DenseArray.Factory<Double> direct32Factory = BufferArray.DIRECT32;
        final DenseArray.Factory<Double> direct64Factory = BufferArray.DIRECT64;
        final DenseArray.Factory<Double> primitive32Factory = Primitive32Array.FACTORY;
        final DenseArray.Factory<Double> primitive64Factory = Primitive64Array.FACTORY;
        final DenseArray.Factory<Quaternion> quaternionFactory = QuaternionArray.FACTORY;
        final DenseArray.Factory<RationalNumber> rationalFactory = RationalArray.FACTORY;

        // These can be used directly to instantiate plain/dense arrays
        final DenseArray<BigDecimal> bigArray = bigFactory.makeZero(512);
        final DenseArray<ComplexNumber> complexArray = complexFactory.makeFilled(512, new Normal());
        final DenseArray<Double> direct32Array = direct32Factory.makeFilled(512, new Uniform());
        final DenseArray<Double> direct64Array = direct32Factory.makeFilled(512, new Exponential());
        final DenseArray<Double> primitive32Array = direct32Factory.copy(bigArray);
        final DenseArray<Double> primitive64Array = direct32Factory.copy(complexArray);
        final DenseArray<Quaternion> quaternionArray = quaternionFactory.copy(direct32Array);
        final DenseArray<RationalNumber> rationalArray = rationalFactory.copy(direct64Array);

        // ... but mostly they'll be used with other factory methods to create more complex data structures
        final ArrayAnyD<ComplexNumber> complexAmyD = ArrayAnyD.factory(complexFactory).makeZero(1_000, 1_000_000, 1_000_000_000, 3);
        final Array2D<Double> primitive2D = Array2D.factory(direct32Factory).makeZero(1_000, 1_000);
        final Array1D<Quaternion> quaternion1D = Array1D.factory(quaternionFactory).makeZero(1_000_000);
        final SparseArray<BigDecimal> bigSparse = SparseArray.factory(bigFactory, 1_000_000_000).make();
        final NumberList<RationalNumber> rationalList = NumberList.factory(rationalFactory).make();
        final LongToNumberMap<Double> primitiveMap = LongToNumberMap.factory(primitive64Factory).make();

    }
}