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...
v37 (future release; after switch to Java 8)
First version to require Java 8!
v36 (not yet released; corresponds to the latest snapshot)
Last version to not require Java 8! (Targets Java 7)
- The methods isInfinite(long), isNaN(long), isPositive(long) and isReal(long) of Access1D.Elements are deprecated.
- The methods isInfinite(long,long), isNaN(long,long), isPositive(long,long) and isReal(long,long) of Access2D.Elements are deprecated.
- The methods isInfinite(long), isNaN(long), isPositive(long) and isReal(long) of AccessAnyD.Elements are deprecated.
- AccessUtils provides (element) type convertion wrappers.
- A new class CharacterRing - a circular fixed size char buffer.
- Refactored BasicLogger. Didn't bother with deprecations - just changed it. There's now a BasicLogger.Appender that is used rather than working directlywith PrintStream.
- 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.
v35 (latest release)
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 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().
- 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,
- 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!
- 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.
- 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.
- 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...
- 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.
- 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.
- 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.
- 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).
Last vaersion to target Java 5!
- 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.
- 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 org.ojalgo.finance.portfolio 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.
- 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.
- 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.
- 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.
- Deprecated ArrayAccess - moved it to the org.ojalgo.array package and renamed it SimpleArray.
- Access1D now extends Iterable, and there is a new default implementation Iterator1D of the Iterator interface. This means a whole bunch of ojAlgo classes are now iterable.
- Refactoring and additions...
- Modified implementations of the SingularValue and Eigenvalue decompositions. They primarily use less memory than previous implementations.
- Fixed a couple of bugs related to complex valued Householder transformations. Complex valued matrix decompositions that used Householder transformations didn't work properly. Now it is fixed.
- Refactored the CholeskyDecomposition and LUDecomposition implementations a bit, and made sure the worked correctly with ComplexNumber elements.
- 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.
- The QuadraticSolver has been improved to handle a greater set of problems.
- Major refactoring of Expression and ExpressionBasedModel. Almost everything is deprecated... and some things are already removed/changed.
- Models are no longer ModelEntities themselves (revert change made with v31).
- The method setContributionWeight(...) has been removed from the Objective interface.
- The methods setLowerLimit(...) and setUpperLimit(...) have been removed from the Constraint interface.
- The methods setContributionWeight(...), setLowerLimit(...) and setUpperLimit(...) in ModelEntity are deprecated.
- ExpressionsBasedModel is no longer abstract, and its subclasses LinearExpressionsModel and QuadraticExpressionsModel are deprecated.
- 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 class MultidimensionalGaussian has been renamed Gaussian1D.
- The class MultidimensionalProcess has been deprecated and replaced by Wierner1D and GeometricBrownian1D.
- 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 simulate method in RandomProcess (WienerProcess and GeometricBrownianMotion) used to return an array of SampleSet. Now it returns a SimulationResults instance. You get the SampleSets by calling getSampleSet(index).
- Added new methods toString(NumberContext) and toPlainString(NumberContext) to the Scalar interface, Also redefined what the existing toString() should return.
- New class CalendarDateDuration. It's expresses durations/intervals like 5 years, 1.567 months 0.5 hours....
- The parseObject() and formatString() methods in TypeContext has been deprecated/renamed and replaced by methods parse() and format().
- Added the ability to get java.sql.Date, java.sql.Time and java.sql.Timestamp instances directly from a CalandarDate instance.
- New class ChartBuilder that replaces the package org.ojalgo.chart deprecated with v31.
- The (contents of the) packages org.ojalgo.type.attribute and org.ojalgo.structure are removed.
- The SQL_DATE, SQL_TIME and SQL_DATETIME formattter constants in TypeUtils have been deprecated. Use corresponding functionality in StandardType instead.
- The imported JAMA files were by mistake public in v30 rather than package-private. They've always been package-private before, and they are now again.
- There is no longer a DecompositionStore.Factory interface. Its methods are now defined in PhysicalStore.Factory.
- 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.
- The compute(Access2D<N>) method of MatrixDecomposition is changes to be compute(Access2D<?>).
- New, optional, methods in the MatrixDecomposition interface - solve(MatrixStore, DecompostionStore) and getInverse(DecompostionStore) - that allow you to preallocate memory for the results.
- Refactored the code for LU and Cholesky dcompositions.
- New, refactored, versions of the Eigenvalue and SingularValue decomposition algorithms.
- Refactoring to the ModelEntity hierarchy. Models are now also model entities themselves. Nothing api-breaking yet, but I expect there will be.
- Fixed a bug with the LinearSolver that caused som models to incorrectly be reported as UNBOUNDED.
- Fixed a bug with the IntegerSolver that caused a NullPointerException if the relaxed problem was infeasible or unbounded.
- New method getQuantile() in ContinuousDistribution that in turn is used to calculate getLowerConfidenceQuantile() and getUpperConfidenceQuantile() for some distributions.
- Deprecated getLowerConfidenceBound and getUpperConfidenceBound in GeometricBrownianMotion - they're incorrect, and have an unfortunate api.
- The classes WienerProcess and GeometricBrownianMotion have new methods getLowerConfidenceQuantile() and getUpperConfidenceQuantile() equivalent to the methods with the same names in ContinuousDistribution.
- New method isPositive() in Scalar.
- Minor refactoring and additions to the various 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.
- The toScalar(...) methods of Access1D, Access2D and AccessAnyD has been removed. Also removed the getMinDim() method in Access2D.
- Added a new interface Basic2D.
- Added a new class ArrayAccess - simply a class that encapsulates an array of numbers and implements Access1D.
- The bulk of the methods defined in BasicArray are now protected instead of public - probably doesn't affect you.
- New methods in ArrayUtils that wrap 1- and 2-dimensional arrays of any subclass of Number in an Access1D or Access2D.
- Toatl refactoring... not API compatible at all.
- Major additions and, api-breaking, refactoring to the org.ojalgo.finance.portfolio.* package.
- Added support for min/max weight constraints on arbitrary groups of instrumnets to the MarkowitzModel class.
- New class PortfolioMixer - a fund of funds optimiser.
- New package org.ojalgo.matrix.store.operation that will contain code that is now in the PhysicalStore implementations. This is purely an organosational change that shouldn't affect you.
- The method set(int,int,Number) in BasicMatrx has been removed. This is an API-breaking change!
There are several alternatives:
- replace(int,int,Number) does exactly what set(int,int,Number) used to do.
- add(int,int,Number) is a variation
- There is now a new bulder accessible from the factory or directly from the various BasicMatrix implementations.
- New matrix decompositions; Bidiagonal, Hessenberg, Tridiagonal and Schur.
- The compute(...) method in MatrixDecomposition now takes an Access2D instead of a MatrixStore as input.
- Major improvements to existing Eigenvalue and SingularValue decompositions.
- Added some new MatrixStore implementations: WrapperStore, LowerTriangularStore, UpperTriangularStore, LowerHessenbergStore and UpperHessenbergStore.
- Some old MatrixStore implementations got new names: AboveBelowStore (MergedColumnsStore), ColumnsStore (SelectedColumnsStore), LeftRightStore (MergedRowsStore) and RowsStore (SelectedRowsStore).
- Reviewed and modified the matrix multiplication code in all MatrixStore implementations, PhysicalStore implementations in particular.
- Added makeColumn(Access1D) method to the PhysicalStore.Factory interface.
- BasicMatrix now extends the new Basic2D.
- Refactored how solve(...) and invert() are implemented in the Cholesky and LU decompositions as well as the BasicMatrix implementations - should use less memory now.
- Householder is no longer a class, it's just an interface now. There's been some refactoring regarding how Householder transformations are implemented.
- Rotation is now an abstract class. There's been some refactoring regarding how Rotation transformations are implemented.
- Re-imported JAMA, and re-applied the fixes/additions,
- Fixed a bug with the ExpressionsBasedModel that caused integer constrained models to always be solved as minimisation problems (even if you defined them as maximisation problems).
- Fixed a bug with the IntegerSolver that caused some non-integer solution to be recognised as integer solutions.
- Modified (improved) the LinearSolver.
- Some refactoring to Expression and ExpressionsBasedModel.
- Slight improvement to SampleSet. The median value is now cached, and it is possible cast a SampleSet as a PrimitiveSeries.
- New class MultidimensionalGaussian that generates multidimensional Normal(0,1) random numbers.
- Complete rewrite of the org.ojalgo.random.process package. Even if some interfaces/classes/methods existed before with the same name, they are now different.
- Internal refactoring of ComplexNumber including improved numerical accuracy.
- New package.
- 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.)
- New utility method makeCovarianceMatrix(...) in FinanceUtils that calculates a covariance matrix from a collection of BasicTimeSeries.
- Major refactoring of the ...data package. It is now possible to use GoogleSymbol and YahooSymbol independant of SymbolDataCache.
- Minor refactoring of the ...portfolio package. It is now possible to get the State of the underlying optimisation model/solver.
- BasicMatrx.Factory has a new method copyAnything2D(Access2D) and the methods copyArray(Array2D) and copyStore(MatrixStore) are deprecated, and corresponding changes are made in PhysicalStore.Factory as well. Both Array2D and MatrixStore implement the new interface Access2D.
- 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.
- Two new methods aggregateAll(ChainableAggregator) and aggregateAll(CollectableAggregator) in MatrixStore.
- Rewrote the algorithms for Cholesky and LU decompositions.
- New SingularValueDecomposition algorithm.
- Fixed a bug in QRDecomposition related to extracting "R" from decompositions of fat matrices.
- Extended the Eigenvalue interface and added a new primitive EigenvalueDecomposition implementation. This new implementation is a refactored copy of the Jama eigenvalue decomposition.
- Fixed a bug realted to solving equation systems for LU and Cholesky decompositions. With 10000 elements or more and at least two CPUs the reults would be wrong!
- 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.
- All BigDecimal constant are now correct to a precision of a 128 bit (34 digits) floating point number.
- All double constants are now created from their BigDecimal counterpart.
- 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.)
- It is now possible to get the preconfigured elements of PreconfiguredFirst, PreconfiguredSecond and PreconfiguredParameter.
- Some changes regarding the available constructors and factory methods.
- Everything related to LogicalFunction has been deprecated.
- 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).
- SuperimposedMatrixStore has been renamed/deprecated SuperimposedStore.
- RawStore has been deprecated. Use JamaMatrix instead.
- Internal changes to BigMatrix, ComplexMatrix and PrimitiveMatrix.
- A bit of (internal) tweaking of all the MatrixStore implementations.
- New methods maxpy(), raxpy() and caxpy() in PhysicalStore. ;-)
- New class MatrixStore.Builder.
- Refactored the "time filter" functionality out of this package.
- 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.
- 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.
- 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.
- Two new methods in Scalar – equals(Scalar) and round(NumberContext).
- 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".