Getting Started

A simple use of Jeometry classes. This document is not exhaustive. Please refer to specific pages for more detailled content.

Creating objects: The Jeometry factory

Jeometry library relies on interfaces for use and builders for instanciation. For the sake of simplicity, all object creation can be done using static methods from the JeometryFactory class (or GeometryFactory class for older version). The following example illustrates how to create basic mathematical objects:

package org.jeometry.sample;

import org.jeometry.factory.JeometryFactory;
import org.jeometry.math.Matrix;
import org.jeometry.math.Quaternion;
import org.jeometry.math.Vector;

/**
 * A first sample program.
 */
public class FirstSample {

  /**
    * The main method.
    * @param args program arguments
    */
    public static void main(String[] args) {
		
      // Create a 3x3 matrix
      Matrix m = JeometryFactory.createMatrix(3, 3);

      // Create a vector of dimension 3
      Vector v = JeometryFactory.createVector(3);

      // Create a quaternion
      Quaternion q = JeometryFactory.createQuaternion();
    }
}

Mathematics

One of the first interest of the Jeometry library is it's mathematical package (org.geometry.math) that provides objects and methods dedicated to computation. The most common objects are Vector, Quaternion and Matrix.

Matrix

A Jeometry Matrix is the representation of a mathematical matrix, it enables to store real numbers and provide standard computation methods (multiplication, inversion, ...).

Creation

A matrix can be instantiated following different ways:

1. by specifying its dimensions (rows, columns)
2. by initializing with a 2D double array
3. by copying an existing matrix
4. by initializing with a linear double array (using row / column order)

The following sample illustrates all possible ways.

package org.jeometry.sample.math;

import org.jeometry.factory.JeometryFactory;
import org.jeometry.math.Matrix;

/**
 * A matrix creation sample.
 */
public class MatrixCreationSample {

	/**
	 * The main method.
	 * @param args the program arguments
	 */
	public static void main(String[] args) {
	
		// 1. Matrix creation using dimensions.
		Matrix a = JeometryFactory.createMatrix(3, 3);
		
		// 2. Matrix creation using 2D array
		double[][] bdata = new double[][] {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
		
		Matrix b = JeometryFactory.createMatrix(bdata);
		
		// 3. Matrix creation by copy 
		Matrix c = JeometryFactory.createMatrix(b);
		
		// 4. Matrix creation using a linear array, row major and column major
		double[] ddata = new double[] {1, 2, 3, 4, 5, 6, 7, 8, 9};
	
		Matrix d = JeometryFactory.createMatrix(3, 3, ddata, Matrix.ROW_MAJOR);
		
		Matrix e = JeometryFactory.createMatrix(3, 3, ddata, Matrix.COLUMN_MAJOR);
	}
}

Operations

Standard operations on matrices are implemented. The first operations are related to matrix data access as illustrated within the following example:

package org.jeometry.sample.math;

import org.jeometry.factory.JeometryFactory;
import org.jeometry.math.Matrix;

/**
 * Matrix operations samples.
 */
public class MatrixDataOperationsSample {

	/**
	 * The main method.
	 * @param args the program arguments
	 */
	public static void main(String[] args) {
		
		
		//Matrix creation using 2D array
		double[][] bdata = new double[][] {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
				
		Matrix a = JeometryFactory.createMatrix(bdata);
		
		// Matrix creation using dimension 
		Matrix b = JeometryFactory.createMatrix(4, 3);
		
		// Display matrix dimension
		System.out.println("A["+a.getRowsCount()+"x"+a.getColumnsCount()+"]");
		
		// Get matrix value
		System.out.println("A[2x3] = "+a.getValue(2, 3));

		// Set matrix value
		for(int row = 0; row < b.getRowsCount(); row++) {
			for(int col = 0; col < b.getColumnsCount(); col++) {
				b.setValue(row, col, row*col);
			}
		}
	}
}

Mathematical operations on matrices are also available. There is 3 groups of operations:

1. Addition / subtraction
2. Multiplication
3. Transposition / inversion

package org.jeometry.sample.math;

import org.jeometry.factory.JeometryFactory;
import org.jeometry.math.Matrix;

/**
 * Matrix mathematical operations sample.
 */
public class MatrixMathOperationsSample {

	/**
	 * The main method.
	 * @param args the program arguments
	 */
	public static void main(String[] args) {
				
		Matrix a = JeometryFactory.createMatrix(new double[][] {
			{ 3.45692302, -1.36528596,    1.3685204, -459.0254136},
			{22.65974148,  0.00698741,    8.1269853,   23.5410397},
			{12.87456921, -3.12586921,   11.3685214,  -33.2154242},
			{36.25697942, -3.01127952, 6984.3652127,   12.6985412}
		});
				
		Matrix b = JeometryFactory.createMatrix(new double[][] {{6, 5, 4, 1}, {9, 8, 7, 2}, {3, 2, 1, 5}, {10, 11, 12, 4}});
		
		// Add the scalar 5.0 to all matrix cells
		Matrix ap = a.add(5.0);
		
		// Create a new matrix where each cell is the addition of the corresponding
		// cells from matrix a and b
		Matrix apb = a.add(b);
		
		// Subtract the scalar 4.0 from all matrix cells
		Matrix am = a.subtract(4.0);
		
		// Create a new matrix where each cell is the subtraction of the corresponding
		// cells from matrix a and b
		Matrix amb = a.subtract(b);
		
		// Multiply all matrix cells by the scalar 2.0
		Matrix ax = a.multiply(2.0);
		
		// The standard matrix product a x b
		Matrix axb = a.multiply(amb);
		
		// Transpose the matrix
		Matrix t = a.transpose();
		
		// Invert the matrix
		Matrix i = a.invert();
	}
}

All operations propose different ways of use. In most of the case, for a specific operation, 3 methods are available:

• A method that return the result as a new object
• A method that set the result within a given pre-instanciated parameter
• A method that modyfy the object itself