tgt

The ILNumerics Changelog

Major improvements found in an ILNumerics release are listed here. Since version 6 ILNumerics Ultimate VS is distributed as a collection of nuget packages from nuget.org.

Changes in version 7

7.1.9

Accelerator first stable version, all CPU resources are automatically and efficiently used. See: documentation.
Improved performance, mainly for small and very small workloads, including scalar workloads.
ILNumerics Visualization Engine and Interpolation toolboxes are now accelerated, too.
Reworked getting started guides.
Performance comparison: ILNumerics, numpy, FORTRAN

7.0.245 (release candidate rc03)

Optimized speed for Visualization Engine: transparent shapes are faster preprocessed, overall faster interactions.
Accelerator: added some missing functions for acceleration, fixed multiple bugs and race conditions.
Started implenting smart rules for automatic detection of parallel potential among array instructions. If no potential speed-up is found, accelerator shall adjust resource utilization accordingly (work in progress).
Free Trial version now works with Accelerator. Make sure to stay on the latest package version during evaluation!
Reworked getting started guides:
- Simple acceleration, sum() expressions
- Strong acceleration with zero effort: Faster KMeans
- Faster (than MKL) Fourier Transforms
- Advantages of Array Pipelining in ILNumerics Accelerator

7.0.230 (release candidate rc02)

Optimized speed for Visualization Engine, mostly for the GDI+ Renderer, but the OpenGL renderer profits too.
Improved rendering results for GDI+ Renderer: removed Z-fighting between lines on top of steep triangles.
Some more optimizations for scalar workload acceleration.
Enum ILNumerics.StorageOrders moved from ILNumerics.Core to ILNumerics.Core.Runtime.

7.0.223 (release candidate rc01)

All static array functions of ILNumerics.ILMath and numpy are now subject of automatic acceleration.
The Accelerator is now a regular compile time dependency of ILNumerics.Computing. It is activated by default for Release builds and can be controlled on code-, file-, project-, or solution level. See: configuration
The Accelerator compiler now supports all indexers (get/set), SetRange members, subarray(), SetValue and all assignment operators in C# code.
The Getting Started section was updated. See here
Fixed several bugs related to thread safety of Array<T> and Logical arrays.
ILNumerics toolboxes for interpolation, statistics and optimization now work accelerated.
This release candidate passes all internal stress tests (robustness, long running and parallel stress tests).
Added support for recent C# language versions: up to C# 12.0.

7.0.163 (Accelerator only: beta05)

ILMath.FFTImplementation is now configurable. By default, ILNumerics uses the managed fft on all platforms. Only when available (Windows, x64 and with ILNumerics.Core.Native package added) optimized, native MKL implementation is used. In order to enforce using the managed FFT implementation or to provide your own IFFT implementation one can now set this value manually: ILMath.FFTImplementation = new ILNumerics.F2NET.ManagedFFTPACK5();
Computing Engine (non accelerated code):
- All numeric and logical arrays are now thread safe in a single writer-multiple reader-manner (lock free reads on arrays, blocking writes). See: ILNumerics threading model.
- Array<T>: removed MaxValue and MinValue properties. They were marked as 'obsolete' since version 5. Use GetLimits() as replacement.
- ILMath.permute(A, dim): removed deprecated overload, where dim is Array<int>, leaving overload for Array<long> and Array<uint> dimension argument.
- Performance: significant speed-up throughout all of ILNumerics.Computing. Especially most unary functions were greatly improved.
Accelerator Compiler:
- low-level kernel support for new functions: abs(complex), abs(fcomplex).
- array pipelining support for new functions: fft, ifft (real / complex, double / single precision, all dimensionalities, managed and unmanaged implementations). See: array pipelining I and array pipelining II.
- the compiler was made more robust on unseen user code:
  - custom, non-supported element types are ignored
  - added support for Logical (assignments, indexing / subarray get/set)
  - added support for recent C# features: file scoped namespaces, global usings, global statements, and more.
- Build speed for Accelerator builds was significantly improved:
  - code replacements now work on all project files in parallel.
Significantly reworked / newly added & highly recommended documentation:

7.0.120 (Accelerator only: beta04)

Accelerator is now more robust when building an VS2022 preview, when using Rebuild targets and when only a certain, small set of SDKs is installed. Building projects on the CLI, via msbuild (all recent SDKs) and from VS is now supported.
Accelerator: new functions supported: bitxor(), mod() and corresponding operators (^ and %) for all numeric element types.
All modules, incremental builds: prevent from some redundant builds.
Accelerator web service currently works with the most up to-date version only! Make sure to have updated your project to the newest version!

7.0.115 (Accelerator only: beta03)

Accelerator now supports: file scoped namespace declarations (C#8.0 feature).
Accelerator now supports: nullable system scalars as input arguments to array parameters in segments,
Accelerator now supports: ILMath.prod(A,dim) function.
Accelerator web service currently works with the most up to-date version only! Make sure to have updated your project to the newest version!

7.0.104 (Accelerator only: beta02)

ILNumerics Ultimate VS is released as version 7.0 for production. The Accelerator compiler stays in evaluation, still.
Accelerator is now active / on by default. Just register the package from nuget to your Computing Engine project: docu
Accelerator: supports many new elementary functions: docu
Accelerator now handles many new array expressions: full (variable) assignments and all partial assignments and reads.
Accelerator is now able to write binary logs of internal events. This allows to monitor and analyze the computing strategy it choses at runtime. Logs create only a very little overhead and can be visualized using a in-house tool, which will be released to the public soon.
Computing Engine: binary operators on integer arrays saturate in ArrayStyle.ILNumericsV4 for compatibility with Matlab. In version 6 this was true for all binary operators, even those, which cannot cause under- or overflow. Version 7 does not saturate by default for the element wise division operator '/'. Saturation behavior (rounding instead of truncating) can be achieved by using ILMath.divide_sat() explicitly.
Bugfix, managed Lapack: pinv(), svd() on complex elements could cause an error in certain situations with high memory pressure. Native Lapack (ILNumerics.Core.Native) was not affected.
Bugfix, Visualization: Label rendering has been stabilized and beautified. This mostly affects the OpenGL renderer.
Bugfix, Visualization: multi-panel setups have been stabilized. Situations, where multiple drawing panels were using shared rendering data (f.e.: shared position buffers for multiple shapes) have been improved.
ILNumerics Array<T> & co can now easily be used from multiple threads. They use a single memory pool concurrently for pooling memory. All objects supporting the arrays and internal functions are either thread local or threadsafe. (Docu follows)
The ILNumerics EULA has been updated to conform with new legal requirements, to make it easier to understand and to make it more clear which companies had to be excluded from licensing.

7.0.-beta01

Introducing ILNumerics Accelerator: importing the nuget package ILNumerics.Accelerator.Command optimizes chunks of array expressions for accelerated, parallel execution on the fastest hardware found at runtime. Start here.
Reworked infrastructure: build times on licensed developer seats are cut into half in most scenarios. By handling more edge cases individually, builds became more robust.

Changes in version 6.0

6.0.148

A bug preventing ILNumerics from running on Ubuntu 20.04 was removed. This potentially also applied to other distros / versions of Linux.
Made Interpolation Toolbox more robust in multithreading scenarios.
Keep in mind: all features of ILNumerics are (intentionally) not thread-safe but one can utilize them on multiple threads simultaneously. Keep your data arrays separate and synchronized!
Removed a reference to internal development packages, left over in the ILNumerics.F2NET.LAPACK package.

6.0.127

Bugfix: matrix multiply, when running with 32 bit or without using the package ILNumerics.Core.Native and if the size of the 2nd argument to ILMath.multiply lays within certain ranges and uses non-column-major storage layout may produced wrong values. This bug does not apply for 64 bit programs.

6.0.124

Updates to XML documentation.
Building tools do not depend on the existence of .NET SDK 2.1 anymore.
Minimal .NET Core SDKversion required for compiling: .NET Core 3.0 SDK

6.0.120

Updates to documentation (code, online).
Visualization: more robust axis scaling for very tiny plots. Now works reliably, even if the controls rendering area becomes empty.
Visualization: new ContentFitModes: ContentXYZ (considers all data dimensions for aspect ratio scaling) and Manual (allows full control over aspect ratio). See: documentation
Computing: more robust complex division (complex and fcomplex data types). This has been a long discussed feature as a result of translating LAPACK to .NET. See: lapack issue.

6.0.119 (Visual Studio Extension only)

Support for Visual Studio 2022 preview.

6.0.115

Updates to documentation (code, online).
Finished upgrading examples to version 6. Most example apps now utilize latest version 6 nuget packages, targeting .NET 5.0.
Fixed issue with *.licx files, which are automatically generated by the Visual Studio WindowsForms designer. The designer keeps (re)generating licenses.licx files which trigger LC tasks to run during build. This relates to the general .NET licensing mechanism and is not related to ILNumerics. However, the LC task often caused errors during build. This fix removes all ILNumerics components from the automatically generated licenses.licx file. Components of other vendors are not affected and should remain functioning.

6.0.111

Incorporated late feedback from beta testers, making the build system more robust for .NET Framework projects (non-SDK and SDK styles).
Allows to recompile projects formerly built on licensed seats (see: https://ilnumerics.net/licensing-scenarios.html) and to change Configuration and/or Platform settings (without changing the code).
Bugfix: building on partially licensed seats (f.e.: Visualization Engine-only license) and targeting non-AnyCPU platforms now works for .NET Framework, .NET Core, .NET Standard and .NET 5.0 targets.
Started reworking and upgrading ~30 of 109 examples to use latest .NET SDK styles projects, .NET 5 and nuget packages.

6.0.87 (unlisted):

Visualization: bugfix in Legend when copying Legends (f.e.: by GetCurrentScene())
Build chain more robust when building for multiple configurations / platforms and for legacy .NET Framework, non-SDK style projects.

6.0.86:

Fixed missing dependency warning during build: ILNumerics.Core.Runtime was referencing non-release dependency ILNumerics.Tools.CodeTransforms. Referenced current version instead. Removed corresponding reference from ILNumerics.Core.
Fixed non-release dependency to Microsoft.CodeAnalysis 4.0.0.0-final2: referenced version 3.7.0 instead.
More clean trace log: got rid of repetitive info messages during startup phase.

6.0.78:

API changes:
- Visualization Engine: ILNumerics.Drawing.MouseEvents now uses ILNumerics.Drawing.MouseButtons for its Button property. It is a drop-in replacement which only requires to adjust the namespace if required. (It makes the ILNumerics.Drawing package independent from WindowsForms for static visualizations. See: upgrade guide vers.6)
No installer anymore.
Visual Studio extension is loaded and installed from the Gallery.
Visual Studio extension does no longer maintain deployment items in your projects. No project is touched.
Licenses are automatically maintained for your projects by the nuget packages.
Support for multi-targeting library development.
Visual Studio extension (incl. Array Visualizer) is free for commercial and non-commercial use.
Visual Studio extension is supported in Visual Studio 2017 and 2019.
Nuget: all modules are distributed as nuget packages from nuget.org. Look for 'ILNumerics_GmbH'.
All packages support .NET Framework 4.6.1 and .NET Standard 2.1.
Compatibility: ILNumerics does no longer rely on native DLLs (exceptions below). LAPACK, FFT etc. which formerly relied on MKL are now available as direct translations of the official netlib FORTRAN sources - as fully managed modules.
ILNumerics.Core.Native optionally adds the known native DLLS for Windows, x64.
Visualization Engine was split into ILNumerics.Drawing (.NET Standard 2.0) and ILNumerics.Drawing.Platforms (requires Windows, .NET Core App 3.0 / .NET461).
HDF5 requires x64 and is supported on Windows and Linux. The beta package targets x64, will be AnyCPU in the release.
Bugfix, Visualization: when plotting very small constant (i.e.: all equal) values in PlotCube configured for logarithmic scales auto-scaling and Reset() did not function correctly.
ILNumerics.IO.HDF5 : string datasets with fixed length and NULLTERM padding mode: detect and allow non-terminated strings when reading in from H5StringDataset.
BaseArray (and therefore all array types) support IDisposable interface. This is for rare situations only, where you are handling untyped arrays and cannot rely on the common array disposal by Array<T>.
Substituted BinaryFormatter throughout the library (obsoleted by Microsoft).

BETA04:

translated managed MINPACK as last native fallback (Optimization toolbox).
removed trial messages from Array Visualizer (not needed anymore).
fixed a bug in ILNumerics.Drawing when assigning new scenes, as in: 'panel.Scene = myScene': mixed up mouse click handling.
removed some left-over PInvoke definitions for netstandard targets.
Visualization / ILNumerics.Drawing: more robust positioning of 2D PlotCube scenes within the cube, when very small scales are used for individual or all axes. Better positioning of PlotCube content along the Z axis: 2D scenes are now at Z=0, with a depth of 1.0.
Visualization / ILNumerics.Drawing, mouse click events are only triggered when not preceeded by dragging actions. I.e: when the mouse had moved after pressing down for more then a certain amount of pixels (3) the click event will not trigger when the mouse button is released. MouseUp does trigger, though.
Visualization: new setting controls 'natural' aspect ratio of 3D plots: ContentFitMode.
Visualization: improved documentation of plot cube properties: DataScreenRect, more
ArrayVisualizer: made styles & colors more coherent. Fixed styling issues in dark and light schemes.
ArrayVisualizer / ILNumerics.Drawing: fixed a bug in plotcube, where logarithmic scales did not work in certain configurations of AspectRatio and ContentFill modes.
nuget: updated documentation for all modules on nuget.org.

BETA05:

bugfix in HDF5 module: compound datatypes for ILNumerics.complex and fcomplex are not reused but recreated on the fly at each attempt to write to/ read from a dataset.
ILNumerics.IO.HDF5 package now references the same version of ILNumerics.IO.HDF5.Native, which will also be updated by each release.
Visualization: new rotation method property 'PlotCube.RotationMethod' allows to select between 'EulerAngles' (rotation as in version 5, default in vers. 6 and going forward) and 'AltitudeAzimuth' (rotation limited to locked spherical coordinates, more simple and commonly known from other visualizers).

BETA06 (RC1) / 6.0.78:

improved compilation speed of parent projects, having only 2nd level dependencies to ILNumerics, but no direct reference to ILNumerics modules.
license compiler automatically detects during build, when runtime licenses are really required (skipping more special cases where it was not needed).
added / improved documentation on following Visualization topics, dealing with plot cubes:
- PlotCube positioning and sizing (ScreenRect & DataScreenRect)
- PlotCube aspect ratio modes, including real-world aspect ratio for rotating 3D scenes

Changes in version 5.5

Kriging interpolation more robust regarding floating point issues. Preventing from NaN values in kriging() and KrigingInterpolator.
ArrayVisualizer, text output:
- adds configuration option for row/column major display. (sponsored feature)
- better handles huge data, displays beginning and end of dimensions, and allows to configure the overall number of elements and maximum number of elements per dimension to be displayed.
ArrayVisualizer: visualizations based on graphical plot cubes now allow to better control the size and aspect ratio of the content. Four new size states iterate all permutations of: aspect ratio modes and/or enlarging the plot cube by also using the space for its axis labels.See: plot configuration
ArrayVisualizer: plot cube panels reset the plot cube to its initial XY-plane view when enabling 2D mode (via the 2D / 3D button)
ArrayVisualizer, Array Descriptor: user entered descriptor components are now locked and not overwritten by actual array data from memory. Can be disabled by a new menu item: Auto Update Array Properties.
ArrayVisualizer, ArrayDescriptor: locked components are now unlocked by holding CTRL + clicking on them with the mouse. CTRL + ENTER clears the whole array descriptor expression.
ArrayVisualizer, ArrayDescriptor: interactive, context sensitive hints are now provided as tool tips.
ArrayVisualizer: supports Visual Studio theming. Optimized display for dark and light themes. We like it a lot.
ArrayVisualizer: reordered tool strip menus for more clean usability. In top-down order: expression -> plot style selection -> plot output controls -> output.
Visualization, PlotCube: the blue selection rectangle when zooming with the mouse on a plot cube in 2D mode now works for all aspect ratio settings.
The blue zoom selection rectangle exposes new property 'Points'. PlotCube.First<SelectionRectangle>().Points, gives access for further configuration to the Points shape used and enables arbitrary configuration. (user request)
Bugfix: the zoom selection rectangle was showing misplaced positions in certain configurations (aspect ratio). The zoom result was not affected.
KrigingInterpolator constructor adds optional parameters: Alpha and Beta of the default power law variogramm. Both parameters are read-only. [this is a breaking change]
Drawing Extension Toolbox: new SmoothSurface class adds support for quickly generating beautiful surfaces out of scattered data points and smoothing the result to configurable extent. See: https://ilnumerics.net/scattered-data-smooth-surface.html
AspectRatioMode for PlotCubes created with TwoDMode=true (default) remains 'StretchToFill'. For plot cubes in 3D mode (TwoDMode=false) the new default value is 'MaintainRatios'. Therefore, 3D plot cube content now looks more natural during rotations with the mouse. Set plotCube.AspectRatioMode = AspectRatioMode.StretchToFill explicitly to get the former result.
Bugfix: using markers on line plots with varying marker styles was causing the markers filled area to be empty when an empty style had been used before.
Computation: Array.ToString() optimized for long / ulong data types. Better visibility for large arrays in both: column - and row major order.
ArrayVisualizer: more robust. Removed race condition on some graphical display types, could cause freeze at intitialization.
ArrayVisualizer: respects default renderer setting from VS-> Tools-> Options-> ILNumerics during startup and initialization.
[Patch, 2020-09-18] made VS extension more robust. Removes an issue where users encountered failures loading the extensions Options pages into Visual Studio options dialogs. The new file version is: 5.5.7566.3169.

Changes in version 5.4

Improved display of array content in Visual Studio tool windows, in Data Tips and in ToString() conversions. The values of two new Settings are considered:
- ILNumerics.Settings.ToStringMaxNumberElements
- ILNumerics.Settings.ToStringMaxNumberElementsPerDimension They determine upper limits of number of elements to be shown for arrays. Settings.DefaultStorageOrder / Settings.ArrayStyle affect the display too: order pages in ColumnMajor / RowMajor order.
Array Visualizer outputs are not scaled down by default. Even large and huge arrays are attempted to be drawn in full size. Down-scaling can be enabled in Visual Studio Tools->Options->ILNumerics.
Improved support for Visual Studio 2019: no package load warning message (removed deprecated APIs)
Added support for .NET Core 3.1. Microsoft.Windows.Compatibility pack is required (nuget). Visual Studio 2017 or newer is recommended for working with .NET Core. See: getting started
Added support for Windows.Forms projects on .NET Core 3.1. The 'Microsoft.Windows.Compatibility' nuget package is required. See: getting started
Dropped support for Visual Studio 2013.
bugfix: Array Visualizer windows were observed to be transparent/blank in certain situations. This was related to VS2019 when used with multiple displays.
improved handling of automatically generated license files: only ilnumerics.lic is changed during build. Removed all temporary files from recognized project (sub-)folders (.NET Core projects).
Several bugfixes in subarray creation in numpy and Matlab^(R) styles, mostly related to advanced indexing using index arrays.
bugfix: Statistics toolbox: nanmean() produced incorrect values.
Visualization Engine: PlotCube now respects the setting of AspectRatioMode. Default is: MaintainRatios. The old behavior (StretchToFill) may caused small distortions when rendering graphical objects inside PlotCube. See docu and this example.
Performance improvements: interpolation (spline, multi-dim. polynomial and kriging) on large data.
Performance improvements: memory management for x64 targets, better dealing with high memory pressure hosts.

Changes in version 5.3

bugfix in SVD. Overloads with additional output parameters produced a memory leak when called in a loop. Potentially, AccessViolationException may happened when called from multiple threads.
bugfix in eig, eigSymm, chol, fft?, ifft?: when called under memory pressure, GC could cause premature disposal of temporary, internal buffers -> AccessViolationException.
all computational memory is aligned on 0x4000 byte VM address boundaries (for efficient shared memory handling on Intel Processors and integrated OpenCL GPU devices in the upcoming ILNumerics Accelerator).
Support for arbitrary value types T for writing to subarrays and views, even when defined by index arrays.
Array Visualizer: fixed several bugs for handling / displaying large arrays, strided views. Made faster and more robust.
Visual Studio Debugger: support for Locals window. Keeps local arrays and return type arrays alive when being displayed in locals / watch windows. Please report any cases of debug windows interfering with arrays memory management!
Improved initialization of numpy module: (much) faster startup by caching predefined items.
Bugfix in Cell arrays: cell content is now properly disposed after cell expansion via subarray assignments.

Changes in version 5.2

fine tuned internal parallelization flags and properties
adjusted start configuration size for parallelizing operations on small(-ish) arrays
improved performance of license verification for numpy module
new ThreadPool implementation: improved performance for small / mid sized arrays
bugfix: ShowLabel property on contour plots failed for contour lines with too short segments
faster memory pool (x86): when relying on GC (i.e.: long loops involving large arrays w/o Scope.Enter()) GC based cleanup will now be faster, eliminating OOMs in most cases.
speed improvements for binary functions with multiple singleton dimensions.
new generator function: vector<T>(long length, Func<long, T> func); initialize values by index.
new overload for ILMath.apply(A,B,Func<T1,T2,long,Tout>) provides the index of the element to the inner generator function.
bugfix contour plots: ShowLabel property auto configuration failed for small segment sizes.
fixed a bug in installer: upgrading installs finished incomplete on some machines and required to manually install the VS extension afterwards.
New upgrade policy: before installing ILNumerics do manually uninstall any ILNumerics version via Add/Remove Programs (/'Programs & Features') first!
ILNumerics is now prepared to work with Visual Studio 2019 (loading packages asynchronously).
new overload for ILMath.logical(size, order, clear) allows to create (large) logical arrays from scratch.
bugfix: indexing with multi-dim. boolean arrays and region ranges failed in certain cases.
[numpy API] new functions: ILNumerics.numpy.all(),any(),cumprod(),cumsum(),max(),mean(),min(),prod(),put(),repeat(),sum()
fixed bug in bessell1 function, for x values larger than 8
improved support for non-primitive array elements (custom structs). Many creation, storage, retrieval and array modification functions are now working with arbitrary custom structs T as array element type.
Drawing: fixed bug in pickingdriver when picking lines
bugfix in Quicksort (ILMath.sort etc.): sorting with NaNs may returned wrong indices for NaN elements in some cases.
Updated EULA: new version includes new planned licenses: Personal, Academia and Corporate (existing and future business customers). See: https://ilnumerics.net/media/EULA.pdf
Visual Studio: several improvements to Array Visualizer. More stable and faster with large / huge arrays.

Changes in version 5.1

The maximum number of dimensions for ILNumerics arrays is now 32. The value can be retrieved from ILNumerics.Size.MaxNumberOfDimensions.
The 'Array<T>.size' property provided for compatibility with numpy, returning the number of elements has been renamed to 'size_' (with a trailing underscore) to prevent from ambiguity issues in case insensitive languages (Visual Basic).
Array<T>.GetArrayForRead(StorageOrder): new optional parameter 'order' allows to control the storage order of the elements copied into the return array.
All creation functions have a consistent API: ones<T>(InArray<long>, order) was added.
All functions receiving N dimension indices/specifiers now have at least one overload allowing to provide an array of indices. Use this if the number of dimensions exceeds 7. Examples: A.GetValue(), A[] (indexers), A.item(), A.itemset(), A.put(), A.SetValue(), A.SetRange(), A.Subarray(),...
Numpy semantics for ILNumerics arrays is enabled by adding a reference to the ILNumerics.numpy module in the project. The ILNumerics.numpyAPI namespace was removed.
Finished converting ~100 online examples to version 5: https://ilnumerics.net/examples.html
Reworked ToString() for ILNumerics arrays: Large arrays will be abreviated, showing start and end of each dimension only. Overloads exist which allow to control the limits.
ToString() now displays elements according to Settings.DefaultStorageOrder (which is controlled by Settings.ArrayStyle): ColumnMajor - paging along first 2 dimensions;
RowMajor - pages along the last 2 dimensions.
ILMath.cross() now accepts arrays with more than 2 dimensions. The working dimension can be determined by the user and must have at least 3 elements. The way the working dimension is determined automatically by the function has changed. It now takes the first dimension of length 3 or restarts searching for the first dimension being longer than 3.
Removed some installer problems reported for 5.0. Prerequisite versions are more relaxed, accepting earlier installations of VS2017 too.

Changes in version 5.0

This release puts a strong focus on the Computing Engine. It introduces great improvements to the price of some required code adjustments. A comprehensive upgrade guide will support you to get up&running quickly.

New system requirements / supported tools:

Version 5 targets .NET Framework 4.5.2 or above.
Installs into Visual Studio 2013, 2015 and 2017. Dropped support for Visual Studio 2010 and 2012.
The installer does not run quiet anymore! It elevates and triggers the VSIXInstaller and requires your attention during install.

General changes:

removed the "IL..." prefix from almost all ILNumerics class names. 'ILNumerics' and 'ILMath' are the only major exceptions.
when creating vectors the default orientation corresponds to the new Settings.ArrayStyle: column orientation for ILNumerics/Matlab style. 1D vectors for numpy style.
many integer parameters changed from int -> long. Values / parameters corresponding to the number/index of elements are now 'long'. Ex: A.S.NumberOfElements, A.Length.
some parameters semantically refering to unsigned values now expect the unsigned version of the former integer type. Ex.: Settings.MaxNumberThreads.
removed unneeded settings: Settings.CreateRowVectorByDefault, all profiling settings (MemoryPoolProfileMaxLength, MemoryPoolProfileMinLength, MemoryPoolProfileFileName, MeasurePerformanceAtRuntime), UseThreadAffinity were all removed.
Replaced all ILNumerics specific exceptions: ILArgumentException, ILArgumentSizeException, ILIndexOutOfRangeException etc. were replaced with System.ArgumentException, IndexOutOfRangeException, InvalidOperationException or NotSupportedExceptions. Refer to the class reference for details.
more robust licensing: usernames are not case sensitive, FIPS policy can be enabled on the system.
ILapack and all other native interfaces now expose pointers where earlier managed arrays were returned.
Settings.ArrayStyle: new thread local setting to match the behavior of arrays to Matlab or numpy. See: /array-styles_v5.html
Settings.Ensure(): helper function for safely ensuring a certain value for a setting over a limited code area only.
Settings.BroadcastCompatibilityMode was removed. All broadcasting follows the same, common broadcasting rules. Operating a row vector [m] with a column vector [1,n] produces a matrix [m,n].
ILMath & all toolbox classes are now static classes, suitable to be used in C# 'using static ILNumerics.ILMath' statements.
the setting of the optimal number of threads for the MKL is now more robust. (some users reported problems with too many threads being spanned by the MKL in version 4)

Array changes:

removed deprecated properties: ILBaseArray.D, ILBaseArray.Dimensions
A.S.NonSingletonDimensions now counts empty dimensions of A as non-singleton dimensions.
mutating A.Reshape() was removed. Use ILMath.reshape() instead!
creating arrays from existing System.Array does not reuse the System.Array anymore. Instead a copy is made and the source System.Array is not referenced by ILNumerics after the Array<T> has been created.
Casting from multidimensional system array T[,,..]: The shape of the new array now correctly reflects the shape of the source array: a 2D float[,] array of size [4,5] results in a (row-major) ILNumerics 2D array <float> [4,5]. In version 4 a transposed version was created. In version 5 rows remain rows. Columns remain columns.
A.Equals(B) now returns true on empty arrays of the same shape and element type.
improved ToString() for all element types, especially complex and fcomplex.
improved pretty printing for DataTips in Visual Studio, better recognizing NaN, +/-inf
A.GetLimits now ignores NaN values. New overload for floating point types, optionally ignoring +/-inf.
A.MaxValue, A.MinValue are now deprecated. Use ILMath.maxall()/minall() or A.GetLimits() extension methods on numeric arrays A instead.
A.IsMatrix now returns true if A stores less than 3 dimensions.
Iterators have been improved/reimplemented. ILNumerics arrays can now be iterated along the columns or along the rows. The A.Iterator(order) extension methods are imported from the ILNumerics root namespace.
New A.IndexIterator() extension methods on numeric arrays return the values of A in given order casted as <long> indices.
Array<T>'s property 'Name' has been silently and shamefully removed.
A.Size.ToIntArray() changed the return type from int[] to RetArray<long> and is now deprecated. Use A.shape instead!
ILNumerics arrays are now compatible with Matlab & al. arrays (Octave, Julia, etc.) AND numpy's ndarray. For latter include the ILNumerics.numpyAPI namespace in order for the numpy extensions to show up on arrays.
Value type elements are now stored on the unmanged heap from the process' VM. Arrays are no longer limited in size. Elements can be accessed by C# pointers or native libraries without pinning.
Arrays now allow arbitrary storage orders, including row major and column major. A.S has new properties / functions handling with that: StorageOrder, GetStride(i).
Subarrays are now even faster, optimized for ranged access AND single element access, compatible with both: Matlab and numpy.
bitwise and logical binary operators |,&,^ are now applicable on two Logical or two integer arrays and behave as expected.
Logical arrays implicitly cast to System.Boolean, as in 'if (any(A)) {'. The conversion fails on non-scalar Logicals.
Many new array properties/methods on ILNumerics arrays add compatibility to numpy's ndarray. See: array-members.html

Functions changed:

ILMath.New<T> now returns 'MemoryHandle' objects instead of System.Array T[].
ILMath.minall(), maxall() now also optionally return indices of the minimum / maximum element.
ILMath.multiply(InArray[]) has changed to a function expecting 3 input arrays. multiply(A,B) is kept the same.
all binary functions (ILMath.multiplyElem, mod, add, subtract etc..) have a new, saturating version '*_sat()' which saturates/clamps the result to the natural element types value range/limits. The version without the _sat postfix performs the binary operation based on the system type without precautions. Results potentially wrap around / exceed the limits of the element system type (standard in numpy). The version with *_sat prevents from unintended wrapping but may perform slower.
binary operators *,%,+,-,... perform the operation w/o saturation according to the current setting of Settings.ArrayStyle.
conversion functions renamed: ILMath.tobyte -> ILMath.touint8 (compatibility with other .NET languages)
ILMath.eigSymm(A) always received symmetric/hermitian matrices A. For complex A the return value was of complex element type and has now changed to real elements.
overloads for solving generalized eigenproblems ILMath.eigSymm(A,B,...) were renamed to: eigGen(A,B,...) to prevent from naming conflicts.
multiple (redundant) overloads of ILMath.qr() were merged utilizing C# optional arguments. No change API-wise. Use explicit argument naming in case of ambiguities!
ILMath.qr(A,R,E,economy): The type of the permutation output argument E was changed from <double> to <int>.
ILMath.invert() was renamed to: ILMath.negate(). The interface changed from invert(A, result) to: result = negate(A).
ILMath.vec is deprecated and will be replaced with ILMath.arange. The interface was made more simple (receiving double/ T instead of BaseArray). arange() and vec() have the same API and create evenly spaced vectors over closed intervals.
ILMath.cell(A,B,C,...) was renamed into cellv(A,B,C,...). cell(size,arrays,order) creates new cells with specific size, values and storage order. cellv() quickly creates a cell vector from given array values. See: cell arrays.
ILMath.reshape(), repmat(), ones(), zeros() and other functions formerly expecting ILSize as parameter now expect Array<long>.
creation functions ILMath.ones() and zeros() without a type parameter are now deprecated. Specify the generic type explicitly!
creation functions ILMath.ones(), rand() and zeros() with a single size argument create a square matrix!! (compatibility with Matlab)
new overloads for ILMath.apply<Tin1,Tin2,Tout>(A1,A2, Func<Tin1,Tin2,Tout> func) enable the mapping of elements of arbitrary type by an arbitrary function / lambda.
the functions support value types, reference types, broadcasting and efficient parallel execution. You may use it as general map() function, for selects() and for
complex / conditional type conversions based on predicates.
ILMath.sort(), max(), min(), find() etc: arguments returning 'indices' are now OutArray<long> (Int64).
ILMath.find32() is newly provided for compatibility and still handles OutArray<int> indices.
ILMath.linspace<T>(start, end, length): argument types are more strict now. In version 4 any numeric type, convertible to T was allowed for 'start','end'. Now, parameters are expected as T.
ILMath.empty<T>() can still be used to create 0-element arrays (just like ones and zeros). When given a non-empty size they create arbitrarily sized arrays with uninitialized elements.
ILMath.any(), all(): NaN/Inf values are considered 'not zero' and included in the evaluation. (version 4: ignored NaNs)
ILMath.sumall(), prodall(), anyall(), allall() now always return a scalar, even on empty input.
ILMath.max(), min() now can be configured for controlling the handling of NaN values. (see this issue)

Visualization Engine Changes:

ILPanel.Driver was renamed to Panel.RendererType. This may requires updating the designer code in your projects.

HDF5 API Changes

Arrays stored or retrieved via the ILNumerics.IO.HDF5 API will no longer appear to have their dimensions reversed. Instead, all arrays for / from HDF5 files are considered as having a row-major storage layout.
When accessing datasets via hyperslabs (using subarray ranges / slices / indices) it is recommended to provide suitable index / range specifications for all dimensions in the dataset. This is valid for read /write access. Otherwise the retrieval / data assignment will fall back to regular subarray functionlity on an in-memory copy of the full dataset.

Patch 5.0.6821.2371 (2018-09-04)

ILMath.distL2sq is more robust against floating point rounding issues
bugfixes in optimization toolbox, drawing2 (upgraded to v5)
updated HDF.PInvoke dll (-> 1.8.20)

Changes in version 4.14

fixed a bug in qr(A, Q) overload. For certain shapes of A the result of Q was wrong. The overload qr(A) was not affected.
bugfix for ILBarPlot: when using individual colors for bar groups in grouped mode solid color assignments to individual bars within a group were not working.
Array Visualizer: the history list of expressions entered into the expression text field are now shared with other Array Visualizer tool window instances.
bugfix: _upgrading_ installations of 4.13 may failed to install 64bit managed assemblies on the system. Fixing this required a new minor version.
bugfix in parallelized binary broadcasting operators, like A / B: On large A and non-uniform B, expanding B along the dense dimensions of A, on a machine with a high enough number of cores that a (thread assigned) chunk of the operation lays in the middle of one dimension, neither touching the 1st element nor the last element of this dimension wrong results could be produced. Updating is recommended.

Changes in version 4.13

HDF5: Improved error messages when utilizing subarray definitions which are not translatable into HDF5 hyperslabs and when the fallback of reading in the full array and deriving the subarray from the result using ILArray's subarray feature fails due to an OutOfMemoryException.
HDF5: Improved preview in Visual Studio data tips for datasets and attributes of more than 2 dimensions.
HDF5: Replaced 32bit 1.8.17 with multithreading binaries (formerly 64bit only).
bugfix: ILMath.sort produced wrong results on input arrays containing NaN values and presorted elements otherwise.
Drawing: new default ZFar for ILCamera: 100 (was: 1000).
ILCamera + orthographic view: removed hard range limit of 1...100 for ZNear...ZFar.
Licensing: more robust Visual Studio Options licensing dialog: warn when attempting to leave the dialog without committing changes; warn when no licenses remain active after activation. More speaking error messages in both cases.
This version will be the last version supporting Visual Studio 2010!
Support for Visual Studio 2017. See: https://ilnumerics.net/blog/release-notes-ilnumerics-4-13-detailed
Drawing2: spline plot color of spline lines (ILSplinePlot) now adopts the auto-coloring behavior of ILLinePlot.
Drawing: Default color for low level line shapes (ILLines, ILLineStrip) is now black. This is to make rendering between all renderes more consistent.
Drawing: Improved antialiasing for lines (GDI).
Drawing, GDI: Improved rendering of triangles and lines in one scene, i.e. borders around triangles etc. (similar to polygon offset in OpenGL).
New/improved plot objects in Drawing2 toolbox: stacked area plots, fill area plots, (geographic) region plots, including country-, continent- and arbitrary region plots.

See this blog article for more details: https://ilnumerics.net/blog/release-notes-ilnumerics-4-13-detailed

Changes in version 4.12

Added missing overload ILMath.add(ILInArray<uint> A, ILInArray<uint> B)
bugfix: partly licensed seats (Visual.Eng. only, no Comp.Eng.) may experienced problems in the VS forms _designer_. Projects set up programmatically were not affected.
ILMath.end can now be used from concurrent threads. (proper synchronizing is still needed when using ILArray<T> concurrently, however!)
HDF5: Added full string support. Fixed / variable length. ASCII / unicode. See: HDF5 unicode strings
HDF5: Greatly improved debugger tooltip display in Visual Studio.
HDF5 is now based on the official HDF.PInvoke for all internal low level HDF5 functions. The full low level API is publicly acessible and can be mixed with ILNumerics' high level API.
The HDF5 version was increased to 1.8.17. Multithreading binaries are used.
Reworked online documentation for the high level HDF5 interface.
Drawing2: new plotting types: error bars, candlesticks, box plots, fill area plots. See here.
Drawing2: spline line plots now automatically adjust their resolution parameter acc. to visible display area.
New tutorial sections. This will constantly grow...

Changes in version 4.11

Array Visualizer: added support for elementwise/bytewise offsets in array descriptors: enables visualizing arrays of structs and interleaved data.
Array Visualizer: added support for arbitrary storage schemes (all languages), custom strides.
Array Visualizer: added support for visualizing pointer expressions (int*, double*, ... IntPtr*, &A, &A[0],...) in all supported pointer aware languages (C#, C/C++).
Array Visualizer: added experimental support for F# and FORTRAN (ifort Intel Composer Visual Studio Extension). See: FORTRAN debug plotting manual
Array Visualizer: CTRL + ENTER re-reads array properties from the debug engine (clearing existing array descriptor, if any)
Reworked Array Visualizer documentation
Core: bugfix in broadcasting: multithreaded runs (release mode, no debugger attached) on large arrays pot. produced wrong results in cert. broadcasting configurations. Update recommended.
Core: bugfix in broadcasting: fixes wrong values on max(A,B) in certain, rather special situations.

Changes in version 4.10

added example: FinancialDataSliced3D
added example: FastSurface rescaling
added example: Voxel Volume Slice Viewer (Scattered Data)
added example: Voxel Splices Viewer (Gridded Data)
added example: Bar Plotting (2D and 3D)
added example: Colormapped 3D Bar Plots using ILBarPlotEx
added example: Interactive Colorbar - Changing Data Range by Dragging with the Mouse
added example: Smoothed Heightmap Interpolation in a combined, stacked surface Plot
bugfix in Shapes.Gear15 and similar complex gear shapes. Now working properly with lighting enabled.
improved apidoc on IILPickingResult
speed improvement on picking driver (more efficient array expansion on huge picking results)
added ILSplinePlot (smoothed line plotting)
added ILBarPlot (creates a bar plots in various styles: grouped, stacked, detached, histogram)
changes in ILColormap.Lines style: removed 'Red' as 4th color to prevent from overly repeating colors
new function: ILMath.permute() permute dimensions of n-dimensional array [sponsored feature].
bugfix OpenGL driver: transparent lines based on ILLineStrip caused artifacts / 'crazy' lines during rendering.
vector expansion (broadcasting) -> extended to arbitrary dimension expansion for _all_ n-dim array cases on all binary operators (similar to numpy) [sponsored feature].
Visualization Engine / GDI driver: implemented anti-aliasing for all lines (default:on) and triangles (default:off).
bitand(), bitor(), bitxor() speed up by removing unnecessary range limit checks.
Added property Antialiasing to ILShape. Removed property Antialiasing from ILLines.
Fixed many bugs in GDI Renderer (lines matching triangle edges, depth tests, z-fighting and many more).
Bugfix: improved perspective Matrix4 implementation realizes true-scales on length, shape sizes and camera positions. Now matches real world aspect ratios / sizes: objects twice as far are now twice as small, exactly.
reworked binary INFIX operators: speed up + memory management. Now 'A.a = A + A' in a loop does not use GC anymore.
ILMath.convert<Tin,Tout>() now supports ALL numeric base value element types.
ILMath.ones<T>() now supports ALL numerics base value element types.
[!!Potential breaking change!!] Binary operator != is now more strict: for testing on null of ILArray<T> A use ILMath.isnull(A) or object.Equals(A, null). A != null corresponds to elementwise test and returns an array! Be careful when using it as in 'if (A != null) {..'!
All basic comparison operators (==, !=, <,<=, >, >=) are now overloaded for the following element types: double, float, complex, fcomplex, Int8, UInt8, Int16, UInt16, Int32, UInt32, Int64, UInt64, char.
ILMath.todouble and ILMath.convert now works with all basic numeric element types: double, float, complex, fcomplex, Int8, UInt8, Int16, UInt16, Int32, UInt32, Int64, UInt64, char.
Licensing: now more robust license compilation on systems with more than one SDK version 8.1 (updates) installed. This affects ILNImports2.targets msbuild files only. Old projects having a version 4.9 file of ILNImports2.targets referenced will be updated to the 4.10 targets file version automatically if the old msbuild targets file has not been changed by the user. So in most cases you will not have to act in any way but allow the project reload to happen the first time the project is build in 4.10.
Major upgrade to Array Visualizer Visual Studio extension: added support for bar plots, automatic downsampling of too large array results, more basic numeric element types. A cleaned up UI, more robust internal design, faster evaluation. Support for x64 and x86 on all languages. Support for plain .NET arrays (1dim and multidim, jagged arrays are not directly supported). Support for C#, VB, C++ (! yes - unmanaged C++) The extension can now be purchased as an individual package.
THIS IS THE LAST VERSION OF ILNUMERICS REFERENCING .NET 4.0! We will switch to 4.5.2 with the next release!
Significant speedup in many situations: ILScope internal resource management (WeakReferences) has been optimized. Now on par with 4.8 (which was not using WeakReference for scope objects yet, hence was slightly faster but to the price of earlier OOM exceptions)
Speedup for subarray specialization: A[":;:;3;4"]. I.e.: single string definition, leading full dim(s), trailing scalar dims -> much faster parsing, reuse original storage if possible (saves memory copy).
new parameter for ILMath.csvread/-csvwrite with streams: Added option to leave the underlying stream open.
new plot object in Drawing2 toolbox: ILFillArea: http://ilnumerics.net/fillareaplot.html
new website online
the installer is now signed. This means that we have to rebuild reputation for SmartScreen again (sic). It will take a while and we have to be prepared for a SmartScreen warning popping up during install.

Changes in version 4.9

bugfix in ILMath.svd(A,U,VT,bool,bool): if the small version of SVD was requested, SVD potentially crashed on large matrices
speed up SVD for frequent computations on large matrices
[Viz.Engine] Improved colormaps: new Colormaps.Custom enum value, speed up mapping by factor 40 (for all colormapped plots), more robust handling of colormaps, improved error handling.
Prevents the license helper class from being recreated on each build for VB projects
new line plot constructor: individual X and Y values (single, double prec.)
great speed up for many subarray expressions involving 'full' (right & left side subarrays)
bugfix in ILMath.find(A,limit, C, V): now correctly returns _empty_ C and V, even if no match was found.
increased speed and parallel efficiency for many internal functions, incl. diff(), ones(), array(), ...
more efficient memory handling: allow much larger data sizes before OOMExceptions are generated.
removed: Settings.AllowInArrayAssignments. Assignements to ILInArray<T> is fully supported (but still not recommended in order to enable future optimizations).
new highly optimized function for computing squared L2 (euclidean) distances of two point sets: ILMath.distL2sq.
Default for ILTitle's position is now: TopCenter (was: TopRight).
Removed obsolete, deprecated properties from ILGroup ('Childs')
Optimized auto-detection of number of processor cores used for parallelization
Even more speed improvements regarding more efficient parallelization.
Deprecated complex.INF and fcomplex.INF in favor of (f)complex.PositiveInfinity.
bugfix: ILMemoryPool crashed when used with certain enum types (ILArray<enum>).
bugfix: linspace, meshgrid, repmat are now able to handle and return all empty array shapes.
bugfix: certain subarray configurations involving A[idx, full] = B failed to throw exception on unmatching array sizes for left side assignments.
Visual Studio Extension now correctly handles solution folders.
bugfix: HDF5 resources were left open, creating a memory leak for frequent dataset operations
bugfix: [Optimization] ILLevMar now tracks intermediate gradient norms in a more stable manner.
proper HDF5 library initialization now forced, always.
allow H5Dataset.Set() on such HDF5 datasets larger than possible for in memory arrays (was limitation of ILSize).

Changes in version 4.8

bugfix in OpenGL driver: clean fallback to GDI on too small GL versions (incl. remote desktop, update recommended).
Internal restructuring, introduction of ILNumerics.Toolboxes namespace.
Users of Machine Learning Toolbox from now on have to use ILNumerics.MachineLearning module and class instead of ILMath for the related methods.
Users of Statistics Toolbox from now on have to use ILNumerics.Statistics module and class instead of ILMath for the related methods.
Documentation fixes: eigSymm()
ILNumerics.Drawing: ILTickCollection.MaxNumberDigitsShowFull property of axis ticks is now populated & synchronized to synched scene and recognized for rendering.
csvread now supports complex and fcomplex types.
csvread is now extensible with a custom delegate method to support arbitrary type parsing.
Introduction of ILNumerics.Core, ILNumerics.Computing and ILNumerics.Drawing modules; split from old monolithic 'ILNumerics.dll'.
The namespaces are not touched, but there are individual assemblies now.
The ILNumerics.Core module must be referenced for all projects from now on!
bugfix: when creating ILArray<T> from empty(!) System.Array, T[] or T[,] the shape of the empty source will be retained.
moved ILNumerics.ILMath.GenEigenType enumeration to: ILNumerics.GenEigenType (please adjust your references!)
new function for initializing ILLogical and ILCell as class attributes. See: http://ilnumerics.net/ClassRules.html
Computing Engine: added support for UInt32, bitand, bitor, bitxor (sponsored features)
Visualization Engine: added option for rotating around arbitrary 3D points in ILCamera: ILCamera.RotationCenter
Installer is now able to complete on machines without Visual Studio installed.
Added new functions to ILMath:
gamma, gammaLog, factorial, factorialLog, beta, binomialCoefficients, binomialCoefficientsLog,gammaIncomplete, betaIncomplete, errorFunction, errorFunctionComplement, errorFunctionInverse, logistic, logit, besselJ0, besselJ1, besselJn, besselY0, besselY1, besselYn, besselModifiedI0, besselModifiedI1, besselModifiedIn, besselModifiedK0, besselModifiedK1, besselModifiedKn, diGamma. See: http://ilnumerics.net/special-functions.html (partially sponsored features)
Computing Engine: added support for ~ operator, ILMath.bitnot: bitwise negation of integer elements
Added Visual Basic item template: simple VB computing module
Statistics Toolbox: new ILNumerics.Toolboxes.Distributions: Chi, ChiSquare, Hypergeometric, LogNormal, Normal and Student. New functions: hist, histn, histnc, histc
Added a cmd line tool to license arbitrary machines, w/o internet connection, w/o Visual Studio (see the /bin and /doc folders)

Changes in version 4.7

bugfix: ILMath.multiply failed for certain cases: num processor cores > 4, Release builds, long thin vectors, vector len < Settings.ManagedMultiplyMaxElementSize, MaxNumThreads > 2. This update is recommended!
Visual Studio item templates: will pick correct assemblies now and add them to project.
added new object to ILNumerics.Drawing: ILTitle adds an easy way of labeling scenes.

Changes in version 4.6

bugfix: quicksort single threaded on large presorted data could cause OutOfRangeException
Computing Engine: added poly() functions
bugfix: GDIDriver failed in certain situations on 64bit platforms
new versioning scheme for all fully licensed products: assembly version: major.minor.0.0, file version: major.minor.rev.build. This simplifies updates and deployment of patches within the same minor version (no recompile necessary). Minor version increase: users must recompile their projects.
Release of optimization toolbox: http://ilnumerics.net/ilnumerics-optimization-toolbox.html

Changes in version 4.5

Update MSVCR version for native libs to MSVCR120 (VS2013). Applications must now ensure vcredist[32/64] (VS2013) for redistribution!
Fixed the "Haswell Bug": 64 bit matrix multiply was crashing on Haswell procs

Changes in version 4.4

Update MKL 32/64 bit version: 11.1 Update 6
Added extension support for Visual Studio 2010...VS2015

Changes in version 4.3

fixed ILLineStrip.GetPrimitiveCount(): return 0 for empty shape
fixed: IILMKLFFT.FreePlans() did not correctly free FFT discriptor in MKL (rarely used expert function)
ILGroup.GetLimits(): new optional argument to take the top nodes transformation into account or ignore it
ILColorbar now recognizes/synchronizes ILTickCollection.TickCreationFuncEx (was: must assign to SceneSyncRoot)
ILTickCollection: allow definition of arbitrary styles & label properties within TickCreationFuncEx for custom ticks + labels
bugfix in ILImageSC: interactive data range changes now auto update colorbar infos
ILCircle and ILCylinder now support Copy() and Synchronize() operations properly
ILSurface: convenience overloads for ILArray<double>
ILMath.convert: now handles null arguments correctly
Visual Studio Array Visualizer now fully supports Visual Basic (x86), F# (x86,x64) and C# (x86,x64) debugging
added: ILMath.checknull - simplified syntax for input parameter checks
speedup: more efficient single element Int32 index access on numerics arrays: A[i], A[i1,i2] (left + right side)

Changes in version 4.2

Removed reference to VisualStudio.DebuggerVisualizer v11 from ILNumerics.dll (causing problems in non-VS setups)
Fixed #205: ILPlotCube.Reset() now handles very small view limits down to ILMath.eps (10e-16)
ILTripod: Arrow3D style implemented + interactive capabilities (see reference docu for ILTripod)
ILCamera: new properties: AllowPan, AllowRotation, AllowZoom eases the control of interactive options
Shapes: new shapes available, Shapes.Cone(s), Shapes.Cylinder(s), ILArrow3D
ILShape.Target: made set accessor public, allowing to configure all shapes as RenderTarget World or Screen
Fixed a bug in OpenGL renderer: auto-hover marking for all shapes now working as expected
Fixed a bug in ILPanel: the sharing of identical ILScenes in multiple ILPanel.Scene is possible for OGL drivers now
Added http://ilnumerics.net/scene-management.html
IO.HDF5.H5Dataset: made constructor parameter 'data' obligatory, preventing from accidentally creating too small chunk sizes
Beautified debug output (hover datatips) in Visual Studio for Visual Basic code on ILArray(Of T)

Changes in version 4.1

Implicit conversion from System.Array to ILArray: support unmatching element types and scalar ILArray as source elements (#204)
made internal and protected internal members public: ILNode.Copy, ILNode.Synchronize. Allows the creation of custom scene node objects.
Improved Zoom for ILCamera: new property ZoomFactor prevents from Z plane clipping on extreme zoom settings.
Custom colormaps allowed for arbitrary objects. Use ILColormap.Map(ILArray<float>,float min, float max) for mapping values to colors
Colorbar now able to be used on arbitrary objects more easily: see: ILStaticColormapProvider in reference documentation.
Array Visualizer now working with arbitrary language packs on all supported ILArray<T> expressions.
new ILTripod object: shows the current camera rotation as X-Y-Z tripod
fixed colorbar and axis for use in non-plotcube szenarios
fixed ILOGLLabel depth error on non-camera setups (when used in ILScreenObject)

Changes in Version 4.0

new function on ILLinePlot.Update(): allows more relaxed updates for X, XY or XYZ components
improved string output alignment for ILArray<float>
Legends for line plots: allow Visible properties to be used
PlotCube.Reset() now ignores hidden nodes which are Visible == false
more robust handling of ILPanel setup for GDI drivers (lazy initialization, removes OpenTK reference)
improved compatibility: Intel HD Graphics now better supported (f.e. on Optimus powered Laptops)
more robust disposal for ILPanel & OpenGL renderers (for switching back / forth between different renderers in VS extension)
fixed AMD OpenGL label rendering bug (issue #0191)
fixed a bug in ILPanel, preventing the BackColor property to be selected from within the designer
simplyfied default driver selection: OpenGL on all places except VS designer
removed default Auto-Dock:Fill for ILPanel (this is a breaking change!)
ILCamera: supports zoom (mouse wheel) with orthographic projection
ILCamera: supports Pan (right mouse click) for perspective projection and large objects
ILCamera: fixed a bug causing the synchronization of certain property changes getting lost
ILPanel can now timeout after specified number of ms elapsed. Subtrees can be excluded from timeouts and prioritized for rendering.
new plot type: ILImageSC
sum: allows summing dimension to be > number of dimensions
bugfix for Contourplots: contour lines has not been closed in certain cases
improved label position selection for contour plots
ILGroup: new optional constructor parameter: target, allows definition of rendering target for subtree
ILPanel: new option for picking details on shapes
OpenGL: more robust for legacy cards, compatible context fallback
switched to new installer
deprecated nuget packages
Quicksort: fixed race condition on multithreaded large single vector sorts
Quicksort: now recognized Settings.MaxNumThread setting; if 0 -> sorts single threaded always
MemoryPool: adjusted initial max default size: 350MB
Ultimate VS Extension: now supports EN and DE language packs
fixed AspectMode.MaintainRatios for Orthograpic views for ILCamera (not for ILPlotCube)

Changes in Version 3.3.3

XML driver: smaller output, reduced to 10 supported scene node base types
new ILMath functions: csvread, csvwrite
bugfix: expanding large arrays by index assignments failed to clear the new array in certain situations
bugfix: large surfaces may created corrupted colors (rel. to issue #000176)
bufgix: ILColorbar _completely_ disabled when no suitable colormap provider is found
bugfix: (issue #000171) corrupted memory pool in special multithreading setups, having multiple pools (double, float...) involved
bugfix: automatic detection of MKL native dependencies failed if path contained a '#' character
bugfix: (issue #000179) more robust handling of graphics in VS design mode, defaulting to OpenGL but falling back to GDI within common IDEs (via blacklisting), new Settings switch: ILNDefaultRenderer
switched to OpenTK nuget packages
ILPanel/all renderers clean up properly after Dispose() now -> allows utilization in dynamic environments (e.g. LinqPAD)
bugfix: issue #000185 ILMath.min returned wrong value when used with scalar values only
improved rendering of logarithmic axes: major/minor ticks/grid, log tick labels, automatic scaling
deprecated default tick creation methods on ILAxis.Ticks: TickCreationFunc, DefaultTickCreationFunc
added TickCreationFuncEx: gives more flexibility/context for custom ticks creation
improved text rendering: OpenGL; small fonts are now rendered crisp
got rid of unused dummy objects in ILScene (OpenGL renderers)
homogenized stipple pattern display for GDI and OpenGL renderers
allow ILSize to be used with != and ==; A.S == B.S is now working intuitively (issue #00186)
fixed axis tick-/ main label position for negative tick length (ticks inside plotting area; #00168)
Plot cube: axis tick labels now keep margin (ILAxis.TickLabelMargin) to tick lines
Axes: more robust creation of "few ticks" on smaller plots
bugfix: (issue #00189) InArrays were disposed off unintendedly after returning from a nested function in a multiple scoping setup

Changes in Version 3.3.2

bugfix in GDI driver: points smaller 3px did not render properly
all nodes are not markable by default (was: ILNode.Markable = true)
- !! This is a potentially breaking change in the API! !!
DesignMode determination prepared for VS package hosting
general DesignMode detection for ILPanel simplyfied and made more robust
fixed an issue with signing ILNumerics in NuGet package builds
added array conversion functions from/to UInt64 element types
- ILMath.convert<>(), ILMath.touint64() - needed for upcoming HDF5 API
work around a bug in Xamarin: 'is' operator struggles with generic array value types
added cumprod (feature request #105)
set ILPlotPanel internal -> will not show in Toolbox; use ILPanel instead!
bugfix: dynamic removal of multiple plots from ILScene now working correctly
bugfix: synchronization after dynamic reordering / removal / addition of groups now working correctly
bugfix: #172, corrupted memory pool due to a bug in eigSymm()
bugfix: custom legend item handling improved:
- handling of legends in dynamic situations: adding / removing items, reconnecting plots to items etc.
bugfix: OpenGL buffers now correctly managed in dynamic trees, recreates once a shape changes its buffers
improved synchronization of shapes in scene graphs with shared buffers
improved legend layout: the padding property is now correctly recognized
moved ILNumerics.Drawing.ILColorbar -> ILNumerics.Drawing.Plotting.ILColorbar
ILSurface: 2 new constructors
- provide Z, X and Y values individually (optional)
- construct surface from lambda expressions (function evaluator)

Changes in Version 3.2.2

bugfix: frobenius norm for matrices, homogenized with vector input ('degree' == 0.0)
ccomplex (complex, fcomplex): allow for scalar arguments for one/both parameters
bugfix: spaces in path to ILNumerics.dll made AnyCPU resolution via PATH environment fail
new Settings switch: IsHosted - disable DesignMode checking for Drawing controls in hosted environments (VSTO, LinqPad, ...)
ILPanel in VSTO: auto disable DesignMode detection; no automatic "Fill" docking

Changes in version 3.2

ILNumerics targets AnyCPU – restructured all editions/ packages; see: http://ilnumerics.net/blog/?p=398
Name changed: ILScreenRect.DefaultBorderTag -> BorderTag
Name changed: ILScreenRect.DefaultFillTag -> BackgroundTag
Same names changed for ILColorbar ...Tag public static members
All above -> readonly
ILGroup.Childs -> deprecated + replaced by ILGroup.Children

Changes in version 3.1

improved GDI renderer / web component: scan line triangles
added support for MKL.FreeBuffers() on Windows 32 / 64 bit (requested)
improved stability contour plots: level values outside range
CommunityEdition: new _unsigned_ project file provided
missing terrain.bin data file included
fixed issue: [#00140] some properties not configuable interactively
added code documentation on many places
hide designer visibility for unsupported ILPanel properties
fixed a threading issue in GDIDriver [#00108] and ILBMPBackBuffer
fixed GDI triangle depth buffering on 64 bit (reported)
ILOGLLabel now refreshes render queues after color changes
bugfix: ILColormap.Map now handles empty input parameters (reported)
plot cube: removed redundant group node reference attributes
made ILNode.IsSynchedNode available as protected property (requested)
increased PolygonOffset => 0.001f for lines (affects GDI Renderer)

Changes in version 3.0

new scene graph implementation, ILNumerics.Drawing reworked + now supports GDI+ driver and OpenGL 3.1 + scene based plotting implementation (old 2.0 API is no longer supported!)
bugfix: complete dimension array removal retains other dim sizes
managed matrix multiply: blocked algorithm, huge speed-up
all functions returning / expecting INDICES -> element type Int32 (sort, min, max, find, randperm, knn)
bugfix: subarray remove failed, for row vectors with insufficient dimensions specified
ILNumerics is now strongly named and runs in a medium trust environment

Changes in version 2.14a (patch)

reverted to unsigned assemblies due to several reported issues (signed assemblies will be provided in the pro edition seperately in the future)

Changes in version 2.14

bugfix in mvnrnd: certain input data led to dimension mismatch error
bugfix in ILSize.IndexFromArray, corrected OOB checks
Updated MKL: version 11.1 (Windows, large matrix eigSymm bugfix)
Community + Professional Edition: strongly named assemblies

Changes in version 2.13

implemented cross(A,B,normalize) for array columns
included Powershell module into nuget package, see: http://ilnumerics.net/blog

Changes in version 2.12

Added partial support for ILArray + ToString(), ILMath.convert and vice versa.
Added Complex[].ToILArray and ILArray.ToMSComplex Extension Methods
bugfix: expansion on emtpy arrays with first dim specified > 0 failed
bugfix: sort, on arrays with all but the last element sorted and no nans failed in certain cases do only exist for non-temporary arrays (all except ILRet???)
removed license manager and toolbox license control
introduced Community (GPL) and Professional Edition
removed free and evaluation licenses (-> Community Edition)

Changes in version 2.11

bug in var() fixed: in optimized scenarios may lead to inefficient memory handling
more robust license file handling for Free Trial Licenses

Changes in version 2.10

loading of license from resources more robust: Now works even in secondary app domain scenarios. Recommended: Licenses should be loaded from file if the application is not started within a managed application domain (what happens when started from a console f.e.). This bugfix makes the library ignore an empty AppDomain Resource Manager and try to load the license from a regular file instead.
parallelized randn()

Changes in version 2.9 (bugfix release)

fixes a bug in repmat: repmat did not handle insufficient dimension specifications for row vectors properly

Changes in version 2.8.4408.34136

increased speed of all binary and unary functions
improved vector expansion: more efficient implace operations
some ML functions 2..3 times faster (especially kmeans)
new optimized ML function: distL1 (user request)
more robust license file handling: ignoring common encoding issues
option to (re)load license file at runtime
option to embed license file into execution assembly
removed a common privilege issue with performance counter installation

Changes in version 2.7.4368.41400 (bugfix patch)

bugfix: qr in economy mode failed in certain situations

Changes in version 2.7.4363.39308

bugfix: memory management had limited efficiency in certain situations
ILMath.check: provide "Default" parameter on input 'null'
reworked threading control for MKL
added support for 32 bit Linux, MKL, v.10.3
new Drawing example: LitSurfaceExample
enabled COM/Interop for ILNumerics

Changes in version 2.6.4343.42870

removed namespace ILNumerics.BuiltInFunctions -> ILNumerics
MachineParameterFloat -> MachineParameterSingle
reduced number of supported types
removed reference array feature -> lazy full clones instead
removed CreateReference(), ILArray.R
removed "shifted subarrays"
all binary operators receive arrays of same type only! (or System.Value type)
types array creation: ILMath.create<>, .empty<>, .zeros<>
removed: ILArray.Diagonal -> use ILMath.diag
ILArray.GetShifted -> ILArray.Shifted
removed ILIterator
GetArrayForRead()/-Write()
improved array debugger display
ILCell (always) returns ILArrays!, scalars are unboxed
optional setting: implicitly cast logical array to bool with allall()
ILArray.Reshape does return reshaped array but does NOT alter self
binary functions (add, subtract... ) dimension SIZE sufficient to match (was:shape)
trailing singleton dimensions are not trimmed by default
renamed: ILMath.vector -> ILMath.vec, explicit element type overloads (double, float, int)
A[int[]] is not supported anymore due to conflicts with A[cell(1,2,3,4,5)]
A[string[]] is integrated into A[params BaseArray[]], reducing compiler overload resolution problems .. -> simply replace "new int[]" (double,string,..) with "new ILBaseArray[]"
A[null] -> empty !
new subarray specifications: cell(A,B,2,full,r(1,2)),r(0:end(A,1)-1),full):
- ILMath.end allows simple calculations (via expressions)
- ILMath.full selects full dimension
default vector orientation: column (specification by single dimension)
Reshape on arrays: removed params int[] overload, use ILMath.size(dim1,dim2,..) instead
meshgrid -> return arrays as cell
subarray index specifier can now be mixed between string and array format: A[":",i,end]
ILNumerics.Drawing is integrated into ILNumerics
removed ILNumerics.Drawing.Controls namespace -> ILNumerics.Drawing
changed function signatures for functions with multiple return parameters: removed ref keyword, incoming out parameters (if needed) are expected to be initialized already, f.e. ILMath.empty<>()
removed ILArray.zeros - use ILMath.zeros() instead
cart2pol removed result type. regular new ILNumerics API instead
ILMath.FFT renamed to: ILMath.FFTImplementation (VB compatibility)
ILMemoryPool: created generic equivalents for some functionality
ILMath... API: removed all ref parameter (according to new general API parameter type schema)
C# limited support: var and compound assignment operators are not supported anymore!!
removed namespace ILNumerics.Settings -> ILSettings renamed to ILNumerics.Settings
parallelized all internal functions
complex structs are now serializable
speed up repmat by factor 200
changed typed interface for ILCell: indexer return cells only, scalar cells are dereferenced, added GetArray, GetCell, GetScalar
homogenized interface for ILMatfile
added xor()
enabled virtual vector expansion on matching arrays for all binary operators (saving repmats)
added isempty, mod + % operator, std, var, cov
default orientation for vectors from elements: column vector
conf setting: CreateRowVectorByDefault, defaults to: false / 'column'
renamed ILDimension -> ILSize
renamed A.Dimensions -> A.Size (original is deprecated)
renamed A.D[] -> A.S[] (orig. is deprecated)
added pif (single prec. pi constant)
added epsf (single prec. eps constant)
added nanmean(), nansum()
added license management
reworked all examples
provided 64 bit binaries (MKL)
primary support for MKL now, options for FFTW3 and ACML kept
implemented new memory management
simplyfied ILNumerics.Drawing namespace
removed support for ILFigure, ILControl
removed ILNumerics.BuiltinFunctions namespace; moved ILMath -> ILNumerics
several new settings -> ILSettings class
implemented windows performance counters for memory pool
windows performance counter for thread pool measures