Fork me on GitHub

What's in it?

Linear Algebra
Mathematical Programming
Modern Portfolio Theory

Support & Services
BLaadin Edge

Change Log

Do NOT use anything deprecated - it will be removed very soon! Most of what was deprecated at the time of the last release has already been removed. Removing something that was already deprecated is not mentioned in the change log. If you're lagging behind and need to update over several versions it is recommended that you upgrade incrementally to each intermediate version (and finally to the latest snapshot).

About the version numbers: You should not think of a ".1" version as v66 with only a small number of minor changes. v66.1 is probably already closer to v67 than it is to v66.

All versions ever released have a tag/version in CVS
Release Version CVS tag/version
1 jar_1_0
2 jar_2
3 - 31 Version3, Version4, Version5 ... Version31
32 - v32, v33, v34...

v38 (not yet released; corresponds to the latest snapshot)

The first version to require Java 8!

  • org.ojalgo.array.*
  • org.ojalgo.concurrent.*
    • Stopped using fork-join (directly) and reverted back to code/structure used before switching to Java 7 (v34). If you've directly referenced this package the changes are (probably) api-breaking.
  • org.ojalgo.function.*
    • Refactored the existing interfaces and classes in this package to implement/extends as much as possible from the java.util.function package. Several abstract classases were converted to interfaces utilising default methods.

v37 (latest release)

Last version to not require Java 8! (Targets Java 7) No real new features compared to v36.



  • org.ojalgo.access.*

    Just about everything in ojAlgo implements one or more of the interfaces in this package - these changes affect everything.

    • The methods size(), getRowDim(), getColDim() and size(int) are deprecated and replaced with count(), countRows(), countColumns() and count(int) respectively. The new methods return long rather than int.
    • Most/all methods in the various supplementary interfaces in this package now take long rather than int arguments.
    • The Factory*D, Builder*D and Modify*D interfaces are renamed and moved to be inner interfaces of Access1D, Access2D and AccessAnyD. Each of those interfaces now has inner interfaces named Builder and Factory as well as Elements, Fillable, Modifiable and Visitable.

    There are 3 reasons for making these changes:

    1. The general change from int to long allows for much larger structures
    2. The new/altered method names are better. ( Does getRowDim() return the number of rows or the dimension of a row? )
    3. These changes differentiates the interfaces in this package from the java collections api.
  • org.ojalgo.array.*
  • org.ojalgo.concurrent.*
  • org.ojalgo.function.*
  • org.ojalgo.machine.*
  • org.ojalgo.matrix.*
  • org.ojalgo.optimiation.*
    • The package org.ojalgo.optimisation.linear.mps has been moved/renamed org.ojalgo.optimisation.mps.
    • The Optimisation.Options option solution has been split in to; solution, objective and integer. Check the javadoc for descriptions of what they do.
    • The presolve functionality of ExpressionsBasedModel has been improved.
    • Refactoring and improvements to the IntegerSolver.
    • All models and model entities now have a destroy() method that clears/nullifies the internal data structures to help garbage collection.
    • The solve() method of ExpressionsBasedModel no longer writes the solver's solution back to the model's variables. If you want that to happen you should instead use minimise() or maximise().
  • org.ojalgo.scalar.*
    • The methods hashCode() and equals(Object) are re-implemented. There used to be common methods (in an abstract superclass) used by all Scalar implementors. Now each implemenation class has its own type-specific version of those methods.
    • The implementation logic of isAbsolute(), isPositive(), isReal... are now factored out into static methods available to other parts of ojAlgo without actually creating Scalar instances.
    • There is now a Scalar.Factory interface and each of the Scalar implementation has a public static FACTORY field. The PhysicalStore.Factory used to have set of methods related to scalars. These are now replaced by a method that returns a Scalar.Factory instance.
    • The enforce(NumberContext) and round(NumberContext) methods have been removed from the Scalar interface. Instead each of the implementations implement the new NumberContext.Enforceable interface.
    • There is a new Scalar implementation Quaternion.
    • The methods getReal(), getImaginary(), getModulus() and getArgument() have been removed from the interface Scalar and all the implementations except (of course) ComplexNumber. There is instead a new method norm() to replace getModulus() and compliment the already existing signum().
    • The methods toComplexNumber() and toRationalNumber() have been removed from the Scalar interface.
    • The methods power(int) and root(int) have been removed,
  • org.ojalgo.series.*
  • org.ojalgo.type.*
    • IntCount can now be incremented and duplicated is addition to (as before) decrenented and halved.
    • TypeContext is now an interface, and there is a new GenericContext class.
    • There is now an interface NumberContext.Enforceable. The various Scalar implementations implement it.
    • The 3 methods isSmallComparedTo(double,double), isSmallError(double,double) and isZero(double) in NumberContext have altered implementations/behaviour.
    • The method error() in NumberContext is deprecated. You should use isSmallComparedTo(double,double), isSmallError(double,double) or isZero(double) instead.
    • The enforce(BigDecimal) of NumberContext no longer does "stripTrailingZeros" before returning.

Apart from this a significant amount of time has been spent improving the unit tests.


First version to target Java 7!

  • org.ojalgo.access.*
  • org.ojalgo.array.*
    • The various array classes now implement the new Modify*D interfaces from the org.ojalgo.access package.
    • Array1D now has a copy(int...) method - that will create a copy containing only the indicated elements.
  • org.ojalgo.concurrent.*
    • The class DivideAndMerge is deprecated.
    • DivideAndConquer is sligthly refactored. There are new methods execute(...) and invoke(...) that you should use to initiate calculations. The method divide(...) is no longer public.
    • DaemonPoolExecutor now extends ForkJoinPool rather than ThreadPoolExecutor.
  • org.ojalgo.constant.*
    • FinancePortfolio has two new methods getLossProbabilty() and getLossProbabilty(horizon).
    • MarkowitzModel now has a constructor that simply takes a covariance matrix and a returns matrix as input. Also some internal refactoring/tidying.
    • Fix for GoogleSymbol to handle the "-" that is used in place for missing values.
    • New method clean() in MarketEquilibrium that copies the instance and at same time cleans the covariance matrix of negative and very small eigenvalues.
    • Fixed so that there wont be an exception when calling nomalise() on a FinancePortfolio that has all weights set to zero.
    • The PortfolioMixer now takes Number instead of BigDecimal when specifying constaints.
    • The enum MarketEquilibium.CalibrationTarget has been removed
    • Additional refactoring...
  • org.ojalgo.function.*
    • The previous interface BinaryFunction and abstract class ConfigurableBinaryFunction has been combined into a new abstract class BinaryFunction.
    • The previous interface ParameterFunction and abstract class ConfigurableParameterFunction has been combined into a new abstract class ParameterFunction.
    • All classes in org.ojalgo.function.implementation have moved to org.ojalgo.function. The old package/classes still exists but everything is deprecated. You (only) need to change the import statement!
    • New AggregatorFunction:s MINIMUM and MAXIMUM. The ComplexNumber implementations do the same as SMALLEST and LARGEST.
  • org.ojalgo.matrix.*
    • Updated the included version of Jama to 1.03. There was a bug in the Jama's EigenvalueDecomposition that caused the new release.
    • Fixed a bug with the SVD that caused it to hang with some special matrices.
    • Fixed the EigenvalueDecomposition: It did not allow extraction of the eigenvalues and the diagonal matrix when/if you had specified "eigenvalues only".
    • The QRDecomposition, BidiagonalDecomposition and SingularValueDecomposition can now be computed as "full size" - useful if you want to calculate the nullspace of a matrix.
    • Householder implemenattions now have a copy finction that uses a precalculated "beta".
    • BasicMatrix is now generic, and extends Access2D.
    • API-breaking changes to BasicMatrix.Factory and the related builders (not difficult to fix) - they now implement the new Builder2D interface.
  • org.ojalgo.optimisation.*
    • Optimisation.Result has a new constructor, and there's now options to set a basis and active set as
    • The method getDefaultSolver() in Optimisation.Model has been removed. The implementation i ExpressionsBasedModel is still there.
    • The set of methods named selectExpressions**() and selectVariables**() in ExpressionsBasedModel are refactored in many ways. This is api-breaking changes, but those methods are primarily used when creating solver instances from a model - not something an average user would do.
    • ExpressionsBasedModel is refactored (internal changes only) to generate solver specific data structures faster.
    • ExpressionsBasedModel no longer includes fixed (equality constrained) variables when creating solver instances.
    • The IntegerSolver has been improved some: less copying / less garbage, branches are now stopped based on a configurable relative MIP gap, and other minor improvements...
    • Various refactoring to Optimisation.Options - name changes, changed default values, additions, removals... - API breaking!
    • Optimisation.Options can now be set/defined on the ExpressionsBasedModel, and they will be passed on to the solver.
    • The Optimisation.ValidationException has been removed, and code that relied on it has been refactored - API breaking!
    • IntegerSolver should now has a mechanism to "hot start" the calculation nodes. It's not actually implemented for the LP solver yet, but the QP-solver is done, and it's generally much faster now.
    • Better defaults for many of the parameters in Optimisation.Options.
    • The LinearSolver can now handle more cases.
    • ... actually there's a whole bunch of refactoring and improvements that I lost track of. Particularily the IntegerSolver should be much more efficient now.
  • org.ojalgo.scalar.*
    • Internal refactoring to ComplexNumber. It should now be significantly faster on some operations. The public constructor taking a single double as input has been removed. The class is now abstract. Instead of that construcor you should use the static factory method makeReal(double).
  • org.ojalgo.type.*
    • New standard types, in StandardType; MATH_032, MATH, 064 and MATH_128, and a couple of new factory methods in NumberContext.


Last vaersion to target Java 5!

  • org.ojalgo.access.*
    • Both Access2D and AccessAnyD now extend Access1D. (AccessAnyD no longer extends Access2D.) Anything in ojAlgo that is *2D or *AnyD can also be treated as a 1-dimensional data structure.
  • org.ojalgo.array.*
    • The methods getRowDim(), getColDim() and getMinDim() in ArrayAnyD are deprecated.
    • With v32 the concept of "risk appetite" (the inverse of risk aversion) was introduced to the classes in the package. This has been removed again. If you need it, then do the inversion yourself.
    • The interface PortfolioContext has been moved/renamed FinancePortfolio.Context.
    • The PortfolioMixer can now handle constraints (lower and upper limits) on individual asset weights and/or component portfolio weights.
  • org.ojalgo.matrix.*
    • The "intelligent" factory methods; CholeskyDecomposition.make(Access2D), EigenvalueDecomposition.make(Access2D), LUDecomposition.make(Access2D), QRDecomposition.make(Access2D) and SingularValueDecomposition.make(Access2D) have been refactored to return the JAMA based instances when the element type is double and the element count is larger than (2^31 - 1). Performance will be disastrous, but it should work.
    • The BasicMatrix implementations BigMatrix, ComplexMatrix and PrimitiveMatrix now use the "intelligent" matrix decomposition factories.
    • The two printToStream(?) methods in MatrixUtils are deprecated and moved to BasicLogger.
    • ComplexNumber valued Bidiagonal and SingularValue decompositions now work "better". The primary fix is to make sure the result of the bidiagonal decomposition is real even for arbitrary complex valued matrices.
    • The methods rows(int...) and columns(int...) in MatrixStore.Builder have been renamed row(int...) and column(int...) respectively. Then there are two new methods rows(int, int) and columns(int, int). The old vararg versions take one (or several) row/column indeces as input - each row/column has to be explictly referenced. With the new, two int parameter, version you specify a range - first and last/limit. If you used these methods to explicitly reference precisley two rows or columns you have a problem! You have to change the code, and the compiler wont tell you about the problem - you have a bug.
    • New methods getRowsRange(int,int) and getColumnsRange(int,int) in BasicMatrix.
  • org.ojalgo.netio.*
  • org.ojalgo.optimisation.*
    • A whole bunch of refactoring. Together with what was reafctored/deprecated with v32 these are major changes to the optimisation package. A lot of things have been moved around or had its name changed. You will have to modify your code! The main classes are still there ExpressionsBasedModel, LinearSolver and QuadraticSolver... and you use them roughly the same way as you did before. There's now only one addExpression(?) method in ExpressionsBasedModel - all the variations are removed. (Most of them were deprecated already with v32.) Corresponding functionality has been added to Expresion instead.
    • Fixed a bug in QuadraticSolver (one of its subclasses) that caused some problems to take much longer than needed to solve. If it took too long the solver would report failure. The problem would have been most notable with a bit larger problems with tight (inequality) constraints on most of the variables.
    • Fixed a bug in LinearSolver (one of its subclasses) that caused some ExpressionBasedModel instances to be incorrectly interpreted. In particular constraints with negative valued upper bounds were handled incorrectly.
    • When building linear models (LP models) using ExpressionsBasedModel you are no longer restricted to using positive valued variables. Previously when you built linear models an unset lower limit was assumed to be 0.0. Now this is no longer assumed. You may have to modify your models to explicitly set the lower limit.
    • Declarations of semi-continuous column (variable) bounds in MPS files are now supported.
    • The MPS related enum ColumnType has been renamed BoundType.
  • org.ojalgo.random.*
  • org.ojalgo.series.*
    • The getAllSeriesNames() and getAllCalendarDates() methods of CoordinationSet now returns List:s rather the Set:s.
    • PrimitiveSeries now lets you specify the period when transforming to series of quotients or differences. Instances can now also be pruned (cut off) at either end.
  • org.ojalgo.type.*






v27 LogoProject and site sponsored by Optimatika
Copyright © 2000 - 2014


Using JProfiler from ej-technologies