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
3 - 31
Version3, Version4, Version5 ... Version31
v32, v33, v34...
v38 (not yet released; corresponds to the latest snapshot)
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.
The entire package org.ojalgo.optimisation.quadratic has been removed (it was deprecated with v36). It is replaced by the org.ojalgo.optimisation.convex package. The new API is currently/still identical to the one it replaces.
Reviewed implementations and documentation for isAbsolute(), isInfinite(), isNaN(), isPositive(), isReal() and isZero() in Scalar - there are changes. Further all of those methods, except isAbsolute() and isZero(), are deprecated.
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:
The general change from int to long allows for much larger structures
The new/altered method names are better. ( Does getRowDim() return the number of rows or the dimension of a row? )
These changes differentiates the interfaces in this package from the java collections api.
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 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,
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!
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).
With v32 the concept of "risk appetite" (the inverse of risk aversion) was introduced to the classes in the org.ojalgo.finance.portfolio package. This has been removed again. If you need it, then do the inversion yourself.
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.
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.
Added convenience methods to MatrixBuilder to create (column) vectors. The BasicMatrix.Factory interface now also defines a 1-dimensional getBuilder(int) method.
Changes to BasicMatrix: The methods getRows(...) and getColumns(...) have been renamed selectRows(...) and selectColumns(...). The method replace(...) has been deprecated. Using it was rarely a good idea. Added a new method copyToBuilder() that creates a MatrixBuilder initiated with the matrix' current elements.
All methods in the ModelEntity hiearchy named getAdjusted*(...) now return double intead of BigDecimal. These methods are used when copying data from models to solvers. The change probably wont affect your code.
The RandomProcess implementations had methods named getExpected(...), getVariance(...) and more that took a "step size" as input. Most of the time you simply wanted to call these methods with argument 1.0. The original methods have been made package private and new public methods where the 1.0 is implicit are in their place. You can still/also call getDistribution(...) with a "step size" other than 1.0, and then call getExpected(), getVariance() ... on the distribution.
The BasicMatrix.Factory interface now extends Factory2D, and the same for the PhysicalStore.Factory interface. This caused slight refactoring of some parts of ojAlgo, and may also affect your code if you keep references to the various factory implementations.
Deprecated the BasicTimeSeries interface as well as the TimeInMillisSeries, CalendarSeries and DateSeries classes. They've all been replaced by the new CalendarDateSeries. All other classes/methods in ojAlgo that referenced any of the deprecated classes have already been refactored to instead use the new CalendarDateSeries. If you used any of those classes/methods directly you must cahange your code.
New library utility class that you can ask for data about ojAlgo (you can ask which version of ojAlgo you're currently using) or for some basic info (estimate) about the hardware the code is running on.
New interfaces Access1D, Access2D and AccessAnyD. Everything 1, 2 or "Any" dimensional (respectively) should implement these interfaces. Probably BasicMatrix will be the only exception. (BasicMatrix is not generified, and JamaMatrix implements both BasicMatrix and PhysicalStore, that extends Access2D.)
The aggregator norm has been removed from the AggregatorCollection. (There are still specific norm1 and norm2 aggregators.) The AggregatorCollection and the two Aggregator enum contain the same set of AggregatorFunction implementations.
The setParameter(int) method of AggregatorFunction interface has been removed (not deprecated, removed).
Everything related to "shading" MatrixStore:s has been deprecated - a handfull of methods in MatrixStore and PhysicalStore has been deprecated. The shading functionality has already been turned off, and the deprecated methods will be removed shortly.
The methods getVectorZeroNorm and getVectorInfinityNorm in BasicMatrix are deprecated, and the getVectorNorm(int) method now only accept arguments 0, 1, 2 or MAX_VALUE.
Added and re-implemented multithreading with many methods in BigDenseStore, ComplexDenseStore and PrimitiveDenseStore. Some things are now much faster, and others roughly the same... Due to these changes some higher-level code (matrix decompositions & optimisation algorithms) also perform better.
The classes Array1Dim, Array2Dim and ArrayAnyDim have been renamed Array1D, Array2D and ArrayAnyD. If you've used any of these classes directly you need to do a search-and-replace on the class names. A number of methods (in various classes) named asArray1Dim() have been deprecated and renamed asArray1D(). There's also been further internal refactoring and bugfixing in these classes.
The implementation/specification of the "smallest" aggregator function has changed. If there are no non-zero numbers; the default return value is zero. (It used to be infinity or some very big number.)
The previously announced changes (deprecations) related to the org.ojalgo.matrix.factory has been performed. At least in terms of import statements this affects large parts of ojAlgo and probably your code as well. There is now a "new" class MatrixFactory.
The PhysicalStore.Factory interface has gotten two new methods - copyTransposed(MatrixStore) and copyConjugated(MatrixStore).
2 new methods in MatrixStore - transpose() and conjugate() - that produce transposed/conjugated PhysicalStore copies of the MatrixStore.
The Householder-related code in the PhysicalStore implementations is now dual/multi-threaded.
The Rotation-related code in the PhysicalStore implementations have been tweaked. (Roughly the same speed, but cleaner code.)
New SingleStore (it existed before, but was not public).
All methods in SingularValue that return singular values, various norms or the condition number now has a return type of double. This is an api-breaking change. The BasicMatrix interface is however NOT affected by this.
Renamed the PhysicalStore methods multiplyLeft(Rotation) and multiplyRight(Rotation) to transformLeft(Rotation) and transformRight(Rotation). Also added new methods transformLeft(Householder) and transformRight(Householder).
Small changes to QRDecomposition - it should produce less garbage now, and (part of) the Householder code is made common with the new transformLeft(Householder) method in PhysicalStore (which potentially makes the decomposition sligthly slower).