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...

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

v35 (latest release)

  • 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.*








  • org.ojalgo.array.*
    • Array1Dim now implements the List interface. This makes the toList() method redundant, and it has therefore been deprecated.
    • There are now two different modifyMatching() methods - varying in which array's elements make up which function arguments - in all classes in this package. There used to be only one variant, and that one wasn't available in some classes.
    • New class ArrayUtils. It contains utility methods to allow you to work with double[][] arrays the same way you use ojAlgo arrays. This simplified the task of making JamaMatrix implement PhysicalStore.
    • Many methods have changed from being public to protected, and from final to "not final". This is largely/entirely an internal change. It doesn't affect the public api of any class that users could instantiate directly.
    • The visit-methods no longer call reset() on the visitor. You are responsibel for resetting. If you get the AggregatorFunction from the threadlocal collection it is reset when you get it.
  • org.ojalgo.function.*
  • org.ojalgo.matrix.*
    • There's been a couple of changes to BasicMatrix. The method getVectorProduct(BasicMatrix) has been renanamed (deprecated) multiplyVectors(BasicMatrix), and the return type of toListOfElements() has been changed from List<BigDecimal> to List<? extends Number>. Further the methods isVector() and isFullrank() has beenadded.
    • Have extensively reworked all the "equals" methods in this package (and others) as well as the TestUtils class in junit tests.
    • Moved (deprecated) some methods from MatrixUtils to ArrayUtils.
    • LU has a new method getRowEchelonForm() that returns [D][U] or [DU] which others often refer to as simply [U].
    • MatrixStore and PhysicalStore has "inherited" much of the functionality in Array2Dim, and as a consequence of this has deprecated many existing methods that became redundant. (There's been quite a bit API cleaning performed.) Further some methods have been moved up from PhysicalStore to MatrixStore. All togeher this is a big change!
    • Found a problem with ojAlgos LU decomposition algorithms. They didn't produce the correct results in some cases. The "RawPrimitive" algorithm has been removed (deprecated) and the "DensePrimitive" algorithm has been rewritten to function properly in all cases.
    • Added a method computeWithoutPivoting(MatrixStore) to the LU interface.
    • PhysicalFactory has a new method named makeEye(int,int).
    • There used to be a package private abstract class (parent to all non physical stores) that cached a PhysicalStore-copy of itself. This behaviour has been removed. Nothing is copied/cached unless you do it.
  • org.ojalgo.optimisation.*
    • The QuadraticSolver and subclasses are heavily refactored There are no API breaking changes, but the internals are all new. In the process the solver gained a pre-solver.
    • The method getContribution (that used to be called getCost) in Objective has been renamed getContributionWeight.
  • org.ojalgo.scalar.*
    • Two new methods in Scalar – equals(Scalar) and round(NumberContext).
  • org.ojalgo.type.*
    • Quite a few additions and changes to NumberContext. The only api breakling change is that the method setRoundingMode doesn't do anything anymore. The rounding mode is now an immutable (final) property of NumberContext. There are now a set of methods named "round" to complement the "enforce" methods. "round" is a more lightweight type specific version of "enforce". LogoProject and site sponsored by Optimatika
Copyright © 2000 - 2014


Using JProfiler from ej-technologies