Removal of code that has been deprecated past 1 major release is typically not mentioned
[Not yet released]
Corresponds to changes in the
developbranch since the last release
- The stuff that was deprecated with v47.1.0 are now removed. (Keeping it around may cause problems with some IDE:s) Just update your import statements to org.ojalgo.function.constant rather than org.ojalgo.constant.
- Additions and improvements to DataPreprocessors, but they're now column oriented only.
- The ElementsConsumer interface has been renamed TransformableRegion. This is an intermediate definitions interface - subinterfaces and concrete implementations are not affected other than with their implements and extends declarations.
- The interfaces Mutate1D.Transformable, Mutate2D.Transformable and MutateAnyD.Transformable introduced with v47.1.0 are removed again – bad idea.
- The Stream1D, Stream2D and StreamAnyD each got a new method named operateOnAny that takes a Transformation?D as input.
- The Mutate1D.ModifiableReceiver, Mutate2D.ModifiableReceiver and MutateAnyD.ModifiableReceiver each got a new method named modifyAny that takes a Transformation?D as input.
- Everything in this package has been moved to org.ojalgo.function.constant
- New package that currently only contains an (also new) class DataPreprocessors. The intention is that this is where various data preprocessors utilities will go.
- New package org.ojalgo.function.special with currently 4 new classes: CombinatorialFunctions, ErrorFunction, GammaFunction and MissingMath.
- New package org.ojalgo.function.constant with constants related to doing basic maths on different types.
- Moved constants defined in various classes to the new org.ojalgo.function.constant package, and deprecated a ffew others that will be made private.
- Fixed a problem with one of the Eigenvalue implementations - it would check for symmetric/hermitian but then failed to make use of the results.
- Fixed a problem with some of the Eigenvalue implementations regarding ordering of the eigenvales/eigenvectors – they were not always ordered in descending absolut order (used to consider the sign).
- The interface TransformationMatrix has been removed. Partly this functionality has been revoked, and partially replaced by the new Transformation2D interface.
- Refactoring of the presolvers. Among other things there are now presolvers that perform integer rounding. Previously existing presolvers have also been improved. There is also a new presolver that removes (obviously) redundant constraints.
- Modified what happends when you relax an integer model. Now the variables are kept as integer variables, but the model set a flag that it is relaxed. This means the presolvers can now make use of the integer property and thus perform better.
- The MPS file parser, MathProgSysModel, has been modified to not strictly use field index ranges, but instead more freely interpret whitespace as a delimiter. This is in line with commonly used MPS format extensions and allows ojAlgo to correctly parse/use a larger set of models. Further MathProgSysModel is no longer a model – it no longer implements Optimisation.Model. This should/will be a model file parser, and nothinng else.
- Major extension and refactoring of optimisation test cases. In particular the test cases in ojAlgo are now available to the various solver integration modules in ojAlgo-extensions.
- When adding a solver integration to ExpressionsBasedModel it is now possible to differentiate between preferred and fallback solvers - addIntegration() has been replaced with addPreferredSolver() and addFallbackSolver().
- Fixed a concurrency related problem with the sparse simplex solver.
- There is now an options 'options.sparse' that control if sparse/iterative solvers should be favoured over dense/direct solvers, or not.
- Tweaking of ConvexSolver internals – several small changes that in combination makes a big difference on some numerically challenging problems.
- Fixed a bug in ConvexSolver (ActiveSetSolver) that caused the
sufficestopping conditions to not be considered since the state was set to APPROXIMATE raher than FEASIBLE.
- New Cauchy distribution RandomNumber.
- Partial implementation of Student's TDistribution
- Deprecated the RandomUtils class and moved its various methods to classes in the new org.ojalgo.function.special package.
- For continuous distributions the getProbability methods has been renamed getDensity.
- Minor performance improvement to SampleSet when calling getStandardDeviation() repeatedly.
- New interfaces Transformation1D, Transformation2D and TransformationAnyD as well as Mutate1D.Transformable, Mutate2D.Transformable and MutateAnyD.Transformable. The Transformation?D interfaces are functional. With them you can write custom "mutators" that can be used on everything that implements the Transformable interfaces.
- The interfaces Access1D.Elements, Access1D.IndexOf, Access2D.Elements, Access2D.IndexOf, AccessAnyD.Elements and AccessAnyD.IndexOf have been deprecated.
- Additions to Stopwatch that make it easier to compare with time limits in various forms.
- SparseArray: It is now possible to visit the nonzero elements in an index range with a functional callback interface - you can have a lambda called by each nonzero element in a range.
- The BasicMatrix interface has been removed. More precisely it has been merged with the abstract package private class AbstractMatrix (and that class was then renamed BasicMatrix). Further all supporting (nested) classes and interfaces as well as the MatrixFactory class has been refactored in a similar way. The various matrix implementations (PrimitiveMatrix, ComplexMatrix, RationalMatrix and QuaternionMatrix) are now entirely self-contained - not generic in any way.
- The MatrixUtils class has been deprecated. Everything in it has been moved to other (different) places. No features or functionality are removed.
- Reshuffled the declarations in Mutate1D, Mutate2D and MutateAnyD. Nothing is removed. This only affects those doing low-level ojAlgo programming.
- Internal refactoring and performance improvements in SparseStore.
- Complete rewrite of ResourceLocator. It can still be used the same was as before (roughly the same API for that) but it now also support more advanced usage. ResourceLocator has taken steps towards becoming an "http client" with support for cookies, sessions, requests and responses.
- New interface BasicLogger.Printable to be used by classes that need detailed debug logging.
- Iterations and time limits are now enforced for the LP solver. (Only worked for the QP and MIP solver before.)
- Changed how the initial solution, extracted from the model and supplied to the solvers, is derived. This primarily affects the ConvexSolver.
- Changed how the ConvexSolver utilises the supplied initial solution to derive a better set of initially active inequalities.
- Modified the ConvexSolver/ActiveSetSolver behaviour regarding failed subproblems and iteration limits. Re-solving a failed subproblem now counts as a separate iteration, and iteration and time limits are enforced when determining if a failed subproblem should be re-solved or not.
- ConvexSolver validation is now slightly less strict. (Tiny negative eigenvalues are now allowed.)
- The ´resample´ methods have been removed from the NaturallySequenced interface. Resampling is now only possible with the CalendarDateSeries implementation.
- Refactoring to CalendarDate, CalendarDateUnit and CalendarDateDuration; simplified implementations that are better aligned with the java.time classes.
- Now builds a separate test-jar artefact. It contains a test utilities class that can be used by libraries that extend ojAlgo to help test some ojAlgo specific types.
- Added a main method in org.ojalgo.OjAlgoUtils that output info about the environment.
- The BasicMatrix interface has been deprecated!!! The various implementations will remain - all of them - but you should use those implementations directly/explicitly rather than the interface.
Nothing in ojAlgo implements Serializable - a few odd classes used to declare that they did, but serialization has never been supported.
- Fixed a bug related to transposing ElementConsumer/Supplier
- Performance improvements on some SparseStore operations
- Refactored the various IDX.print(...) methods
- Access1D no longer extends Iterable. To iterate over the elements use
- Refactoring, tuning and improvements.
- The Array1D, Array2D and ArrayAnyD factories now have specific makeSparse(...) methods. Previously the makeZero(...) methods would automatically switch to creating sparse internals when it was large enough. Users were not aware of this (didn't want/need sparse) and performance was very poor.
- New class IDX with utilities to read, parse and print contents of IDX-files. (To access the MNIST database of handwritten digits: http://yann.lecun.com/exdb/mnist/)
- A new abstract class, ExactDecimal, to help implement exact decimal numbers (fixed scale) as well as an example implementation Money.
org.ojalgo.structure (previously org.ojalgo.access)
- Added default methods to get all primitive number types from Access1D, Access2D and AccessAnyD and to somewhat modified the ones in AccessScalar:
byteValue(), shortValue(), intValue(), longValue(), floatValue(), doubleValue().
- AccessAnyD now has a method
matrices()that return a
Iterable<MatrixView<N>>. On a multi-dimensional data structure you can iterate over its 2D (sub)matrices. Useful when you have a 3-dimensional (or more) data structure that is actually a collection of 2D matrices.
- package renamed org.ojalgo.structure
- Rudimentary support for ArtificialNeuralNetwork. You can build, train and use feedforward neural networks.
- The BasicArray.factory(?) method has been removed. It should never have been public
- New indexOf(array, value) utility methods in Raw1D
- New constants in BigMath and PrimitiveMath: TWO_THIRDS and THREE_QUARTERS
- New PredicateFunction interface.
- New PlainUnary interface.
- BigMatrix, BigDenseStore and ComplexDenseStore are removed. They were deprecated before - now they're actually gone!
- Fixed bug: The getEigenpair(int) method of the Eigenvalue interface threw an ArrayIndexOutOfBoundsException
- Fixed a couple of issues related to calculating the nullspace (using QR or SVD decompositions).
- Revised the BasicMatrix interface - cleaned up some old deprecated stuff.
- BasicMatrix.Builder interface has been renamed BasicMatrix.PhysicalBuilder and its feature set extended. In addition there is now a BasicMatrix.LogicalBuilder. Stuff that should be done via those builders are now deprecated in the main, BasicMatrix, interface.
- The various BasicMatrix implementations now implement Access2D.Collectable which allows them to be more efficiently used with MatrixDecomposition:s.
- Improvements/extensions to the BasicParser interface - it is now possible to skip a header line.
- New interface UpdatableSolver that will contain a selection of optional methods to do in-place updates of solvers. Currently there is only one such method - fixVariable(?).
- New class ExpressionsBasedModel.Intermediate used by the IntegerSolver to exploit the capabilities exposed by UpdatableSolver.
- Many thing internal to the IntegerSolver (MIP solver) have changed. In general things are cached, re-used and updated in-place more than before.
- New option 'mip_defer' that control an aspect of the branch-and-bound algorithm in IntegerSolver. (Read its javadoc.)
- There is now a ComplexNumber.NaN constant.
org.ojalgo.structure (previously org.ojalgo.access)
- New default methods aggregateDiagonal(..), sliceDiagonal(...), visitDiagonal(...), fillDiagonal(...) and modifyDiagonal(..) targeting the main diagonal.
- New default methods in Factory2D to make it easier to create 2D-structures of single rows or columns.
- Mutate2D.BiModifiable now (again) extends Mutate2D.Modifiable and defines additional methods modifyMatchingInRows(...) and modifyMatchingInColumns(...)
- New class ObjectPool
- The generics type parameter of NumberContext.Enforceable changed from
<N extends Number>to
- 3 new interfaces Structure2D.ReducibleTo1D, StructureAnyD.ReducibleTo1D and StructureAnyD.ReducibleTo2D
- Most (all) of the *AnyD interfaces got new or updated methods "set" methods: aggregateSet(...), visitSet(...), fillSet(..), modifySet(...), sliceSet(...)
- New functional interface Structure1D.LoopCallback to be used when iterating through a set of subloops.
- Array1D now implements Access1D.Aggregatable
- Array2D now implements Access2D.Aggregatable as well as Structure2D.ReducibleTo1D
- ArrayAnyD now implements AccessAnyD.Aggregatable as well as StructureAnyD.ReducibleTo1D and StructureAnyD.ReducibleTo2D
- Additions or cleanup of the various methods relating subsets of elements: aggregateSet(...), visitSet(...), fillSet(..), modifySet(...), sliceSet(...)
- Fixed a bug regarding fillAll(...) on a SparseArray - it didn't fill all, just the currently set (already existing) elements. (Performing fillAll on a SparseArray is stupid.)
- New aggregator function AVERAGE. (The Aggregator enum has a new member, and the AggregatorSet class has new method.)
- BasicMatrix now implements Structure2D.ReducibleTo1D
- Improved firstInRow/Column and limitOfRow/Column logic of AboveBelowStore and LeftRightStore.
- MatrixStore now implements Structure2D.ReducibleTo1D. The rows/columns are reduced to ElementSupplier:s so you can continue working with the numbers before supplying the elements to some ElementsConsumer.
- New class LineSplittingParser - a very simple csv parser
- New class TableData - used to create a "table" of values that can then be exported to a csv file.
Switced to using JUnit 5!
- Methods Access1D.wrapAccess1D(...) has been renamed simply Access1D.wrap(...), and similarly Access2D.wrap(...)
- Add/restore fillMatching(...) methods to the Mutate1D.Fillable interface.
- New method getLinearFactors() in MultiaryFunction.TwiceDifferentiable that returns the gradient at 0.
- Changed matrix multiplication code to be better on modern hardware & JVM:s (not fully verified to be better).
- Everything "Big" has been deprecated: BigMatrix, BigDenseStore and everything else using BigDecimal elements. This is intended to be replaced by the new RationalNumber based implementations.
- The ComplexNumber related code (all of it) has been refactored/generalised to handle any Scalar implementation (ComplexNumber, RationalNumber, Quaternion and any other future implementations). ComplexDenseStore has been deprecated and replaced by GenericDenseStore.
- New interfaces MatrixTransformation and MatrixTransformation.Transformable - an attempt to unify matrix transformation implementations.
- New package org.ojalgo.matrix.geometry containing mutable 3D vector math classes.
- Fixed a bug with sparse matrix multiplication – in some cases the result was wrong (depending on the internal structure of the nonzero elements). The bug was actually in the SparseArray class.
- Fixed a bug with incorrect pseudoinverse in RawSingularValue.
- Fixed correct sign on determinant in QR decompositions
- Added default methods to BasicLogger.Printer to simplify creating custom implementations.
- Added new methods getUnadjustedLowerLimit() and getUnadjustedUpperLimit() to the Variable and Expression classes.
- Optimisation.Options now allow to specify a solver specific configurator method. This is useful when creating 3:d party solvers.
- Experimental support for Special Ordered Sets (SOS) in ExpressionsBasedModel.
- Variable:s are now ordered (compared using) their indices rather than their names.
- New variants of addVariable() and addExpression() methods that don't require you to supply an entity name. (A name is generated for you.)
- Changes to presolver and validation code. Fixed a whole bunch of problems, mainly related to rounding errors.
- Refactoring in the IntegerSolver. It should now be more memory efficient. Also, somewhat, modified the branching strategy.
- Added the possibility to get progress logging from the solvers (Currently only implemented in IntegerSolver).
- The 'slack', 'problem', 'objective' and 'integer' properties of Optimisation.Options have been unified and replaced by a new property 'feasibility'.
- It is now possible to setSeed(long) on any RandomNumber and Random1D instance.
- RationalNumber has been re-implemented using primitive long and numerator and denominator (they used to be BigInteger).
- RationalNumber can now be instatiated from a double without creating any objevts other than the resulting RationalNumber instance. There is also an alternative implementation using rational approximation.
- New TypeContext implementation, named TemporalContext, to handle the classes from Java's new date time API. The older DateContext is still available.
- Bug fixed in a NumberContext factory method - getPercent(int,Locale)
- Deprecated AccessUtils. All the various utility methods have been moved to other places - primarily to the Acess1D, Access2D or AccessAnyD interfaces.
- The generic declaration of the IndexMapper interface has been changed from <T extends Comparable<? super T>> to simply , and it is now a nested interface of Structure1D. Similarly there are now nested interfaces RowColumnMapper and ReferenceMapper in Structure2D and StructureAnyD respectively.
- The ElementView1D interface no longer extends ListIterator, but only Iterator. Instead it now extends Spliterator, and there is now a metod stream(boolean).
- The Mutate1D interface now declares a method reset() that should reset the mutable structure to an (all zeros) initial state.
- The Factory_D interfaces now has new variants of the makeZero(...) and makeFilled(...) methods that take Structure_D instances as input.
- Deprecated ArrayUtils. All the various utility methods have been moved to other places - primarily to the new Raw1D, Raw2D or RawAnyD classes. (ArrayUtils was split into Raw1D, Raw2D and RawAnyD.)
- The DivideAndConquer class now has a limit on the total number of threads it will create. (If a program had multiple threads that each invoked some multithreaded part of ojAlgo, the total number of threads would multiply and grow out of control.)
- New constant GOLDEN_RATIO
- This entire package has been moved to the ojAlgo-finance repository/project/artefact !!!
- Fixed a bug related to downloading historical data from Google and/or Yahoo Finance. When parsing the initial header line failed it was still translated to an actual data item with all zero values at a default/dummy date.
- New version of YahooSymbol that works with Yahoo Finance's changes. (They deliberately changed/broke the previously existing method of downloading.)
- org.ojalgo.matrix.task.TaskException has been removed and replaced with org.ojalgo.RecoverableCondition.
- org.ojalgo.matrix.MatrixError has been removed and replaced with various standard java.lang.RuntimeException subclasses instantiated via factory methods in org.ojalgo.ProgrammingError.
- New interface MatrixDecomposition.RankRevealing that define two methods: getRank() and isFullRank(). Several of the existing decompositions now implement this interface. This also caused a review of the implementations of the isSolvable() method of the MatrixDecomposition.Solver interface.
- Deprecated isSquareAndNotSingular() of the LU interface.
- Improved the multiplication code of SparseStore, ZeroStore and IdentityStore. In particular sparse matrix multiplication is now parallelised.
- Moved (deprecated) the matrix size thresholds methods from org.ojalgo.matrix.MatrixUtils to org.ojalgo.matrix.store.operation.MatrixOperation.
- Altered the RowsSupplier and ColumnsSupplier classes to (always) use sparse rows/columns.
- The parse(String) method of BasicParser now declares to throw a RecoverableCondition. Failure to parse an individual line now just results in that line being skipped, and the process moves on to the next line.
- The ResourceLocator class has been refactored. Essentially it's a URI/URL builder and it is now implemented using the builder pattern. The changes are API breaking this class is rarely used directly. It is mostly used indirectly via GoogleSymbol and YahooSymbol, and those classes' public API:s are intact.
- Improved the ConvexSolver to better handle cases with not positive definite and/or rank deficient covariance matrices (the quadratic term).
- Improved the IntegerSolver to better handle cases with problem parameters with significant magnitude differences (it affected the branching strategy unfavourably).
- Fixed a problem with debug printing in the IntegerSolver.
- Refactored major parts of the LinearSolver. Among other things the internal data structures are now sometimes sparse depending on the problem size (and sparsity).
- Refactored parts of the ConvexSolver to make better use of sparsity (and other things).
- The declaration of the resample(...) methods of CalendarDateSeries have been moved to the BasicSeries.NaturallySequenced interface with generalised signatures.
- The TimeSeriesBuilder can now be configured using CalendarDate.Resolution rather than only CalendarDateDuration.
- New Stopwatch class
- The CalendarDate constructor with a String argument/parameter now declares to throw a RecoverableCondition.
- NumberContext now has specific format(double) and format(long) methods, and now formats decimals with a variable number of fraction digits.
- NumberContext now has new compare(double,double) and compare(float,float) that are alternatives to the compare(...) methods in Double and Float - the only difference is that these return 0 when the two input args are ==.
- It is now possible to turn off warnings related to missing hardware profiles. Set a system property 'shut.up.ojAlgo' to anything, not null, and you won't see those warnings. (It would be must better if you contributed your hardware profile to ojAlgo.)
- Added new interfaces Access_D.Collectable to be used as super interfaces to the Stream_D interfaces, and used as input parameter type for matrix tasks and decompositions. The new interfaces interacts with the Mutate_D.Receiver interfaces and to some extent replaces the Supplier_D interfaces removed with v42.
- There's a new package private interface FactorySupplement used as a common superinterface to the Facory_D interfaces. It declares methods that give access to FunctionSet, AggregatorSet and Scalar.Factory instances - all 1D, 2D and AnyD factories now have this.
- The Stream_D interfaces got some new utility variants of operateOnAll-methods.
- New interfaces Mutate_D.Mixable that allow aggregating individual elements using the supplied binary "mixer" function.
- New interface Mutate1D.Sortable
- Addedd a Collector (Java 8 streams) that creates NumberList instances.
- Deprecated all previously existing factory methods in NumberList, LongToNumberMap and SparseArray. They are replaced with new alternatives (1 each). The new factories are configurable using builder pattern.
- SegmentedArray now package private. If you had explicit references to this class you have a compilation error. Switch to using some of the BasicArray pr DenseArray factories. If necessary things will be segmented for you.
- BufferArray is now abstract and has two package private subclasses DoubleBufferArray and FloatBufferArray. You instantiate them via factories in BufferArray.
- Yahoo now requires to use https rather http when downloading historical financial data. Both YahooSymbol and GoogleSymbol now use https.
- Two new additions to FunctionSet - "logistic" and "logit".
- Replaced all usage of ElementsSupplier as input parameter type with Access2D.Collectable.
- Removed all public/external usage of DecompositionStore and replaced it with PhysicalStore.
- Moved (deprecated) the various equals(...) and reconstruct(...) methods from MatrixUtils to the respective matrix decomposition interfaces.
- Deprecated Eigenvalue.getEigenvector(int) and replaced it with Eigenvalue.getEigenpair(int)
- Various internal improvements to the Eigenvalue and Singular Value implementations.
- Deprecated the Schur decomposition. Eigenvalue decompositions are of course still supported. It's just Schur "on its own" that is deprecated.
- The default scheme of ResourceLocator is changed from http to https.
- Extremely large (absolute value) lower/upper limits on variables or expressions are now treated as "no limit" (null).
- Extremely small (absolute value) lower/upper limits on variables or expressions are now treated as exactly 0.0.
- Fixed a minor bug in SampleSet - calculations would fail when repeatedly using SampleSet with empty sample sets
- Various refactoring to the BasicSeries implementations. There is also a new nested interface BasicSeries.NaturallySequenced and some declarations have been moved there.
- Added the concept of an accumulator that may be used to accumulate the values of multiple put operations on the same key.
- New class CoordinatedSet - a set of coordinated (same start, end & resolution) series.
- New package!
- New interface Tensor with an implementation and a factory method. Not much you can do with this yet - functionality will be expanded slowly.
- Refactoring and additions to CalendarDate, CalendarDateUnit and CalendarDateDuration. Among other things there is a now an interface CalendarDate.Resolution that both CalendarDateUnit and CalendarDateDuration implement.
- Added a method aggregateRange(...) to Access1D.Aggregatable and created new Access2D.Aggregatable and AccessAnyD.Aggregatable interfaces. Their set of methods now match what's available in the Visitable interfaces.
- The interfaces Consumer1D, Consumer2D, ConsumerAnyD, Supplier1D, Supplier2D and SupplierAnyD have been removed - they didn't add anything.
- New interfaces Stream1D, Stream2D and StreamAnyD. They're not real streams, they don't (yet) extend BaseStream, but are intended to be stream-like.
- New interfaces Mutate1D.Receiver, Mutate2D.Receiver and MutateAnyD.Receiver. They extend Mutate_D and all their nested interfaces respectively and extends Consumer. In part these are replacements for the removed Consumer_D interfaces.
- The Callback_D interfaces as well as the passMatching(...) methods in the Access_D and Mutate_D interfaces are deprecated. They're replaced by a collection of messages named loop_(...) in the Structure_D interfaces.
- The method indexOfLargestInDiagonal(long,long) in Access2D.IndexOf is deprecated and replaced by indexOfLargestOnDiagonal(long). The new alternative is restricted to work on the main diagonal only, but the returned index is easier to understand and use.
- PrimitveArray is now abstract but has 2 instantiable subclasses Primitive32Array and Primitive64Array.
- New factory methods in Array1D, Array2D and ArrayAnyD that can delegate to any BasicMatrix factory that you supply.
- NumberList now implements Access1D.Visitable.
- New package org.ojalgo.array.blas: The aim is to refactor the code base so that methods matching BLAS functionality should be moved to this new package.
- The Unsafe/off-heap array implementations have been moved to the new ojAlgo-unsafe project (part of ojAlgo-extensions).
- The POWERS_OF_2 in PrimitiveMath were incorrectly calculated - it's fixed now. At the same time the type was changed from int to long and the number of entries extended.
- New constructor in SimplePortfolio taking an array of double as input (representing individual asset weights).
- The AggregatorSet class has a new nethod get(...) that will return the correct AggregatorFunction for a specified Aggregator instance.
- BigAggregator, ComplexAggregator, PrimitiveAggregator, QuaternionAggregator and RationalAggregator all now extend AggregatorSet.
- All previously existing variations of getXXFunction(...) in Aggregator has been deprecated and are replaced by by 1 new variant.
- Added a (NumberContext) enforce method to the FunctionSet class. It returns a UnaryFunction that enforces a NumberContext on the the function's input argument.
- Added andThen(...) and compose(...) methods, where applicable, to all BasicFunction subinterfaces.
- Both BasicMatrix and MatrixStore now extends the new Access2D.Aggregatable rather than Access1D.Aggregatable.
- Tweaking of several of the matrix decomposition (and task) implementations to improve numerical stability.
- New classes RowsSupplier and ColumnsSupplier that can be instantiated from the PhysicalStore.Factory:s (experimental design)
- All previously existing variations of getXXFunction(...) in NumberContext has been deprecated and are replaced by by 1 new variant that takes a FunctionSet as input.
- New class NativeMemory used as single point to allocate, read or write native memory.
- Moved the modifyMatching(...) methods from Mutate1D.Modifiable to a new interface Mutate1D.BiModifiable and only those classes that absolutely need to (to preserve existing functionality) implements that new interface. (Potentially api-breaking, but most likely not.) There are also corresponding interfaces Mutate2D.BiModifiable and MutateAnyD.BiModifiable
- The fillMatching(..) methods in Mutate1D.Fillable are deprecated.
- New (functional) interfaces Callback1D, Callback2D & CallbackAnyD. The Access?D and Mutate?D interfaces have also gotten new default methods named passMathing(...) that makes use of those new interfaces.
- There's a new method elements() in Access1D that returns an Iterable of ElementView1D - it allows to iterate over the instance's element "positions" without actually extracting the elements (unless you explicitly do so). There a corresponding method in Access2D. That interface also has methods rows() and columns() that does similar things but with rows and columns.
- ElementView1D now implements ListIterator rather than Iterator.
- New interface IndexMapper translates back and forth between an arbitrary "key" and a long index. Among other things used to implement the new (time) series classes.
- The previously package private class ArrayFactory is now public, and the static factory instances of BigArray, ComplexArray, PrimitiveArray, QuaternionArray and RationalArray are now also public.
- There's been additions to the ArrayFactory regarding how to create sparse or segmented arrays.
- New class NumberList - essentially an "ArrayList" backed by ojAlgo's BasicArray hierarchy of classes.
- New class LongToNumberMap - a long -> Number map - backed by ojAlgo's array classes.
- The previously deprecated methods searchAscending() and searchDescending() are now actually deleted, but the corresponding sortAscending() and sortDescending() got new implementation and had their deprecations removed instead.
- There is now a new class EfficientFrontier to complement MarkowitzModel. If you don't want/need to be able set constraints and/or a target return/variance (like you can with the MarkowitzModel) then this new class is more efficient. Particular in regards to reusing partial results when calculating several points along the efficient frontier.
- The MarkowitzModel class now has a method optimiser() that return an instance of Optimiser that enable turning validation and debugging of the underlying optimization algorithm on/off.
- It is now possible to normalize any FinancePortfolio to the precision and scale (NumberContext) of your choice.
- The optional "cleaning" functionality of FinanceUtils' toCorrelations(...) and toVolatilities(...) methods have been improved.
- The DataSource class now implements the new org.ojalgo.netio.BasicParser interface.
- Additions to FunctionSet: atan2, cbrt, ceil, floor & rint.
- Made sure ojAlgo consistently (internally) uses PrimitiveFunction rather than java.lang.Math directly
- Improved the BigDecimal implementations of sqrt, root and the new cbrt functions.
- The resolve methods in IterativeSolverTask.SparseDelegate and MutableSolver, respectively, now return double rather than void or MatrixStore - they return the magnitude of the solution error.
- The method factory() in ElementsSupplier is renamed (deprecated) physical(). In MatrixStore you now have methods logical() and physical() returning MatrixStore.LogicalBuilder and PhysicalStore.Factory respectively.
- The nested class org.ojalgo.matrix.decomposition.DecompositionStore.HouseholderReference has been moved to the org.ojalgo.matrix.transformation package. Further it is now an interface rather than a class.
- The method copyToBuilder() in BasicMatrix has been renamed copy()
- It is now possible to extract complex valued eigenvectors (actually having ComplexNumber elements) using the getEigenvetors() and getEigenvetor(int) methods.
- The eigenvalue array returned by getEigenvalues() is no longer required to always be sorted. If it is sorted or not is indicated by the isSorted() method.
- The solve(...) methods in MatrixDecomposition.Solver are renamed getSolution(...)
- The 2 classes BufferedInputStreamReader and BufferedOutputStreamWriter have been removed - they didn't do anything other/more than the usual streams and reader/writer classes.
- The getStreamReader() method of ResourceLocator now simply return a Reader rather than a BufferedReader.
- The model parameter rescaling feature of ExpressionsBasedModel has been modified. Previously it didn't work very well with extremely large or small model parameters. Now with very large or small model parameters the rescaling functionality is turned off.
- Improved ExpressionsBasedModel's presolve functionality to identify and handle some cases of unbounded and/or uncorrelated variables.
- Added quartiles to SampleSet: getQuartile1(), getQuartile2(), getQuartile3() and getInterquartileRange()
- New builder instances in the BasicSeries interface. If you use them they will return implementations, new to v41, backed by array classes from the org.ojalgo.array package. It is now possible to use just about any date/time related class as a time series key.
- The methods getDataSeries() and getPrimitiveValues() are deprecated, both replaced by the new method getPrimitiveSeries(). Further the modifyAll(UnaryFunction) method is deprecated. You should do modifications on the series returned by getPrimitiveSeries().
- The Access1D.Builder, Access2D.Builder and AccessAnyD.Builder interfaces have been removed. The API of the BasicMatrix builder have changed slightly as a consequence of this.
- Many of the nested interfaces within Access1D, Access2D and AccessAnyD have been moved/renamed to be normal top level interfaces (declared in their own files). Typically this just means that import, implements and extends declarations within ojAlgo have changed.
- New nested interface Access1D.Aggregatable defining a new method N aggregateAll(Aggregator)
- New methods in Access1D - dot(Access1D<?>) and daxpy(double,Mutate1D) that bring basic (primitive double) linear algebra functionality to any/all Access1D implementation. Those are very useful operations to "always" have available.
- It is now possible to specify the initial capacity (the number of nonzeros) of a SparseArray, and a SparseArray can now be emptied / reset to all zeros.
- Fixed a bug that erroneously set null constraints (unbounded) to zero with the MarkowitzModel and PortfolioMixer classes. This was mostly a problem when defining custom constraints on MarkowitzModel instances with lower limits only (the upper limit was erroneously set to 0.0).
- Fixed a bug in MarkowitzModel: Portfolios with shorting allowed and a target return/variance were not always calculated correctly.
- Deprecated org.ojalgo.function.aggregator.AggregationResults as well as the snapshot() method of org.ojalgo.function.aggregator.AggregationFunction.
- There is a new interface BasicMatrix.Builder that specifies the API of the BasicMatrix builder. Previously this was specified by Access2D.Builder that is now removed. The API changed in that the various builder methods no longer return the builder instance, but void.
- Improved performance with sparse and/or structured matrices - refactored existing multiplication code to actually make use of the firstInRow/Column and limitOfRow/Column methods. (Also fixed a couple of bugs related to implementations of those methods.)
- New package org.ojalgo.matrix.task.iterative containing interative equation system solvers such as JacobiSolver, GaussSeidelSolver and ConjugateGradientSolver.
- Two new methods in MatrixStore.Builder - limits(int,int) and offsets(int,int) - that lets you treat a subregion of a matrix as a (full) matrix.
- Changes to BasicMatrix:
- The method add(int,int,Number) has been removed. BasicMatrix instances are immutable! Use copyToBuilder() instead.
- It now extends as much as possible from the org.ojalgo.access and org.ojalgo.algebra packages. Similar methods previously defined in BasicMatrix are now replaced by whatever is in the superinterfaces resulting in some (api-breaking) signature changes.
- As much as possible has been moved up from BasicMatrix to the various interfaces in org.ojalgo.access
- Lots of things have been deprecated to enabled changes (possible) changes in the next version.
- New matrix decomposition factory instances. There is now one factory interface for each of the matrix decompositions as well as standard instantiations for "BIG", "COMPLEX" and "PRIMITIVE".
- The method MatrixStore#multiplyLeft(Access1D) has been renamed premultiply(Access1D), and the signature of MatrixStore#multiply(Access1D) has changed to multiply(MatrixStore). That's because it is now declared in org.ojalgo.algebra.Opreation.Multiplication.
- The class MatrixStore.Builder has been renamed MatrixStore.LogicalBuilder and the method in MatrixStore that returned an instance of it has been renamed from MatrixStore.builder() to MatrixStore.logical(). Further the MatrixStore.LogicalBuilder#build() method has been deprecated in favor of get().
- Fixed accuracy problem with the SVD and pseudoinverse for larger matrices, as well as a problem that could cause indefinite iterations with the SVD decomposition.
- The multiply-method where you supply a target (product) matrix has changed signature. It now returns void, and the target is an ElementsConsumer rather than a PhysicalStore.
- SparseStore now implements ElementsConsumer.
- The signature of the MatrixTask factory methods have changed. You now have to specify boolean flags for symmetric/hermitian and positive definite independantly.
- Improved ConvexSolver. It now has much better performance with larger models. Current tests indicate a 50x speed improvement on a model of roughly 4k variables. With smaller models, < 100 variables, there's no significant difference between the old and new versions. These are internal changes only, but "significant". All unit test pass, but you should expect some changed behaviour.
- Some internal modifications to LinearSolver.
- Fixed bugs in CoordinationSet related to pruning and resampling when the series did not have specified names.
- Renamed Colour to ColourData
- Fixed a bug in CalendarDate#toSqlDate(). The Date was 70 years off. (The bug was introduced in v39.)
- CalendarDate now implements Temporal
- CalendarDateUnit now implements TemporalUnit
- CalendarDateDuration now implements TemporalAmount
Everything (wasn't much) that made use of code outside the JRE profile "compact1" has been removed from ojAlgo. In terms of library functionality nothing has been removed, but there could be incompatibilities.
- Each of Access1D, Access2D and AccessAnyD now has a new nested interface Settable. The "set" methods of the Fillable interfaces are moved to Settable. Fillable and Modifiable now both extend Settable. The Settable interface declares "add" methods to complement "set". The Fillable interface now declares a set of "fillMatching" methods (moved up from some lower level implementations).
- The structure() method of AccessAnyD is deprecated and replaced with shape() that does exactly the same thing.
- The previously package private interfaces Structure1D, Structure2D and StructureAnyD are now public.
- New interfaces Access1D.Sliceable, Access2D.Sliceable and AccessAnyD.Sliceable.
- New package containing abstract algebra interfaces. This doesn't add any new features to ojAlgo. It just formalises and unifies some of the definitions. There are interfaces for Group, Ring, Field, VectorSpace...
- BasicMatrix now extends NormedVectorSpace from the new algebra package.
- MatrixStore now extends NormedVectorSpace from the new algebra package.
- The method scale(Number) is deprecated and replaced by multiply(Number).
- Refactoring of the MatrixStore hierarchy (their methods) due to api changes caused by the new algebra package. There are some new implementations and methods have been moved up and down the hierarchy.
- The methods isLowerLeftShaded() and isUpperRightShaded() of MatrixStore are deprecated and replaced by firstInRow(int), firstInColumn(int), limitOfRow(int) and limitOfColumn(int).
- The roles of the ElementsConsumer and ElementsSupplier interfaces have been greatly expanded. ElementsSupplier is now a superinterface to MatrixStore and it gained additional features. The ElementsConsumer largely defines the extensions to MatrixStore that make out the PhysicalStore interface.
- Refactoring of the MatrixDecompostion hierarchy (the org.ojalgo.matrix.decomposition package):
- The capabilities of the various decompositions have been factored out to new/separate interfaces.
- Integrated/merged the decomposition implementations from JAMA. (They've always been part of ojAlgo, but they were now moved, renamed and refactored.)
- Performance tuning.
- Matrix decompositions can now accept ElementsSupplier:s as input.
- All MatrixStore implementations (except the PhysicalStore implementations) are now package private. All constructors, factory methods or instances are now either removed och made package private.
- There is a new MatrixStore.Factory interface (as well as implementations for BIG, COMPLEX and PRIMITIVE). Through this new factory, and the previously existing, MatrixStore.Builder, you can access all features available with/by the various MatrixStore implementations.
- The MatrixStore.Builder has been cleaned of any methods that would require calculations on the matrix elements.
- The method multiplyLeft now returns an ElementsSupplier rather than a MatrixStore (a MatrixStore is an ElementsSupplier and you get a MatrixStore from any ElementsSupplier by calling "get")
- Some methods defined in the MatrixDecomposition interface now take an ElementsSupplier as input rather than an Access2D or a MatrixStore.
- MatrixStore now extends Access2D.Sliceable.
- There is a new SparseStore class (a MatrixStore implementation)
- Additions to MatrixUtils that get/copy the real, imaginary, modulus and argument properties of ComplexNumber matrices into primitive double valued matrices.
- Refactoring related to BasicLogger and CharacterRing. In particular it is now possible (easier) to use a CharacterRing as a buffering BasicLogger.Printer.
- Fixed a problem where you could get a NullPointerException with debug logging in the ConvexSolver.
- Changed the behaviour of the ConvexSolver (ActiveSetSolver) initialisation so that it now initiates to the optimal solution of the linear part of the model rather than any other feasible solution.
- Improved the presolve functionality of ExpressionsBasedModel to identify and eliminate some degenerate constraints.
- Modified how the initial solution extracted from the ExpressionsBasedModel is composed. Variable constraints are now considered to ensure feasibility. This primarily effects how the ConvexSolver is initialised.
- It is now possible to register solver integrations with the ExpressionsBasedModel. In other words; it is now possible to use third party solvers with ojAlgo's modelling tools. We've already built a basic CPLEX integration. The plan is to build a couple more and to release them all as Open Source here at GitHub.
- Optimisation.Options.slack changed from 14,8 to 10,8 and the logic for how the ExpressionsBasedModel validates a solution changed slightly.
- The ConvexSolver is now deterministic! For many years the ConvexSolver (previously QuadraticSolver) incorporated an element of randomness to break out of possible indefinite cycles. With numerically difficult problems this "feature" could result in varying solutions between subsequent solves - confusing. This strategy has now been replaced by a deterministic one that seems to work equally well, and being deterministic it is obviously much better.
- Slightly modified how the model parameters are scaled before being sent to a solver.
- ExpressionsBasedModel now accepts presolver plugins. The existing presolve functionality has been refactored to plugin implementations that can be individually turned on/off. It is possible for anyone to write an additional plugin.
- Refactoring and deprecations in ExpressionsBasedModel. Among other things all the get/set-linear/quadratic-factor methods are deprecated. There simply called get/set now.
- All select-methods are deprecated and (will be) replaced by the new methods variables(), constraints() and bounds().
- The entire package org.ojalgo.optimisation.system has been deleted. Its functionality is now provided by the various solvers directly.
- SampleSet now has a method getStandardScore(index) that returns the normalized standard score (z-score) of that particular sample.
- It is now possible to swap/change the underlying data of a SampleSet using the swap(Access1D<?>) method.
- Scalar now extends the interfaces from the new algebra package
- Improved numerical accuracy of complex number division
- All public constructors are removed in favour of factory methods.
The first version to require Java 8!
v37.0.0 / v37.1.0
The last version to not require Java 8! (Targets Java 7) No real new features compared to v36.
v37.1 contains a backport of the optimisation packages from the upcoming v38 (as it was 2015-01-31). It has a number of important improvements. Apart from that it is identical to v37, and still targets Java 7.