Efficient Java Matrix Library - User contributions [en]

Download

2025-03-22T01:25:38Z

Peter:

== Source Code ==

Source code is hosted on Github. There you can access the absolute bleeding edge code. Most of the time it is in an usable state, but not always!

[https://github.com/lessthanoptimal/ejml https://github.com/lessthanoptimal/ejml]

The command to clone it is:

<syntaxhighlight lang="groovy">
git clone https://github.com/lessthanoptimal/ejml.git
</syntaxhighlight>

Current status of developmental code:

[https://github.com/lessthanoptimal/ejml/actions/workflows/gradle.yml https://github.com/lessthanoptimal/ejml/actions/workflows/gradle.yml/badge.svg]

== Download ==

Jars of the latest stable release can be found on Source Forge using the following link: [https://sourceforge.net/projects/ejml/files/v0.44.0/ EJML Downloads]

== Gradle and Maven ==

EJML is broken up into several packages (see list below) and including each individually can be tedious. To include all the packages simply reference "all", as is shown below:

Gradle:
<syntaxhighlight lang="groovy">
compile group: 'org.ejml', name: 'ejml-all', version: '0.44.0'
</syntaxhighlight>

Maven:
<syntaxhighlight lang="xml">
<dependency>
<groupId>org.ejml</groupId>
<artifactId>ejml-all</artifactId>
<version>0.44.0</version>
</dependency>
</syntaxhighlight>

Individual modules:

{| class="wikitable"
! Module Name !! Description
|-
| ejml-all || All the modules
|-
| ejml-ddense || Dense Real Double Matrices
|-
| ejml-fdense || Dense Real Float Matrices
|-
| ejml-zdense || Dense Complex Double Matrices
|-
| ejml-cdense || Dense Complex Float Matrices
|-
| ejml-simple || SimpleMatrix and Equations
|-
| ejml-dsparse || Sparse Real Double Matrices
|-
| ejml-fsparse || Sparse Real Float Matrices
|}

Download

2025-03-22T01:25:14Z

Peter:

== Source Code ==

Source code is hosted on Github. There you can access the absolute bleeding edge code. Most of the time it is in an usable state, but not always!

[https://github.com/lessthanoptimal/ejml https://github.com/lessthanoptimal/ejml]

The command to clone it is:

<syntaxhighlight lang="groovy">
git clone https://github.com/lessthanoptimal/ejml.git
</syntaxhighlight>

Current status of developmental code:

[https://github.com/lessthanoptimal/ejml/actions/workflows/gradle.yml https://github.com/lessthanoptimal/ejml/actions/workflows/gradle.yml/badge.svg]

== Download ==

Jars of the latest stable release can be found on Source Forge using the following link: [https://sourceforge.net/projects/ejml/files/v0.43/ EJML Downloads]

== Gradle and Maven ==

EJML is broken up into several packages (see list below) and including each individually can be tedious. To include all the packages simply reference "all", as is shown below:

Gradle:
<syntaxhighlight lang="groovy">
compile group: 'org.ejml', name: 'ejml-all', version: '0.44.0'
</syntaxhighlight>

Maven:
<syntaxhighlight lang="xml">
<dependency>
<groupId>org.ejml</groupId>
<artifactId>ejml-all</artifactId>
<version>0.44.0</version>
</dependency>
</syntaxhighlight>

Individual modules:

{| class="wikitable"
! Module Name !! Description
|-
| ejml-all || All the modules
|-
| ejml-ddense || Dense Real Double Matrices
|-
| ejml-fdense || Dense Real Float Matrices
|-
| ejml-zdense || Dense Complex Double Matrices
|-
| ejml-cdense || Dense Complex Float Matrices
|-
| ejml-simple || SimpleMatrix and Equations
|-
| ejml-dsparse || Sparse Real Double Matrices
|-
| ejml-fsparse || Sparse Real Float Matrices
|}

Download

2025-03-22T01:25:03Z

Peter:

== Source Code ==

Source code is hosted on Github. There you can access the absolute bleeding edge code. Most of the time it is in an usable state, but not always!

[https://github.com/lessthanoptimal/ejml https://github.com/lessthanoptimal/ejml]

The command to clone it is:

<syntaxhighlight lang="groovy">
git clone https://github.com/lessthanoptimal/ejml.git
</syntaxhighlight>

Current status of developmental code:

[https://github.com/lessthanoptimal/ejml/actions/workflows/gradle.yml https://github.com/lessthanoptimal/ejml/actions/workflows/gradle.yml/badge.svg]

== Download ==

Jars of the latest stable release can be found on Source Forge using the following link: [https://sourceforge.net/projects/ejml/files/v0.43/ EJML Downloads]

== Gradle and Maven ==

EJML is broken up into several packages (see list below) and including each individually can be tedious. To include all the packages simply reference "all", as is shown below:

Gradle:
<syntaxhighlight lang="groovy">
compile group: 'org.ejml', name: 'ejml-all', version: '0.43'
</syntaxhighlight>

Maven:
<syntaxhighlight lang="xml">
<dependency>
<groupId>org.ejml</groupId>
<artifactId>ejml-all</artifactId>
<version>0.44.0</version>
</dependency>
</syntaxhighlight>

Individual modules:

{| class="wikitable"
! Module Name !! Description
|-
| ejml-all || All the modules
|-
| ejml-ddense || Dense Real Double Matrices
|-
| ejml-fdense || Dense Real Float Matrices
|-
| ejml-zdense || Dense Complex Double Matrices
|-
| ejml-cdense || Dense Complex Float Matrices
|-
| ejml-simple || SimpleMatrix and Equations
|-
| ejml-dsparse || Sparse Real Double Matrices
|-
| ejml-fsparse || Sparse Real Float Matrices
|}

Main Page

2025-03-22T01:17:09Z

Peter:

__NOTOC__

<center>
{| style="width:640pt;"
| align="center" |
[[File:Ejml_logo.gif]]
|-
|

Efficient Java Matrix Library (EJML) is a [http://en.wikipedia.org/wiki/Linear_algebra linear algebra] library for manipulating real/complex/dense/sparse matrices. Its design goals are; 1) to be as computationally and memory efficient as possible for small and large, dense and sparse, real and complex matrices, and 2) to be accessible to both novices and experts. These goals are accomplished by dynamically selecting the best algorithms to use at runtime, clean API, and multiple interfaces. EJML is free, written in 100% Java and has been released under an Apache v2.0 license.

EJML has three distinct ways to interact with it: 1) ''procedural'', 2) ''SimpleMatrix'', and 3) ''Equations''. ''Procedure'' provides all capabilities of EJML and almost complete control over memory creation, speed, and specific algorithms. ''SimpleMatrix'' provides a simplified subset of the core capabilities in an easy to use flow styled object-oriented API, inspired by [http://math.nist.gov/javanumerics/jama/ Jama]. ''Equations'' is a symbolic interface, similar in spirit to [http://www.mathworks.com/products/matlab/ Matlab] and other [http://en.wikipedia.org/wiki/Computer_algebra_system CAS], that provides a compact way of writing equations.
|}

{|
| colspan="3" align="center" |
{|style="font-size:120%; text-align:left;"
|-
| '''Version:''' ''v0.44.0''
|-
| '''Date:''' ''March 21, 2025''
|-
| [https://github.com/lessthanoptimal/ejml/blob/master/convert_to_ejml31.py v0.31 Upgrade Script]
|-
| [https://github.com/lessthanoptimal/ejml/blob/v0.44.0/change.txt Change Log]
|}
|- valign="top"
| width="220pt" |
{| width="200pt" border="1" align="center" style="font-size:120%; text-align:center; border-collapse:collapse; background-color:#ffffee;"
|-
| [[Download|Download]]
|-
| [[manual|Manual]]
|-
| [http://ejml.org/javadoc/ JavaDoc]
|}
| width="220pt" |
{| width="200pt" border="1" align="center" style="font-size:120%; text-align:center; border-collapse:collapse; background-color:#ffffee;"
|-
| [http://groups.google.com/group/efficient-java-matrix-library-discuss Message Board]
|-
| [https://github.com/lessthanoptimal/ejml/issues Bug Reports]
|-
| [[Frequently Asked Questions|FAQ]]
|-
| [[Kotlin|Kotlin]]
|}
| width="220pt" |
{| width="200pt" border="1" align="center" style="font-size:120%; text-align:center; border-collapse:collapse; background-color:#ffffee;"
|-
| [[Acknowledgments|Acknowledgments]]
|-
| [[Performance|Performance]]
|-
| [[Users|Users]]
|}
|}

== News 2023 ==

{| width="500pt" |
| -
|
* SimpleMatrix is going through bit of a rejuvenation
* SimpleMatrix has much improved support for complex matrices
* Introduced ConstMatrix for when you want to restrict access to read only
|}

== Code Examples ==

Demonstrations on how to compute the Kalman gain "K" using each interface in EJML.

{| width="500pt" |
|-
|
'''Procedural'''
<syntaxhighlight lang="java">
mult(H,P,c);
multTransB(c,H,S);
addEquals(S,R);
if( !invert(S,S_inv) )
throw new RuntimeException("Invert failed");
multTransA(H,S_inv,d);
mult(P,d,K);
</syntaxhighlight>

'''SimpleMatrix'''
<syntaxhighlight lang="java">
SimpleMatrix S = H.mult(P).mult(H.transpose()).plus(R);
SimpleMatrix K = P.mult(H.transpose().mult(S.invert()));
</syntaxhighlight>

'''Equations'''
<syntaxhighlight lang="java">
eq.process("K = P*H'*inv( H*P*H' + R )");
</syntaxhighlight>
|}

== Functionality ==

{| class="wikitable" width="650pt" border="1" |
! Data Structures || Operations
|-
| style="vertical-align:top;" |
* Fixed Sized
** Matrix 2x2 to 6x6
** Vector 2 to 6
* Dense Real
** Row-major
** Block
* Dense Complex
** Row-major
* Sparse Real
** Compressed Column

| style="vertical-align:top;" |
* Full support for floats and doubles
* Basic Operators (addition, multiplication, ... )
* Matrix Manipulation (extract, insert, combine, ... )
* Linear Solvers (linear, least squares, incremental, ... )
* Decompositions (LU, QR, Cholesky, SVD, Eigenvalue, ...)
* Matrix Features (rank, symmetric, definitiveness, ... )
* Random Matrices (covariance, orthogonal, symmetric, ... )
* Unit Testing
|}.

{| class="wikitable" width="650pt" border="1" |
! style="width: 40%;" | Decomposition || style="width: 15%;" |Dense Real || style="width: 15%;" |Dense Complex || style="width: 15%;" |Sparse Real || style="width: 15%;" |Sparse Complex
|-
| LU || style="text-align:center;" | X || style="text-align:center;" | X || style="text-align:center;" | X ||
|-
| Cholesky LL || style="text-align:center;" | X || style="text-align:center;" | X || style="text-align:center;" | X ||
|-
| Cholesky LDL || style="text-align:center;" | X || style="text-align:center;" | || ||
|-
| QR || style="text-align:center;" | X || style="text-align:center;" | X || style="text-align:center;" | X ||
|-
| QRP || style="text-align:center;" | X || style="text-align:center;" | || ||
|-
| SVD || style="text-align:center;" | X || style="text-align:center;" | || ||
|-
| Eigen-Symmetric || style="text-align:center;" | X || style="text-align:center;" | || ||
|-
| Eigen-General || style="text-align:center;" | X || style="text-align:center;" | || ||
|}
Support for floats (32-bit) and doubles (64-bit) is available. Sparse matrix support is only available for basic operations at this time.
</center>

Main Page

2023-09-24T04:33:04Z

Peter:

__NOTOC__

<center>
{| style="width:640pt;"
| align="center" |
[[File:Ejml_logo.gif]]
|-
|

Efficient Java Matrix Library (EJML) is a [http://en.wikipedia.org/wiki/Linear_algebra linear algebra] library for manipulating real/complex/dense/sparse matrices. Its design goals are; 1) to be as computationally and memory efficient as possible for small and large, dense and sparse, real and complex matrices, and 2) to be accessible to both novices and experts. These goals are accomplished by dynamically selecting the best algorithms to use at runtime, clean API, and multiple interfaces. EJML is free, written in 100% Java and has been released under an Apache v2.0 license.

EJML has three distinct ways to interact with it: 1) ''procedural'', 2) ''SimpleMatrix'', and 3) ''Equations''. ''Procedure'' provides all capabilities of EJML and almost complete control over memory creation, speed, and specific algorithms. ''SimpleMatrix'' provides a simplified subset of the core capabilities in an easy to use flow styled object-oriented API, inspired by [http://math.nist.gov/javanumerics/jama/ Jama]. ''Equations'' is a symbolic interface, similar in spirit to [http://www.mathworks.com/products/matlab/ Matlab] and other [http://en.wikipedia.org/wiki/Computer_algebra_system CAS], that provides a compact way of writing equations.
|}

{|
| colspan="3" align="center" |
{|style="font-size:120%; text-align:left;"
|-
| '''Version:''' ''v0.43.1''
|-
| '''Date:''' ''September 23, 2023''
|-
| [https://github.com/lessthanoptimal/ejml/blob/master/convert_to_ejml31.py v0.31 Upgrade Script]
|-
| [https://github.com/lessthanoptimal/ejml/blob/v0.43.1/change.txt Change Log]
|}
|- valign="top"
| width="220pt" |
{| width="200pt" border="1" align="center" style="font-size:120%; text-align:center; border-collapse:collapse; background-color:#ffffee;"
|-
| [[Download|Download]]
|-
| [[manual|Manual]]
|-
| [http://ejml.org/javadoc/ JavaDoc]
|}
| width="220pt" |
{| width="200pt" border="1" align="center" style="font-size:120%; text-align:center; border-collapse:collapse; background-color:#ffffee;"
|-
| [http://groups.google.com/group/efficient-java-matrix-library-discuss Message Board]
|-
| [https://github.com/lessthanoptimal/ejml/issues Bug Reports]
|-
| [[Frequently Asked Questions|FAQ]]
|-
| [[Kotlin|Kotlin]]
|}
| width="220pt" |
{| width="200pt" border="1" align="center" style="font-size:120%; text-align:center; border-collapse:collapse; background-color:#ffffee;"
|-
| [[Acknowledgments|Acknowledgments]]
|-
| [[Performance|Performance]]
|-
| [[Users|Users]]
|}
|}

== News 2023 ==

{| width="500pt" |
| -
|
* SimpleMatrix is going through bit of a rejuvenation
* SimpleMatrix has much improved support for complex matrices
* Introduced ConstMatrix for when you want to restrict access to read only
|}

== Code Examples ==

Demonstrations on how to compute the Kalman gain "K" using each interface in EJML.

{| width="500pt" |
|-
|
'''Procedural'''
<syntaxhighlight lang="java">
mult(H,P,c);
multTransB(c,H,S);
addEquals(S,R);
if( !invert(S,S_inv) )
throw new RuntimeException("Invert failed");
multTransA(H,S_inv,d);
mult(P,d,K);
</syntaxhighlight>

'''SimpleMatrix'''
<syntaxhighlight lang="java">
SimpleMatrix S = H.mult(P).mult(H.transpose()).plus(R);
SimpleMatrix K = P.mult(H.transpose().mult(S.invert()));
</syntaxhighlight>

'''Equations'''
<syntaxhighlight lang="java">
eq.process("K = P*H'*inv( H*P*H' + R )");
</syntaxhighlight>
|}

== Functionality ==

{| class="wikitable" width="650pt" border="1" |
! Data Structures || Operations
|-
| style="vertical-align:top;" |
* Fixed Sized
** Matrix 2x2 to 6x6
** Vector 2 to 6
* Dense Real
** Row-major
** Block
* Dense Complex
** Row-major
* Sparse Real
** Compressed Column

| style="vertical-align:top;" |
* Full support for floats and doubles
* Basic Operators (addition, multiplication, ... )
* Matrix Manipulation (extract, insert, combine, ... )
* Linear Solvers (linear, least squares, incremental, ... )
* Decompositions (LU, QR, Cholesky, SVD, Eigenvalue, ...)
* Matrix Features (rank, symmetric, definitiveness, ... )
* Random Matrices (covariance, orthogonal, symmetric, ... )
* Unit Testing
|}.

{| class="wikitable" width="650pt" border="1" |
! style="width: 40%;" | Decomposition || style="width: 15%;" |Dense Real || style="width: 15%;" |Dense Complex || style="width: 15%;" |Sparse Real || style="width: 15%;" |Sparse Complex
|-
| LU || style="text-align:center;" | X || style="text-align:center;" | X || style="text-align:center;" | X ||
|-
| Cholesky LL || style="text-align:center;" | X || style="text-align:center;" | X || style="text-align:center;" | X ||
|-
| Cholesky LDL || style="text-align:center;" | X || style="text-align:center;" | || ||
|-
| QR || style="text-align:center;" | X || style="text-align:center;" | X || style="text-align:center;" | X ||
|-
| QRP || style="text-align:center;" | X || style="text-align:center;" | || ||
|-
| SVD || style="text-align:center;" | X || style="text-align:center;" | || ||
|-
| Eigen-Symmetric || style="text-align:center;" | X || style="text-align:center;" | || ||
|-
| Eigen-General || style="text-align:center;" | X || style="text-align:center;" | || ||
|}
Support for floats (32-bit) and doubles (64-bit) is available. Sparse matrix support is only available for basic operations at this time.
</center>

Download

2023-04-15T15:51:57Z

Peter:

== Source Code ==

Source code is hosted on Github. There you can access the absolute bleeding edge code. Most of the time it is in an usable state, but not always!

[https://github.com/lessthanoptimal/ejml https://github.com/lessthanoptimal/ejml]

The command to clone it is:

<syntaxhighlight lang="groovy">
git clone https://github.com/lessthanoptimal/ejml.git
</syntaxhighlight>

Current status of developmental code:

[https://github.com/lessthanoptimal/ejml/actions/workflows/gradle.yml https://github.com/lessthanoptimal/ejml/actions/workflows/gradle.yml/badge.svg]

== Download ==

Jars of the latest stable release can be found on Source Forge using the following link: [https://sourceforge.net/projects/ejml/files/v0.43/ EJML Downloads]

== Gradle and Maven ==

EJML is broken up into several packages (see list below) and including each individually can be tedious. To include all the packages simply reference "all", as is shown below:

Gradle:
<syntaxhighlight lang="groovy">
compile group: 'org.ejml', name: 'ejml-all', version: '0.43'
</syntaxhighlight>

Maven:
<syntaxhighlight lang="xml">
<dependency>
<groupId>org.ejml</groupId>
<artifactId>ejml-all</artifactId>
<version>0.43</version>
</dependency>
</syntaxhighlight>

Individual modules:

{| class="wikitable"
! Module Name !! Description
|-
| ejml-all || All the modules
|-
| ejml-ddense || Dense Real Double Matrices
|-
| ejml-fdense || Dense Real Float Matrices
|-
| ejml-zdense || Dense Complex Double Matrices
|-
| ejml-cdense || Dense Complex Float Matrices
|-
| ejml-simple || SimpleMatrix and Equations
|-
| ejml-dsparse || Sparse Real Double Matrices
|-
| ejml-fsparse || Sparse Real Float Matrices
|}

Download

2023-04-15T15:46:52Z

Peter:

== Source Code ==

Source code is hosted on Github. There you can access the absolute bleeding edge code. Most of the time it is in an usable state, but not always!

[https://github.com/lessthanoptimal/ejml https://github.com/lessthanoptimal/ejml]

The command to clone it is:

<syntaxhighlight lang="groovy">
git clone https://github.com/lessthanoptimal/ejml.git
</syntaxhighlight>

Current status of developmental code:

[https://travis-ci.org/lessthanoptimal/ejml https://api.travis-ci.org/lessthanoptimal/ejml.png]

== Download ==

Jars of the latest stable release can be found on Source Forge using the following link: [https://sourceforge.net/projects/ejml/files/v0.43/ EJML Downloads]

== Gradle and Maven ==

EJML is broken up into several packages (see list below) and including each individually can be tedious. To include all the packages simply reference "all", as is shown below:

Gradle:
<syntaxhighlight lang="groovy">
compile group: 'org.ejml', name: 'ejml-all', version: '0.43'
</syntaxhighlight>

Maven:
<syntaxhighlight lang="xml">
<dependency>
<groupId>org.ejml</groupId>
<artifactId>ejml-all</artifactId>
<version>0.43</version>
</dependency>
</syntaxhighlight>

Individual modules:

{| class="wikitable"
! Module Name !! Description
|-
| ejml-all || All the modules
|-
| ejml-ddense || Dense Real Double Matrices
|-
| ejml-fdense || Dense Real Float Matrices
|-
| ejml-zdense || Dense Complex Double Matrices
|-
| ejml-cdense || Dense Complex Float Matrices
|-
| ejml-simple || SimpleMatrix and Equations
|-
| ejml-dsparse || Sparse Real Double Matrices
|-
| ejml-fsparse || Sparse Real Float Matrices
|}

Main Page

2023-04-15T15:46:10Z

Peter:

__NOTOC__

<center>
{| style="width:640pt;"
| align="center" |
[[File:Ejml_logo.gif]]
|-
|

Efficient Java Matrix Library (EJML) is a [http://en.wikipedia.org/wiki/Linear_algebra linear algebra] library for manipulating real/complex/dense/sparse matrices. Its design goals are; 1) to be as computationally and memory efficient as possible for small and large, dense and sparse, real and complex matrices, and 2) to be accessible to both novices and experts. These goals are accomplished by dynamically selecting the best algorithms to use at runtime, clean API, and multiple interfaces. EJML is free, written in 100% Java and has been released under an Apache v2.0 license.

EJML has three distinct ways to interact with it: 1) ''procedural'', 2) ''SimpleMatrix'', and 3) ''Equations''. ''Procedure'' provides all capabilities of EJML and almost complete control over memory creation, speed, and specific algorithms. ''SimpleMatrix'' provides a simplified subset of the core capabilities in an easy to use flow styled object-oriented API, inspired by [http://math.nist.gov/javanumerics/jama/ Jama]. ''Equations'' is a symbolic interface, similar in spirit to [http://www.mathworks.com/products/matlab/ Matlab] and other [http://en.wikipedia.org/wiki/Computer_algebra_system CAS], that provides a compact way of writing equations.
|}

{|
| colspan="3" align="center" |
{|style="font-size:120%; text-align:left;"
|-
| '''Version:''' ''v0.43''
|-
| '''Date:''' ''April 15, 2023''
|-
| [https://github.com/lessthanoptimal/ejml/blob/master/convert_to_ejml31.py v0.31 Upgrade Script]
|-
| [https://github.com/lessthanoptimal/ejml/blob/v0.43/change.txt Change Log]
|}
|- valign="top"
| width="220pt" |
{| width="200pt" border="1" align="center" style="font-size:120%; text-align:center; border-collapse:collapse; background-color:#ffffee;"
|-
| [[Download|Download]]
|-
| [[manual|Manual]]
|-
| [http://ejml.org/javadoc/ JavaDoc]
|}
| width="220pt" |
{| width="200pt" border="1" align="center" style="font-size:120%; text-align:center; border-collapse:collapse; background-color:#ffffee;"
|-
| [http://groups.google.com/group/efficient-java-matrix-library-discuss Message Board]
|-
| [https://github.com/lessthanoptimal/ejml/issues Bug Reports]
|-
| [[Frequently Asked Questions|FAQ]]
|-
| [[Kotlin|Kotlin]]
|}
| width="220pt" |
{| width="200pt" border="1" align="center" style="font-size:120%; text-align:center; border-collapse:collapse; background-color:#ffffee;"
|-
| [[Acknowledgments|Acknowledgments]]
|-
| [[Performance|Performance]]
|-
| [[Users|Users]]
|}
|}

== News 2023 ==

{| width="500pt" |
| -
|
* SimpleMatrix is going through bit of a rejuvenation
* SimpleMatrix has much improved support for complex matrices
* Introduced ConstMatrix for when you want to restrict access to read only
|}

== Code Examples ==

Demonstrations on how to compute the Kalman gain "K" using each interface in EJML.

{| width="500pt" |
|-
|
'''Procedural'''
<syntaxhighlight lang="java">
mult(H,P,c);
multTransB(c,H,S);
addEquals(S,R);
if( !invert(S,S_inv) )
throw new RuntimeException("Invert failed");
multTransA(H,S_inv,d);
mult(P,d,K);
</syntaxhighlight>

'''SimpleMatrix'''
<syntaxhighlight lang="java">
SimpleMatrix S = H.mult(P).mult(H.transpose()).plus(R);
SimpleMatrix K = P.mult(H.transpose().mult(S.invert()));
</syntaxhighlight>

'''Equations'''
<syntaxhighlight lang="java">
eq.process("K = P*H'*inv( H*P*H' + R )");
</syntaxhighlight>
|}

== Functionality ==

{| class="wikitable" width="650pt" border="1" |
! Data Structures || Operations
|-
| style="vertical-align:top;" |
* Fixed Sized
** Matrix 2x2 to 6x6
** Vector 2 to 6
* Dense Real
** Row-major
** Block
* Dense Complex
** Row-major
* Sparse Real
** Compressed Column

| style="vertical-align:top;" |
* Full support for floats and doubles
* Basic Operators (addition, multiplication, ... )
* Matrix Manipulation (extract, insert, combine, ... )
* Linear Solvers (linear, least squares, incremental, ... )
* Decompositions (LU, QR, Cholesky, SVD, Eigenvalue, ...)
* Matrix Features (rank, symmetric, definitiveness, ... )
* Random Matrices (covariance, orthogonal, symmetric, ... )
* Unit Testing
|}.

{| class="wikitable" width="650pt" border="1" |
! style="width: 40%;" | Decomposition || style="width: 15%;" |Dense Real || style="width: 15%;" |Dense Complex || style="width: 15%;" |Sparse Real || style="width: 15%;" |Sparse Complex
|-
| LU || style="text-align:center;" | X || style="text-align:center;" | X || style="text-align:center;" | X ||
|-
| Cholesky LL || style="text-align:center;" | X || style="text-align:center;" | X || style="text-align:center;" | X ||
|-
| Cholesky LDL || style="text-align:center;" | X || style="text-align:center;" | || ||
|-
| QR || style="text-align:center;" | X || style="text-align:center;" | X || style="text-align:center;" | X ||
|-
| QRP || style="text-align:center;" | X || style="text-align:center;" | || ||
|-
| SVD || style="text-align:center;" | X || style="text-align:center;" | || ||
|-
| Eigen-Symmetric || style="text-align:center;" | X || style="text-align:center;" | || ||
|-
| Eigen-General || style="text-align:center;" | X || style="text-align:center;" | || ||
|}
Support for floats (32-bit) and doubles (64-bit) is available. Sparse matrix support is only available for basic operations at this time.
</center>

Download

2023-02-10T17:26:41Z

Peter:

== Source Code ==

Source code is hosted on Github. There you can access the absolute bleeding edge code. Most of the time it is in an usable state, but not always!

[https://github.com/lessthanoptimal/ejml https://github.com/lessthanoptimal/ejml]

The command to clone it is:

<syntaxhighlight lang="groovy">
git clone https://github.com/lessthanoptimal/ejml.git
</syntaxhighlight>

Current status of developmental code:

[https://travis-ci.org/lessthanoptimal/ejml https://api.travis-ci.org/lessthanoptimal/ejml.png]

== Download ==

Jars of the latest stable release can be found on Source Forge using the following link: [https://sourceforge.net/projects/ejml/files/v0.42/ EJML Downloads]

== Gradle and Maven ==

EJML is broken up into several packages (see list below) and including each individually can be tedious. To include all the packages simply reference "all", as is shown below:

Gradle:
<syntaxhighlight lang="groovy">
compile group: 'org.ejml', name: 'ejml-all', version: '0.42'
</syntaxhighlight>

Maven:
<syntaxhighlight lang="xml">
<dependency>
<groupId>org.ejml</groupId>
<artifactId>ejml-all</artifactId>
<version>0.42</version>
</dependency>
</syntaxhighlight>

Individual modules:

{| class="wikitable"
! Module Name !! Description
|-
| ejml-all || All the modules
|-
| ejml-ddense || Dense Real Double Matrices
|-
| ejml-fdense || Dense Real Float Matrices
|-
| ejml-zdense || Dense Complex Double Matrices
|-
| ejml-cdense || Dense Complex Float Matrices
|-
| ejml-simple || SimpleMatrix and Equations
|-
| ejml-dsparse || Sparse Real Double Matrices
|-
| ejml-fsparse || Sparse Real Float Matrices
|}

Main Page

2023-02-10T16:39:42Z

Peter:

__NOTOC__

<center>
{| style="width:640pt;"
| align="center" |
[[File:Ejml_logo.gif]]
|-
|

Efficient Java Matrix Library (EJML) is a [http://en.wikipedia.org/wiki/Linear_algebra linear algebra] library for manipulating real/complex/dense/sparse matrices. Its design goals are; 1) to be as computationally and memory efficient as possible for small and large, dense and sparse, real and complex matrices, and 2) to be accessible to both novices and experts. These goals are accomplished by dynamically selecting the best algorithms to use at runtime, clean API, and multiple interfaces. EJML is free, written in 100% Java and has been released under an Apache v2.0 license.

EJML has three distinct ways to interact with it: 1) ''procedural'', 2) ''SimpleMatrix'', and 3) ''Equations''. ''Procedure'' provides all capabilities of EJML and almost complete control over memory creation, speed, and specific algorithms. ''SimpleMatrix'' provides a simplified subset of the core capabilities in an easy to use flow styled object-oriented API, inspired by [http://math.nist.gov/javanumerics/jama/ Jama]. ''Equations'' is a symbolic interface, similar in spirit to [http://www.mathworks.com/products/matlab/ Matlab] and other [http://en.wikipedia.org/wiki/Computer_algebra_system CAS], that provides a compact way of writing equations.
|}

{|
| colspan="3" align="center" |
{|style="font-size:120%; text-align:left;"
|-
| '''Version:''' ''v0.42''
|-
| '''Date:''' ''February 10, 2023''
|-
| [https://github.com/lessthanoptimal/ejml/blob/master/convert_to_ejml31.py v0.31 Upgrade Script]
|-
| [https://github.com/lessthanoptimal/ejml/blob/v0.42/change.txt Change Log]
|}
|- valign="top"
| width="220pt" |
{| width="200pt" border="1" align="center" style="font-size:120%; text-align:center; border-collapse:collapse; background-color:#ffffee;"
|-
| [[Download|Download]]
|-
| [[manual|Manual]]
|-
| [http://ejml.org/javadoc/ JavaDoc]
|}
| width="220pt" |
{| width="200pt" border="1" align="center" style="font-size:120%; text-align:center; border-collapse:collapse; background-color:#ffffee;"
|-
| [http://groups.google.com/group/efficient-java-matrix-library-discuss Message Board]
|-
| [https://github.com/lessthanoptimal/ejml/issues Bug Reports]
|-
| [[Frequently Asked Questions|FAQ]]
|-
| [[Kotlin|Kotlin]]
|}
| width="220pt" |
{| width="200pt" border="1" align="center" style="font-size:120%; text-align:center; border-collapse:collapse; background-color:#ffffee;"
|-
| [[Acknowledgments|Acknowledgments]]
|-
| [[Performance|Performance]]
|-
| [[Users|Users]]
|}
|}

== News 2023 ==

{| width="500pt" |
| -
|
* SimpleMatrix is going through bit of a rejuvenation
* SimpleMatrix has much improved support for complex matrices
* Introduced ConstMatrix for when you want to restrict access to read only
|}

== Code Examples ==

Demonstrations on how to compute the Kalman gain "K" using each interface in EJML.

{| width="500pt" |
|-
|
'''Procedural'''
<syntaxhighlight lang="java">
mult(H,P,c);
multTransB(c,H,S);
addEquals(S,R);
if( !invert(S,S_inv) )
throw new RuntimeException("Invert failed");
multTransA(H,S_inv,d);
mult(P,d,K);
</syntaxhighlight>

'''SimpleMatrix'''
<syntaxhighlight lang="java">
SimpleMatrix S = H.mult(P).mult(H.transpose()).plus(R);
SimpleMatrix K = P.mult(H.transpose().mult(S.invert()));
</syntaxhighlight>

'''Equations'''
<syntaxhighlight lang="java">
eq.process("K = P*H'*inv( H*P*H' + R )");
</syntaxhighlight>
|}

== Functionality ==

{| class="wikitable" width="650pt" border="1" |
! Data Structures || Operations
|-
| style="vertical-align:top;" |
* Fixed Sized
** Matrix 2x2 to 6x6
** Vector 2 to 6
* Dense Real
** Row-major
** Block
* Dense Complex
** Row-major
* Sparse Real
** Compressed Column

| style="vertical-align:top;" |
* Full support for floats and doubles
* Basic Operators (addition, multiplication, ... )
* Matrix Manipulation (extract, insert, combine, ... )
* Linear Solvers (linear, least squares, incremental, ... )
* Decompositions (LU, QR, Cholesky, SVD, Eigenvalue, ...)
* Matrix Features (rank, symmetric, definitiveness, ... )
* Random Matrices (covariance, orthogonal, symmetric, ... )
* Unit Testing
|}.

{| class="wikitable" width="650pt" border="1" |
! style="width: 40%;" | Decomposition || style="width: 15%;" |Dense Real || style="width: 15%;" |Dense Complex || style="width: 15%;" |Sparse Real || style="width: 15%;" |Sparse Complex
|-
| LU || style="text-align:center;" | X || style="text-align:center;" | X || style="text-align:center;" | X ||
|-
| Cholesky LL || style="text-align:center;" | X || style="text-align:center;" | X || style="text-align:center;" | X ||
|-
| Cholesky LDL || style="text-align:center;" | X || style="text-align:center;" | || ||
|-
| QR || style="text-align:center;" | X || style="text-align:center;" | X || style="text-align:center;" | X ||
|-
| QRP || style="text-align:center;" | X || style="text-align:center;" | || ||
|-
| SVD || style="text-align:center;" | X || style="text-align:center;" | || ||
|-
| Eigen-Symmetric || style="text-align:center;" | X || style="text-align:center;" | || ||
|-
| Eigen-General || style="text-align:center;" | X || style="text-align:center;" | || ||
|}
Support for floats (32-bit) and doubles (64-bit) is available. Sparse matrix support is only available for basic operations at this time.
</center>

Main Page

2023-02-10T16:36:21Z

Peter:

__NOTOC__

<center>
{| style="width:640pt;"
| align="center" |
[[File:Ejml_logo.gif]]
|-
|

Efficient Java Matrix Library (EJML) is a [http://en.wikipedia.org/wiki/Linear_algebra linear algebra] library for manipulating real/complex/dense/sparse matrices. Its design goals are; 1) to be as computationally and memory efficient as possible for small and large, dense and sparse, real and complex matrices, and 2) to be accessible to both novices and experts. These goals are accomplished by dynamically selecting the best algorithms to use at runtime, clean API, and multiple interfaces. EJML is free, written in 100% Java and has been released under an Apache v2.0 license.

EJML has three distinct ways to interact with it: 1) ''procedural'', 2) ''SimpleMatrix'', and 3) ''Equations''. ''Procedure'' provides all capabilities of EJML and almost complete control over memory creation, speed, and specific algorithms. ''SimpleMatrix'' provides a simplified subset of the core capabilities in an easy to use flow styled object-oriented API, inspired by [http://math.nist.gov/javanumerics/jama/ Jama]. ''Equations'' is a symbolic interface, similar in spirit to [http://www.mathworks.com/products/matlab/ Matlab] and other [http://en.wikipedia.org/wiki/Computer_algebra_system CAS], that provides a compact way of writing equations.
|}

{|
| colspan="3" align="center" |
{|style="font-size:120%; text-align:left;"
|-
| '''Version:''' ''v0.42''
|-
| '''Date:''' ''February 10, 2023''
|-
| [https://github.com/lessthanoptimal/ejml/blob/master/convert_to_ejml31.py v0.31 Upgrade Script]
|-
| [https://github.com/lessthanoptimal/ejml/blob/v0.42/change.txt Change Log]
|}
|- valign="top"
| width="220pt" |
{| width="200pt" border="1" align="center" style="font-size:120%; text-align:center; border-collapse:collapse; background-color:#ffffee;"
|-
| [[Download|Download]]
|-
| [[manual|Manual]]
|-
| [http://ejml.org/javadoc/ JavaDoc]
|}
| width="220pt" |
{| width="200pt" border="1" align="center" style="font-size:120%; text-align:center; border-collapse:collapse; background-color:#ffffee;"
|-
| [http://groups.google.com/group/efficient-java-matrix-library-discuss Message Board]
|-
| [https://github.com/lessthanoptimal/ejml/issues Bug Reports]
|-
| [[Frequently Asked Questions|FAQ]]
|-
| [[Kotlin|Kotlin]]
|}
| width="220pt" |
{| width="200pt" border="1" align="center" style="font-size:120%; text-align:center; border-collapse:collapse; background-color:#ffffee;"
|-
| [[Acknowledgments|Acknowledgments]]
|-
| [[Performance|Performance]]
|-
| [[Users|Users]]
|}
|}

== News 2021 ==

{| width="500pt" |
| -
|
* Read and write EJML in Matlab format with [https://github.com/HebiRobotics/MFL MFL] from HEBI Robotics
* Graph BLAS continues to be flushed out with masks being added to latest SNAPSHOT
* Concurrency/threading has been added to some operations
|}

== Code Examples ==

Demonstrations on how to compute the Kalman gain "K" using each interface in EJML.

{| width="500pt" |
|-
|
'''Procedural'''
<syntaxhighlight lang="java">
mult(H,P,c);
multTransB(c,H,S);
addEquals(S,R);
if( !invert(S,S_inv) )
throw new RuntimeException("Invert failed");
multTransA(H,S_inv,d);
mult(P,d,K);
</syntaxhighlight>

'''SimpleMatrix'''
<syntaxhighlight lang="java">
SimpleMatrix S = H.mult(P).mult(H.transpose()).plus(R);
SimpleMatrix K = P.mult(H.transpose().mult(S.invert()));
</syntaxhighlight>

'''Equations'''
<syntaxhighlight lang="java">
eq.process("K = P*H'*inv( H*P*H' + R )");
</syntaxhighlight>
|}

== Functionality ==

{| class="wikitable" width="650pt" border="1" |
! Data Structures || Operations
|-
| style="vertical-align:top;" |
* Fixed Sized
** Matrix 2x2 to 6x6
** Vector 2 to 6
* Dense Real
** Row-major
** Block
* Dense Complex
** Row-major
* Sparse Real
** Compressed Column

| style="vertical-align:top;" |
* Full support for floats and doubles
* Basic Operators (addition, multiplication, ... )
* Matrix Manipulation (extract, insert, combine, ... )
* Linear Solvers (linear, least squares, incremental, ... )
* Decompositions (LU, QR, Cholesky, SVD, Eigenvalue, ...)
* Matrix Features (rank, symmetric, definitiveness, ... )
* Random Matrices (covariance, orthogonal, symmetric, ... )
* Unit Testing
|}.

{| class="wikitable" width="650pt" border="1" |
! style="width: 40%;" | Decomposition || style="width: 15%;" |Dense Real || style="width: 15%;" |Dense Complex || style="width: 15%;" |Sparse Real || style="width: 15%;" |Sparse Complex
|-
| LU || style="text-align:center;" | X || style="text-align:center;" | X || style="text-align:center;" | X ||
|-
| Cholesky LL || style="text-align:center;" | X || style="text-align:center;" | X || style="text-align:center;" | X ||
|-
| Cholesky LDL || style="text-align:center;" | X || style="text-align:center;" | || ||
|-
| QR || style="text-align:center;" | X || style="text-align:center;" | X || style="text-align:center;" | X ||
|-
| QRP || style="text-align:center;" | X || style="text-align:center;" | || ||
|-
| SVD || style="text-align:center;" | X || style="text-align:center;" | || ||
|-
| Eigen-Symmetric || style="text-align:center;" | X || style="text-align:center;" | || ||
|-
| Eigen-General || style="text-align:center;" | X || style="text-align:center;" | || ||
|}
Support for floats (32-bit) and doubles (64-bit) is available. Sparse matrix support is only available for basic operations at this time.
</center>

Example Sparse Matrices

2023-02-10T15:56:54Z

Peter:

Support for sparse matrices has recently been added to EJML. It supports many but not all of the standard operations that are supported for dense matrics. The code below shows the basics of working with a sparse matrix. In some situations the speed improvement of using a sparse matrix can be substantial. Do note that if your system isn't sparse enough or if its structure isn't advantageous it could run even slower using sparse operations!

<center>
{| class="wikitable"
! Type !! Execution Time (ms)
|-
| Dense || 12660
|-
| Sparse || 1642
|}
</center>

External Resources:
* [https://github.com/lessthanoptimal/ejml/blob/v0.41/examples/src/org/ejml/example/ExampleSparseMatrix.java ExampleSparseMatrix.java]

== Sparse Matrix Example ==

<syntaxhighlight lang="java">
/**
* Example showing how to construct and solve a linear system using sparse matrices
*
* @author Peter Abeles
*/
public class ExampleSparseMatrix {
public static int ROWS = 100000;
public static int COLS = 1000;
public static int XCOLS = 1;

public static void main( String[] args ) {
Random rand = new Random(234);

// easy to work with sparse format, but hard to do computations with
// NOTE: It is very important to you set 'initLength' to the actual number of elements in the final array
// If you don't it will be forced to thrash memory as it grows its internal data structures.
// Failure to heed this advice will make construction of large matrices 4x slower and use 2x more memory
var work = new DMatrixSparseTriplet(5, 4, 5);
work.addItem(0, 1, 1.2);
work.addItem(3, 0, 3);
work.addItem(1, 1, 22.21234);
work.addItem(2, 3, 6);

// convert into a format that's easier to perform math with
DMatrixSparseCSC Z = DConvertMatrixStruct.convert(work, (DMatrixSparseCSC)null);

// print the matrix to standard out in two different formats
Z.print();
System.out.println();
Z.printNonZero();
System.out.println();

// Create a large matrix that is 5% filled
DMatrixSparseCSC A = RandomMatrices_DSCC.rectangle(ROWS, COLS, (int)(ROWS*COLS*0.05), rand);
// large vector that is 70% filled
DMatrixSparseCSC x = RandomMatrices_DSCC.rectangle(COLS, XCOLS, (int)(XCOLS*COLS*0.7), rand);

System.out.println("Done generating random matrices");
// storage for the initial solution
var y = new DMatrixSparseCSC(ROWS, XCOLS, 0);
var z = new DMatrixSparseCSC(ROWS, XCOLS, 0);

// To demonstration how to perform sparse math let's multiply:
// y=A*x
// Optional storage is set to null so that it will declare it internally
long before = System.currentTimeMillis();
var workA = new IGrowArray(A.numRows);
var workB = new DGrowArray(A.numRows);
for (int i = 0; i < 100; i++) {
CommonOps_DSCC.mult(A, x, y, workA, workB);
CommonOps_DSCC.add(1.5, y, 0.75, y, z, workA, workB);
}
long after = System.currentTimeMillis();

System.out.println("norm = " + NormOps_DSCC.fastNormF(y) + " sparse time = " + (after - before) + " ms");

DMatrixRMaj Ad = DConvertMatrixStruct.convert(A, (DMatrixRMaj)null);
DMatrixRMaj xd = DConvertMatrixStruct.convert(x, (DMatrixRMaj)null);
var yd = new DMatrixRMaj(y.numRows, y.numCols);
var zd = new DMatrixRMaj(y.numRows, y.numCols);

before = System.currentTimeMillis();
for (int i = 0; i < 100; i++) {
CommonOps_DDRM.mult(Ad, xd, yd);
CommonOps_DDRM.add(1.5, yd, 0.75, yd, zd);
}
after = System.currentTimeMillis();
System.out.println("norm = " + NormOps_DDRM.fastNormF(yd) + " dense time = " + (after - before) + " ms");
}
}
</syntaxhighlight>

Example Kalman Filter

2023-02-10T15:52:56Z

Peter:

Here are three examples that demonstrate how a [http://en.wikipedia.org/wiki/Kalman_filter Kalman filter] can be created using different API's in EJML. Each API has different advantages and disadvantages. High level interfaces tend to be easier to use, but sacrifice efficiency. The intent of this article is to illustrate this trend empirically. Runtime performance of each approach is shown below. To see how complex and readable each approach is check out the source code below.

<center>
{| class="wikitable"
! API !! Execution Time (ms)
|-
| SimpleMatrix || 1875
|-
| Operations || 1280
|-
| Equations || 1698
|}
</center>

__TOC__

External Resources:
* [https://github.com/lessthanoptimal/ejml/blob/v0.42/examples/src/org/ejml/example/KalmanFilterSimple.java KalmanFilterSimple]
* [https://github.com/lessthanoptimal/ejml/blob/v0.42/examples/src/org/ejml/example/KalmanFilterOperations.java KalmanFilterOperations]
* [https://github.com/lessthanoptimal/ejml/blob/v0.42/examples/src/org/ejml/example/KalmanFilterEquation.java KalmanFilterEquation]
* <disqus>Discuss this example</disqus>

----

'''NOTE:''' While the Kalman filter code below is fully functional and will work well in most applications, it might not be the best. Other variants seek to improve stability and/or avoid the matrix inversion. It's worth point out that some people say you should never invert the matrix in a Kalman filter. There are applications, such as target tracking, where matrix inversion of the innovation covariance is helpful as a preprocessing step.

== SimpleMatrix Example ==

<syntaxhighlight lang="java">
/**
* A Kalman filter implemented using SimpleMatrix. The code tends to be easier to
* read and write, but the performance is degraded due to excessive creation/destruction of
* memory and the use of more generic algorithms. This also demonstrates how code can be
* seamlessly implemented using both SimpleMatrix and DMatrixRMaj. This allows code
* to be quickly prototyped or to be written either by novices or experts.
*
* @author Peter Abeles
*/
public class KalmanFilterSimple implements KalmanFilter {
// kinematics description
private ConstMatrix<SimpleMatrix> F, Q, H;

// sytem state estimate
private SimpleMatrix x, P;

@Override public void configure( DMatrixRMaj F, DMatrixRMaj Q, DMatrixRMaj H ) {
this.F = new SimpleMatrix(F);
this.Q = new SimpleMatrix(Q);
this.H = new SimpleMatrix(H);
}

@Override public void setState( DMatrixRMaj x, DMatrixRMaj P ) {
this.x = new SimpleMatrix(x);
this.P = new SimpleMatrix(P);
}

@Override public void predict() {
// x = F x
x = F.mult(x);

// P = F P F' + Q
P = F.mult(P).mult(F.transpose()).plus(Q);
}

@Override public void update( DMatrixRMaj _z, DMatrixRMaj _R ) {
// a fast way to make the matrices usable by SimpleMatrix
SimpleMatrix z = SimpleMatrix.wrap(_z);
SimpleMatrix R = SimpleMatrix.wrap(_R);

// y = z - H x
ConstMatrix<?> y = z.minus(H.mult(x));

// S = H P H' + R
ConstMatrix<?> S = H.mult(P).mult(H.transpose()).plus(R);

// K = PH'S^(-1)
ConstMatrix<?> K = P.mult(H.transpose().mult(S.invert()));

// x = x + Ky
x = x.plus(K.mult(y));

// P = (I-kH)P = P - KHP
P = P.minus(K.mult(H).mult(P));
}

@Override public DMatrixRMaj getState() { return x.getMatrix(); }

@Override public DMatrixRMaj getCovariance() { return P.getMatrix(); }
}
</syntaxhighlight>

== Operations Example ==

<syntaxhighlight lang="java">
/**
* A Kalman filter that is implemented using the operations API, which is procedural. Much of the excessive
* memory creation/destruction has been reduced from the KalmanFilterSimple. A specialized solver is
* under to invert the SPD matrix.
*
* @author Peter Abeles
*/
public class KalmanFilterOperations implements KalmanFilter {
// kinematics description
private DMatrixRMaj F, Q, H;

// system state estimate
private DMatrixRMaj x, P;

// these are predeclared for efficiency reasons
private DMatrixRMaj a, b;
private DMatrixRMaj y, S, S_inv, c, d;
private DMatrixRMaj K;

private LinearSolverDense<DMatrixRMaj> solver;

@Override public void configure( DMatrixRMaj F, DMatrixRMaj Q, DMatrixRMaj H ) {
this.F = F;
this.Q = Q;
this.H = H;

int dimenX = F.numCols;
int dimenZ = H.numRows;

a = new DMatrixRMaj(dimenX, 1);
b = new DMatrixRMaj(dimenX, dimenX);
y = new DMatrixRMaj(dimenZ, 1);
S = new DMatrixRMaj(dimenZ, dimenZ);
S_inv = new DMatrixRMaj(dimenZ, dimenZ);
c = new DMatrixRMaj(dimenZ, dimenX);
d = new DMatrixRMaj(dimenX, dimenZ);
K = new DMatrixRMaj(dimenX, dimenZ);

x = new DMatrixRMaj(dimenX, 1);
P = new DMatrixRMaj(dimenX, dimenX);

// covariance matrices are symmetric positive semi-definite
solver = LinearSolverFactory_DDRM.symmPosDef(dimenX);
}

@Override public void setState( DMatrixRMaj x, DMatrixRMaj P ) {
this.x.setTo(x);
this.P.setTo(P);
}

@Override public void predict() {
// x = F x
mult(F, x, a);
x.setTo(a);

// P = F P F' + Q
mult(F, P, b);
multTransB(b, F, P);
addEquals(P, Q);
}

@Override public void update( DMatrixRMaj z, DMatrixRMaj R ) {
// y = z - H x
mult(H, x, y);
subtract(z, y, y);

// S = H P H' + R
mult(H, P, c);
multTransB(c, H, S);
addEquals(S, R);

// K = PH'S^(-1)
if (!solver.setA(S)) throw new RuntimeException("Invert failed");
solver.invert(S_inv);
multTransA(H, S_inv, d);
mult(P, d, K);

// x = x + Ky
mult(K, y, a);
addEquals(x, a);

// P = (I-kH)P = P - (KH)P = P-K(HP)
mult(H, P, c);
mult(K, c, b);
subtractEquals(P, b);
}

@Override public DMatrixRMaj getState() { return x; }

@Override public DMatrixRMaj getCovariance() { return P; }
}
</syntaxhighlight>

== Equations Example ==

<syntaxhighlight lang="java">
/**
* Example of how the equation interface can greatly simplify code
*
* @author Peter Abeles
*/
public class KalmanFilterEquation implements KalmanFilter {
// system state estimate
private DMatrixRMaj x, P;

private Equation eq;

// Storage for precompiled code for predict and update
Sequence predictX, predictP;
Sequence updateY, updateK, updateX, updateP;

@Override public void configure( DMatrixRMaj F, DMatrixRMaj Q, DMatrixRMaj H ) {
int dimenX = F.numCols;

x = new DMatrixRMaj(dimenX, 1);
P = new DMatrixRMaj(dimenX, dimenX);

eq = new Equation();

// Provide aliases between the symbolic variables and matrices we normally interact with
// The names do not have to be the same.
eq.alias(x, "x", P, "P", Q, "Q", F, "F", H, "H");

// Dummy matrix place holder to avoid compiler errors. Will be replaced later on
eq.alias(new DMatrixRMaj(1, 1), "z");
eq.alias(new DMatrixRMaj(1, 1), "R");

// Pre-compile so that it doesn't have to compile it each time it's invoked. More cumbersome
// but for small matrices the overhead is significant
predictX = eq.compile("x = F*x");
predictP = eq.compile("P = F*P*F' + Q");

updateY = eq.compile("y = z - H*x");
updateK = eq.compile("K = P*H'*inv( H*P*H' + R )");
updateX = eq.compile("x = x + K*y");
updateP = eq.compile("P = P-K*(H*P)");
}

@Override public void setState( DMatrixRMaj x, DMatrixRMaj P ) {
this.x.setTo(x);
this.P.setTo(P);
}

@Override public void predict() {
predictX.perform();
predictP.perform();
}

@Override public void update( DMatrixRMaj z, DMatrixRMaj R ) {

// Alias will overwrite the reference to the previous matrices with the same name
eq.alias(z, "z", R, "R");

updateY.perform();
updateK.perform();
updateX.perform();
updateP.perform();
}

@Override public DMatrixRMaj getState() { return x; }

@Override public DMatrixRMaj getCovariance() { return P; }
}
</syntaxhighlight>

Main Page

2022-12-05T03:27:02Z

Peter:

__NOTOC__

<center>
{| style="width:640pt;"
| align="center" |
[[File:Ejml_logo.gif]]
|-
|

Efficient Java Matrix Library (EJML) is a [http://en.wikipedia.org/wiki/Linear_algebra linear algebra] library for manipulating real/complex/dense/sparse matrices. Its design goals are; 1) to be as computationally and memory efficient as possible for small and large, dense and sparse, real and complex matrices, and 2) to be accessible to both novices and experts. These goals are accomplished by dynamically selecting the best algorithms to use at runtime, clean API, and multiple interfaces. EJML is free, written in 100% Java and has been released under an Apache v2.0 license.

EJML has three distinct ways to interact with it: 1) ''procedural'', 2) ''SimpleMatrix'', and 3) ''Equations''. ''Procedure'' provides all capabilities of EJML and almost complete control over memory creation, speed, and specific algorithms. ''SimpleMatrix'' provides a simplified subset of the core capabilities in an easy to use flow styled object-oriented API, inspired by [http://math.nist.gov/javanumerics/jama/ Jama]. ''Equations'' is a symbolic interface, similar in spirit to [http://www.mathworks.com/products/matlab/ Matlab] and other [http://en.wikipedia.org/wiki/Computer_algebra_system CAS], that provides a compact way of writing equations.
|}

{|
| colspan="3" align="center" |
{|style="font-size:120%; text-align:left;"
|-
| '''Version:''' ''v0.41.1''
|-
| '''Date:''' ''December 4, 2022''
|-
| [https://github.com/lessthanoptimal/ejml/blob/master/convert_to_ejml31.py v0.31 Upgrade Script]
|-
| [https://github.com/lessthanoptimal/ejml/blob/v0.41.1/change.txt Change Log]
|}
|- valign="top"
| width="220pt" |
{| width="200pt" border="1" align="center" style="font-size:120%; text-align:center; border-collapse:collapse; background-color:#ffffee;"
|-
| [[Download|Download]]
|-
| [[manual|Manual]]
|-
| [http://ejml.org/javadoc/ JavaDoc]
|}
| width="220pt" |
{| width="200pt" border="1" align="center" style="font-size:120%; text-align:center; border-collapse:collapse; background-color:#ffffee;"
|-
| [http://groups.google.com/group/efficient-java-matrix-library-discuss Message Board]
|-
| [https://github.com/lessthanoptimal/ejml/issues Bug Reports]
|-
| [[Frequently Asked Questions|FAQ]]
|-
| [[Kotlin|Kotlin]]
|}
| width="220pt" |
{| width="200pt" border="1" align="center" style="font-size:120%; text-align:center; border-collapse:collapse; background-color:#ffffee;"
|-
| [[Acknowledgments|Acknowledgments]]
|-
| [[Performance|Performance]]
|-
| [[Users|Users]]
|}
|}

== News 2021 ==

{| width="500pt" |
| -
|
* Read and write EJML in Matlab format with [https://github.com/HebiRobotics/MFL MFL] from HEBI Robotics
* Graph BLAS continues to be flushed out with masks being added to latest SNAPSHOT
* Concurrency/threading has been added to some operations
|}

== Code Examples ==

Demonstrations on how to compute the Kalman gain "K" using each interface in EJML.

{| width="500pt" |
|-
|
'''Procedural'''
<syntaxhighlight lang="java">
mult(H,P,c);
multTransB(c,H,S);
addEquals(S,R);
if( !invert(S,S_inv) )
throw new RuntimeException("Invert failed");
multTransA(H,S_inv,d);
mult(P,d,K);
</syntaxhighlight>

'''SimpleMatrix'''
<syntaxhighlight lang="java">
SimpleMatrix S = H.mult(P).mult(H.transpose()).plus(R);
SimpleMatrix K = P.mult(H.transpose().mult(S.invert()));
</syntaxhighlight>

'''Equations'''
<syntaxhighlight lang="java">
eq.process("K = P*H'*inv( H*P*H' + R )");
</syntaxhighlight>
|}

== Functionality ==

{| class="wikitable" width="650pt" border="1" |
! Data Structures || Operations
|-
| style="vertical-align:top;" |
* Fixed Sized
** Matrix 2x2 to 6x6
** Vector 2 to 6
* Dense Real
** Row-major
** Block
* Dense Complex
** Row-major
* Sparse Real
** Compressed Column

| style="vertical-align:top;" |
* Full support for floats and doubles
* Basic Operators (addition, multiplication, ... )
* Matrix Manipulation (extract, insert, combine, ... )
* Linear Solvers (linear, least squares, incremental, ... )
* Decompositions (LU, QR, Cholesky, SVD, Eigenvalue, ...)
* Matrix Features (rank, symmetric, definitiveness, ... )
* Random Matrices (covariance, orthogonal, symmetric, ... )
* Unit Testing
|}.

{| class="wikitable" width="650pt" border="1" |
! style="width: 40%;" | Decomposition || style="width: 15%;" |Dense Real || style="width: 15%;" |Dense Complex || style="width: 15%;" |Sparse Real || style="width: 15%;" |Sparse Complex
|-
| LU || style="text-align:center;" | X || style="text-align:center;" | X || style="text-align:center;" | X ||
|-
| Cholesky LL || style="text-align:center;" | X || style="text-align:center;" | X || style="text-align:center;" | X ||
|-
| Cholesky LDL || style="text-align:center;" | X || style="text-align:center;" | || ||
|-
| QR || style="text-align:center;" | X || style="text-align:center;" | X || style="text-align:center;" | X ||
|-
| QRP || style="text-align:center;" | X || style="text-align:center;" | || ||
|-
| SVD || style="text-align:center;" | X || style="text-align:center;" | || ||
|-
| Eigen-Symmetric || style="text-align:center;" | X || style="text-align:center;" | || ||
|-
| Eigen-General || style="text-align:center;" | X || style="text-align:center;" | || ||
|}
Support for floats (32-bit) and doubles (64-bit) is available. Sparse matrix support is only available for basic operations at this time.
</center>

Download

2021-07-07T16:23:08Z

Peter:

== Source Code ==

Source code is hosted on Github. There you can access the absolute bleeding edge code. Most of the time it is in an usable state, but not always!

[https://github.com/lessthanoptimal/ejml https://github.com/lessthanoptimal/ejml]

The command to clone it is:

<syntaxhighlight lang="groovy">
git clone https://github.com/lessthanoptimal/ejml.git
</syntaxhighlight>

Current status of developmental code:

[https://travis-ci.org/lessthanoptimal/ejml https://api.travis-ci.org/lessthanoptimal/ejml.png]

== Download ==

Jars of the latest stable release can be found on Source Forge using the following link: [https://sourceforge.net/projects/ejml/files/v0.41/ EJML Downloads]

== Gradle and Maven ==

EJML is broken up into several packages (see list below) and including each individually can be tedious. To include all the packages simply reference "all", as is shown below:

Gradle:
<syntaxhighlight lang="groovy">
compile group: 'org.ejml', name: 'ejml-all', version: '0.41'
</syntaxhighlight>

Maven:
<syntaxhighlight lang="xml">
<dependency>
<groupId>org.ejml</groupId>
<artifactId>ejml-all</artifactId>
<version>0.41</version>
</dependency>
</syntaxhighlight>

Individual modules:

{| class="wikitable"
! Module Name !! Description
|-
| ejml-all || All the modules
|-
| ejml-ddense || Dense Real Double Matrices
|-
| ejml-fdense || Dense Real Float Matrices
|-
| ejml-zdense || Dense Complex Double Matrices
|-
| ejml-cdense || Dense Complex Float Matrices
|-
| ejml-simple || SimpleMatrix and Equations
|-
| ejml-dsparse || Sparse Real Double Matrices
|-
| ejml-fsparse || Sparse Real Float Matrices
|}

Download

2021-07-07T15:58:48Z

Peter:

== Source Code ==

Source code is hosted on Github. There you can access the absolute bleeding edge code. Most of the time it is in an usable state, but not always!

[https://github.com/lessthanoptimal/ejml https://github.com/lessthanoptimal/ejml]

The command to clone it is:

<syntaxhighlight lang="groovy">
git clone https://github.com/lessthanoptimal/ejml.git
</syntaxhighlight>

Current status of developmental code:

[https://travis-ci.org/lessthanoptimal/ejml https://api.travis-ci.org/lessthanoptimal/ejml.png]

== Download ==

Jars of the latest stable release can be found on Source Forge using the following link: [https://sourceforge.net/projects/ejml/files/v0.40/ EJML Downloads]

== Gradle and Maven ==

EJML is broken up into several packages (see list below) and including each individually can be tedious. To include all the packages simply reference "all", as is shown below:

Gradle:
<syntaxhighlight lang="groovy">
compile group: 'org.ejml', name: 'ejml-all', version: '0.41'
</syntaxhighlight>

Maven:
<syntaxhighlight lang="xml">
<dependency>
<groupId>org.ejml</groupId>
<artifactId>ejml-all</artifactId>
<version>0.41</version>
</dependency>
</syntaxhighlight>

Individual modules:

{| class="wikitable"
! Module Name !! Description
|-
| ejml-all || All the modules
|-
| ejml-ddense || Dense Real Double Matrices
|-
| ejml-fdense || Dense Real Float Matrices
|-
| ejml-zdense || Dense Complex Double Matrices
|-
| ejml-cdense || Dense Complex Float Matrices
|-
| ejml-simple || SimpleMatrix and Equations
|-
| ejml-dsparse || Sparse Real Double Matrices
|-
| ejml-fsparse || Sparse Real Float Matrices
|}

Main Page

2021-07-07T15:58:20Z

Peter:

__NOTOC__

<center>
{| style="width:640pt;"
| align="center" |
[[File:Ejml_logo.gif]]
|-
|

Efficient Java Matrix Library (EJML) is a [http://en.wikipedia.org/wiki/Linear_algebra linear algebra] library for manipulating real/complex/dense/sparse matrices. Its design goals are; 1) to be as computationally and memory efficient as possible for small and large, dense and sparse, real and complex matrices, and 2) to be accessible to both novices and experts. These goals are accomplished by dynamically selecting the best algorithms to use at runtime, clean API, and multiple interfaces. EJML is free, written in 100% Java and has been released under an Apache v2.0 license.

EJML has three distinct ways to interact with it: 1) ''procedural'', 2) ''SimpleMatrix'', and 3) ''Equations''. ''Procedure'' provides all capabilities of EJML and almost complete control over memory creation, speed, and specific algorithms. ''SimpleMatrix'' provides a simplified subset of the core capabilities in an easy to use flow styled object-oriented API, inspired by [http://math.nist.gov/javanumerics/jama/ Jama]. ''Equations'' is a symbolic interface, similar in spirit to [http://www.mathworks.com/products/matlab/ Matlab] and other [http://en.wikipedia.org/wiki/Computer_algebra_system CAS], that provides a compact way of writing equations.
|}

{|
| colspan="3" align="center" |
{|style="font-size:120%; text-align:left;"
|-
| '''Version:''' ''v0.41''
|-
| '''Date:''' ''July 7, 2021''
|-
| [https://github.com/lessthanoptimal/ejml/blob/master/convert_to_ejml31.py v0.31 Upgrade Script]
|-
| [https://github.com/lessthanoptimal/ejml/blob/v0.41/change.txt Change Log]
|}
|- valign="top"
| width="220pt" |
{| width="200pt" border="1" align="center" style="font-size:120%; text-align:center; border-collapse:collapse; background-color:#ffffee;"
|-
| [[Download|Download]]
|-
| [[manual|Manual]]
|-
| [http://ejml.org/javadoc/ JavaDoc]
|}
| width="220pt" |
{| width="200pt" border="1" align="center" style="font-size:120%; text-align:center; border-collapse:collapse; background-color:#ffffee;"
|-
| [http://groups.google.com/group/efficient-java-matrix-library-discuss Message Board]
|-
| [https://github.com/lessthanoptimal/ejml/issues Bug Reports]
|-
| [[Frequently Asked Questions|FAQ]]
|-
| [[Kotlin|Kotlin]]
|}
| width="220pt" |
{| width="200pt" border="1" align="center" style="font-size:120%; text-align:center; border-collapse:collapse; background-color:#ffffee;"
|-
| [[Acknowledgments|Acknowledgments]]
|-
| [[Performance|Performance]]
|-
| [[Users|Users]]
|}
|}

== News 2021 ==

{| width="500pt" |
| -
|
* Read and write EJML in Matlab format with [https://github.com/HebiRobotics/MFL MFL] from HEBI Robotics
* Graph BLAS continues to be flushed out with masks being added to latest SNAPSHOT
* Concurrency/threading has been added to some operations
|}

== Code Examples ==

Demonstrations on how to compute the Kalman gain "K" using each interface in EJML.

{| width="500pt" |
|-
|
'''Procedural'''
<syntaxhighlight lang="java">
mult(H,P,c);
multTransB(c,H,S);
addEquals(S,R);
if( !invert(S,S_inv) )
throw new RuntimeException("Invert failed");
multTransA(H,S_inv,d);
mult(P,d,K);
</syntaxhighlight>

'''SimpleMatrix'''
<syntaxhighlight lang="java">
SimpleMatrix S = H.mult(P).mult(H.transpose()).plus(R);
SimpleMatrix K = P.mult(H.transpose().mult(S.invert()));
</syntaxhighlight>

'''Equations'''
<syntaxhighlight lang="java">
eq.process("K = P*H'*inv( H*P*H' + R )");
</syntaxhighlight>
|}

== Functionality ==

{| class="wikitable" width="650pt" border="1" |
! Data Structures || Operations
|-
| style="vertical-align:top;" |
* Fixed Sized
** Matrix 2x2 to 6x6
** Vector 2 to 6
* Dense Real
** Row-major
** Block
* Dense Complex
** Row-major
* Sparse Real
** Compressed Column

| style="vertical-align:top;" |
* Full support for floats and doubles
* Basic Operators (addition, multiplication, ... )
* Matrix Manipulation (extract, insert, combine, ... )
* Linear Solvers (linear, least squares, incremental, ... )
* Decompositions (LU, QR, Cholesky, SVD, Eigenvalue, ...)
* Matrix Features (rank, symmetric, definitiveness, ... )
* Random Matrices (covariance, orthogonal, symmetric, ... )
* Unit Testing
|}.

{| class="wikitable" width="650pt" border="1" |
! style="width: 40%;" | Decomposition || style="width: 15%;" |Dense Real || style="width: 15%;" |Dense Complex || style="width: 15%;" |Sparse Real || style="width: 15%;" |Sparse Complex
|-
| LU || style="text-align:center;" | X || style="text-align:center;" | X || style="text-align:center;" | X ||
|-
| Cholesky LL || style="text-align:center;" | X || style="text-align:center;" | X || style="text-align:center;" | X ||
|-
| Cholesky LDL || style="text-align:center;" | X || style="text-align:center;" | || ||
|-
| QR || style="text-align:center;" | X || style="text-align:center;" | X || style="text-align:center;" | X ||
|-
| QRP || style="text-align:center;" | X || style="text-align:center;" | || ||
|-
| SVD || style="text-align:center;" | X || style="text-align:center;" | || ||
|-
| Eigen-Symmetric || style="text-align:center;" | X || style="text-align:center;" | || ||
|-
| Eigen-General || style="text-align:center;" | X || style="text-align:center;" | || ||
|}
Support for floats (32-bit) and doubles (64-bit) is available. Sparse matrix support is only available for basic operations at this time.
</center>

Example Fixed Sized Matrices

2021-07-07T15:37:29Z

Peter:

Array access adds a significant amount of overhead to matrix operations. A fixed sized matrix gets around that issue by having each element in the matrix be a variable in the class. EJML provides support for fixed sized matrices and vectors up to 6x6, at which point it loses its advantage. The example below demonstrates how to use a fixed sized matrix and convert to other matrix types in EJML.

External Resources:
* [https://github.com/lessthanoptimal/ejml/blob/v0.41/examples/src/org/ejml/example/ExampleFixedSizedMatrix.java ExampleFixedSizedMatrix]
* <disqus>Discuss this example</disqus>

== Example ==

<syntaxhighlight lang="java">
/**
* In some applications a small fixed sized matrix can speed things up a lot, e.g. 8 times faster. One application
* which uses small matrices is graphics and rigid body motion, which extensively uses 3x3 and 4x4 matrices. This
* example is to show some examples of how you can use a fixed sized matrix.
*
* @author Peter Abeles
*/
public class ExampleFixedSizedMatrix {
public static void main( String[] args ) {
// declare the matrix
DMatrix3x3 a = new DMatrix3x3();
DMatrix3x3 b = new DMatrix3x3();

// Can assign values the usual way
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
a.set(i, j, i + j + 1);
}
}

// Direct manipulation of each value is the fastest way to assign/read values
a.a11 = 12;
a.a23 = 64;

// can print the usual way too
a.print();

// most of the standard operations are support
CommonOps_DDF3.transpose(a, b);
b.print();

System.out.println("Determinant = " + CommonOps_DDF3.det(a));

// matrix-vector operations are also supported
// Constructors for vectors and matrices can be used to initialize its value
DMatrix3 v = new DMatrix3(1, 2, 3);
DMatrix3 result = new DMatrix3();

CommonOps_DDF3.mult(a, v, result);

// Conversion into DMatrixRMaj can also be done
DMatrixRMaj dm = DConvertMatrixStruct.convert(a, null);

dm.print();

// This can be useful if you need do more advanced operations
SimpleMatrix sv = SimpleMatrix.wrap(dm).svd().getV();

// can then convert it back into a fixed matrix
DMatrix3x3 fv = DConvertMatrixStruct.convert(sv.getDDRM(), (DMatrix3x3)null);

System.out.println("Original simple matrix and converted fixed matrix");
sv.print();
fv.print();
}
}
</syntaxhighlight>

Example Principal Component Analysis

2021-07-07T15:32:45Z

Peter:

Principal Component Analysis (PCA) is a popular and simple to implement classification technique, often used in face recognition. The following is an example of how to implement it in EJML using the procedural interface. It is assumed that the reader is already familiar with PCA.

External Resources
* [https://github.com/lessthanoptimal/ejml/blob/v0.41/examples/src/org/ejml/example/PrincipalComponentAnalysis.java PrincipalComponentAnalysis.java source code]
* [http://en.wikipedia.org/wiki/Principal_component_analysis General PCA information on Wikipedia]

= Sample Code =

<syntaxhighlight lang="java">
/**
* 
* The following is a simple example of how to perform basic principal component analysis in EJML.
* 
*
* 
* Principal Component Analysis (PCA) is typically used to develop a linear model for a set of data
* (e.g. face images) which can then be used to test for membership. PCA works by converting the
* set of data to a new basis that is a subspace of the original set. The subspace is selected
* to maximize information.
* 
* 
* PCA is typically derived as an eigenvalue problem. However in this implementation {@link org.ejml.interfaces.decomposition.SingularValueDecomposition SVD}
* is used instead because it will produce a more numerically stable solution. Computation using EVD requires explicitly
* computing the variance of each sample set. The variance is computed by squaring the residual, which can
* cause loss of precision.
* 
*
* 
* Usage: 
* 1) call setup() 
* 2) For each sample (e.g. an image ) call addSample() 
* 3) After all the samples have been added call computeBasis() 
* 4) Call sampleToEigenSpace() , eigenToSampleSpace() , errorMembership() , response()
* 
*
* @author Peter Abeles
*/
public class PrincipalComponentAnalysis {

// principal component subspace is stored in the rows
private DMatrixRMaj V_t;

// how many principal components are used
private int numComponents;

// where the data is stored
private DMatrixRMaj A = new DMatrixRMaj(1, 1);
private int sampleIndex;

// mean values of each element across all the samples
double[] mean;

/**
* Must be called before any other functions. Declares and sets up internal data structures.
*
* @param numSamples Number of samples that will be processed.
* @param sampleSize Number of elements in each sample.
*/
public void setup( int numSamples, int sampleSize ) {
mean = new double[sampleSize];
A.reshape(numSamples, sampleSize, false);
sampleIndex = 0;
numComponents = -1;
}

/**
* Adds a new sample of the raw data to internal data structure for later processing. All the samples
* must be added before computeBasis is called.
*
* @param sampleData Sample from original raw data.
*/
public void addSample( double[] sampleData ) {
if (A.getNumCols() != sampleData.length)
throw new IllegalArgumentException("Unexpected sample size");
if (sampleIndex >= A.getNumRows())
throw new IllegalArgumentException("Too many samples");

for (int i = 0; i < sampleData.length; i++) {
A.set(sampleIndex, i, sampleData[i]);
}
sampleIndex++;
}

/**
* Computes a basis (the principal components) from the most dominant eigenvectors.
*
* @param numComponents Number of vectors it will use to describe the data. Typically much
* smaller than the number of elements in the input vector.
*/
public void computeBasis( int numComponents ) {
if (numComponents > A.getNumCols())
throw new IllegalArgumentException("More components requested that the data's length.");
if (sampleIndex != A.getNumRows())
throw new IllegalArgumentException("Not all the data has been added");
if (numComponents > sampleIndex)
throw new IllegalArgumentException("More data needed to compute the desired number of components");

this.numComponents = numComponents;

// compute the mean of all the samples
for (int i = 0; i < A.getNumRows(); i++) {
for (int j = 0; j < mean.length; j++) {
mean[j] += A.get(i, j);
}
}
for (int j = 0; j < mean.length; j++) {
mean[j] /= A.getNumRows();
}

// subtract the mean from the original data
for (int i = 0; i < A.getNumRows(); i++) {
for (int j = 0; j < mean.length; j++) {
A.set(i, j, A.get(i, j) - mean[j]);
}
}

// Compute SVD and save time by not computing U
SingularValueDecomposition<DMatrixRMaj> svd =
DecompositionFactory_DDRM.svd(A.numRows, A.numCols, false, true, false);
if (!svd.decompose(A))
throw new RuntimeException("SVD failed");

V_t = svd.getV(null, true);
DMatrixRMaj W = svd.getW(null);

// Singular values are in an arbitrary order initially
SingularOps_DDRM.descendingOrder(null, false, W, V_t, true);

// strip off unneeded components and find the basis
V_t.reshape(numComponents, mean.length, true);
}

/**
* Returns a vector from the PCA's basis.
*
* @param which Which component's vector is to be returned.
* @return Vector from the PCA basis.
*/
public double[] getBasisVector( int which ) {
if (which < 0 || which >= numComponents)
throw new IllegalArgumentException("Invalid component");

DMatrixRMaj v = new DMatrixRMaj(1, A.numCols);
CommonOps_DDRM.extract(V_t, which, which + 1, 0, A.numCols, v, 0, 0);

return v.data;
}

/**
* Converts a vector from sample space into eigen space.
*
* @param sampleData Sample space data.
* @return Eigen space projection.
*/
public double[] sampleToEigenSpace( double[] sampleData ) {
if (sampleData.length != A.getNumCols())
throw new IllegalArgumentException("Unexpected sample length");
DMatrixRMaj mean = DMatrixRMaj.wrap(A.getNumCols(), 1, this.mean);

DMatrixRMaj s = new DMatrixRMaj(A.getNumCols(), 1, true, sampleData);
DMatrixRMaj r = new DMatrixRMaj(numComponents, 1);

CommonOps_DDRM.subtract(s, mean, s);

CommonOps_DDRM.mult(V_t, s, r);

return r.data;
}

/**
* Converts a vector from eigen space into sample space.
*
* @param eigenData Eigen space data.
* @return Sample space projection.
*/
public double[] eigenToSampleSpace( double[] eigenData ) {
if (eigenData.length != numComponents)
throw new IllegalArgumentException("Unexpected sample length");

DMatrixRMaj s = new DMatrixRMaj(A.getNumCols(), 1);
DMatrixRMaj r = DMatrixRMaj.wrap(numComponents, 1, eigenData);

CommonOps_DDRM.multTransA(V_t, r, s);

DMatrixRMaj mean = DMatrixRMaj.wrap(A.getNumCols(), 1, this.mean);
CommonOps_DDRM.add(s, mean, s);

return s.data;
}

/**
* 
* The membership error for a sample. If the error is less than a threshold then
* it can be considered a member. The threshold's value depends on the data set.
* 
* 
* The error is computed by projecting the sample into eigenspace then projecting
* it back into sample space and
* 
*
* @param sampleA The sample whose membership status is being considered.
* @return Its membership error.
*/
public double errorMembership( double[] sampleA ) {
double[] eig = sampleToEigenSpace(sampleA);
double[] reproj = eigenToSampleSpace(eig);

double total = 0;
for (int i = 0; i < reproj.length; i++) {
double d = sampleA[i] - reproj[i];
total += d*d;
}

return Math.sqrt(total);
}

/**
* Computes the dot product of each basis vector against the sample. Can be used as a measure
* for membership in the training sample set. High values correspond to a better fit.
*
* @param sample Sample of original data.
* @return Higher value indicates it is more likely to be a member of input dataset.
*/
public double response( double[] sample ) {
if (sample.length != A.numCols)
throw new IllegalArgumentException("Expected input vector to be in sample space");

DMatrixRMaj dots = new DMatrixRMaj(numComponents, 1);
DMatrixRMaj s = DMatrixRMaj.wrap(A.numCols, 1, sample);

CommonOps_DDRM.mult(V_t, s, dots);

return NormOps_DDRM.normF(dots);
}
}
</syntaxhighlight>

Example Polynomial Roots

2021-07-07T15:31:20Z

Peter:

Eigenvalue decomposition can be used to find the roots in a polynomial by constructing the so called [http://en.wikipedia.org/wiki/Companion_matrix companion matrix]. While faster techniques do exist for root finding, this is one of the most stable and probably the easiest to implement.

Because the companion matrix is not symmetric a generalized eigenvalue [MatrixDecomposition decomposition] is needed. The roots of the polynomial may also be [http://en.wikipedia.org/wiki/Complex_number complex].

External Resources:
* [https://github.com/lessthanoptimal/ejml/blob/v0.31/examples/src/org/ejml/example/PolynomialRootFinder.java PolynomialRootFinder.java source code]

= Example Code =

<syntaxhighlight lang="java">
public class PolynomialRootFinder {
/**
* 
* Given a set of polynomial coefficients, compute the roots of the polynomial. Depending on
* the polynomial being considered the roots may contain complex number. When complex numbers are
* present they will come in pairs of complex conjugates.
* 
*
* 
* Coefficients are ordered from least to most significant, e.g: y = c[0] + x*c[1] + x*x*c[2].
* 
*
* @param coefficients Coefficients of the polynomial.
* @return The roots of the polynomial
*/
public static Complex_F64[] findRoots( double... coefficients ) {
int N = coefficients.length - 1;

// Construct the companion matrix
DMatrixRMaj c = new DMatrixRMaj(N, N);

double a = coefficients[N];
for (int i = 0; i < N; i++) {
c.set(i, N - 1, -coefficients[i]/a);
}
for (int i = 1; i < N; i++) {
c.set(i, i - 1, 1);
}

// use generalized eigenvalue decomposition to find the roots
EigenDecomposition_F64<DMatrixRMaj> evd = DecompositionFactory_DDRM.eig(N, false);

evd.decompose(c);

Complex_F64[] roots = new Complex_F64[N];

for (int i = 0; i < N; i++) {
roots[i] = evd.getEigenvalue(i);
}

return roots;
}
}
</syntaxhighlight>

Example Polynomial Fitting

2021-07-07T15:30:10Z

Peter:

In this example it is shown how EJML can be used to fit a polynomial of arbitrary degree to a set of data. The key concepts shown here are; 1) how to create a linear using LinearSolverFactory, 2) use an adjustable linear solver, 3) and effective matrix reshaping. This is all done using the procedural interface.

First a best fit polynomial is fit to a set of data and then a outliers are removed from the observation set and the coefficients recomputed. Outliers are removed efficiently using an adjustable solver that does not resolve the whole system again.

External Resources:
* [https://github.com/lessthanoptimal/ejml/blob/v0.41/examples/src/org/ejml/example/PolynomialFit.java PolynomialFit.java source code]

= PolynomialFit Example Code =

<syntaxhighlight lang="java">
/**
* 
* This example demonstrates how a polynomial can be fit to a set of data. This is done by
* using a least squares solver that is adjustable. By using an adjustable solver elements
* can be inexpensively removed and the coefficients recomputed. This is much less expensive
* than resolving the whole system from scratch.
* 
* 
* The following is demonstrated: 
* <ol>
* <li>Creating a solver using LinearSolverFactory</li>
* <li>Using an adjustable solver</li>
* <li>reshaping</li>
* </ol>
*
* @author Peter Abeles
*/
public class PolynomialFit {
// Vandermonde matrix
DMatrixRMaj A;
// matrix containing computed polynomial coefficients
DMatrixRMaj coef;
// observation matrix
DMatrixRMaj y;

// solver used to compute
AdjustableLinearSolver_DDRM solver;

/**
* Constructor.
*
* @param degree The polynomial's degree which is to be fit to the observations.
*/
public PolynomialFit( int degree ) {
coef = new DMatrixRMaj(degree + 1, 1);
A = new DMatrixRMaj(1, degree + 1);
y = new DMatrixRMaj(1, 1);

// create a solver that allows elements to be added or removed efficiently
solver = LinearSolverFactory_DDRM.adjustable();
}

/**
* Returns the computed coefficients
*
* @return polynomial coefficients that best fit the data.
*/
public double[] getCoef() {
return coef.data;
}

/**
* Computes the best fit set of polynomial coefficients to the provided observations.
*
* @param samplePoints where the observations were sampled.
* @param observations A set of observations.
*/
public void fit( double[] samplePoints, double[] observations ) {
// Create a copy of the observations and put it into a matrix
y.reshape(observations.length, 1, false);
System.arraycopy(observations, 0, y.data, 0, observations.length);

// reshape the matrix to avoid unnecessarily declaring new memory
// save values is set to false since its old values don't matter
A.reshape(y.numRows, coef.numRows, false);

// set up the A matrix
for (int i = 0; i < observations.length; i++) {

double obs = 1;

for (int j = 0; j < coef.numRows; j++) {
A.set(i, j, obs);
obs *= samplePoints[i];
}
}

// process the A matrix and see if it failed
if (!solver.setA(A))
throw new RuntimeException("Solver failed");

// solver the the coefficients
solver.solve(y, coef);
}

/**
* Removes the observation that fits the model the worst and recomputes the coefficients.
* This is done efficiently by using an adjustable solver. Often times the elements with
* the largest errors are outliers and not part of the system being modeled. By removing them
* a more accurate set of coefficients can be computed.
*/
public void removeWorstFit() {
// find the observation with the most error
int worstIndex = -1;
double worstError = -1;

for (int i = 0; i < y.numRows; i++) {
double predictedObs = 0;

for (int j = 0; j < coef.numRows; j++) {
predictedObs += A.get(i, j)*coef.get(j, 0);
}

double error = Math.abs(predictedObs - y.get(i, 0));

if (error > worstError) {
worstError = error;
worstIndex = i;
}
}

// nothing left to remove, so just return
if (worstIndex == -1)
return;

// remove that observation
removeObservation(worstIndex);

// update A
solver.removeRowFromA(worstIndex);

// solve for the parameters again
solver.solve(y, coef);
}

/**
* Removes an element from the observation matrix.
*
* @param index which element is to be removed
*/
private void removeObservation( int index ) {
final int N = y.numRows - 1;
final double[] d = y.data;

// shift
for (int i = index; i < N; i++) {
d[i] = d[i + 1];
}
y.numRows--;
}
}
</syntaxhighlight>

Example Polynomial Fitting

2021-07-07T15:29:51Z

Peter:

In this example it is shown how EJML can be used to fit a polynomial of arbitrary degree to a set of data. The key concepts shown here are; 1) how to create a linear using LinearSolverFactory, 2) use an adjustable linear solver, 3) and effective matrix reshaping. This is all done using the procedural interface.

First a best fit polynomial is fit to a set of data and then a outliers are removed from the observation set and the coefficients recomputed. Outliers are removed efficiently using an adjustable solver that does not resolve the whole system again.

External Resources:
* [https://github.com/lessthanoptimal/ejml/blob/v0.41/examples/src/org/ejml/example/PolynomialFit.java PolynomialFit.java source code]
* <disqus>Discuss this example</disqus>

= PolynomialFit Example Code =

<syntaxhighlight lang="java">
/**
* 
* This example demonstrates how a polynomial can be fit to a set of data. This is done by
* using a least squares solver that is adjustable. By using an adjustable solver elements
* can be inexpensively removed and the coefficients recomputed. This is much less expensive
* than resolving the whole system from scratch.
* 
* 
* The following is demonstrated: 
* <ol>
* <li>Creating a solver using LinearSolverFactory</li>
* <li>Using an adjustable solver</li>
* <li>reshaping</li>
* </ol>
*
* @author Peter Abeles
*/
public class PolynomialFit {
// Vandermonde matrix
DMatrixRMaj A;
// matrix containing computed polynomial coefficients
DMatrixRMaj coef;
// observation matrix
DMatrixRMaj y;

// solver used to compute
AdjustableLinearSolver_DDRM solver;

/**
* Constructor.
*
* @param degree The polynomial's degree which is to be fit to the observations.
*/
public PolynomialFit( int degree ) {
coef = new DMatrixRMaj(degree + 1, 1);
A = new DMatrixRMaj(1, degree + 1);
y = new DMatrixRMaj(1, 1);

// create a solver that allows elements to be added or removed efficiently
solver = LinearSolverFactory_DDRM.adjustable();
}

/**
* Returns the computed coefficients
*
* @return polynomial coefficients that best fit the data.
*/
public double[] getCoef() {
return coef.data;
}

/**
* Computes the best fit set of polynomial coefficients to the provided observations.
*
* @param samplePoints where the observations were sampled.
* @param observations A set of observations.
*/
public void fit( double[] samplePoints, double[] observations ) {
// Create a copy of the observations and put it into a matrix
y.reshape(observations.length, 1, false);
System.arraycopy(observations, 0, y.data, 0, observations.length);

// reshape the matrix to avoid unnecessarily declaring new memory
// save values is set to false since its old values don't matter
A.reshape(y.numRows, coef.numRows, false);

// set up the A matrix
for (int i = 0; i < observations.length; i++) {

double obs = 1;

for (int j = 0; j < coef.numRows; j++) {
A.set(i, j, obs);
obs *= samplePoints[i];
}
}

// process the A matrix and see if it failed
if (!solver.setA(A))
throw new RuntimeException("Solver failed");

// solver the the coefficients
solver.solve(y, coef);
}

/**
* Removes the observation that fits the model the worst and recomputes the coefficients.
* This is done efficiently by using an adjustable solver. Often times the elements with
* the largest errors are outliers and not part of the system being modeled. By removing them
* a more accurate set of coefficients can be computed.
*/
public void removeWorstFit() {
// find the observation with the most error
int worstIndex = -1;
double worstError = -1;

for (int i = 0; i < y.numRows; i++) {
double predictedObs = 0;

for (int j = 0; j < coef.numRows; j++) {
predictedObs += A.get(i, j)*coef.get(j, 0);
}

double error = Math.abs(predictedObs - y.get(i, 0));

if (error > worstError) {
worstError = error;
worstIndex = i;
}
}

// nothing left to remove, so just return
if (worstIndex == -1)
return;

// remove that observation
removeObservation(worstIndex);

// update A
solver.removeRowFromA(worstIndex);

// solve for the parameters again
solver.solve(y, coef);
}

/**
* Removes an element from the observation matrix.
*
* @param index which element is to be removed
*/
private void removeObservation( int index ) {
final int N = y.numRows - 1;
final double[] d = y.data;

// shift
for (int i = index; i < N; i++) {
d[i] = d[i + 1];
}
y.numRows--;
}
}
</syntaxhighlight>

Example Large Dense Matrices

2021-07-07T15:27:29Z

Peter:

Different approaches are required when writing high performance dense matrix operations for large matrices. For the most part, EJML will automatically switch to using these different approaches. A key parameter that needs to be tuned for specific systems is block size. It can also make sense to work directly with block matrices instead of assuming EJML does the best for your system.

External Resources:
* [https://github.com/lessthanoptimal/ejml/blob/v0.41/examples/src/org/ejml/example/OptimizingLargeMatrixPerformance.java OptimizingLargeMatrixPerformance.java]

== Example Code ==

<syntaxhighlight lang="java">
/**
* For many operations EJML provides block matrix support. These block or tiled matrices are designed to reduce
* the number of cache misses which can kill performance when working on large matrices. A critical tuning parameter
* is the block size and this is system specific. The example below shows you how this parameter can be optimized.
*
* @author Peter Abeles
*/
public class OptimizingLargeMatrixPerformance {
public static void main( String[] args ) {
// Create larger matrices to experiment with
var rand = new Random(0xBEEF);
DMatrixRMaj A = RandomMatrices_DDRM.rectangle(3000, 3000, -1, 1, rand);
DMatrixRMaj B = A.copy();
DMatrixRMaj C = A.createLike();

// Since we are dealing with larger matrices let's use the concurrent implementation. By default
UtilEjml.printTime("Row-Major Multiplication:", () -> CommonOps_MT_DDRM.mult(A, B, C));

// Converts A into a block matrix and creates a new matrix while leaving A unmodified
DMatrixRBlock Ab = MatrixOps_DDRB.convert(A);
// Converts A into a block matrix, but modifies it's internal array inplace. The returned block matrix
// will share the same data array as the input. Much more memory efficient, but you need to be careful.
DMatrixRBlock Bb = MatrixOps_DDRB.convertInplace(B, null, null);
DMatrixRBlock Cb = Ab.createLike();

// Since we are dealing with larger matrices let's use the concurrent implementation. By default
UtilEjml.printTime("Block Multiplication: ", () -> MatrixOps_MT_DDRB.mult(Ab, Bb, Cb));

// Can we make this faster? Probably by adjusting the block size. This is system dependent so let's
// try a range of values
int defaultBlockWidth = EjmlParameters.BLOCK_WIDTH;
System.out.println("Default Block Size: " + defaultBlockWidth);
for (int block : new int[]{10, 20, 30, 50, 70, 100, 140, 200, 500}) {
EjmlParameters.BLOCK_WIDTH = block;

// Need to create the block matrices again since we changed the block size
DMatrixRBlock Ac = MatrixOps_DDRB.convert(A);
DMatrixRBlock Bc = MatrixOps_DDRB.convert(B);
DMatrixRBlock Cc = Ac.createLike();
UtilEjml.printTime("Block " + EjmlParameters.BLOCK_WIDTH + ": ", () -> MatrixOps_MT_DDRB.mult(Ac, Bc, Cc));
}

// On my system the optimal block size is around 100 and has an improvement of about 5%
// On some architectures the improvement can be substantial in others the default value is very reasonable

// Some decompositions will switch to a block format automatically. Matrix multiplication might in the
// future and others too. The main reason this hasn't happened for it to be memory efficient it would
// need to modify then undo the modification for input matrices which would be very confusion if you're
// writing concurrent code.
}
}
</syntaxhighlight>

Example Levenberg-Marquardt

2021-07-07T15:26:21Z

Peter:

Levenberg-Marquardt (LM) is a popular non-linear optimization algorithm. This example demonstrate how a basic implementation of Levenberg-Marquardt can be created using EJML's [[Procedural|procedural]] interface. Unnecessary allocation of new memory is avoided by reshaping matrices. When a matrix is reshaped its width and height is changed but new memory is not declared unless the new shape requires more memory than is available.

LM works by being provided a function which computes the residual error. Residual error is defined has the difference between the predicted output and the actual observed output, e.g. f(x)-y. Optimization works
by finding a set of parameters which minimize the magnitude of the residuals based on the F2-norm.

'''Note:''' This is a simple straight forward implementation of Levenberg-Marquardt and is not as robust as Minpack's implementation. If you are looking for a robust non-linear least-squares minimization library in Java check out [http://ddogleg.org DDogleg].

External Resources:
* [https://github.com/lessthanoptimal/ejml/blob/v0.41/examples/src/org/ejml/example/LevenbergMarquardt.java LevenbergMarquardt.java code]
* <disqus>Discuss this example</disqus>

== Example Code ==

<syntaxhighlight lang="java">
/**
* 
* This is a straight forward implementation of the Levenberg-Marquardt (LM) algorithm. LM is used to minimize
* non-linear cost functions: 
* 
* S(P) = Sum{ i=1:m , [yi - f(xi,P)]2} 
* 
* where P is the set of parameters being optimized.
* 
*
* 
* In each iteration the parameters are updated using the following equations: 
* 
* Pi+1 = (H + λ I)-1 d 
* d = (1/N) Sum{ i=1..N , (f(xi;Pi) - yi) * jacobian(:,i) } 
* H = (1/N) Sum{ i=1..N , jacobian(:,i) * jacobian(:,i)T }
* 
* 
* Whenever possible the allocation of new memory is avoided. This is accomplished by reshaping matrices.
* A matrix that is reshaped won't grow unless the new shape requires more memory than it has available.
* 
*
* @author Peter Abeles
*/
public class LevenbergMarquardt {
// Convergence criteria
private int maxIterations = 100;
private double ftol = 1e-12;
private double gtol = 1e-12;

// how much the numerical jacobian calculation perturbs the parameters by.
// In better implementation there are better ways to compute this delta. See Numerical Recipes.
private final static double DELTA = 1e-8;

// Dampening. Larger values means it's more like gradient descent
private double initialLambda;

// the function that is optimized
private ResidualFunction function;

// the optimized parameters and associated costs
private DMatrixRMaj candidateParameters = new DMatrixRMaj(1, 1);
private double initialCost;
private double finalCost;

// used by matrix operations
private DMatrixRMaj g = new DMatrixRMaj(1, 1); // gradient
private DMatrixRMaj H = new DMatrixRMaj(1, 1); // Hessian approximation
private DMatrixRMaj Hdiag = new DMatrixRMaj(1, 1);
private DMatrixRMaj negativeStep = new DMatrixRMaj(1, 1);

// variables used by the numerical jacobian algorithm
private DMatrixRMaj temp0 = new DMatrixRMaj(1, 1);
private DMatrixRMaj temp1 = new DMatrixRMaj(1, 1);
// used when computing d and H variables
private DMatrixRMaj residuals = new DMatrixRMaj(1, 1);

// Where the numerical Jacobian is stored.
private DMatrixRMaj jacobian = new DMatrixRMaj(1, 1);

public double getInitialCost() {
return initialCost;
}

public double getFinalCost() {
return finalCost;
}

/**
* @param initialLambda Initial value of dampening parameter. Try 1 to start
*/
public LevenbergMarquardt( double initialLambda ) {
this.initialLambda = initialLambda;
}

/**
* Specifies convergence criteria
*
* @param maxIterations Maximum number of iterations
* @param ftol convergence based on change in function value. try 1e-12
* @param gtol convergence based on residual magnitude. Try 1e-12
*/
public void setConvergence( int maxIterations, double ftol, double gtol ) {
this.maxIterations = maxIterations;
this.ftol = ftol;
this.gtol = gtol;
}

/**
* Finds the best fit parameters.
*
* @param function The function being optimized
* @param parameters (Input/Output) initial parameter estimate and storage for optimized parameters
* @return true if it succeeded and false if it did not.
*/
public boolean optimize( ResidualFunction function, DMatrixRMaj parameters ) {
configure(function, parameters.getNumElements());

// save the cost of the initial parameters so that it knows if it improves or not
double previousCost = initialCost = cost(parameters);

// iterate until the difference between the costs is insignificant
double lambda = initialLambda;

// if it should recompute the Jacobian in this iteration or not
boolean computeHessian = true;

for (int iter = 0; iter < maxIterations; iter++) {
if (computeHessian) {
// compute some variables based on the gradient
computeGradientAndHessian(parameters);
computeHessian = false;

// check for convergence using gradient test
boolean converged = true;
for (int i = 0; i < g.getNumElements(); i++) {
if (Math.abs(g.data[i]) > gtol) {
converged = false;
break;
}
}
if (converged)
return true;
}

// H = H + lambda*I
for (int i = 0; i < H.numRows; i++) {
H.set(i, i, Hdiag.get(i) + lambda);
}

// In robust implementations failure to solve is handled much better
if (!CommonOps_DDRM.solve(H, g, negativeStep)) {
return false;
}

// compute the candidate parameters
CommonOps_DDRM.subtract(parameters, negativeStep, candidateParameters);

double cost = cost(candidateParameters);
if (cost <= previousCost) {
// the candidate parameters produced better results so use it
computeHessian = true;
parameters.setTo(candidateParameters);

// check for convergence
// ftol <= (cost(k) - cost(k+1))/cost(k)
boolean converged = ftol*previousCost >= previousCost - cost;

previousCost = cost;
lambda /= 10.0;

if (converged) {
return true;
}
} else {
lambda *= 10.0;
}
}
finalCost = previousCost;
return true;
}

/**
* Performs sanity checks on the input data and reshapes internal matrices. By reshaping
* a matrix it will only declare new memory when needed.
*/
protected void configure( ResidualFunction function, int numParam ) {
this.function = function;
int numFunctions = function.numFunctions();

// reshaping a matrix means that new memory is only declared when needed
candidateParameters.reshape(numParam, 1);
g.reshape(numParam, 1);
H.reshape(numParam, numParam);
negativeStep.reshape(numParam, 1);

// Normally these variables are thought of as row vectors, but it works out easier if they are column
temp0.reshape(numFunctions, 1);
temp1.reshape(numFunctions, 1);
residuals.reshape(numFunctions, 1);
jacobian.reshape(numFunctions, numParam);
}

/**
* Computes the d and H parameters.
*
* d = J'*(f(x)-y) <--- that's also the gradient
* H = J'*J
*/
private void computeGradientAndHessian( DMatrixRMaj param ) {
// residuals = f(x) - y
function.compute(param, residuals);

computeNumericalJacobian(param, jacobian);

CommonOps_DDRM.multTransA(jacobian, residuals, g);
CommonOps_DDRM.multTransA(jacobian, jacobian, H);

CommonOps_DDRM.extractDiag(H, Hdiag);
}

/**
* Computes the "cost" for the parameters given.
*
* cost = (1/N) Sum (f(x) - y)^2
*/
private double cost( DMatrixRMaj param ) {
function.compute(param, residuals);

double error = NormOps_DDRM.normF(residuals);

return error*error/(double)residuals.numRows;
}

/**
* Computes a simple numerical Jacobian.
*
* @param param (input) The set of parameters that the Jacobian is to be computed at.
* @param jacobian (output) Where the jacobian will be stored
*/
protected void computeNumericalJacobian( DMatrixRMaj param,
DMatrixRMaj jacobian ) {
double invDelta = 1.0/DELTA;

function.compute(param, temp0);

// compute the jacobian by perturbing the parameters slightly
// then seeing how it effects the results.
for (int i = 0; i < param.getNumElements(); i++) {
param.data[i] += DELTA;
function.compute(param, temp1);
// compute the difference between the two parameters and divide by the delta
// temp1 = (temp1 - temp0)/delta
CommonOps_DDRM.add(invDelta, temp1, -invDelta, temp0, temp1);

// copy the results into the jacobian matrix
// J(i,:) = temp1
CommonOps_DDRM.insert(temp1, jacobian, 0, i);

param.data[i] -= DELTA;
}
}

/**
* The function that is being optimized. Returns the residual. f(x) - y
*/
public interface ResidualFunction {
/**
* Computes the residual vector given the set of input parameters
* Function which goes from N input to M outputs
*
* @param param (Input) N by 1 parameter vector
* @param residual (Output) M by 1 output vector to store the residual = f(x)-y
*/
void compute( DMatrixRMaj param, DMatrixRMaj residual );

/**
* Number of functions in output
*
* @return function count
*/
int numFunctions();
}
}
</syntaxhighlight>

Example Sparse Matrices

2021-07-07T15:25:22Z

Peter:

Support for sparse matrices has recently been added to EJML. It supports many but not all of the standard operations that are supported for dense matrics. The code below shows the basics of working with a sparse matrix. In some situations the speed improvement of using a sparse matrix can be substantial. Do note that if your system isn't sparse enough or if its structure isn't advantageous it could run even slower using sparse operations!

<center>
{| class="wikitable"
! Type !! Execution Time (ms)
|-
| Dense || 12660
|-
| Sparse || 1642
|}
</center>

External Resources:
* [https://github.com/lessthanoptimal/ejml/blob/v0.41/examples/src/org/ejml/example/ExampleSparseMatrix.java ExampleSparseMatrix.java]

== Sparse Matrix Example ==

<syntaxhighlight lang="java">
/**
* Example showing how to construct and solve a linear system using sparse matrices
*
* @author Peter Abeles
*/
public class ExampleSparseMatrix {
public static int ROWS = 100000;
public static int COLS = 1000;
public static int XCOLS = 1;

public static void main( String[] args ) {
Random rand = new Random(234);

// easy to work with sparse format, but hard to do computations with
// NOTE: It is very important to you set 'initLength' to the actual number of elements in the final array
// If you don't it will be forced to thrash memory as it grows its internal data structures.
// Failure to heed this advice will make construction of large matrices 4x slower and use 2x more memory
DMatrixSparseTriplet work = new DMatrixSparseTriplet(5, 4, 5);
work.addItem(0, 1, 1.2);
work.addItem(3, 0, 3);
work.addItem(1, 1, 22.21234);
work.addItem(2, 3, 6);

// convert into a format that's easier to perform math with
DMatrixSparseCSC Z = DConvertMatrixStruct.convert(work, (DMatrixSparseCSC)null);

// print the matrix to standard out in two different formats
Z.print();
System.out.println();
Z.printNonZero();
System.out.println();

// Create a large matrix that is 5% filled
DMatrixSparseCSC A = RandomMatrices_DSCC.rectangle(ROWS, COLS, (int)(ROWS*COLS*0.05), rand);
// large vector that is 70% filled
DMatrixSparseCSC x = RandomMatrices_DSCC.rectangle(COLS, XCOLS, (int)(XCOLS*COLS*0.7), rand);

System.out.println("Done generating random matrices");
// storage for the initial solution
DMatrixSparseCSC y = new DMatrixSparseCSC(ROWS, XCOLS, 0);
DMatrixSparseCSC z = new DMatrixSparseCSC(ROWS, XCOLS, 0);

// To demonstration how to perform sparse math let's multiply:
// y=A*x
// Optional storage is set to null so that it will declare it internally
long before = System.currentTimeMillis();
IGrowArray workA = new IGrowArray(A.numRows);
DGrowArray workB = new DGrowArray(A.numRows);
for (int i = 0; i < 100; i++) {
CommonOps_DSCC.mult(A, x, y, workA, workB);
CommonOps_DSCC.add(1.5, y, 0.75, y, z, workA, workB);
}
long after = System.currentTimeMillis();

System.out.println("norm = " + NormOps_DSCC.fastNormF(y) + " sparse time = " + (after - before) + " ms");

DMatrixRMaj Ad = DConvertMatrixStruct.convert(A, (DMatrixRMaj)null);
DMatrixRMaj xd = DConvertMatrixStruct.convert(x, (DMatrixRMaj)null);
DMatrixRMaj yd = new DMatrixRMaj(y.numRows, y.numCols);
DMatrixRMaj zd = new DMatrixRMaj(y.numRows, y.numCols);

before = System.currentTimeMillis();
for (int i = 0; i < 100; i++) {
CommonOps_DDRM.mult(Ad, xd, yd);
CommonOps_DDRM.add(1.5, yd, 0.75, yd, zd);
}
after = System.currentTimeMillis();
System.out.println("norm = " + NormOps_DDRM.fastNormF(yd) + " dense time = " + (after - before) + " ms");
}
}
</syntaxhighlight>

Example Masked Triangle Count

2021-07-07T15:23:21Z

Peter: Created page with "Many Graph operations can be performed using linear algebra and this connection is the subject of much recent research. EJML now has basic "Graph BLAS" capabilities as this ex..."

Many Graph operations can be performed using linear algebra and this connection is the subject of much recent research. EJML now has basic "Graph BLAS" capabilities as this example shows.

External Resources:
* [https://github.com/lessthanoptimal/ejml/blob/v0.41/examples/src/org/ejml/example/ExampleMaskedTriangleCount.java ExampleMaskedTriangleCount.java]

== Example Code ==

<syntaxhighlight lang="java">
/**
* Example using masked matrix multiplication to count the triangles in a graph.
* Triangle counting is used to detect communities in graphs and often used to analyse social graphs.
*
* More about the connection between graphs and linear algebra can be found at:
* https://github.com/GraphBLAS/GraphBLAS-Pointers.
*
* @author Florentin Doerre
*/
public class ExampleMaskedTriangleCount {
public static void main( String[] args ) {
// For the example we will be using the following graph:
// (0)--(1)--(2)--(0), (2)--(3)--(4)--(2), (5)
var adjacencyMatrix = new DMatrixSparseCSC(6, 6, 24);
adjacencyMatrix.set(0, 1, 1);
adjacencyMatrix.set(0, 2, 1);
adjacencyMatrix.set(1, 2, 1);
adjacencyMatrix.set(2, 3, 1);
adjacencyMatrix.set(2, 4, 1);
adjacencyMatrix.set(3, 4, 1);

// Triangle Count is defined over undirected graphs, therefore we make matrix symmetric (i.e. undirected)
adjacencyMatrix.copy().createCoordinateIterator().forEachRemaining(v -> adjacencyMatrix.set(v.col, v.row, v.value));

// In a graph context mxm computes all path of length 2 (a->b->c).
// But, for triangles we are only interested in the "closed" path which form a triangle (a->b->c->a).
// To avoid computing irrelevant paths, we can use the adjacency matrix as the mask, which assures (a->c) exists.
var mask = DMaskFactory.builder(adjacencyMatrix, true).build();
var triangleMatrix = CommonOpsWithSemiRing_DSCC.mult(adjacencyMatrix, adjacencyMatrix, null, DSemiRings.PLUS_TIMES, mask, null, null);

// To compute the triangles per vertex we calculate the sum per each row.
// For the correct count, we need to divide the count by 2 as each triangle was counted twice (a--b--c, and a--c--b)
var trianglesPerVertex = CommonOps_DSCC.reduceRowWise(triangleMatrix, 0, Double::sum, null);
CommonOps_DDRM.apply(trianglesPerVertex, v -> v/2);

System.out.println("Triangles including vertex 0 " + trianglesPerVertex.get(0));
System.out.println("Triangles including vertex 2 " + trianglesPerVertex.get(2));
System.out.println("Triangles including vertex 5 " + trianglesPerVertex.get(5));

// Note: To avoid counting each triangle twice, the lower triangle over the adjacency matrix can be used TRI<A> = A * L
}
}
</syntaxhighlight>

Manual

2021-07-07T15:22:31Z

Peter: /* Example Code */

= The Basics =

Efficient Java Matrix Library (EJML) is a Java library for performing standard linear algebra operations on dense matrices. Typically the list of standard operations is divided up unto basic (addition, subtraction, multiplication, ...etc), decompositions (LU, QR, SVD, ... etc), and solving linear systems. A complete list of its core functionality can be found on the [[Capabilities]] page.

This manual describes how to use and develop an application using EJML. Other questions, like how to build or include it in your project, is provided in the list below. If you have a question which isn't answered or is confusion feel free to post a question on the message board! Instructions on how to use EJML is primarily done in this manual through example, see below. The examples are selected from common real-world problems, such as Kalman filters. Some times the same example is provided in three different formats using one of the three interfaces provided in EJML to help you understand the differences.

* [[Download|Download and Building]]
* [[Frequently Asked Questions|Frequently Asked Questions]]
* [http://groups.google.com/group/efficient-java-matrix-library-discuss Message Board]

EJML is compatible with Java 1.8 and beyond.

== The Interfaces ==

A primary design goal of EJML was to provide users the capability to write both highly optimized code and easy to read/write code. Since it's hard to do this with a single API BoofCV provides three different ways to interact with it.

* [[Procedural]]: You have full access to all of EJML's capabilities, can select individual algorithms, and almost complete control over memory. The downside is it feels a bit like you're programming in assembly and it's tedious to have that much control over memory.
* [[SimpleMatrix]]: An object oriented API that allows you to connect multiple operations together using a flow strategy, which is much easier to read and write. Limited subset of operations are supported and memory is constantly created and destroyed.
* [[Equations]]: Is a symbolic interface that allows you to manipulate matrices in a similar manor to Matlab/Octave. Can be precompiled and won't declare new memory if the input size doesn't change. It's a bit of a black box and the compiler isn't smart enough to pick the most efficient functions.

Example of compute the Kalman gain "K"

{| width="500pt" |
|-
|
'''Procedural'''
<syntaxhighlight lang="java">
mult(H,P,c);
multTransB(c,H,S);
addEquals(S,R);
if( !invert(S,S_inv) )
throw new RuntimeException("Invert failed");
multTransA(H,S_inv,d);
mult(P,d,K);
</syntaxhighlight>

'''SimpleMatrix'''
<syntaxhighlight lang="java">
SimpleMatrix S = H.mult(P).mult(H.transpose()).plus(R);
SimpleMatrix K = P.mult(H.transpose().mult(S.invert()));
</syntaxhighlight>

'''Equations'''
<syntaxhighlight lang="java">
eq.process("K = P*H'*inv( H*P*H' + R )");
</syntaxhighlight>
|}

It's hard to say which interface is the best. If you are dealing with small matrices and need to write highly optimized code then ''Procedural'' is the way to go. For large matrices it doesn't really matter which one you use since the overhead is insignificant compared to the matrix operations. If you want to write something quickly then [[SimpleMatrix]] or [[Equations]] is the way to go. For those of you who are concerned about performance, I recommend coding it up first using SimpleMatrix or Equations then benchmarking to see if that code is a bottleneck. Much easier to debug that way.

[[Performance|Comparison of Interface Runtime Performance]]

= Tutorials =

* [[Matlab to EJML|Matlab to EJML]]
* [[Tutorial Complex|Complex]]
* [[Solving Linear Systems|Solving Linear Systems]]
* [[Matrix Decompositions|Matrix Decompositions]]
* [[Random matrices, Matrix Features, and Matrix Norms]]
* [[Extract and Insert|Extracting and Inserting submatrices and vectors]]
* [[Input and Output|Matrix Input/Output]]
* [[Unit Testing]]

= Example Code =

The follow are code examples of common linear algebra problems intended to demonstrate different parts of EJML. In the table below it indicates which interface or interfaces the example uses.

{| class="wikitable" border="1" |
! Name !! Procedural !! SimpleMatrix !! Equations
|-
| [[Example Kalman Filter|Kalman Filter]] || X || X || X
|-
| [[Example Sparse Matrices|Sparse Matrix Basics]] || X || ||
|-
| [[Example Levenberg-Marquardt|Levenberg-Marquardt]] || X || ||
|-
| [[Example Principal Component Analysis|Principal Component Analysis]] || X || ||
|-
| [[Example Polynomial Fitting|Polynomial Fitting]] || X || ||
|-
| [[Example Polynomial Roots|Polynomial Roots]] || X || ||
|-
| [[Example Customizing Equations|Customizing Equations]] || || || X
|-
| [[Example Customizing SimpleMatrix|Customizing SimpleMatrix]] || || X ||
|-
| [[Example Fixed Sized Matrices|Fixed Sized Matrices]] || X || ||
|-
| [[Example Complex Math|Complex Math]] || X || ||
|-
| [[Example Complex Matrices|Complex Matrices]] || X || ||
|-
| [[Example Concurrent Operations|Concurrent Operations]] || X || ||
|-
| [[Example Graph Paths|(GraphBLAS) Graph Paths]] || X || ||
|-
| [[Example Masked Triangle Count|(GraphBLAS) Masked Triangle Count]] || X || ||
|-
| [[Example Large Dense Matrices|Optimizing Large Dense]] || X || ||
|}

= External References =

Want to learn more about how EJML works to write more effective code and employ more advanced techniques? Understand where EJML's logo comes from? The following books are recommended reading and made EJML's early development possible.
* Best introduction to the subject that balances clarity without sacrificing important implementation details:
** Fundamentals of Matrix Computations by David S. Watkins
* Classic reference book that tersely covers hundreds of algorithms
** Matrix Computations by G. Golub and C. Van Loan
* Direct Methods for Sparse Linear Systems by Timothy A. Davis
** Covers the sparse algorithms used in EJML
* Popular book on linear algebra
** Linear Algebra and Its Applications by Gilbert Strang

Example Graph Paths

2021-07-07T15:08:10Z

Peter:

Many Graph operations can be performed using linear algebra and this connection is the subject of much recent research. EJML now has basic "Graph BLAS" capabilities as this example shows.

External Resources:
* [https://github.com/lessthanoptimal/ejml/blob/v0.41/examples/src/org/ejml/example/ExampleGraphPaths.java ExampleGraphPaths.java]

== Example Code ==

<syntaxhighlight lang="java">
/**
* Example including one iteration of the graph traversal algorithm breath-first-search (BFS),
* using different semirings. So following the outgoing relationships for a set of starting nodes.
*
* More about the connection between graphs and linear algebra can be found at:
* https://github.com/GraphBLAS/GraphBLAS-Pointers.
*
* @author Florentin Doerre
*/
public class ExampleGraphPaths {
private static final int NODE_COUNT = 4;

public static void main( String[] args ) {
DMatrixSparseCSC adjacencyMatrix = new DMatrixSparseCSC(NODE_COUNT, 4);

// For the example we will be using the following graph:
// (3)<-[cost: 0.2]-(0)<-[cost: 0.1]->(2)<-[cost: 0.3]-(1)

adjacencyMatrix.set(0, 2, 0.1);
adjacencyMatrix.set(0, 3, 0.2);
adjacencyMatrix.set(2, 0, 0.1);
adjacencyMatrix.set(3, 2, 0.3);

// Semirings are used to redefine + and * f.i. with OR for + and AND for *
DSemiRing lor_land = DSemiRings.OR_AND;
DSemiRing min_times = DSemiRings.MIN_TIMES;
DSemiRing plus_land = new DSemiRing(DMonoids.PLUS, DMonoids.AND);

// sparse Vector (Matrix with one column)
DMatrixSparseCSC startNodes = new DMatrixSparseCSC(1, NODE_COUNT);
// setting the node 0 as the start-node
startNodes.set(0, 0, 1);

DMatrixSparseCSC outputVector = startNodes.createLike();

// Compute which nodes can be reached from the node 0 (disregarding the costs of the relationship)
CommonOpsWithSemiRing_DSCC.mult(startNodes, adjacencyMatrix, outputVector, lor_land, null, null, null);

System.out.println("Node 3 can be reached from node 0: " + (outputVector.get(0, 3) == 1));
System.out.println("Node 1 can be reached from node 0: " + (outputVector.get(0, 1) == 1));

// Add node 3 to the start nodes
startNodes.set(0, 3, 1);

// Find the number of path the nodes can be reached with
CommonOpsWithSemiRing_DSCC.mult(startNodes, adjacencyMatrix, outputVector, plus_land, null, null, null);
System.out.println("The number of start-nodes leading to node 2 is " + (int)outputVector.get(0, 2));

// Find the path with the minimal cost (direct connection from one of the specified starting nodes)
// the calculated cost equals the cost specified in the relationship (as both startNodes have a weight of 1)
// as an alternative you could use the MIN_PLUS semiring to consider the existing cost specified in the startNodes vector
CommonOpsWithSemiRing_DSCC.mult(startNodes, adjacencyMatrix, outputVector, min_times, null, null, null);
System.out.println("The minimal cost to reach the node 2 is " + outputVector.get(0, 2));
}
}
</syntaxhighlight>

Example Concurrent Operations

2021-07-07T15:05:16Z

Peter:

Concurrent or Mult Threaded operations are a relatively recent to EJML. EJML has traditionally been focused on single threaded performance but this recently changed when "low hanging fruit" has been converted into threaded code. Not all and in fact most operations don't have threaded variants yet and it is always possible to call code which is purely single threaded. See below for more details.

External Resources:
* [https://github.com/lessthanoptimal/ejml/blob/v0.41/examples/src/org/ejml/example/ExampleConcurrent.java ExampleConcurrent.java code]

== Example Code ==

<syntaxhighlight lang="java">
/**
* Concurrent or multi-threaded algorithms are a recent addition to EJML. Classes with concurrent implementations
* can be identified with _MT_ in the class name. For example CommonOps_MT_DDRM will contain concurrent implementations
* of operations such as matrix multiplication for dense row-major algorithms. Not everything has a concurrent
* implementation yet and in some cases entirely new algorithms will need to be implemented.
*
* @author Peter Abeles
*/
public class ExampleConcurrent {
public static void main( String[] args ) {
// Create a few random matrices that we will multiply and decompose
var rand = new Random(0xBEEF);
DMatrixRMaj A = RandomMatrices_DDRM.rectangle(4000, 4000, -1, 1, rand);
DMatrixRMaj B = RandomMatrices_DDRM.rectangle(A.numCols, 1000, -1, 1, rand);
DMatrixRMaj C = new DMatrixRMaj(1, 1);

// First do a concurrent matrix multiply using the default number of threads
System.out.println("Matrix Multiply, threads=" + EjmlConcurrency.getMaxThreads());
UtilEjml.printTime(" ", "Elapsed: ", () -> CommonOps_MT_DDRM.mult(A, B, C));

// Set it to two threads
EjmlConcurrency.setMaxThreads(2);
System.out.println("Matrix Multiply, threads=" + EjmlConcurrency.getMaxThreads());
UtilEjml.printTime(" ", "Elapsed: ", () -> CommonOps_MT_DDRM.mult(A, B, C));

// Then let's compare it against the single thread implementation
System.out.println("Matrix Multiply, Single Thread");
UtilEjml.printTime(" ", "Elapsed: ", () -> CommonOps_DDRM.mult(A, B, C));

// Setting the number of threads to 1 then running am MT implementation actually calls completely different
// code than the regular function calls and will be less efficient. This will probably only be evident on
// small matrices though

// If the future we will provide a way to optionally automatically switch to concurrent implementations
// for larger when calling standard functions.
}
}
</syntaxhighlight>

Example Kalman Filter

2021-07-07T15:02:57Z

Peter:

Here are three examples that demonstrate how a [http://en.wikipedia.org/wiki/Kalman_filter Kalman filter] can be created using different API's in EJML. Each API has different advantages and disadvantages. High level interfaces tend to be easier to use, but sacrifice efficiency. The intent of this article is to illustrate this trend empirically. Runtime performance of each approach is shown below. To see how complex and readable each approach is check out the source code below.

<center>
{| class="wikitable"
! API !! Execution Time (ms)
|-
| SimpleMatrix || 1875
|-
| Operations || 1280
|-
| Equations || 1698
|}
</center>

__TOC__

External Resources:
* [https://github.com/lessthanoptimal/ejml/blob/v0.41/examples/src/org/ejml/example/KalmanFilterSimple.java KalmanFilterSimple]
* [https://github.com/lessthanoptimal/ejml/blob/v0.41/examples/src/org/ejml/example/KalmanFilterOperations.java KalmanFilterOperations]
* [https://github.com/lessthanoptimal/ejml/blob/v0.41/examples/src/org/ejml/example/KalmanFilterEquation.java KalmanFilterEquation]
* <disqus>Discuss this example</disqus>

----

'''NOTE:''' While the Kalman filter code below is fully functional and will work well in most applications, it might not be the best. Other variants seek to improve stability and/or avoid the matrix inversion. It's worth point out that some people say you should never invert the matrix in a Kalman filter. There are applications, such as target tracking, where matrix inversion of the innovation covariance is helpful as a preprocessing step.

== SimpleMatrix Example ==

<syntaxhighlight lang="java">
/**
* A Kalman filter implemented using SimpleMatrix. The code tends to be easier to
* read and write, but the performance is degraded due to excessive creation/destruction of
* memory and the use of more generic algorithms. This also demonstrates how code can be
* seamlessly implemented using both SimpleMatrix and DMatrixRMaj. This allows code
* to be quickly prototyped or to be written either by novices or experts.
*
* @author Peter Abeles
*/
public class KalmanFilterSimple implements KalmanFilter {
// kinematics description
private SimpleMatrix F, Q, H;

// sytem state estimate
private SimpleMatrix x, P;

@Override public void configure( DMatrixRMaj F, DMatrixRMaj Q, DMatrixRMaj H ) {
this.F = new SimpleMatrix(F);
this.Q = new SimpleMatrix(Q);
this.H = new SimpleMatrix(H);
}

@Override public void setState( DMatrixRMaj x, DMatrixRMaj P ) {
this.x = new SimpleMatrix(x);
this.P = new SimpleMatrix(P);
}

@Override public void predict() {
// x = F x
x = F.mult(x);

// P = F P F' + Q
P = F.mult(P).mult(F.transpose()).plus(Q);
}

@Override public void update( DMatrixRMaj _z, DMatrixRMaj _R ) {
// a fast way to make the matrices usable by SimpleMatrix
SimpleMatrix z = SimpleMatrix.wrap(_z);
SimpleMatrix R = SimpleMatrix.wrap(_R);

// y = z - H x
SimpleMatrix y = z.minus(H.mult(x));

// S = H P H' + R
SimpleMatrix S = H.mult(P).mult(H.transpose()).plus(R);

// K = PH'S^(-1)
SimpleMatrix K = P.mult(H.transpose().mult(S.invert()));

// x = x + Ky
x = x.plus(K.mult(y));

// P = (I-kH)P = P - KHP
P = P.minus(K.mult(H).mult(P));
}

@Override public DMatrixRMaj getState() { return x.getMatrix(); }

@Override public DMatrixRMaj getCovariance() { return P.getMatrix(); }
}
</syntaxhighlight>

== Operations Example ==

<syntaxhighlight lang="java">
/**
* A Kalman filter that is implemented using the operations API, which is procedural. Much of the excessive
* memory creation/destruction has been reduced from the KalmanFilterSimple. A specialized solver is
* under to invert the SPD matrix.
*
* @author Peter Abeles
*/
public class KalmanFilterOperations implements KalmanFilter {
// kinematics description
private DMatrixRMaj F, Q, H;

// system state estimate
private DMatrixRMaj x, P;

// these are predeclared for efficiency reasons
private DMatrixRMaj a, b;
private DMatrixRMaj y, S, S_inv, c, d;
private DMatrixRMaj K;

private LinearSolverDense<DMatrixRMaj> solver;

@Override public void configure( DMatrixRMaj F, DMatrixRMaj Q, DMatrixRMaj H ) {
this.F = F;
this.Q = Q;
this.H = H;

int dimenX = F.numCols;
int dimenZ = H.numRows;

a = new DMatrixRMaj(dimenX, 1);
b = new DMatrixRMaj(dimenX, dimenX);
y = new DMatrixRMaj(dimenZ, 1);
S = new DMatrixRMaj(dimenZ, dimenZ);
S_inv = new DMatrixRMaj(dimenZ, dimenZ);
c = new DMatrixRMaj(dimenZ, dimenX);
d = new DMatrixRMaj(dimenX, dimenZ);
K = new DMatrixRMaj(dimenX, dimenZ);

x = new DMatrixRMaj(dimenX, 1);
P = new DMatrixRMaj(dimenX, dimenX);

// covariance matrices are symmetric positive semi-definite
solver = LinearSolverFactory_DDRM.symmPosDef(dimenX);
}

@Override public void setState( DMatrixRMaj x, DMatrixRMaj P ) {
this.x.setTo(x);
this.P.setTo(P);
}

@Override public void predict() {
// x = F x
mult(F, x, a);
x.setTo(a);

// P = F P F' + Q
mult(F, P, b);
multTransB(b, F, P);
addEquals(P, Q);
}

@Override public void update( DMatrixRMaj z, DMatrixRMaj R ) {
// y = z - H x
mult(H, x, y);
subtract(z, y, y);

// S = H P H' + R
mult(H, P, c);
multTransB(c, H, S);
addEquals(S, R);

// K = PH'S^(-1)
if (!solver.setA(S)) throw new RuntimeException("Invert failed");
solver.invert(S_inv);
multTransA(H, S_inv, d);
mult(P, d, K);

// x = x + Ky
mult(K, y, a);
addEquals(x, a);

// P = (I-kH)P = P - (KH)P = P-K(HP)
mult(H, P, c);
mult(K, c, b);
subtractEquals(P, b);
}

@Override public DMatrixRMaj getState() { return x; }

@Override public DMatrixRMaj getCovariance() { return P; }
}
</syntaxhighlight>

== Equations Example ==

<syntaxhighlight lang="java">
/**
* Example of how the equation interface can greatly simplify code
*
* @author Peter Abeles
*/
public class KalmanFilterEquation implements KalmanFilter {
// system state estimate
private DMatrixRMaj x, P;

private Equation eq;

// Storage for precompiled code for predict and update
Sequence predictX, predictP;
Sequence updateY, updateK, updateX, updateP;

@Override public void configure( DMatrixRMaj F, DMatrixRMaj Q, DMatrixRMaj H ) {
int dimenX = F.numCols;

x = new DMatrixRMaj(dimenX, 1);
P = new DMatrixRMaj(dimenX, dimenX);

eq = new Equation();

// Provide aliases between the symbolic variables and matrices we normally interact with
// The names do not have to be the same.
eq.alias(x, "x", P, "P", Q, "Q", F, "F", H, "H");

// Dummy matrix place holder to avoid compiler errors. Will be replaced later on
eq.alias(new DMatrixRMaj(1, 1), "z");
eq.alias(new DMatrixRMaj(1, 1), "R");

// Pre-compile so that it doesn't have to compile it each time it's invoked. More cumbersome
// but for small matrices the overhead is significant
predictX = eq.compile("x = F*x");
predictP = eq.compile("P = F*P*F' + Q");

updateY = eq.compile("y = z - H*x");
updateK = eq.compile("K = P*H'*inv( H*P*H' + R )");
updateX = eq.compile("x = x + K*y");
updateP = eq.compile("P = P-K*(H*P)");
}

@Override public void setState( DMatrixRMaj x, DMatrixRMaj P ) {
this.x.setTo(x);
this.P.setTo(P);
}

@Override public void predict() {
predictX.perform();
predictP.perform();
}

@Override public void update( DMatrixRMaj z, DMatrixRMaj R ) {

// Alias will overwrite the reference to the previous matrices with the same name
eq.alias(z, "z", R, "R");

updateY.perform();
updateK.perform();
updateX.perform();
updateP.perform();
}

@Override public DMatrixRMaj getState() { return x; }

@Override public DMatrixRMaj getCovariance() { return P; }
}
</syntaxhighlight>

Users

2021-07-06T17:35:06Z

Peter:

= Projects which use EJML =

Feel free to add your own project!
* [https://github.com/FlorentinD/GraphBlasInJavaBenchmarks Graph Blas in Java Benchmarks]
* [https://neo4j.com/ Neo4J]'s graph-data-science library.
* [https://www.db.bme.hu/preprints/thesis2018-multidimensional-graph-analysis.pdf Petra Várhegyi's masters thesis on graph analysis]
* [http://wiki.industrial-craft.net Industrial Craft 2] modification for minecraft
* [http://www-lium.univ-lemans.fr/diarization/doku.php/ LIUM_SpkDiarization] is a software dedicated to speaker diarization (ie speaker segmentation and clustering).
* [http://researchers.lille.inria.fr/~freno/JProGraM.html JProGraM]: Library for learning a number of statistical models from data.
* [http://code.google.com/p/gogps/ goGPS]: Improve the positioning accuracy of low-cost GPS devices by RTK technique.
* [http://www-edc.eng.cam.ac.uk/tools/set_visualiser/ Set Visualiser]: Visualises the way that a number of items is classified into one or more categories or sets using Euler diagrams.
* Universal Java Matrix Library (UJML): http://www.ujmp.org/
* Scalalab: http://code.google.com/p/scalalab/
* Java Content Based Image Retrieval (JCBIR): http://code.google.com/p/jcbir/
* JLabGroovy: http://code.google.com/p/jlabgroovy/
* JquantLib (Will be added): http://www.jquantlib.org/
* Matlube: https://github.com/hohonuuli/matlube
* Geometric Regression Library: http://georegression.org/
* BoofCV: Computer Vision Library: http://boofcv.org/
* ICY: bio-imaging: http://www.bioimageanalysis.com/icy/
* JSkills: Java implementation of TrueSkill algorithm https://github.com/nsp/JSkills
* Portfolio applets at http://www.christoph-junge.de/optimizer.php
* Distributed Control Framework (DCF) http://www.i-a-i.com/dcfpro/
* JptView point cloud viewer: http://www.seas.upenn.edu/~aiv/jptview/
* JPrIME Bayesian phylogenetics library: http://code.google.com/p/jprime/
* J-Matrix quantum mechanics scattering https://code.google.com/p/jmatrix/
* DDogleg Numerics: http://ddogleg.org
* Saddle: http://saddle.github.io/doc/index.html
* GDSC ImageJ Plugins: http://www.sussex.ac.uk/gdsc/intranet/microscopy/imagej/gdsc_plugins
* Robot Controller for Humanoid Robots: http://www.ihmc.us/Research/projects/HumanoidRobots/index.html
* Credit Analytics: http://code.google.com/p/creditanalytics
* Spline Library: http://code.google.com/p/splinelibrary - http://www.credit-trader.org/CreditSuite/docs/SplineLibrary_2.2.pdf
* Fixed Point Finder: http://code.google.com/p/rootfinder - http://www.credit-trader.org/CreditSuite/docs/FixedPointFinder_2.2.pdf
* Sensitivity generation scheme in Credit Analytics: http://www.credit-trader.org/CreditSuite/docs/SensitivityGenerator_2.2.pdf
* Stanford CoreNLP: A set of natural language analysis tools: http://nlp.stanford.edu/software/corenlp.shtml
* OpenChrom: Open source software for the mass spectrometric analysis of chromatographic data. https://www.openchrom.net

= Papers That Cite EJML =
* A ton of [https://scholar.google.com/scholar?q=%22efficient+java+matrix+library%22&hl=en&as_sdt=0,5 academic papers]
* [https://dl.acm.org/doi/abs/10.1145/3461837.3464627 Florentin Dörre, Alexander Krause, Dirk Habich, and Martin Junghanns. 2021. A GraphBLAS implementation in pure Java. In Proceedings of the 4th ACM SIGMOD Joint International Workshop on Graph Data Management Experiences & Systems (GRADES) and Network Data Analytics (NDA)]
* Zewdie, Dawit Dawit Habtamu. "Representation discovery in non-parametric reinforcement learning." Diss. Massachusetts Institute of Technology, 2014.
* Sanfilippo, Filippo, et al. "A mapping approach for controlling different maritime cranes and robots using ANN." Mechatronics and Automation (ICMA), 2014 IEEE International Conference on. IEEE, 2014.
* Kushman, Nate, et al. "Learning to automatically solve algebra word problems." ACL (1) (2014): 271-281.
* Stergios Papadimitriou, Seferina Mavroudi, Kostas Theofilatos, and Spiridon Likothanasis, “MATLAB-Like Scripting of Java Scientific Libraries in ScalaLab,” Scientific Programming, vol. 22, no. 3, pp. 187-199, 2014.
* Alberto Castellini, Daniele Paltrinieri, and Vincenzo Manca "MP-GeneticSynth: Inferring Biological Network Regulations from Time Series" Bioinformatics 2014
* Blasinski, H., Bulan, O., & Sharma, G. (2013). Per-Colorant-Channel Color Barcodes for Mobile Applications: An Interference Cancellation Framework.
* Marin, R. C., & Dobre, C. (2013, November). Reaching for the clouds: contextually enhancing smartphones for energy efficiency. In Proceedings of the 2nd ACM workshop on High performance mobile opportunistic systems (pp. 31-38). ACM.
* Oletic, D., Skrapec, M., & Bilas, V. (2013). Monitoring Respiratory Sounds: Compressed Sensing Reconstruction via OMP on Android Smartphone. In Wireless Mobile Communication and Healthcare (pp. 114-121). Springer Berlin Heidelberg.
* Santhiar, Anirudh and Pandita, Omesh and Kanade, Aditya "Discovering Math APIs by Mining Unit Tests" Fundamental Approaches to Software Engineering 2013
* Sanjay K. Boddhu, Robert L. Williams, Edward Wasser, Niranjan Kode, "Increasing Situational Awareness using Smartphones" Proc. SPIE 8389, Ground/Air Multisensor Interoperability, Integration, and Networking for Persistent ISR III, 83891J (May 1, 2012)
* J. A. Álvarez-Bermejo, N. Antequera, R. García-Rubio and J. A. López-Ramos, _"A scalable server for key distribution and its application to accounting,"_ The Journal of Supercomputing, 2012
* Realini E., Yoshida D., Reguzzoni M., Raghavan V., _"Enhanced satellite positioning as a web service with goGPS open source software"_. Applied Geomatics 4(2), 135-142. 2012
* Stergios Papadimitriou, Constantinos Terzidis, Seferina Mavroudi, Spiridon D. Likothanassis: _Exploiting java scientific libraries with the scala language within the scalalab environment._ IET Software 5(6): 543-551 (2011)
* L. T. Lim, B. Ranaivo-Malançon and E. K. Tang. _“Symbiosis Between a Multilingual Lexicon and Translation Example Banks”._ In: Procedia: Social and Behavioral Sciences 27 (2011), pp. 61–69.
* G. Taboada, S. Ramos, R. Expósito, J. Touriño, R. Doallo, _Java in the High Performance Computing arena: Research, practice and experience,_ Science of Computer Programming, 2011.
* http://geomatica.como.polimi.it/presentazioni/Osaka_Summer_goGPS.pdf
* http://www.holger-arndt.de/library/MLOSS2010.pdf
* http://www.ateji.com/px/whitepapers/Ateji%20PX%20MatMult%20Whitepaper%20v1.2.pdf

Note: Slowly working on an EJML paper for publication. About 1/2 way through a first draft.

= On The Web =
* https://softwarerecs.stackexchange.com/questions/51330/sparse-matrix-library-for-java
* https://lessthanoptimal.github.io/Java-Matrix-Benchmark/
* http://java.dzone.com/announcements/introduction-efficient-java
* https://shakthydoss.wordpress.com/2011/01/13/jama-shortcoming/
* Various questions on stackoverflow.com

Acknowledgments

2021-07-06T17:31:36Z

Peter:

== Development ==

EJML has been developed most by [https://www.linkedin.com/profile/view?id=9580871 Peter Abeles] in his spare time. Much of the development of EJML was inspired by his frustration with existing libraries at that time. They had very poor performance with small matrices, excessive memory creation/destruction, (arguably) not the best API, and tended to be quickly abandoned by their developers after decided he liked one. The status of Java numerical libraries has improved since then in general. More recently, Graph BLAS operations have been added by Florentin Dorre ([https://dl.acm.org/doi/abs/10.1145/3461837.3464627 paper]), filling in an often requested feature.

Additional thanks should go towards the [http://ihmc.us Institute for Human Machine Cognition] (IHMC) which encouraged the continued development of EJML and even commissioned the inclusion of the first few complex matrix operations after he had left. [https://www.hebirobotics.com/ HEBI Robotics] sponsored the continued developement of support for sparse matrix operations, a much needed feature.

All the feedback and bug reports from its users have also had a significant influence on this library. Without their encouragement and help it would be less stable and much less flushed out than it is today. The book [http://www.amazon.com/gp/product/0470528338/ref=as_li_ss_tl?ie=UTF8&tag=ejml-20&linkCode=as2&camp=1789&creative=390957&creativeASIN=0470528338 Fundamentals of Matrix Computations by David S. Watkins] also significantly influence the development of the library in its early days. It is probably the best introduction to to the computational side of linear algebra written so far and includes many important implementation details left out in other books.

== Dependencies ==

EJML is entirely self contained and is only dependent on JUnit for tests.

* http://www.junit.org/

Acknowledgments

2021-07-06T17:30:22Z

Peter:

== Development ==

EJML has been developed most by [https://www.linkedin.com/profile/view?id=9580871 Peter Abeles] in his spare time. Much of the development of EJML was inspired by his frustration with existing libraries at that time. They had very poor performance with small matrices, excessive memory creation/destruction, (arguably) not the best API, and tended to be quickly abandoned by their developers after decided he liked one. The status of Java numerical libraries has improved since then in general. More recently, Graph BLAS features have been added by Florentin Dorre ([https://dl.acm.org/doi/abs/10.1145/3461837.3464627 paper]).

Additional thanks should go towards the [http://ihmc.us Institute for Human Machine Cognition] (IHMC) which encouraged the continued development of EJML and even commissioned the inclusion of the first few complex matrix operations after he had left. [https://www.hebirobotics.com/ HEBI Robotics] sponsored the continued developement of support for sparse matrix operations, a much needed feature.

All the feedback and bug reports from its users have also had a significant influence on this library. Without their encouragement and help it would be less stable and much less flushed out than it is today. The book [http://www.amazon.com/gp/product/0470528338/ref=as_li_ss_tl?ie=UTF8&tag=ejml-20&linkCode=as2&camp=1789&creative=390957&creativeASIN=0470528338 Fundamentals of Matrix Computations by David S. Watkins] also significantly influence the development of the library in its early days. It is probably the best introduction to to the computational side of linear algebra written so far and includes many important implementation details left out in other books.

== Dependencies ==

EJML is entirely self contained and is only dependent on JUnit for tests.

* http://www.junit.org/

Procedural

2021-03-24T15:58:15Z

Peter:

The procedural interface in EJML provides access to all of its capabilities and provides much more control over which algorithms are used and when memory is created. The downside to this increased control is the added difficulty in programming, kinda resembles writing in assembly. Code can be made very efficient, but managing all the temporary data structures can be tedious.

The procedural supports all matrix types in EJML and follows a consistent naming pattern across all matrix types. Ops classes end in a suffix that indicate which type of matrix they can process. From the matrix name you can determine the type of element (float,double,real,complex) and it's internal data structure, e.g. row-major or block. In general, almost everyone will want to interact with row major matrices. Conversion to block format is done automatically internally when it becomes advantageous.

{| class="wikitable"
! Matrix Name !! Description !! Suffix
|-
| {{DataDocLink|DMatrixRMaj}} || Dense Double Real - Row Major || DDRM
|-
| {{DataDocLink|FMatrixRMaj}} || Dense Float Real - Row Major || FDRM
|-
| {{DataDocLink|ZDMatrixRMaj}} || Dense Double Complex - Row Major || ZDRM
|-
| {{DataDocLink|CDMatrixRMaj}} || Dense Float Complex - Row Major || CDRM
|-
| {{DataDocLink|DMatrixSparseCSC}} || Sparse Double Real - Compressed Column || DSCC
|-
| {{DataDocLink|DMatrixSparseTriplet}} || Sparse Double Real - Triplet || DSTL
|-
| {{DocLink|org/ejml/data/DMatrix3x3.html|DMatrix3x3}} || Dense Double Real 3x3 || DDF3
|-
| {{DocLink|org/ejml/data/DMatrix3.html|DMatrix3}} || Dense Double Real 3 || DDF3
|-
| {{DocLink|org/ejml/data/FMatrix3x3.html|FMatrix3x3}} || Dense Float Real 3x3 || FDF3
|-
| {{DocLink|org/ejml/data/FMatrix3.html|FMatrix3}} || Dense Float Real 3 || FDF3
|}
Fixed sized matrix from 2 to 6 are supported. Just replaced the 3 with the desired size. ''NOTE: In previous versions of EJML the matrix DMatrixRMaj was known as DenseMatrix64F.''

= Matrix Element Accessors =

* get( row , col )
* set( row , col , value )
** Returns or sets the value of an element at the specified row and column.
* unsafe_get( row , col )
* unsafe_set( row , col , value )
** Faster version of get() or set() that does not perform bounds checking.
* get( index )
* set( index )
** Returns or sets the value of an element at the specified index. Useful for vectors and element-wise operations.
* iterator( boolean rowMajor, int minRow, int minCol, int maxRow, int maxCol )
** An iterator that iterates through the sub-matrix by row or by column.

= Operations Classes =

Several "Ops" classes provide functions for manipulating different types of matrices and most are contained inside of the org.ejml.dense.* package, where * is replaced with the matrix structure package type, e.g. row for row-major. The list below is provided for DMatrixRMaj, other matrix can be found by changing the suffix as discussed above.

; {{DocLink|org/ejml/dense/row/CommonOps_DDRM.html|CommonOps_DDRM}} : Provides the most common matrix operations.
; {{DocLink|org/ejml/dense/row/EigenOps_DDRM.html|EigenOps_DDRM}} : Provides operations related to eigenvalues and eigenvectors.
; {{DocLink|org/ejml/dense/row/MatrixFeatures_DDRM.html|MatrixFeatures_DDRM}} : Used to compute various features related to a matrix.
; {{DocLink|org/ejml/dense/row/NormOps_DDRM.html|NormOps_DDRM}} : Operations for computing different matrix norms.
; {{DocLink|org/ejml/dense/row/SingularOps_DDRM.html|SingularOps_DDRM}} : Operations related to singular value decompositions.
; {{DocLink|org/ejml/dense/row/SpecializedOps_DDRM.html|SpecializedOps_DDRM}} : Grab bag for operations which do not fit in anywhere else.
; {{DocLink|org/ejml/dense/row/RandomMatrices_DDRM.html|RandomMatrices_DDRM}} : Used to create different types of random matrices.

For fixed sized matrices FixedOpsN is provided, where N = 2 to 6. FixedOpsN is similar in functionality to CommonOps.

Main Page

2021-02-18T02:45:41Z

Peter: /* News */

__NOTOC__

<center>
{| style="width:640pt;"
| align="center" |
[[File:Ejml_logo.gif]]
|-
|

Efficient Java Matrix Library (EJML) is a [http://en.wikipedia.org/wiki/Linear_algebra linear algebra] library for manipulating real/complex/dense/sparse matrices. Its design goals are; 1) to be as computationally and memory efficient as possible for small and large, dense and sparse, real and complex matrices, and 2) to be accessible to both novices and experts. These goals are accomplished by dynamically selecting the best algorithms to use at runtime, clean API, and multiple interfaces. EJML is free, written in 100% Java and has been released under an Apache v2.0 license.

EJML has three distinct ways to interact with it: 1) ''procedural'', 2) ''SimpleMatrix'', and 3) ''Equations''. ''Procedure'' provides all capabilities of EJML and almost complete control over memory creation, speed, and specific algorithms. ''SimpleMatrix'' provides a simplified subset of the core capabilities in an easy to use flow styled object-oriented API, inspired by [http://math.nist.gov/javanumerics/jama/ Jama]. ''Equations'' is a symbolic interface, similar in spirit to [http://www.mathworks.com/products/matlab/ Matlab] and other [http://en.wikipedia.org/wiki/Computer_algebra_system CAS], that provides a compact way of writing equations.
|}

{|
| colspan="3" align="center" |
{|style="font-size:120%; text-align:left;"
|-
| '''Version:''' ''v0.40''
|-
| '''Date:''' ''November 4, 2020''
|-
| [https://github.com/lessthanoptimal/ejml/blob/master/convert_to_ejml31.py v0.31 Upgrade Script]
|-
| [https://github.com/lessthanoptimal/ejml/blob/v0.40/change.txt Change Log]
|}
|- valign="top"
| width="220pt" |
{| width="200pt" border="1" align="center" style="font-size:120%; text-align:center; border-collapse:collapse; background-color:#ffffee;"
|-
| [[Download|Download]]
|-
| [[manual|Manual]]
|-
| [http://ejml.org/javadoc/ JavaDoc]
|}
| width="220pt" |
{| width="200pt" border="1" align="center" style="font-size:120%; text-align:center; border-collapse:collapse; background-color:#ffffee;"
|-
| [http://groups.google.com/group/efficient-java-matrix-library-discuss Message Board]
|-
| [https://github.com/lessthanoptimal/ejml/issues Bug Reports]
|-
| [[Frequently Asked Questions|FAQ]]
|-
| [[Kotlin|Kotlin]]
|}
| width="220pt" |
{| width="200pt" border="1" align="center" style="font-size:120%; text-align:center; border-collapse:collapse; background-color:#ffffee;"
|-
| [[Acknowledgments|Acknowledgments]]
|-
| [[Performance|Performance]]
|-
| [[Users|Users]]
|}
|}

== News 2021 ==

{| width="500pt" |
| -
|
* Read and write EJML in Matlab format with [https://github.com/HebiRobotics/MFL MFL] from HEBI Robotics
* Graph BLAS continues to be flushed out with masks being added to latest SNAPSHOT
* Concurrency/threading has been added to some operations
|}

== Code Examples ==

Demonstrations on how to compute the Kalman gain "K" using each interface in EJML.

{| width="500pt" |
|-
|
'''Procedural'''
<syntaxhighlight lang="java">
mult(H,P,c);
multTransB(c,H,S);
addEquals(S,R);
if( !invert(S,S_inv) )
throw new RuntimeException("Invert failed");
multTransA(H,S_inv,d);
mult(P,d,K);
</syntaxhighlight>

'''SimpleMatrix'''
<syntaxhighlight lang="java">
SimpleMatrix S = H.mult(P).mult(H.transpose()).plus(R);
SimpleMatrix K = P.mult(H.transpose().mult(S.invert()));
</syntaxhighlight>

'''Equations'''
<syntaxhighlight lang="java">
eq.process("K = P*H'*inv( H*P*H' + R )");
</syntaxhighlight>
|}

== Functionality ==

{| class="wikitable" width="650pt" border="1" |
! Data Structures || Operations
|-
| style="vertical-align:top;" |
* Fixed Sized
** Matrix 2x2 to 6x6
** Vector 2 to 6
* Dense Real
** Row-major
** Block
* Dense Complex
** Row-major
* Sparse Real
** Compressed Column

| style="vertical-align:top;" |
* Full support for floats and doubles
* Basic Operators (addition, multiplication, ... )
* Matrix Manipulation (extract, insert, combine, ... )
* Linear Solvers (linear, least squares, incremental, ... )
* Decompositions (LU, QR, Cholesky, SVD, Eigenvalue, ...)
* Matrix Features (rank, symmetric, definitiveness, ... )
* Random Matrices (covariance, orthogonal, symmetric, ... )
* Unit Testing
|}.

{| class="wikitable" width="650pt" border="1" |
! style="width: 40%;" | Decomposition || style="width: 15%;" |Dense Real || style="width: 15%;" |Dense Complex || style="width: 15%;" |Sparse Real || style="width: 15%;" |Sparse Complex
|-
| LU || style="text-align:center;" | X || style="text-align:center;" | X || style="text-align:center;" | X ||
|-
| Cholesky LL || style="text-align:center;" | X || style="text-align:center;" | X || style="text-align:center;" | X ||
|-
| Cholesky LDL || style="text-align:center;" | X || style="text-align:center;" | || ||
|-
| QR || style="text-align:center;" | X || style="text-align:center;" | X || style="text-align:center;" | X ||
|-
| QRP || style="text-align:center;" | X || style="text-align:center;" | || ||
|-
| SVD || style="text-align:center;" | X || style="text-align:center;" | || ||
|-
| Eigen-Symmetric || style="text-align:center;" | X || style="text-align:center;" | || ||
|-
| Eigen-General || style="text-align:center;" | X || style="text-align:center;" | || ||
|}
Support for floats (32-bit) and doubles (64-bit) is available. Sparse matrix support is only available for basic operations at this time.
</center>

Main Page

2021-02-18T02:44:08Z

Peter:

__NOTOC__

<center>
{| style="width:640pt;"
| align="center" |
[[File:Ejml_logo.gif]]
|-
|

Efficient Java Matrix Library (EJML) is a [http://en.wikipedia.org/wiki/Linear_algebra linear algebra] library for manipulating real/complex/dense/sparse matrices. Its design goals are; 1) to be as computationally and memory efficient as possible for small and large, dense and sparse, real and complex matrices, and 2) to be accessible to both novices and experts. These goals are accomplished by dynamically selecting the best algorithms to use at runtime, clean API, and multiple interfaces. EJML is free, written in 100% Java and has been released under an Apache v2.0 license.

EJML has three distinct ways to interact with it: 1) ''procedural'', 2) ''SimpleMatrix'', and 3) ''Equations''. ''Procedure'' provides all capabilities of EJML and almost complete control over memory creation, speed, and specific algorithms. ''SimpleMatrix'' provides a simplified subset of the core capabilities in an easy to use flow styled object-oriented API, inspired by [http://math.nist.gov/javanumerics/jama/ Jama]. ''Equations'' is a symbolic interface, similar in spirit to [http://www.mathworks.com/products/matlab/ Matlab] and other [http://en.wikipedia.org/wiki/Computer_algebra_system CAS], that provides a compact way of writing equations.
|}

{|
| colspan="3" align="center" |
{|style="font-size:120%; text-align:left;"
|-
| '''Version:''' ''v0.40''
|-
| '''Date:''' ''November 4, 2020''
|-
| [https://github.com/lessthanoptimal/ejml/blob/master/convert_to_ejml31.py v0.31 Upgrade Script]
|-
| [https://github.com/lessthanoptimal/ejml/blob/v0.40/change.txt Change Log]
|}
|- valign="top"
| width="220pt" |
{| width="200pt" border="1" align="center" style="font-size:120%; text-align:center; border-collapse:collapse; background-color:#ffffee;"
|-
| [[Download|Download]]
|-
| [[manual|Manual]]
|-
| [http://ejml.org/javadoc/ JavaDoc]
|}
| width="220pt" |
{| width="200pt" border="1" align="center" style="font-size:120%; text-align:center; border-collapse:collapse; background-color:#ffffee;"
|-
| [http://groups.google.com/group/efficient-java-matrix-library-discuss Message Board]
|-
| [https://github.com/lessthanoptimal/ejml/issues Bug Reports]
|-
| [[Frequently Asked Questions|FAQ]]
|-
| [[Kotlin|Kotlin]]
|}
| width="220pt" |
{| width="200pt" border="1" align="center" style="font-size:120%; text-align:center; border-collapse:collapse; background-color:#ffffee;"
|-
| [[Acknowledgments|Acknowledgments]]
|-
| [[Performance|Performance]]
|-
| [[Users|Users]]
|}
|}

== News ==

{| width="500pt" |
| -
|
* Read and write EJML in Matlab format with [https://github.com/HebiRobotics/MFL MFL] from HEBI Robotics
* Graph BLAS continues to be flushed out with masks being added to latest SNAPSHOT
* Concurrency/threading has been added to some operations
|}

== Code Examples ==

Demonstrations on how to compute the Kalman gain "K" using each interface in EJML.

{| width="500pt" |
|-
|
'''Procedural'''
<syntaxhighlight lang="java">
mult(H,P,c);
multTransB(c,H,S);
addEquals(S,R);
if( !invert(S,S_inv) )
throw new RuntimeException("Invert failed");
multTransA(H,S_inv,d);
mult(P,d,K);
</syntaxhighlight>

'''SimpleMatrix'''
<syntaxhighlight lang="java">
SimpleMatrix S = H.mult(P).mult(H.transpose()).plus(R);
SimpleMatrix K = P.mult(H.transpose().mult(S.invert()));
</syntaxhighlight>

'''Equations'''
<syntaxhighlight lang="java">
eq.process("K = P*H'*inv( H*P*H' + R )");
</syntaxhighlight>
|}

== Functionality ==

{| class="wikitable" width="650pt" border="1" |
! Data Structures || Operations
|-
| style="vertical-align:top;" |
* Fixed Sized
** Matrix 2x2 to 6x6
** Vector 2 to 6
* Dense Real
** Row-major
** Block
* Dense Complex
** Row-major
* Sparse Real
** Compressed Column

| style="vertical-align:top;" |
* Full support for floats and doubles
* Basic Operators (addition, multiplication, ... )
* Matrix Manipulation (extract, insert, combine, ... )
* Linear Solvers (linear, least squares, incremental, ... )
* Decompositions (LU, QR, Cholesky, SVD, Eigenvalue, ...)
* Matrix Features (rank, symmetric, definitiveness, ... )
* Random Matrices (covariance, orthogonal, symmetric, ... )
* Unit Testing
|}.

{| class="wikitable" width="650pt" border="1" |
! style="width: 40%;" | Decomposition || style="width: 15%;" |Dense Real || style="width: 15%;" |Dense Complex || style="width: 15%;" |Sparse Real || style="width: 15%;" |Sparse Complex
|-
| LU || style="text-align:center;" | X || style="text-align:center;" | X || style="text-align:center;" | X ||
|-
| Cholesky LL || style="text-align:center;" | X || style="text-align:center;" | X || style="text-align:center;" | X ||
|-
| Cholesky LDL || style="text-align:center;" | X || style="text-align:center;" | || ||
|-
| QR || style="text-align:center;" | X || style="text-align:center;" | X || style="text-align:center;" | X ||
|-
| QRP || style="text-align:center;" | X || style="text-align:center;" | || ||
|-
| SVD || style="text-align:center;" | X || style="text-align:center;" | || ||
|-
| Eigen-Symmetric || style="text-align:center;" | X || style="text-align:center;" | || ||
|-
| Eigen-General || style="text-align:center;" | X || style="text-align:center;" | || ||
|}
Support for floats (32-bit) and doubles (64-bit) is available. Sparse matrix support is only available for basic operations at this time.
</center>

Input and Output

2021-02-18T02:36:55Z

Peter:

EJML provides several different methods for loading, saving, and displaying a matrix. A matrix can be saved and loaded from a file, displayed visually in a window, printed to the console, created from raw arrays or strings.

__TOC__

= Text Output =

A matrix can be printed to standard out using its built in ''print()'' command, this works for both DMatrixRMaj and SimpleMatrix. To create a custom output the user can provide a formatting string that is compatible with printf().

Code:
<syntaxhighlight lang="java">
public static void main( String []args ) {
DMatrixRMaj A = new DMatrixRMaj(2,3,true,1.1,2.34,3.35436,4345,59505,0.00001234);

A.print();
System.out.println();
A.print("%e");
System.out.println();
A.print("%10.2f");
}
</syntaxhighlight>

Output:
<pre>
Type = dense real , numRows = 2 , numCols = 3
1.100 2.340 3.354
4345.000 59505.000 0.000

Type = dense real , numRows = 2 , numCols = 3
1.100000e+00 2.340000e+00 3.354360e+00
4.345000e+03 5.950500e+04 1.234000e-05

Type = dense real , numRows = 2 , numCols = 3
1.10 2.34 3.35
4345.00 59505.00 0.00
</pre>

= CSV Input/Outut =

A Column Space Value (CSV) reader and writer is provided by EJML. The advantage of this file format is that it's human readable, the disadvantage is that its large and slow. Two CSV formats are supported, one where the first line specifies the matrix dimension and the other the user specifies it pro grammatically.

In the example below, the matrix size and type is specified in the first line; row, column, and real/complex. The remainder of the file contains the value of each element in the matrix in a row-major format. A file containing
<pre>
2 3 real
2.4 6.7 9
-2 3 5
</pre>
would describe a real matrix with 2 rows and 3 columns.

DMatrixRMaj Example:
<syntaxhighlight lang="java">
public static void main( String args[] ) {
DMatrixRMaj A = new DMatrixRMaj(2,3,true,new double[]{1,2,3,4,5,6});

try {
MatrixIO.saveCSV(A, "matrix_file.csv");
DMatrixRMaj B = MatrixIO.loadCSV("matrix_file.csv");
B.print();
} catch (IOException e) {
throw new RuntimeException(e);
}
}
</syntaxhighlight>

SimpleMatrix Example:
<syntaxhighlight lang="java">
public static void main( String args[] ) {
SimpleMatrix A = new SimpleMatrix(2,3,true,new double[]{1,2,3,4,5,6});

try {
A.saveToFileCSV("matrix_file.csv");
SimpleMatrix B = SimpleMatrix.loadCSV("matrix_file.csv");
B.print();
} catch (IOException e) {
throw new RuntimeException(e);
}
}
</syntaxhighlight>

= Matlab =

Want to read and write EJML matrices in matlab format? HEBI Robotic's got you covered with their library https://github.com/HebiRobotics/MFL

= Visual Display =

Understanding the state of a matrix from text output can be difficult, especially for large matrices. To help in these situations a visual way of viewing a matrix is provided in DMatrixVisualization. By calling MatrixIO.show() a window will be created that shows the matrix. Positive elements will appear as a shade of red, negative ones as a shade of blue, and zeros as black. How red or blue an element is depends on its magnitude.

Example Code:
<syntaxhighlight lang="java">
public static void main( String args[] ) {
DMatrixRMaj A = new DMatrixRMaj(4,4,true,
0,2,3,4,-2,0,2,3,-3,-2,0,2,-4,-3,-2,0);

MatrixIO.show(A,"Small Matrix");

DMatrixRMaj B = new DMatrixRMaj(25,50);
for( int i = 0; i < 25; i++ )
B.set(i,i,i+1);

MatrixIO.show(B,"Larger Diagonal Matrix");
}
</syntaxhighlight>

Output:
{|
| http://ejml.org/wiki/MY_IMAGES/small_matrix.gif || http://ejml.org/wiki/MY_IMAGES/larger_matrix.gif
|}

= Deprecated =

The binary format which used Java serialization has been deprecated and will be removed in the not to distant future. Basically it's now considered a significant security risk.

https://medium.com/swlh/hacking-java-deserialization-7625c8450334

In the future a new binary format might be provided (you can request this on Github) but for now you can use the Matlab format discussed above.

Capabilities

2021-01-23T16:33:26Z

Peter:

= Linear Algebra Capabilities =

{| class="wikitable"
! !! Dense Real !! Fixed real !! Dense Complex || Sparse Real
|-
| Basic Arithmetic || X || X || X || X
|-
| Element-Wise Ops || X || X || X || X
|-
| Transpose || X || X || X || X
|-
| Determinant || X || X || X || X
|-
| Norm || X || || X || X
|-
| Inverse || X || X || X || X
|-
| Solve m=n || X || || X || X
|-
| Solve m>n || X || || X || X
|-
| LU || X || || X || X
|-
| Cholesky || X || || X || X
|-
| QR || X || || X || X
|-
| QRP || X || || ||
|-
| SVD || X || || ||
|-
| Eigen Symm || X || || ||
|-
| Eigen General || X || || ||
|}

The above table summarizes at a high level the capabilities available by matrix type. To see a complete list of features check out the following classes and factories. Note that the capabilities also vary by which interface you use. See interface specific documentation for that information. Procedural interface supports everything.

{| class="wikitable"
! Ops !! Dense Real !! Fixed real !! Dense Complex || Sparse Real
|-
| CommonOps
| {{OpsDocLink|row/CommonOps_DDRM|X}} || {{OpsDocLink|fixed/CommonOps_DDF3|X}} || {{OpsDocLink|row/CommonOps_ZDRM|X}} || {{SparseLink|csc/CommonOps_DSCC|X}}
|-
| EigenOps
| {{OpsDocLink|row/EigenOps_DDRM|X}} || || ||
|-
| MatrixFeatures
| {{OpsDocLink|row/MatrixFeatures_DDRM|X}} || || {{OpsDocLink|row/MatrixFeatures_ZDRM|X}} || {{SparseLink|csc/MatrixFeatures_DSCC|X}}
|-
| MatrixVisualization
| {{OpsDocLink|row/MatrixVisualization_DDRM|X}} || || ||
|-
| NormOps
| {{OpsDocLink|row/NormOps_DDRM|X}} || || {{OpsDocLink|row/NormOps_ZDRM|X}} || {{SparseLink|csc/NormOps_DSCC|X}}
|-
| RandomMatrices
| {{OpsDocLink|row/RandomMatrices_DDRM|X}} || || {{OpsDocLink|row/RandomMatrices_ZDRM|X}} || {{SparseLink|csc/RandomMatrices_DSCC|X}}
|-
| SingularOps
| {{OpsDocLink|row/SingularOps_DDRM|X}} || || ||
|-
| SpecializedOps
| {{OpsDocLink|row/SpecializedOps_DDRM|X}} || || {{OpsDocLink|row/SpecializedOps_ZDRM|X}} ||
|}

= Other Features =

File IO
Visualization

Template:SparseLink

2021-01-23T16:22:40Z

Peter: Created page with "{{DocLink|org/ejml/sparse/{{{1}}}.html|{{{2}}} }}"

{{DocLink|org/ejml/sparse/{{{1}}}.html|{{{2}}} }}

Template:OpsDocLink

2021-01-23T16:20:05Z

Peter:

{{DocLink|org/ejml/dense/{{{1}}}.html|{{{2}}} }}

Template:OpsDocLink

2021-01-23T16:18:00Z

Peter:

{{DocLink|org/ejml/dense/row/{{{1}}}.html|{{{2}}} }}

Template:OpsDocLink

2021-01-23T16:14:07Z

Peter:

{{DocLink|org/ejml/{{{1}}}.html|{{{2}}} }}

Template:OpsDocLink

2021-01-23T16:11:04Z

Peter:

{{DocLink|org/ejml/{{{2}}}.html|{{{1}}} }}

Capabilities

2021-01-23T16:04:40Z

Peter: /* Linear Algebra Capabilities */

= Linear Algebra Capabilities =

{| class="wikitable"
! !! Dense Real !! Fixed real !! Dense Complex || Sparse Real
|-
| Basic Arithmetic || X || X || X || X
|-
| Element-Wise Ops || X || X || X || X
|-
| Transpose || X || X || X || X
|-
| Determinant || X || X || X || X
|-
| Norm || X || || X || X
|-
| Inverse || X || X || X || X
|-
| Solve m=n || X || || X || X
|-
| Solve m>n || X || || X || X
|-
| LU || X || || X || X
|-
| Cholesky || X || || X || X
|-
| QR || X || || X || X
|-
| QRP || X || || ||
|-
| SVD || X || || ||
|-
| Eigen Symm || X || || ||
|-
| Eigen General || X || || ||
|}

The above table summarizes at a high level the capabilities available by matrix type. To see a complete list of features check out the following classes and factories. Note that the capabilities also vary by which interface you use. See interface specific documentation for that information. Procedural interface supports everything.

{| class="wikitable"
! Dense Real !! Fixed real !! Dense Complex || Sparse Real
|-
| {{OpsDocLink|CommonOps}} || {{DocLink|org/ejml/alg/fixed/FixedOps3.html|FixedOps}} || {{OpsDocLink|CCommonOps}} ||
|-
| {{OpsDocLink|EigenOps}} || ||
|-
| {{OpsDocLink|MatrixFeatures}} || || {{OpsDocLink|CMatrixFeatures}}
|-
| {{OpsDocLink|MatrixVisualization}} || ||
|-
| {{OpsDocLink|NormOps}} || || {{OpsDocLink|CNormOps}}
|-
| {{OpsDocLink|RandomMatrices}} || || {{OpsDocLink|CRandomMatrices}}
|-
| {{OpsDocLink|SingularOps}} || ||
|-
| {{OpsDocLink|SpecializedOps}} || || {{OpsDocLink|CSpecializedOps}}
|}

= Other Features =

File IO
Visualization

Users

2021-01-05T03:55:24Z

Peter:

= Projects which use EJML =

Feel free to add your own project!

* [https://neo4j.com/ Neo4J]'s graph-data-science library.
* [https://www.db.bme.hu/preprints/thesis2018-multidimensional-graph-analysis.pdf Petra Várhegyi's masters thesis on graph analysis]
* [http://wiki.industrial-craft.net Industrial Craft 2] modification for minecraft
* [http://www-lium.univ-lemans.fr/diarization/doku.php/ LIUM_SpkDiarization] is a software dedicated to speaker diarization (ie speaker segmentation and clustering).
* [http://researchers.lille.inria.fr/~freno/JProGraM.html JProGraM]: Library for learning a number of statistical models from data.
* [http://code.google.com/p/gogps/ goGPS]: Improve the positioning accuracy of low-cost GPS devices by RTK technique.
* [http://www-edc.eng.cam.ac.uk/tools/set_visualiser/ Set Visualiser]: Visualises the way that a number of items is classified into one or more categories or sets using Euler diagrams.
* Universal Java Matrix Library (UJML): http://www.ujmp.org/
* Scalalab: http://code.google.com/p/scalalab/
* Java Content Based Image Retrieval (JCBIR): http://code.google.com/p/jcbir/
* JLabGroovy: http://code.google.com/p/jlabgroovy/
* JquantLib (Will be added): http://www.jquantlib.org/
* Matlube: https://github.com/hohonuuli/matlube
* Geometric Regression Library: http://georegression.org/
* BoofCV: Computer Vision Library: http://boofcv.org/
* ICY: bio-imaging: http://www.bioimageanalysis.com/icy/
* JSkills: Java implementation of TrueSkill algorithm https://github.com/nsp/JSkills
* Portfolio applets at http://www.christoph-junge.de/optimizer.php
* Distributed Control Framework (DCF) http://www.i-a-i.com/dcfpro/
* JptView point cloud viewer: http://www.seas.upenn.edu/~aiv/jptview/
* JPrIME Bayesian phylogenetics library: http://code.google.com/p/jprime/
* J-Matrix quantum mechanics scattering https://code.google.com/p/jmatrix/
* DDogleg Numerics: http://ddogleg.org
* Saddle: http://saddle.github.io/doc/index.html
* GDSC ImageJ Plugins: http://www.sussex.ac.uk/gdsc/intranet/microscopy/imagej/gdsc_plugins
* Robot Controller for Humanoid Robots: http://www.ihmc.us/Research/projects/HumanoidRobots/index.html
* Credit Analytics: http://code.google.com/p/creditanalytics
* Spline Library: http://code.google.com/p/splinelibrary - http://www.credit-trader.org/CreditSuite/docs/SplineLibrary_2.2.pdf
* Fixed Point Finder: http://code.google.com/p/rootfinder - http://www.credit-trader.org/CreditSuite/docs/FixedPointFinder_2.2.pdf
* Sensitivity generation scheme in Credit Analytics: http://www.credit-trader.org/CreditSuite/docs/SensitivityGenerator_2.2.pdf
* Stanford CoreNLP: A set of natural language analysis tools: http://nlp.stanford.edu/software/corenlp.shtml
* OpenChrom: Open source software for the mass spectrometric analysis of chromatographic data. https://www.openchrom.net

= Papers That Cite EJML =
* A ton of [https://scholar.google.com/scholar?q=%22efficient+java+matrix+library%22&hl=en&as_sdt=0,5 academic papers]
* Zewdie, Dawit Dawit Habtamu. "Representation discovery in non-parametric reinforcement learning." Diss. Massachusetts Institute of Technology, 2014.
* Sanfilippo, Filippo, et al. "A mapping approach for controlling different maritime cranes and robots using ANN." Mechatronics and Automation (ICMA), 2014 IEEE International Conference on. IEEE, 2014.
* Kushman, Nate, et al. "Learning to automatically solve algebra word problems." ACL (1) (2014): 271-281.
* Stergios Papadimitriou, Seferina Mavroudi, Kostas Theofilatos, and Spiridon Likothanasis, “MATLAB-Like Scripting of Java Scientific Libraries in ScalaLab,” Scientific Programming, vol. 22, no. 3, pp. 187-199, 2014.
* Alberto Castellini, Daniele Paltrinieri, and Vincenzo Manca "MP-GeneticSynth: Inferring Biological Network Regulations from Time Series" Bioinformatics 2014
* Blasinski, H., Bulan, O., & Sharma, G. (2013). Per-Colorant-Channel Color Barcodes for Mobile Applications: An Interference Cancellation Framework.
* Marin, R. C., & Dobre, C. (2013, November). Reaching for the clouds: contextually enhancing smartphones for energy efficiency. In Proceedings of the 2nd ACM workshop on High performance mobile opportunistic systems (pp. 31-38). ACM.
* Oletic, D., Skrapec, M., & Bilas, V. (2013). Monitoring Respiratory Sounds: Compressed Sensing Reconstruction via OMP on Android Smartphone. In Wireless Mobile Communication and Healthcare (pp. 114-121). Springer Berlin Heidelberg.
* Santhiar, Anirudh and Pandita, Omesh and Kanade, Aditya "Discovering Math APIs by Mining Unit Tests" Fundamental Approaches to Software Engineering 2013
* Sanjay K. Boddhu, Robert L. Williams, Edward Wasser, Niranjan Kode, "Increasing Situational Awareness using Smartphones" Proc. SPIE 8389, Ground/Air Multisensor Interoperability, Integration, and Networking for Persistent ISR III, 83891J (May 1, 2012)
* J. A. Álvarez-Bermejo, N. Antequera, R. García-Rubio and J. A. López-Ramos, _"A scalable server for key distribution and its application to accounting,"_ The Journal of Supercomputing, 2012
* Realini E., Yoshida D., Reguzzoni M., Raghavan V., _"Enhanced satellite positioning as a web service with goGPS open source software"_. Applied Geomatics 4(2), 135-142. 2012
* Stergios Papadimitriou, Constantinos Terzidis, Seferina Mavroudi, Spiridon D. Likothanassis: _Exploiting java scientific libraries with the scala language within the scalalab environment._ IET Software 5(6): 543-551 (2011)
* L. T. Lim, B. Ranaivo-Malançon and E. K. Tang. _“Symbiosis Between a Multilingual Lexicon and Translation Example Banks”._ In: Procedia: Social and Behavioral Sciences 27 (2011), pp. 61–69.
* G. Taboada, S. Ramos, R. Expósito, J. Touriño, R. Doallo, _Java in the High Performance Computing arena: Research, practice and experience,_ Science of Computer Programming, 2011.
* http://geomatica.como.polimi.it/presentazioni/Osaka_Summer_goGPS.pdf
* http://www.holger-arndt.de/library/MLOSS2010.pdf
* http://www.ateji.com/px/whitepapers/Ateji%20PX%20MatMult%20Whitepaper%20v1.2.pdf

Note: Slowly working on an EJML paper for publication. About 1/2 way through a first draft.

= On The Web =
* https://softwarerecs.stackexchange.com/questions/51330/sparse-matrix-library-for-java
* https://lessthanoptimal.github.io/Java-Matrix-Benchmark/
* http://java.dzone.com/announcements/introduction-efficient-java
* https://shakthydoss.wordpress.com/2011/01/13/jama-shortcoming/
* Various questions on stackoverflow.com

Users

2020-12-23T11:54:25Z

Peter:

= Projects which use EJML =

Feel free to add your own project!

* A ton of [https://scholar.google.com/scholar?q=%22efficient+java+matrix+library%22&hl=en&as_sdt=0,5 academic papers]
* [https://www.db.bme.hu/preprints/thesis2018-multidimensional-graph-analysis.pdf Petra Várhegyi's masters thesis on graph analysis]
* [http://wiki.industrial-craft.net Industrial Craft 2] modification for minecraft
* [http://www-lium.univ-lemans.fr/diarization/doku.php/ LIUM_SpkDiarization] is a software dedicated to speaker diarization (ie speaker segmentation and clustering).
* [http://researchers.lille.inria.fr/~freno/JProGraM.html JProGraM]: Library for learning a number of statistical models from data.
* [http://code.google.com/p/gogps/ goGPS]: Improve the positioning accuracy of low-cost GPS devices by RTK technique.
* [http://www-edc.eng.cam.ac.uk/tools/set_visualiser/ Set Visualiser]: Visualises the way that a number of items is classified into one or more categories or sets using Euler diagrams.
* Universal Java Matrix Library (UJML): http://www.ujmp.org/
* Scalalab: http://code.google.com/p/scalalab/
* Java Content Based Image Retrieval (JCBIR): http://code.google.com/p/jcbir/
* JLabGroovy: http://code.google.com/p/jlabgroovy/
* JquantLib (Will be added): http://www.jquantlib.org/
* Matlube: https://github.com/hohonuuli/matlube
* Geometric Regression Library: http://georegression.org/
* BoofCV: Computer Vision Library: http://boofcv.org/
* ICY: bio-imaging: http://www.bioimageanalysis.com/icy/
* JSkills: Java implementation of TrueSkill algorithm https://github.com/nsp/JSkills
* Portfolio applets at http://www.christoph-junge.de/optimizer.php
* Distributed Control Framework (DCF) http://www.i-a-i.com/dcfpro/
* JptView point cloud viewer: http://www.seas.upenn.edu/~aiv/jptview/
* JPrIME Bayesian phylogenetics library: http://code.google.com/p/jprime/
* J-Matrix quantum mechanics scattering https://code.google.com/p/jmatrix/
* DDogleg Numerics: http://ddogleg.org
* Saddle: http://saddle.github.io/doc/index.html
* GDSC ImageJ Plugins: http://www.sussex.ac.uk/gdsc/intranet/microscopy/imagej/gdsc_plugins
* Robot Controller for Humanoid Robots: http://www.ihmc.us/Research/projects/HumanoidRobots/index.html
* Credit Analytics: http://code.google.com/p/creditanalytics
* Spline Library: http://code.google.com/p/splinelibrary - http://www.credit-trader.org/CreditSuite/docs/SplineLibrary_2.2.pdf
* Fixed Point Finder: http://code.google.com/p/rootfinder - http://www.credit-trader.org/CreditSuite/docs/FixedPointFinder_2.2.pdf
* Sensitivity generation scheme in Credit Analytics: http://www.credit-trader.org/CreditSuite/docs/SensitivityGenerator_2.2.pdf
* Stanford CoreNLP: A set of natural language analysis tools: http://nlp.stanford.edu/software/corenlp.shtml
* OpenChrom: Open source software for the mass spectrometric analysis of chromatographic data. https://www.openchrom.net

= Papers That Cite EJML =
* Zewdie, Dawit Dawit Habtamu. "Representation discovery in non-parametric reinforcement learning." Diss. Massachusetts Institute of Technology, 2014.
* Sanfilippo, Filippo, et al. "A mapping approach for controlling different maritime cranes and robots using ANN." Mechatronics and Automation (ICMA), 2014 IEEE International Conference on. IEEE, 2014.
* Kushman, Nate, et al. "Learning to automatically solve algebra word problems." ACL (1) (2014): 271-281.
* Stergios Papadimitriou, Seferina Mavroudi, Kostas Theofilatos, and Spiridon Likothanasis, “MATLAB-Like Scripting of Java Scientific Libraries in ScalaLab,” Scientific Programming, vol. 22, no. 3, pp. 187-199, 2014.
* Alberto Castellini, Daniele Paltrinieri, and Vincenzo Manca "MP-GeneticSynth: Inferring Biological Network Regulations from Time Series" Bioinformatics 2014
* Blasinski, H., Bulan, O., & Sharma, G. (2013). Per-Colorant-Channel Color Barcodes for Mobile Applications: An Interference Cancellation Framework.
* Marin, R. C., & Dobre, C. (2013, November). Reaching for the clouds: contextually enhancing smartphones for energy efficiency. In Proceedings of the 2nd ACM workshop on High performance mobile opportunistic systems (pp. 31-38). ACM.
* Oletic, D., Skrapec, M., & Bilas, V. (2013). Monitoring Respiratory Sounds: Compressed Sensing Reconstruction via OMP on Android Smartphone. In Wireless Mobile Communication and Healthcare (pp. 114-121). Springer Berlin Heidelberg.
* Santhiar, Anirudh and Pandita, Omesh and Kanade, Aditya "Discovering Math APIs by Mining Unit Tests" Fundamental Approaches to Software Engineering 2013
* Sanjay K. Boddhu, Robert L. Williams, Edward Wasser, Niranjan Kode, "Increasing Situational Awareness using Smartphones" Proc. SPIE 8389, Ground/Air Multisensor Interoperability, Integration, and Networking for Persistent ISR III, 83891J (May 1, 2012)
* J. A. Álvarez-Bermejo, N. Antequera, R. García-Rubio and J. A. López-Ramos, _"A scalable server for key distribution and its application to accounting,"_ The Journal of Supercomputing, 2012
* Realini E., Yoshida D., Reguzzoni M., Raghavan V., _"Enhanced satellite positioning as a web service with goGPS open source software"_. Applied Geomatics 4(2), 135-142. 2012
* Stergios Papadimitriou, Constantinos Terzidis, Seferina Mavroudi, Spiridon D. Likothanassis: _Exploiting java scientific libraries with the scala language within the scalalab environment._ IET Software 5(6): 543-551 (2011)
* L. T. Lim, B. Ranaivo-Malançon and E. K. Tang. _“Symbiosis Between a Multilingual Lexicon and Translation Example Banks”._ In: Procedia: Social and Behavioral Sciences 27 (2011), pp. 61–69.
* G. Taboada, S. Ramos, R. Expósito, J. Touriño, R. Doallo, _Java in the High Performance Computing arena: Research, practice and experience,_ Science of Computer Programming, 2011.
* http://geomatica.como.polimi.it/presentazioni/Osaka_Summer_goGPS.pdf
* http://www.holger-arndt.de/library/MLOSS2010.pdf
* http://www.ateji.com/px/whitepapers/Ateji%20PX%20MatMult%20Whitepaper%20v1.2.pdf

Note: Slowly working on an EJML paper for publication. About 1/2 way through a first draft.

= On The Web =
* https://softwarerecs.stackexchange.com/questions/51330/sparse-matrix-library-for-java
* https://lessthanoptimal.github.io/Java-Matrix-Benchmark/
* http://java.dzone.com/announcements/introduction-efficient-java
* https://shakthydoss.wordpress.com/2011/01/13/jama-shortcoming/
* Various questions on stackoverflow.com

Users

2020-12-23T11:50:28Z

Peter:

= Projects which use EJML =

Feel free to add your own project!

* [https://www.db.bme.hu/preprints/thesis2018-multidimensional-graph-analysis.pdf Petra Várhegyi's masters thesis on graph analysis]
* [http://wiki.industrial-craft.net Industrial Craft 2] modification for minecraft
* [http://www-lium.univ-lemans.fr/diarization/doku.php/ LIUM_SpkDiarization] is a software dedicated to speaker diarization (ie speaker segmentation and clustering).
* [http://researchers.lille.inria.fr/~freno/JProGraM.html JProGraM]: Library for learning a number of statistical models from data.
* [http://code.google.com/p/gogps/ goGPS]: Improve the positioning accuracy of low-cost GPS devices by RTK technique.
* [http://www-edc.eng.cam.ac.uk/tools/set_visualiser/ Set Visualiser]: Visualises the way that a number of items is classified into one or more categories or sets using Euler diagrams.
* Universal Java Matrix Library (UJML): http://www.ujmp.org/
* Scalalab: http://code.google.com/p/scalalab/
* Java Content Based Image Retrieval (JCBIR): http://code.google.com/p/jcbir/
* JLabGroovy: http://code.google.com/p/jlabgroovy/
* JquantLib (Will be added): http://www.jquantlib.org/
* Matlube: https://github.com/hohonuuli/matlube
* Geometric Regression Library: http://georegression.org/
* BoofCV: Computer Vision Library: http://boofcv.org/
* ICY: bio-imaging: http://www.bioimageanalysis.com/icy/
* JSkills: Java implementation of TrueSkill algorithm https://github.com/nsp/JSkills
* Portfolio applets at http://www.christoph-junge.de/optimizer.php
* Distributed Control Framework (DCF) http://www.i-a-i.com/dcfpro/
* JptView point cloud viewer: http://www.seas.upenn.edu/~aiv/jptview/
* JPrIME Bayesian phylogenetics library: http://code.google.com/p/jprime/
* J-Matrix quantum mechanics scattering https://code.google.com/p/jmatrix/
* DDogleg Numerics: http://ddogleg.org
* Saddle: http://saddle.github.io/doc/index.html
* GDSC ImageJ Plugins: http://www.sussex.ac.uk/gdsc/intranet/microscopy/imagej/gdsc_plugins
* Robot Controller for Humanoid Robots: http://www.ihmc.us/Research/projects/HumanoidRobots/index.html
* Credit Analytics: http://code.google.com/p/creditanalytics
* Spline Library: http://code.google.com/p/splinelibrary - http://www.credit-trader.org/CreditSuite/docs/SplineLibrary_2.2.pdf
* Fixed Point Finder: http://code.google.com/p/rootfinder - http://www.credit-trader.org/CreditSuite/docs/FixedPointFinder_2.2.pdf
* Sensitivity generation scheme in Credit Analytics: http://www.credit-trader.org/CreditSuite/docs/SensitivityGenerator_2.2.pdf
* Stanford CoreNLP: A set of natural language analysis tools: http://nlp.stanford.edu/software/corenlp.shtml
* OpenChrom: Open source software for the mass spectrometric analysis of chromatographic data. https://www.openchrom.net

= Papers That Cite EJML =
* Zewdie, Dawit Dawit Habtamu. "Representation discovery in non-parametric reinforcement learning." Diss. Massachusetts Institute of Technology, 2014.
* Sanfilippo, Filippo, et al. "A mapping approach for controlling different maritime cranes and robots using ANN." Mechatronics and Automation (ICMA), 2014 IEEE International Conference on. IEEE, 2014.
* Kushman, Nate, et al. "Learning to automatically solve algebra word problems." ACL (1) (2014): 271-281.
* Stergios Papadimitriou, Seferina Mavroudi, Kostas Theofilatos, and Spiridon Likothanasis, “MATLAB-Like Scripting of Java Scientific Libraries in ScalaLab,” Scientific Programming, vol. 22, no. 3, pp. 187-199, 2014.
* Alberto Castellini, Daniele Paltrinieri, and Vincenzo Manca "MP-GeneticSynth: Inferring Biological Network Regulations from Time Series" Bioinformatics 2014
* Blasinski, H., Bulan, O., & Sharma, G. (2013). Per-Colorant-Channel Color Barcodes for Mobile Applications: An Interference Cancellation Framework.
* Marin, R. C., & Dobre, C. (2013, November). Reaching for the clouds: contextually enhancing smartphones for energy efficiency. In Proceedings of the 2nd ACM workshop on High performance mobile opportunistic systems (pp. 31-38). ACM.
* Oletic, D., Skrapec, M., & Bilas, V. (2013). Monitoring Respiratory Sounds: Compressed Sensing Reconstruction via OMP on Android Smartphone. In Wireless Mobile Communication and Healthcare (pp. 114-121). Springer Berlin Heidelberg.
* Santhiar, Anirudh and Pandita, Omesh and Kanade, Aditya "Discovering Math APIs by Mining Unit Tests" Fundamental Approaches to Software Engineering 2013
* Sanjay K. Boddhu, Robert L. Williams, Edward Wasser, Niranjan Kode, "Increasing Situational Awareness using Smartphones" Proc. SPIE 8389, Ground/Air Multisensor Interoperability, Integration, and Networking for Persistent ISR III, 83891J (May 1, 2012)
* J. A. Álvarez-Bermejo, N. Antequera, R. García-Rubio and J. A. López-Ramos, _"A scalable server for key distribution and its application to accounting,"_ The Journal of Supercomputing, 2012
* Realini E., Yoshida D., Reguzzoni M., Raghavan V., _"Enhanced satellite positioning as a web service with goGPS open source software"_. Applied Geomatics 4(2), 135-142. 2012
* Stergios Papadimitriou, Constantinos Terzidis, Seferina Mavroudi, Spiridon D. Likothanassis: _Exploiting java scientific libraries with the scala language within the scalalab environment._ IET Software 5(6): 543-551 (2011)
* L. T. Lim, B. Ranaivo-Malançon and E. K. Tang. _“Symbiosis Between a Multilingual Lexicon and Translation Example Banks”._ In: Procedia: Social and Behavioral Sciences 27 (2011), pp. 61–69.
* G. Taboada, S. Ramos, R. Expósito, J. Touriño, R. Doallo, _Java in the High Performance Computing arena: Research, practice and experience,_ Science of Computer Programming, 2011.
* http://geomatica.como.polimi.it/presentazioni/Osaka_Summer_goGPS.pdf
* http://www.holger-arndt.de/library/MLOSS2010.pdf
* http://www.ateji.com/px/whitepapers/Ateji%20PX%20MatMult%20Whitepaper%20v1.2.pdf

Note: Slowly working on an EJML paper for publication. About 1/2 way through a first draft.

= On The Web =
* https://softwarerecs.stackexchange.com/questions/51330/sparse-matrix-library-for-java
* https://lessthanoptimal.github.io/Java-Matrix-Benchmark/
* http://java.dzone.com/announcements/introduction-efficient-java
* https://shakthydoss.wordpress.com/2011/01/13/jama-shortcoming/
* Various questions on stackoverflow.com

Main Page

2020-11-05T05:37:12Z

Peter:

__NOTOC__

<center>
{| style="width:640pt;"
| align="center" |
[[File:Ejml_logo.gif]]
|-
|

Efficient Java Matrix Library (EJML) is a [http://en.wikipedia.org/wiki/Linear_algebra linear algebra] library for manipulating real/complex/dense/sparse matrices. Its design goals are; 1) to be as computationally and memory efficient as possible for small and large, dense and sparse, real and complex matrices, and 2) to be accessible to both novices and experts. These goals are accomplished by dynamically selecting the best algorithms to use at runtime, clean API, and multiple interfaces. EJML is free, written in 100% Java and has been released under an Apache v2.0 license.

EJML has three distinct ways to interact with it: 1) ''procedural'', 2) ''SimpleMatrix'', and 3) ''Equations''. ''Procedure'' provides all capabilities of EJML and almost complete control over memory creation, speed, and specific algorithms. ''SimpleMatrix'' provides a simplified subset of the core capabilities in an easy to use flow styled object-oriented API, inspired by [http://math.nist.gov/javanumerics/jama/ Jama]. ''Equations'' is a symbolic interface, similar in spirit to [http://www.mathworks.com/products/matlab/ Matlab] and other [http://en.wikipedia.org/wiki/Computer_algebra_system CAS], that provides a compact way of writing equations.
|}

{|
| colspan="3" align="center" |
{|style="font-size:120%; text-align:left;"
|-
| '''Version:''' ''v0.40''
|-
| '''Date:''' ''November 4, 2020''
|-
| [https://github.com/lessthanoptimal/ejml/blob/master/convert_to_ejml31.py v0.31 Upgrade Script]
|-
| [https://github.com/lessthanoptimal/ejml/blob/v0.40/change.txt Change Log]
|}
|- valign="top"
| width="220pt" |
{| width="200pt" border="1" align="center" style="font-size:120%; text-align:center; border-collapse:collapse; background-color:#ffffee;"
|-
| [[Download|Download]]
|-
| [[manual|Manual]]
|-
| [http://ejml.org/javadoc/ JavaDoc]
|}
| width="220pt" |
{| width="200pt" border="1" align="center" style="font-size:120%; text-align:center; border-collapse:collapse; background-color:#ffffee;"
|-
| [http://groups.google.com/group/efficient-java-matrix-library-discuss Message Board]
|-
| [https://github.com/lessthanoptimal/ejml/issues Bug Reports]
|-
| [[Frequently Asked Questions|FAQ]]
|-
| [[Kotlin|Kotlin]]
|}
| width="220pt" |
{| width="200pt" border="1" align="center" style="font-size:120%; text-align:center; border-collapse:collapse; background-color:#ffffee;"
|-
| [[Acknowledgments|Acknowledgments]]
|-
| [[Performance|Performance]]
|-
| [[Users|Users]]
|}
|}

== Code Examples ==

Demonstrations on how to compute the Kalman gain "K" using each interface in EJML.

{| width="500pt" |
|-
|
'''Procedural'''
<syntaxhighlight lang="java">
mult(H,P,c);
multTransB(c,H,S);
addEquals(S,R);
if( !invert(S,S_inv) )
throw new RuntimeException("Invert failed");
multTransA(H,S_inv,d);
mult(P,d,K);
</syntaxhighlight>

'''SimpleMatrix'''
<syntaxhighlight lang="java">
SimpleMatrix S = H.mult(P).mult(H.transpose()).plus(R);
SimpleMatrix K = P.mult(H.transpose().mult(S.invert()));
</syntaxhighlight>

'''Equations'''
<syntaxhighlight lang="java">
eq.process("K = P*H'*inv( H*P*H' + R )");
</syntaxhighlight>
|}

== Functionality ==

{| class="wikitable" width="650pt" border="1" |
! Data Structures || Operations
|-
| style="vertical-align:top;" |
* Fixed Sized
** Matrix 2x2 to 6x6
** Vector 2 to 6
* Dense Real
** Row-major
** Block
* Dense Complex
** Row-major
* Sparse Real
** Compressed Column

| style="vertical-align:top;" |
* Full support for floats and doubles
* Basic Operators (addition, multiplication, ... )
* Matrix Manipulation (extract, insert, combine, ... )
* Linear Solvers (linear, least squares, incremental, ... )
* Decompositions (LU, QR, Cholesky, SVD, Eigenvalue, ...)
* Matrix Features (rank, symmetric, definitiveness, ... )
* Random Matrices (covariance, orthogonal, symmetric, ... )
* Unit Testing
|}.

{| class="wikitable" width="650pt" border="1" |
! style="width: 40%;" | Decomposition || style="width: 15%;" |Dense Real || style="width: 15%;" |Dense Complex || style="width: 15%;" |Sparse Real || style="width: 15%;" |Sparse Complex
|-
| LU || style="text-align:center;" | X || style="text-align:center;" | X || style="text-align:center;" | X ||
|-
| Cholesky LL || style="text-align:center;" | X || style="text-align:center;" | X || style="text-align:center;" | X ||
|-
| Cholesky LDL || style="text-align:center;" | X || style="text-align:center;" | || ||
|-
| QR || style="text-align:center;" | X || style="text-align:center;" | X || style="text-align:center;" | X ||
|-
| QRP || style="text-align:center;" | X || style="text-align:center;" | || ||
|-
| SVD || style="text-align:center;" | X || style="text-align:center;" | || ||
|-
| Eigen-Symmetric || style="text-align:center;" | X || style="text-align:center;" | || ||
|-
| Eigen-General || style="text-align:center;" | X || style="text-align:center;" | || ||
|}
Support for floats (32-bit) and doubles (64-bit) is available. Sparse matrix support is only available for basic operations at this time.

EJML is currently a single threaded library only. Multi threaded work will start once block implementations of SVD and Eigenvalue are finished.
</center>

Download

2020-11-05T05:33:43Z

Peter:

== Source Code ==

Source code is hosted on Github. There you can access the absolute bleeding edge code. Most of the time it is in an usable state, but not always!

[https://github.com/lessthanoptimal/ejml https://github.com/lessthanoptimal/ejml]

The command to clone it is:

<syntaxhighlight lang="groovy">
git clone https://github.com/lessthanoptimal/ejml.git
</syntaxhighlight>

Current status of developmental code:

[https://travis-ci.org/lessthanoptimal/ejml https://api.travis-ci.org/lessthanoptimal/ejml.png]

== Download ==

Jars of the latest stable release can be found on Source Forge using the following link: [https://sourceforge.net/projects/ejml/files/v0.40/ EJML Downloads]

== Gradle and Maven ==

EJML is broken up into several packages (see list below) and including each individually can be tedious. To include all the packages simply reference "all", as is shown below:

Gradle:
<syntaxhighlight lang="groovy">
compile group: 'org.ejml', name: 'ejml-all', version: '0.40'
</syntaxhighlight>

Maven:
<syntaxhighlight lang="xml">
<dependency>
<groupId>org.ejml</groupId>
<artifactId>ejml-all</artifactId>
<version>0.40</version>
</dependency>
</syntaxhighlight>

Individual modules:

{| class="wikitable"
! Module Name !! Description
|-
| ejml-all || All the modules
|-
| ejml-ddense || Dense Real Double Matrices
|-
| ejml-fdense || Dense Real Float Matrices
|-
| ejml-zdense || Dense Complex Double Matrices
|-
| ejml-cdense || Dense Complex Float Matrices
|-
| ejml-simple || SimpleMatrix and Equations
|-
| ejml-dsparse || Sparse Real Double Matrices
|-
| ejml-fsparse || Sparse Real Float Matrices
|}

Main Page

2020-11-05T05:31:26Z

Peter:

__NOTOC__

<center>
{| style="width:640pt;"
| align="center" |
[[File:Ejml_logo.gif]]
|-
|

Efficient Java Matrix Library (EJML) is a [http://en.wikipedia.org/wiki/Linear_algebra linear algebra] library for manipulating real/complex/dense/sparse matrices. Its design goals are; 1) to be as computationally and memory efficient as possible for both small and large matrices, and 2) to be accessible to both novices and experts. These goals are accomplished by dynamically selecting the best algorithms to use at runtime, clean API, and multiple interfaces. EJML is free, written in 100% Java and has been released under an Apache v2.0 license.

EJML has three distinct ways to interact with it: 1) ''procedural'', 2) ''SimpleMatrix'', and 3) ''Equations''. ''Procedure'' provides all capabilities of EJML and almost complete control over memory creation, speed, and specific algorithms. ''SimpleMatrix'' provides a simplified subset of the core capabilities in an easy to use flow styled object-oriented API, inspired by [http://math.nist.gov/javanumerics/jama/ Jama]. ''Equations'' is a symbolic interface, similar in spirit to [http://www.mathworks.com/products/matlab/ Matlab] and other [http://en.wikipedia.org/wiki/Computer_algebra_system CAS], that provides a compact way of writing equations.
|}

{|
| colspan="3" align="center" |
{|style="font-size:120%; text-align:left;"
|-
| '''Version:''' ''v0.40''
|-
| '''Date:''' ''November 4, 2020''
|-
| [https://github.com/lessthanoptimal/ejml/blob/master/convert_to_ejml31.py v0.31 Upgrade Script]
|-
| [https://github.com/lessthanoptimal/ejml/blob/v0.40/change.txt Change Log]
|}
|- valign="top"
| width="220pt" |
{| width="200pt" border="1" align="center" style="font-size:120%; text-align:center; border-collapse:collapse; background-color:#ffffee;"
|-
| [[Download|Download]]
|-
| [[manual|Manual]]
|-
| [http://ejml.org/javadoc/ JavaDoc]
|}
| width="220pt" |
{| width="200pt" border="1" align="center" style="font-size:120%; text-align:center; border-collapse:collapse; background-color:#ffffee;"
|-
| [http://groups.google.com/group/efficient-java-matrix-library-discuss Message Board]
|-
| [https://github.com/lessthanoptimal/ejml/issues Bug Reports]
|-
| [[Frequently Asked Questions|FAQ]]
|-
| [[Kotlin|Kotlin]]
|}
| width="220pt" |
{| width="200pt" border="1" align="center" style="font-size:120%; text-align:center; border-collapse:collapse; background-color:#ffffee;"
|-
| [[Acknowledgments|Acknowledgments]]
|-
| [[Performance|Performance]]
|-
| [[Users|Users]]
|}
|}

== Code Examples ==

Demonstrations on how to compute the Kalman gain "K" using each interface in EJML.

{| width="500pt" |
|-
|
'''Procedural'''
<syntaxhighlight lang="java">
mult(H,P,c);
multTransB(c,H,S);
addEquals(S,R);
if( !invert(S,S_inv) )
throw new RuntimeException("Invert failed");
multTransA(H,S_inv,d);
mult(P,d,K);
</syntaxhighlight>

'''SimpleMatrix'''
<syntaxhighlight lang="java">
SimpleMatrix S = H.mult(P).mult(H.transpose()).plus(R);
SimpleMatrix K = P.mult(H.transpose().mult(S.invert()));
</syntaxhighlight>

'''Equations'''
<syntaxhighlight lang="java">
eq.process("K = P*H'*inv( H*P*H' + R )");
</syntaxhighlight>
|}

== Functionality ==

{| class="wikitable" width="650pt" border="1" |
! Data Structures || Operations
|-
| style="vertical-align:top;" |
* Fixed Sized
** Matrix 2x2 to 6x6
** Vector 2 to 6
* Dense Real
** Row-major
** Block
* Dense Complex
** Row-major
* Sparse Real
** Compressed Column

| style="vertical-align:top;" |
* Full support for floats and doubles
* Basic Operators (addition, multiplication, ... )
* Matrix Manipulation (extract, insert, combine, ... )
* Linear Solvers (linear, least squares, incremental, ... )
* Decompositions (LU, QR, Cholesky, SVD, Eigenvalue, ...)
* Matrix Features (rank, symmetric, definitiveness, ... )
* Random Matrices (covariance, orthogonal, symmetric, ... )
* Unit Testing
|}.

{| class="wikitable" width="650pt" border="1" |
! style="width: 40%;" | Decomposition || style="width: 15%;" |Dense Real || style="width: 15%;" |Dense Complex || style="width: 15%;" |Sparse Real || style="width: 15%;" |Sparse Complex
|-
| LU || style="text-align:center;" | X || style="text-align:center;" | X || style="text-align:center;" | X ||
|-
| Cholesky LL || style="text-align:center;" | X || style="text-align:center;" | X || style="text-align:center;" | X ||
|-
| Cholesky LDL || style="text-align:center;" | X || style="text-align:center;" | || ||
|-
| QR || style="text-align:center;" | X || style="text-align:center;" | X || style="text-align:center;" | X ||
|-
| QRP || style="text-align:center;" | X || style="text-align:center;" | || ||
|-
| SVD || style="text-align:center;" | X || style="text-align:center;" | || ||
|-
| Eigen-Symmetric || style="text-align:center;" | X || style="text-align:center;" | || ||
|-
| Eigen-General || style="text-align:center;" | X || style="text-align:center;" | || ||
|}
Support for floats (32-bit) and doubles (64-bit) is available. Sparse matrix support is only available for basic operations at this time.

EJML is currently a single threaded library only. Multi threaded work will start once block implementations of SVD and Eigenvalue are finished.
</center>