LMath and Components 0.6.1

Components

lmFilters. For TMoveAvFilter and TMedianFilter, possibility of a filtering in real time, during data aquisition, is added. In TGaussFilter, new event, OnInputBackward, was added. This was necessary because TGaussFilter algorihtm fulfils filtering in two steps, first from beginning to end (forward filtering), and this once filtered dataset is subsequently filtered from the end to the beginning. If the calling program keeps initial dataset unmodified and places the filtered data to a new one, you must define the OnInputBackward event such that it reads data from the new, filtered, dataset. If you filter data in situ, modifying initial data, defining this event is not necessary; filter will use the usual OnInput event both for forward and backward filtering. Now lmFilters uses uVectorHelper and uFilters from LMath library. Hence, functions GaussCascadeFreq, GaussRiseTime, MovAvRiseTime, MoveAvCutoffFreq, MoveAvFindWindow were removed, because they are contained in uFilters.

lmRecursFilters. This is a new unit, which defines several new filters: THighPassFilter, which passes high frequency and stops low; TNotchFilter, which filters out a narrow band around a selected frequency and may be useful for example to filter out 50 Hz hum; TBandPassFilter, which passes only selected band; TChebyshevFilter, which implements a Chebyshev type filter. All these filters are able to filter in real time mode.

LMath

In the unit uVecUtils from the package lmMathUtils 1. Version with open arrays was added for function ApplyRecursive.

1. function FirstElement: -1 is returned if nothing is found. Previous behaviour: \code{Ub+1} was returned. Reason for change: -1 is definitely impossible value, therefore it is easier to organize testing.

2. function CompVec: if compared arrays have different length, the function returns normally and FALSE is returned. Previous behaviour: incompatible dimensions error was generated. Reason for the change: vectors of diffrent length are indeed not equal.

3. Apply, ApplyRecursive, InitWithFunc, CompVec, Any, FirstElement, MaxLoc, MinLoc, Seq, ISeq, SelElement: check for Lb<0 added.

4. In the unit uMeanSD_MD functions LastDefined, StdErr, Defined, and Undefined for array element added; for many functions versions with open arrays added or default values Lb = 0 and Ub = -1 added, where -1 means to use High(A) for Ub. These changes allow to omit Lb, Ub at a function call.

5. In the unit uStrings, functions ArrayToStr and ArrayToStrMD added.

6. In the unit uMinMax, function InRange added.

LMath and Components 0.6.0

1. Package lmDSP created, which contains functions for digital signal processing. It includes uFFT unit for fast Fourier transform, moved from lmOptimum package, and new units: uConvolutions, for convolution of two arrays of Float, uDFT unit, for digital Fourier transform of signals with length other then degrees of two. Importantly, this unit is distributed under GPL license, not LGPL, as the rest of the library. Unit uFilters contains procedures for various data filtering: low pass, high pass, bandstop and bandpass.

2. Call convention of many functions and procedures working with arrays is revisited. Mostly for historical reasons, related in part to Fortran inheritance, in part to limitations of old Pascal implementations, standard API of DMath/LMath includes passing of a dynamic array (TVector, TIntVector, etc) and bounds of a slice which is actually processed by a function (Lb,Ub). Function Apply(V:TVector; Lb, Ub:integer; Func:TFunc) is an example of such call. This approach has an important limitation that only dynamic, but not static, arrays may be used with LMath. Besides, mandatory passing of bounds, even if the whole array must be processed, makes the call too complicated. Modern Pascal implementations have open array parameter mechanism and even allow to pass slices of arrays, both static and dynamic. Therefore, as an experimental feature, LMath 0.6 introduced new form of function calls where instead of V:TVector, Lb, Ub:integer, open array is passed. Apply in this new form looks like: Apply(var V:array of Float, Func:TFunc); In most cases, old forms are kept for backward compatibility as overloaded functions. Operators over arrays defined in uMatrix unit were also redefined for open arrays. This makes them much more flexible. For example, it is possible now to write: V := MyArr[4..9]+AnotherArr[7..12], which will create V:TVector with length 6, containing sums of elements MyArr[4]+AnotherArr[7], etc. Work with new call conventions is still in progress and this feature is considered experimental. For now, functions and procedures from uMatrix, uVecUtils, uCompVecUtils, uMedian, uMeanSD, uFFT got these new forms. New units have only form with open arrays. Unfortunately, there is now way to define open two-dimentional arrays, therefore all operations with TMatrix keep old form only. It must be noted, that in some cases subtle differences in implementation of functions in these two forms exist. For example, function Median(V:TVector,Lb,Ub:integer); gets V by reference, as always with dynamic arrays and rearranges it in the process of median search. In contrast, function Median(V:array of Float) gets it by value, hence, old array remains unchanged. This is done deliberately to avoid unwanted side effect. In most other cases open arrays are passed by reference, either as var or constref parameters.

3. In uTypes unit, Euler constant defined (base if natural logarithms).

4. In uComplex unit, in one of the previous releases function CReal was erroneously renamed to CFloat. Now it is corrected.
5. In uComplex unit, functions CToPolar and CToRect added, for conversions between polar and rectangular representations of complex numbers.
6. New unit uCompVecUtils in lmMathUtil package. The unit implements several utility routines for work with arrays of Complex numbers, somewhat similar to uVecUtils for Float.
7. Unit uEval now initializes variables Pi and Euler with the values of corresponding constants, so they can be used in expressions. In principle, a user can modify them, but it is of course is not advisable.

LMath and Components 0.5.1

This is mostly bug fix release.

Bug fixes

1. All packages are distributed now with very conservative optimization options to ensure compatibility with any system.
2. Fixed bug in COBYLA implementation (package lmOptimum) which delayed convergence and in some cases lead to algorithm failure.
3. Fixed bug in uGauss (package uSpecRegress) which sometimes lead to inaccurate model fit.
4. Fixed errors in TVectorHelper.Remove and TVectorHelper.InsertFrom functions (uVectorHeplers, lmMathUtil).
5. Note that lmLineAlgebra package renamed to lmLinearAlgebra.

New functionality

1. For convenience, package LMath added, which depends on all packages. Hence, it is sufficient to add it into the dependencies of your project instead of every needed package of the library. Drawback is slightly longer compilation time.
2. Unit uVecFileUtils added to lmMathUtil package. It implements procedures and functions for loading of TVector or TMatrix from a delimited text file, or for saving them into delimited files.

LMath and Components 0.5

This is major release which contains many changes. Main of them are listed here. What was changed in LMath compared in DMath in more detail is described in New_in_LMath.pdf document. Besides, all procedures introduced in this version are labelled as LMath 0.5 in LMath0_5.pdf.

1. Naming of packages and units made more systematic. Now names of all units begin from u (for example, uTypes), while names of all packages begin from lm (for example, lmMathUtil).
2. Units uVectorHelper, uVecUtils, uVecFunc and uVecPrn in lmMathUtil package define several handy functions for work with arrays.
3. Unit uMatrix in lmLineAlgebra defines several general operations over vectors and matrices.
4. COBYLA algorithm for tasks of constrained optimization included in lmOptimum package, unit uCobyla.
5. Procedure for constrained non-linear regression ConstrNLFit in the unit uConstrLNFit which uses COBYLA algorithm included in lmRegression package.
6. Procedure LinProgSolve in the unit uLinSimplex, package lmOptimum implements simplex method for solution of linear programming problems.
7. Unit uintPoints in lmGenMath package defines operators over TIntPoint, similar to uRealPoints.
8. Unit uUnitsFormat in lmMathUtils package allows now using of long prefixes (for example, "pico") along with short ("p") ones.

LMath and Components 0.4

In this version:

1. Fixed bug which prevented use of ueval on Unix systems.
2. Unit lmSearchTrees added which defines object type implementing simple binary tree with a search based on string-type Name.

LMath 0.3 Difference with ver. 0.2

1. Expression evaluator (unit uEval in Optimum package) supports names of identifiers with arbitrary length, unlimited number of variables and functions; operator ** added for exponentiation.
2. LMath and LMComponents are distributed in the single archive; documentation is included into this archive too.

LMath 0.2 Difference with ver. 0.1

1. Fixed bug in SameValue which caused float overflow when -MaxNum and MaxNum were compared.
2. procedure MoveInterval(V:float; var Interval:TInterval); and procedure MoveIntervalTo(V:float; var Interval:TInterval); added to Intervals unit. First of them adds V to both Hi and Lo of the interval, efficiently moving it by value V without length change; second one sets Lo equal to V and adjusts Hi correspondingly, such that length remains constant, moving interval to V.