oj! Algorithms

http://www.ojalgo.org
Admin
oj! Algorithms is an open source pure Java library for mathematics, linear algebra, optimization,...
Tokens:182,427
Snippets:776
Trust Score:8.5
Update:2 weeks ago
Show doc for...
Tokens:
Raw
### StatQuestPCA example setup with data matrices

Source: http://www.ojalgo.org/code-examples

Starts a PCA example using data from StatQuest's video. Imports ojAlgo classes and defines a StatQuestPCA class with a main method that logs debug information and creates transposed data matrices (data2, data3, data4) using RawStore.wrap.

```java
| import static org.ojalgo.function.constant.PrimitiveMath.DIVIDE;  
|   
| import java.util.Locale;  
|   
| import org.ojalgo.OjAlgoUtils;  
| import org.ojalgo.data.DataProcessors;  
| import org.ojalgo.function.aggregator.Aggregator;  
| import org.ojalgo.matrix.decomposition.Eigenvalue;  
| import org.ojalgo.matrix.decomposition.SingularValue;  
| import org.ojalgo.matrix.store.MatrixStore;  
| import org.ojalgo.matrix.store.R064Store;  
| import org.ojalgo.matrix.store.RawStore;  
| import org.ojalgo.netio.BasicLogger;  
| import org.ojalgo.type.context.NumberContext;  
|   
| /**  
|  * PCA example using data from StatQuest's video "Principal Component Analysis (PCA), Step-by-Step".  
|  *  
|  * @see https://www.ojalgo.org/2019/03/statquest-pca-example/  
|  */  
| public class StatQuestPCA {  
|   
|  private static final NumberContext PERCENTAGE = NumberContext.getPercent(Locale.getDefault());  
|   
|  public static void main(final String[] args) {  
|   
|  BasicLogger.debug();  
|  BasicLogger.debug(StatQuestPCA.class);  
|  BasicLogger.debug(OjAlgoUtils.getTitle());  
|  BasicLogger.debug(OjAlgoUtils.getDate());  
|  BasicLogger.debug();  
|   
|  MatrixStore<Double> data2 = RawStore.wrap(new double[][] { { 10, 11, 8, 3, 2, 1 }, { 6, 4, 5, 3, 2.8, 1 } }).transpose();  
|  MatrixStore<Double> data3 = RawStore.wrap(new double[][] { { 10, 11, 8, 3, 2, 1 }, { 6, 4, 5, 3, 2.8, 1 }, { 12, 9, 10, 2.5, 1.3, 2 } }).transpose();  
|  MatrixStore<Double> data4 = RawStore  
```

--------------------------------

### Getting Started with ojAlgo Matrix Factories

Source: http://www.ojalgo.org/code-examples

Introductory ojAlgo example showing how to create matrices with MatrixR064.FACTORY and R064Store.FACTORY. Demonstrates makeEye for identity-like structures and makeFilled with a Weibull distribution for random elements. Notes that MatrixR064 uses smart structures while R064Store always uses a full array.

```java
import org.ojalgo.OjAlgoUtils;  
import org.ojalgo.RecoverableCondition;  
import org.ojalgo.matrix.MatrixR064;  
import org.ojalgo.matrix.decomposition.QR;  
import org.ojalgo.matrix.store.ElementsSupplier;  
import org.ojalgo.matrix.store.MatrixStore;  
import org.ojalgo.matrix.store.PhysicalStore;  
import org.ojalgo.matrix.store.R064Store;  
import org.ojalgo.matrix.store.RawStore;  
import org.ojalgo.matrix.task.InverterTask;  
import org.ojalgo.matrix.task.SolverTask;  
import org.ojalgo.netio.BasicLogger;  
import org.ojalgo.random.Weibull;  
  
/**  
 * Getting Started with ojAlgo  
 *  
 * @see https://www.ojalgo.org/2019/03/linear-algebra-introduction/  
 */  
public class GettingStarted {  
  
 public static void main(final String[] args) {  
  
 BasicLogger.debug();  
 BasicLogger.debug(GettingStarted.class);  
 BasicLogger.debug(OjAlgoUtils.getTitle());  
 BasicLogger.debug(OjAlgoUtils.getDate());  
 BasicLogger.debug();  
  
 MatrixR064.Factory matrixFactory = MatrixR064.FACTORY;  
 PhysicalStore.Factory<Double, R064Store> storeFactory = R064Store.FACTORY;  
 // PrimitiveMatrix.Factory and PrimitiveDenseStore.Factory are very similar.  
 // Every factory in ojAlgo that makes 2D-structures  
 // extends/implements the same interface.  
  
 MatrixR064 matrixA = matrixFactory.makeEye(5, 5);  
 // Internally this creates an "eye-structure" - not a large array.  
 R064Store storeA = storeFactory.makeEye(5, 5);  
 // A PrimitiveDenseStore is always a "full array". No smart data  
 // structures here.  
  
 MatrixR064 matrixB = matrixFactory.makeFilled(5, 3, new Weibull(5.0, 2.0));  
 R064Store storeB = storeFactory.makeFilled(5, 3, new Weibull(5.0, 2.0));  
 // When you create a matrix with random elements you can specify  
 // their distribution.  
  
 /* Matrix multiplication */
```

--------------------------------

### CreateCustomMatrixStore.java - custom matrix store with BetterPerformingEye

Source: http://www.ojalgo.org/code-examples

Starts a custom matrix store example that exploits special structures. The snippet is truncated mid-class; the full example is available via the linked blog post.

```java
import static org.ojalgo.function.constant.PrimitiveMath.ONE;
import static org.ojalgo.function.constant.PrimitiveMath.ZERO;

import org.ojalgo.OjAlgoUtils;
import org.ojalgo.matrix.decomposition.QR;
import org.ojalgo.matrix.store.MatrixStore;
import org.ojalgo.matrix.store.PhysicalStore;
import org.ojalgo.matrix.store.R064Store;
import org.ojalgo.matrix.store.TransformableRegion;
import org.ojalgo.netio.BasicLogger;
import org.ojalgo.random.Normal;
import org.ojalgo.type.Stopwatch;

/**
 * Creating custom matrix stores exploiting special structures.
 *
 * @see https://www.ojalgo.org/2020/09/sparse-and-special-structure-matrices/
 */
public class CreateCustomMatrixStore {

    /**
     * In addition to the required 4 methods, you probably should also implement these.
     */
    static class BetterPerformingEye extends MostBasicEye {

        public BetterPerformingEye(final int rowsCount, final int columnsCount) {
            super(rowsCount, columnsCount);
        }
```

--------------------------------

### CreateCustomMatrixStore.java: custom MatrixStore implementation and performance comparison

Source: http://www.ojalgo.org/code-examples

Complete example from CreateCustomMatrixStore.java showing how to implement a custom MatrixStore<Double> and benchmark it against built-in ojAlgo matrices. The first block overrides the optional methods (doubleValue, firstInColumn, firstInRow, limitOfColumn, limitOfRow, supplyTo) for a primitive-valued implementation. The second block defines the minimal MostBasicEye class that implements only the four required methods (get, getColDim, getRowDim, physical). The third block is the main method that compares multiplication and QR decomposition performance among MostBasicEye, a built-in identity matrix, and a BetterPerformingEye.

```java
/**
 * For a primitive valued implementation, at least, you should implement this method
 */
@Override
public double doubleValue(final int row, final int col) {
    return row == col ? ONE : ZERO;
}

/**
 * May allow the standard matrix multiplication code to exploit structure, certainly possible here.
 */
@Override
public int firstInColumn(final int col) {
    return Math.min(col, this.getRowDim());
}

/**
 * @see #firstInColumn(int)
 */
@Override
public int firstInRow(final int row) {
    return Math.min(row, this.getColDim());
}

/**
 * @see #firstInColumn(int)
 */
@Override
public int limitOfColumn(final int col) {
    return Math.min(col + 1, this.getRowDim());
}

/**
 * @see #firstInColumn(int)
 */
@Override
public int limitOfRow(final int row) {
    return Math.min(row + 1, this.getColDim());
}

/**
 * Custom/optimised copy functionality.
 */
@Override
public void supplyTo(final TransformableRegion<Double> receiver) {
    receiver.reset();
    receiver.fillDiagonal(ONE);
}

}
```

```java
/**
 * There are only 4 methods you have to implement in a custom MatrixStore, but there's a whole lot you can
 * to with that implementation. It's fully functional!
 */
static class MostBasicEye implements MatrixStore<Double> {

    private final int myColumnsCount;
    private final int myRowsCount;

    public MostBasicEye(final int rowsCount, final int columnsCount) {
        super();
        myRowsCount = rowsCount;
        myColumnsCount = columnsCount;
    }

    @Override
    public Double get(final int row, final int col) {
        return row == col ? ONE : ZERO;
    }

    @Override
    public int getColDim() {
        return myColumnsCount;
    }

    @Override
    public int getRowDim() {
        return myRowsCount;
    }

    @Override
    public PhysicalStore.Factory<Double, R064Store> physical() {
        return R064Store.FACTORY;
    }

}
```

```java
private static int DIM = 2000;

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

    BasicLogger.debug();
    BasicLogger.debug(CreateCustomMatrixStore.class);
    BasicLogger.debug(OjAlgoUtils.getTitle());
    BasicLogger.debug(OjAlgoUtils.getDate());
    BasicLogger.debug();

    MatrixStore<Double> mostBasicEye = new MostBasicEye(DIM + DIM, DIM);
    MatrixStore<Double> identityAndZero = R064Store.FACTORY.makeIdentity(DIM).below(DIM);
    MatrixStore<Double> betterPerformingEye = new BetterPerformingEye(DIM + DIM, DIM);

    Stopwatch stopwatch = new Stopwatch();

    BasicLogger.debug();
    BasicLogger.debug("Compare multiplication");

    PhysicalStore<Double> right = R064Store.FACTORY.makeFilled(DIM, DIM, new Normal());
    PhysicalStore<Double> product = R064Store.FACTORY.make(DIM + DIM, DIM);

    stopwatch.reset();
    mostBasicEye.multiply(right, product);
    BasicLogger.debug("MostBasicEye multiplied in {}", stopwatch.stop());

    stopwatch.reset();
    identityAndZero.multiply(right, product);
    BasicLogger.debug("Built-in ojAlgo multiplied in {}", stopwatch.stop());

    stopwatch.reset();
    betterPerformingEye.multiply(right, product);
    BasicLogger.debug("BetterPerformingEye multiplied in {}", stopwatch.stop());

    BasicLogger.debug();
    BasicLogger.debug("Compare QR decomposition");

    QR<Double> decompQR = QR.R064.make(mostBasicEye);

    stopwatch.reset();
    decompQR.compute(mostBasicEye);
    BasicLogger.debug("MostBasicEye decomposed in {}", stopwatch.stop());

    stopwatch.reset();
    decompQR.compute(identityAndZero);
    BasicLogger.debug("Built-in ojAlgo decomposed in {}", stopwatch.stop());

    stopwatch.reset();
    decompQR.compute(betterPerformingEye);
    BasicLogger.debug("BetterPerformingEye decomposed in {}", stopwatch.stop());

    // Actually decomposing should take exactly the same time for the 3 alternatives.
    // ...and the input is already in the decomposed form.
    // The time difference is the time it takes to copy the input matrix
    // to the decomposer's internal storage.

}
```

--------------------------------

### SparseMatrices.java example using SparseStore

Source: http://www.ojalgo.org/2020/09/sparse-and-special-structure-matrices

Example Java class demonstrating the use of SparseStore and other special MatrixStore implementations. It creates 100,000x100,000 sparse matrices, fills them with random non-zero elements, and performs a sparse-sparse multiplication, logging the number of non-zeroes and the elapsed time.

```java
import static org.ojalgo.type.CalendarDateUnit.MILLIS;

import java.time.Instant;
import java.util.Random;

import org.ojalgo.OjAlgoUtils;
import org.ojalgo.array.ArrayR064;
import org.ojalgo.array.LongToNumberMap;
import org.ojalgo.array.SparseArray;
import org.ojalgo.matrix.store.MatrixStore;
import org.ojalgo.matrix.store.R064Store;
import org.ojalgo.matrix.store.SparseStore;
import org.ojalgo.matrix.task.iterative.ConjugateGradientSolver;
import org.ojalgo.netio.BasicLogger;
import org.ojalgo.series.BasicSeries;
import org.ojalgo.type.Stopwatch;

/**
 * Example use of SparseStore and other special MatrixStore implementations.
 *
 * @see https://www.ojalgo.org/2020/09/sparse-and-special-structure-matrices/
 */
public class SparseMatrices {

    private static String NON_ZEROS = "{} non-zeroes out of {} matrix elements calculated in {}";
    private static Random RANDOM = new Random();

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

        BasicLogger.debug();
        BasicLogger.debug(SparseMatrices.class);
        BasicLogger.debug(OjAlgoUtils.getTitle());
        BasicLogger.debug(OjAlgoUtils.getDate());
        BasicLogger.debug();

        int dim = 100_000;

        SparseStore<Double> mtrxA = SparseStore.R064.make(dim, dim);
        SparseStore<Double> mtrxB = SparseStore.R064.make(dim, dim);
        SparseStore<Double> mtrxC = SparseStore.R064.make(dim, dim);
        MatrixStore<Double> mtrxZ = R064Store.FACTORY.makeZero(dim, dim);
        MatrixStore<Double> mtrxI = R064Store.FACTORY.makeIdentity(dim);

        // 5 matrices * 100k rows * 100k cols * 8 bytes per element => would be more than 372GB if dense
        // This program runs with default settings of any JVM

        for (int i = 0; i < dim; i++) {
            int j = RANDOM.nextInt(dim);
            double val = RANDOM.nextDouble();
            mtrxA.set(i, j, val);
        } // Each row of A contains 1 non-zero element at random column

        for (int j = 0; j < dim; j++) {
            int i = RANDOM.nextInt(dim);
            double val = RANDOM.nextDouble();
            mtrxB.set(i, j, val);
        } // Each column of B contains 1 non-zero element at random row

        Stopwatch stopwatch = new Stopwatch();

        BasicLogger.debug();
        BasicLogger.debug("Sparse-Sparse multiplication");
        stopwatch.reset();
        mtrxA.multiply(mtrxB, mtrxC);
        BasicLogger.debug(NON_ZEROS, mtrxC.nonzeros().estimateSize(), mtrxC.count(), stopwatch.stop(MILLIS));
```

--------------------------------

### FashionMNISTWithBatchNode example

Source: http://www.ojalgo.org/code-examples

Complete example program that demonstrates BatchNode usage and trains a neural network on the Fashion-MNIST dataset. It includes a ConcurrentTrainer consumer that batches training data, a DataAndLabelPair class with a custom DataInterpreter for serialization, and a main method that sets up the network, batch node, batch manager, and runs training and evaluation.

```java
import static org.ojalgo.ann.ArtificialNeuralNetwork.Activator.SOFTMAX;
import static org.ojalgo.function.constant.PrimitiveMath.DIVIDE;

import java.io.DataInput;
import java.io.DataOutput;
import java.io.File;
import java.io.IOException;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.function.Consumer;

import org.ojalgo.OjAlgoUtils;
import org.ojalgo.ann.ArtificialNeuralNetwork;
import org.ojalgo.ann.NetworkInvoker;
import org.ojalgo.ann.NetworkTrainer;
import org.ojalgo.array.ArrayAnyD;
import org.ojalgo.concurrent.DaemonPoolExecutor;
import org.ojalgo.concurrent.Parallelism;
import org.ojalgo.data.DataBatch;
import org.ojalgo.data.batch.BatchManager;
import org.ojalgo.data.batch.BatchNode;
import org.ojalgo.data.image.ImageData;
import org.ojalgo.matrix.store.R032Store;
import org.ojalgo.netio.BasicLogger;
import org.ojalgo.netio.DataInterpreter;
import org.ojalgo.netio.IDX;
import org.ojalgo.netio.ToFileWriter;
import org.ojalgo.random.FrequencyMap;
import org.ojalgo.structure.Access2D;
import org.ojalgo.structure.AccessAnyD.MatrixView;
import org.ojalgo.type.CalendarDateUnit;
import org.ojalgo.type.Stopwatch;
import org.ojalgo.type.format.NumberStyle;
import org.ojalgo.type.function.TwoStepMapper;

/**
 * This example program does two things:
 * <ol>
 * <li>Demonstrates basic usage of the BatchNode utility
 * <li>Train a neural network on the Fashion-MNIST dataset from Zalando Research
 * (https://github.com/zalandoresearch/fashion-mnist)
 * <p>
 * BatchNode is meant to be used with very very large datasets. The dataset used in this example is not very
 * large at all, and we don't always do things the most efficient way. Just want to show a few different ways
 * to use BatchNode.
 *
 * @see https://www.ojalgo.org/2022/05/introducing-batchnode/
 */
public class FashionMNISTWithBatchNode {

	/**
	 * A simple consumer that encapsulates a, batched, neural network trainer. We can have several of these
	 * working concurrently.
	 */
	static class ConcurrentTrainer implements Consumer<DataAndLabelPair> {

		private static final AtomicInteger COUNTER = new AtomicInteger();

		private final DataBatch myInputBatch;
		private final DataBatch myOutputBatch;
		private final NetworkTrainer myTrainer;

		ConcurrentTrainer(final ArtificialNeuralNetwork network, final int batchSize) {
			super();
			myTrainer = network.newTrainer(batchSize).rate(0.005).dropouts();
			myInputBatch = myTrainer.newInputBatch();
			myOutputBatch = myTrainer.newOutputBatch();
		}

		@Override
		public void accept(final FashionMNISTWithBatchNode.DataAndLabelPair item) {

			myInputBatch.addRow(item.data);
			// The label is an integer [0,9] representing the digit in the image
			// That label is used as the index to set a single 1.0
			myOutputBatch.addRowWithSingleUnit(item.label);

			if (myInputBatch.isFull()) {
				myTrainer.train(myInputBatch, myOutputBatch);
				myInputBatch.reset();
				myOutputBatch.reset();
			}

			int iterations = COUNTER.incrementAndGet();
			if (iterations % 1_000_000 == 0) {
				BasicLogger.debug("Done {} training iterations: {}", iterations, STOPWATCH.stop(CalendarDateUnit.SECOND));
			}
		}
	}

	/**
	 * A simple class representing what is stored at each of the batch nodes. In this example it happens so
	 * that we store the same type of data at all the nodes. Usually that would not be case. It's more likely
	 * there is a unique type for each node.
	 */
	static class DataAndLabelPair {

		/**
		 * This is what we feed the {@link BatchNode} builder so that the node knows how to read/write data
		 * from disk.
		 */
		static final DataInterpreter<DataAndLabelPair> INTERPRETER = new DataInterpreter<>() {

			@Override
			public FashionMNISTWithBatchNode.DataAndLabelPair deserialize(final DataInput input) throws IOException {

				int nbRows = input.readInt();
				int nbCols = input.readInt();

				R032Store data = R032Store.FACTORY.make(nbRows, nbCols);

				for (int i = 0; i < nbRows; i++) {
					for (int j = 0; j < nbCols; j++) {
						data.set(i, j, input.readFloat());
					}
				}

				int label = input.readInt();

				return new DataAndLabelPair(data, label);
			}

			@Override
			public void serialize(final FashionMNISTWithBatchNode.DataAndLabelPair pair, final DataOutput output) throws IOException {

				int nbRows = pair.data.getRowDim();
				int nbCols = pair.data.getColDim();

				output.writeInt(nbRows);
				output.writeInt(nbCols);

				for (int i = 0; i < nbRows; i++) {
					for (int j = 0; j < nbCols; j++) {
						output.writeFloat(pair.data.get(i, j));
					}
				}

				output.writeInt(pair.label);
			}
		};

		final R032Store data;
		final int label;

		DataAndLabelPair(final R032Store data, final int label) {
			this.data = data;
			this.label = label;
		}
	}

	private static final Stopwatch STOPWATCH = new Stopwatch();

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

		// The data files are available at https://github.com/zalandoresearch/fashion-mnist
		// Download the 4 files and put them in a directory of your choice
		File trainImages = new File("train-images-idx3-ubyte");
		File trainLabels = new File("train-labels-idx1-ubyte");
		File testImages = new File("t10k-images-idx3-ubyte");
		File testLabels = new File("t10k-labels-idx1-ubyte");

		// Create a neural network with 784 inputs, 2 hidden layers with 128 and 64 nodes, and 10 outputs
		ArtificialNeuralNetwork network = ArtificialNeuralNetwork.builder()
				.inputs(784)
				.layer(128, SOFTMAX)
				.layer(64, SOFTMAX)
				.layer(10, SOFTMAX)
				.build();

		// Create a BatchNode that will manage the data
		BatchNode<DataAndLabelPair> batchNode = BatchNode
				.with(DataAndLabelPair.INTERPRETER)
				.storage(new File("batch-node-storage"))
				.build();

		// Create a BatchManager that will manage the batch nodes
		BatchManager<DataAndLabelPair> batchManager = BatchManager
				.with(batchNode)
				.parallelism(Parallelism.CORES)
				.build();

		// Create a consumer that will train the network
		ConcurrentTrainer trainer = new ConcurrentTrainer(network, 32);

		// Create a consumer that will evaluate the network
		Consumer<DataAndLabelPair> evaluator = new Consumer<>() {

			private final NetworkInvoker invoker = network.newInvoker();
			private final FrequencyMap<Integer> confusion = new FrequencyMap<>();

			@Override
			public void accept(final DataAndLabelPair item) {

				Access2D<Double> output = invoker.invoke(item.data);
				int predicted = output.argmaxRow();
				int actual = item.label;

				if (predicted == actual) {
					confusion.increment(actual);
				} else {
					confusion.increment(-1);
				}
			}
		};

		// Train the network
		batchManager.process(trainImages, trainLabels, trainer);

		// Evaluate the network
		batchManager.process(testImages, testLabels, evaluator);

		// Print the results
		BasicLogger.debug("Training complete");
		BasicLogger.debug("Accuracy: {}", confusion.get(0) / (double) confusion.size());
	}
}
```

--------------------------------

### GettingStarted.java - ojAlgo linear algebra basics

Source: http://www.ojalgo.org/2019/03/linear-algebra-introduction

Complete example class showing matrix creation with MatrixR064 and R064Store factories, matrix multiplication using multiply, premultiply, fillByMultiplying, and supplyTo, and matrix inversion with invert(). Includes debug output via BasicLogger.

```java
import org.ojalgo.OjAlgoUtils;
import org.ojalgo.RecoverableCondition;
import org.ojalgo.matrix.MatrixR064;
import org.ojalgo.matrix.decomposition.QR;
import org.ojalgo.matrix.store.ElementsSupplier;
import org.ojalgo.matrix.store.MatrixStore;
import org.ojalgo.matrix.store.PhysicalStore;
import org.ojalgo.matrix.store.R064Store;
import org.ojalgo.matrix.store.RawStore;
import org.ojalgo.matrix.task.InverterTask;
import org.ojalgo.matrix.task.SolverTask;
import org.ojalgo.netio.BasicLogger;
import org.ojalgo.random.Weibull;

/**
 * Getting Started with ojAlgo
 *
 * @see https://www.ojalgo.org/2019/03/linear-algebra-introduction/
 */
public class GettingStarted {

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

        BasicLogger.debug();
        BasicLogger.debug(GettingStarted.class);
        BasicLogger.debug(OjAlgoUtils.getTitle());
        BasicLogger.debug(OjAlgoUtils.getDate());
        BasicLogger.debug();

        MatrixR064.Factory matrixFactory = MatrixR064.FACTORY;
        PhysicalStore.Factory<Double, R064Store> storeFactory = R064Store.FACTORY;
        // PrimitiveMatrix.Factory and PrimitiveDenseStore.Factory are very similar.
        // Every factory in ojAlgo that makes 2D-structures
        // extends/implements the same interface.

        MatrixR064 matrixA = matrixFactory.makeEye(5, 5);
        // Internally this creates an "eye-structure" - not a large array.
        R064Store storeA = storeFactory.makeEye(5, 5);
        // A PrimitiveDenseStore is always a "full array". No smart data
        // structures here.

        MatrixR064 matrixB = matrixFactory.makeFilled(5, 3, new Weibull(5.0, 2.0));
        R064Store storeB = storeFactory.makeFilled(5, 3, new Weibull(5.0, 2.0));
        // When you create a matrix with random elements you can specify
        // their distribution.

        /* Matrix multiplication */

        MatrixR064 matrixC = matrixA.multiply(matrixB);
        // Multiplying two PrimitiveMatrix:s is trivial. There are no
        // alternatives, and the returned product is a PrimitiveMatrix
        // (same as the inputs).

        // Doing the same thing using PrimitiveDenseStore (MatrixStore) you
        // have options...

        BasicLogger.debug("Different ways to do matrix multiplication with " + "MatrixStore:s");
        BasicLogger.debug();

        MatrixStore<Double> storeC = storeA.multiply(storeB);
        // One option is to do exactly what you did with PrimitiveMatrix.
        // The only difference is that the return type is MatrixStore rather
        // than PhysicalStore, PrimitiveDenseStore or whatever else you input.
        BasicLogger.debugMatrix("MatrixStore MatrixStore#multiply(MatrixStore)", storeC);

        R064Store storeCPreallocated = storeFactory.make(5, 3);
        // Another option is to first create the matrix that should hold the
        // resulting product,
        storeA.multiply(storeB, storeCPreallocated);
        // and then perform the multiplication. This enables reusing memory
        // (the product matrix).
        BasicLogger.debugMatrix("void MatrixStore#multiply(Access1D, ElementsConsumer)", storeCPreallocated);

        ElementsSupplier<Double> storeCSupplier = storeB.premultiply(storeA);
        // A third option is the premultiply method:
        // 1) The left and right argument matrices are interchanged.
        // 2) The return type is an ElementsSupplier rather than
        //    a MatrixStore.
        // This is because the multiplication is not yet performed.
        // It is possible to define additional operation on
        // an ElementsSupplier.
        ElementsSupplier<Double> storeCLater = storeCSupplier;
        // The multiplication, and whatever additional operations you defined,
        // is performed when you call #get().
        BasicLogger.debug("ElementsSupplier MatrixStore#premultiply(Access1D)", storeCLater);

        // A couple of variations that will do the same thing.
        storeCPreallocated.fillByMultiplying(storeA, storeB);
        BasicLogger.debug("void ElementsConsumer#fillByMultiplying(Access1D, Access1D)", storeCLater);
        storeCSupplier.supplyTo(storeCPreallocated);
        BasicLogger.debug("void ElementsSupplier#supplyTo(ElementsConsumer)", storeCLater);

        /* Inverting matrices */

        matrixA.invert();
        // If you want to invert a PrimitiveMatrix then just do it...
        // The matrix doesn't even have to be square or anything.
        // You'll get a pseudoinverse or whatever is possible.
    }
}
```

--------------------------------

### GettingStarted.java - Matrix creation and manipulation

Source: http://www.ojalgo.org/code-examples

Demonstrates creating matrices using a builder and explicitly setting elements. Shows how to use matrixFactory and storeFactory to copy data, and how to set elements directly on a store and a builder. Includes logging the resulting matrix with BasicLogger.

```java
matrixA = matrixBuilder.get();

/* Creating matrices by explicitly setting all elements */

double[][] data = { { 1.0, 2.0, 3.0 }, { 4.0, 5.0, 6.0 }, { 7.0, 8.0, 9.0 } };
matrixFactory.copy(RawStore.wrap(data));
storeFactory.copy(RawStore.wrap(data));

// You don't want/need to first create some (intermediate) array
// for the elements, you can of course set them on the matrix
// directly.
R064Store storeZ = storeFactory.makeEye(3, 3);

// Since PrimitiveMatrix is immutable this has to be done via
// a builder.
MatrixR064.DenseReceiver matrixZBuilder = matrixFactory.newDenseBuilder(3, 3);

for (int j = 0; j < 3; j++) {
for (int i = 0; i < 3; i++) {
matrixZBuilder.set(i, j, i * j);
storeZ.set(i, j, i * j);
}
}

MatrixR064 matrixZ = matrixZBuilder.get();

BasicLogger.debug();
BasicLogger.debugMatrix("PrimitiveMatrix Z", matrixZ);
}
}
```

--------------------------------

### OneBRC example: imports, Aggregator, and Processor class

Source: http://www.ojalgo.org/code-examples

This is the beginning of the OneBRC example class, showing imports, the Aggregator inner class for per-station statistics, and the start of the Processor class that implements TwoStepMapper.Combineable for parallel file processing. The code is truncated at the point where the combine method begins.

```java
import java.io.File;  
import java.io.IOException;  
import java.io.UncheckedIOException;  
import java.nio.file.Files;  
import java.util.DoubleSummaryStatistics;  
import java.util.HashMap;  
import java.util.Map;  
import java.util.Map.Entry;  
import java.util.Set;  
import java.util.SortedMap;  
import java.util.TreeMap;  
import java.util.stream.Collector;  
import java.util.stream.Collectors;  
 
import org.ojalgo.OjAlgoUtils;  
import org.ojalgo.concurrent.ProcessingService;  
import org.ojalgo.netio.BasicLogger;  
import org.ojalgo.netio.SegmentedFile;  
import org.ojalgo.netio.SegmentedFile.Segment;  
import org.ojalgo.netio.TextLineReader;  
import org.ojalgo.type.CalendarDateUnit;  
import org.ojalgo.type.Stopwatch;  
import org.ojalgo.type.function.TwoStepMapper;  
import org.ojalgo.type.keyvalue.EntryPair;  
import org.ojalgo.type.keyvalue.EntryPair.KeyedPrimitive;  
 
/**  
 * An example of how to use the SegmentedFile and ProcessingService classes to process a large file in  
 * parallel.  
 * <p>  
 * This is an implementation of the 1BRC using ojAlgo.  
 *  
 * @see https://github.com/gunnarmorling/1brc  
 * @see https://www.ojalgo.org/2024/02/1brc-using-ojalgo/  
 */  
public class OneBRC {  
 
 /**  
  * There will be one instance of this class per station (city). It is used to aggregate the temperature  
  * measurements for that station. Most 1BRC submissions have a similar class. The  
  * {@link DoubleSummaryStatistics} could have been used for this, but it has some overhead due to handling  
  * of infinities and NaNs not needed here.  
  */  
 static final class Aggregator {  
 
  static double round(final double value) {  
  return Math.round(value * 10.0) / 10.0;  
  }  
 
  int count = 0;  
  double max = Double.NEGATIVE_INFINITY;  
  double min = Double.POSITIVE_INFINITY;  
  double sum = 0.0;  
 
  @Override  
  public String toString() {  
  return min + "/" + Aggregator.round(sum / count) + "/" + max;  
  }  
 
  void merge(final Aggregator other) {  
  if (other.min < min) {  
   min = other.min;  
  }  
  if (other.max > max) {  
   max = other.max;  
  }  
  sum += other.sum;  
  count += other.count;  
  }  
 
  void put(final double value) {  
  if (value < min) {  
   min = value;  
  }  
  if (value > max) {  
   max = value;  
  }  
  sum += value;  
  count++;  
  }  
 
 }  
 
 /**  
  * A file segment processor. This class implements much of the actual processing specific for this use  
  * case. Since it implements the TwoStepMapper interface there is standard functionality implemented in  
  * the ProcessingService class we can use. More precisely since it implements the  
  * TwoStepMapper.Combineable sub-interface it can be used with the  
  * ProcessingService.reduceCombineable(...) method, and we'll make use of that.  
  */  
 static final class Processor implements TwoStepMapper.Combineable<SegmentedFile.Segment, SortedMap<String, Aggregator>, Processor> {  
 
  /**  
   * The standard Java Double.parseDouble(...) method is not used since it is too slow. This method only  
   * handles precisely the format used in the 1BRC data files, and is therefore much faster.  
   */  
  private static double parseDouble(final String sequence, final int first, final int limit) {  
 
  int unscaled = 0;  
  boolean negative = false;  
 
  for (int i = first; i < limit; i++) {  
 
   char digit = sequence.charAt(i);  
 
   switch (digit) {  
   case '-':  
   negative = true;  
   break;  
   case '.':  
   break;  
   default:  
   unscaled = 10 * unscaled + digit - '0';  
   break;  
   }  
  }  
 
  if (negative) {  
  return -unscaled / 10D;  
  } else {  
  return unscaled / 10D;  
  }  
  }  
 
  /**  
   * The actual temperature measurements. The key is the station (city) name, and the value is the  
   * Aggregator instance for that station.  
   */  
  private final Map<String, Aggregator> myAggregates = new HashMap<>(512);  
  /**  
   * The SegmentedFile instance this Processor is processing data from.  
   */  
  private final SegmentedFile mySegmentedFile;  
 
  Processor(final SegmentedFile segmentedFile) {  
  super();  
  mySegmentedFile = segmentedFile;  
  }  
 
  /**  
   * Combine the internal state from another Processor instance into this one.  
   */  
  @Override  
  public void combine(final Processor other) {  
  for (Map.Entry<String, Aggregator> entry : other.getEntries()) {  

```

--------------------------------

### Main method: configure BatchManager and write initial data

Source: http://www.ojalgo.org/2022/05/introducing-batchnode

The main method sets up logging, configures a BatchManager with a temp directory, executor, fragmentation, parallelism, and queue size. It then parses IDX training files, creates a BatchNode for initial data, and writes DataAndLabelPair objects to it, optionally generating images.

```java
    public static void main(final String[] args) throws IOException {

        BasicLogger.debug();
        BasicLogger.debug(FashionMNISTWithBatchNode.class);
        BasicLogger.debug(OjAlgoUtils.getTitle());
        BasicLogger.debug(OjAlgoUtils.getDate());
        BasicLogger.debug();

        int numberToPrint = 10;
        boolean generateImages = false;
        int epochs = 128;
        int batchSize = 100;

        /*
         * Using a BatchManager is entirely optional. It just makes it a bit simpler to create multiple
         * BatchNode instances with common configurations.
         */
        BatchManager batchManager = new BatchManager(TEMP_BATCH_DIR); // Specifying a temp dir for all the node data
        batchManager.executor(DaemonPoolExecutor.newCachedThreadPool("Batch Worker")); // The thread pool used when processing data
        batchManager.fragmentation(epochs); // The number of shards - we'll make use of the fact that it matches the epochs
        batchManager.parallelism(Parallelism.CORES); // The number of worker threads
        batchManager.queue(1024); // Capacity of the queues used when reading/writing to disk
        /*
         * Using BatchManager is optional, and also all of those configurations have usable defaults.
         */

        ArrayAnyD<Double> trainingLabels = IDX.parse(TRAINING_LABELS);
        ArrayAnyD<Double> trainingImages = IDX.parse(TRAINING_IMAGES);

        BasicLogger.debug("Parsed IDX training data files: {}", STOPWATCH.stop(CalendarDateUnit.SECOND));

        /*
         * Declaring a node to store the initial data. We just specify the name of a subdirectory and how to
         * "interpret" its data.
         */
        BatchNode<DataAndLabelPair> initialData = batchManager.newNodeBuilder("initial", DataAndLabelPair.INTERPRETER).build();

        /*
         * Write to that initial data node
         */
        try (ToFileWriter<DataAndLabelPair> initialDataWriter = initialData.newWriter()) {

            for (MatrixView<Double> imageMatrix : trainingImages.matrices()) {

                long imageIndex = imageMatrix.index();
                int label = trainingLabels.intValue(imageIndex);

                DataAndLabelPair pair = new DataAndLabelPair(imageMatrix, label);

                initialDataWriter.write(pair);

                if (generateImages) {
                    FashionMNISTWithBatchNode.generateImage(imageMatrix, label, OUTPUT_TRAINING_IMAGES);
                }
            }

        } catch (Exception cause) {
            throw new RuntimeException(cause);
        }

        BasicLogger.debug("Initial training data: {}", STOPWATCH.stop(CalendarDateUnit.SECOND));
    }
```

--------------------------------

### TravelingSalesmanProblem.java: base model setup

Source: http://www.ojalgo.org/2025/08/model-and-solve-the-traveling-salesman-problem

Initializes the TSP example: sets up logging, problem size (25 cities), random distances, and a base ExpressionsBasedModel with binary decision variables and degree constraints (each city entered/exited exactly once). The base model is copied for the MTZ formulation.

```java
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Random;
import java.util.Set;

import org.ojalgo.OjAlgoUtils;
import org.ojalgo.function.constant.PrimitiveMath;
import org.ojalgo.function.special.MissingMath;
import org.ojalgo.netio.BasicLogger;
import org.ojalgo.optimisation.Expression;
import org.ojalgo.optimisation.ExpressionsBasedModel;
import org.ojalgo.optimisation.Optimisation;
import org.ojalgo.optimisation.Variable;
import org.ojalgo.optimisation.integer.IntegerSolver;
import org.ojalgo.optimisation.integer.IntegerStrategy;
import org.ojalgo.type.CalendarDateUnit;
import org.ojalgo.type.Stopwatch;
import org.ojalgo.type.context.NumberContext;

/**
 * An example of how to model and solve the Traveling Salesman Problem (TSP) using ojAlgo. Two alternative
 * models are developed and compared:
 * <ul>
 * <li>Miller–Tucker–Zemlin (MTZ)
 * <li>Dantzig–Fulkerson–Johnson (DFJ)
 * </ul>
 *
 * @see https://www.ojalgo.org/2025/08/model-and-solve-the-traveling-salesman-problem/
 */
public class TravelingSalesmanProblem {

    static final Random RANDOM = new Random(47);
    static final Stopwatch STOPWATCH = new Stopwatch();

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

        BasicLogger.debug();
        BasicLogger.debug(TravelingSalesmanProblem.class);
        BasicLogger.debug(OjAlgoUtils.getTitle());
        BasicLogger.debug(OjAlgoUtils.getDate());
        BasicLogger.debug();

        STOPWATCH.reset();

        // Specify the problem size (the number of cities to visit)
        int nbCities = 25;

        double nbPossibleRoutes = TravelingSalesmanProblem.calculateNumberOfPossibleRoutes(nbCities);

        BasicLogger.debug("Solving TSP with {} cities and {} possible routes", nbCities, nbPossibleRoutes);

        double[][] distances = TravelingSalesmanProblem.generateRandomDistances(nbCities);

        ExpressionsBasedModel baseModel = new ExpressionsBasedModel();
        baseModel.options.progress(IntegerSolver.class);
        baseModel.options.solution = NumberContext.of(6);
        baseModel.options.integer(IntegerStrategy.DEFAULT.withGapTolerance(NumberContext.of(3)));

        // Decision variables: x[i][j] = 1 if path from i to j is used, 0 otherwise
        // The weights on the variables make up the objective function – to minimise the total distance
        Variable[][] baseVariables = new Variable[nbCities][nbCities];
        for (int i = 0; i < nbCities; i++) { // from
            for (int j = 0; j < nbCities; j++) { // to
                if (i != j) {
                    baseVariables[i][j] = baseModel.addVariable("x_" + i + "_" + j).binary().weight(distances[i][j]);
                } else {
                    baseVariables[i][j] = null;
                }
            }
        }

        // Constraint: Each city is entered exactly once
        for (int j = 0; j < nbCities; j++) {
            Expression inConstraint = baseModel.addExpression("In_" + j).level(1);
            for (int i = 0; i < nbCities; i++) {
                if (i != j) {
                    inConstraint.set(baseVariables[i][j], 1);
                }
            }
        }

        // Constraint: Each city is exited exactly once
        for (int i = 0; i < nbCities; i++) {
            Expression outConstraint = baseModel.addExpression("Out_" + i).level(1);
            for (int j = 0; j < nbCities; j++) {
                if (i != j) {
                    outConstraint.set(baseVariables[i][j], 1);
                }
            }
        }

        BasicLogger.debug("Problem data and base model generated in {}", STOPWATCH.stop());

        /*
         * Miller-Tucker-Zemlin (MTZ) formulation for subtour elimination.
         */

        ExpressionsBasedModel modMTZ = baseModel.copy();
```
Tokens:
Raw