tgt

The ILNumerics Changelog

Major improvements found in an ILNumerics release are listed here. Login to your account in order to download the latest version.

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.

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

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.

: 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!

: before installing ILNumerics do uninstall any ILNumerics version via Add/Remove Programs (/'Programs & Features') first! ILNumerics is now prepared to work with Visual Studio 2019 (loading packages asynchronously).

(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()

] 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.

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

: 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) {..'!

] 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

determination prepared for VS package hosting general DesignMode detection for ILPanel simplyfied and made more robust

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

element types work around a bug in Xamarin: 'is' operator struggles with generic array value types

operator struggles with generic array value types added cumprod (feature request #105)

(feature request #105) set ILPlotPanel internal -> will not show in Toolbox; use ILPanel instead!

internal -> will not show in Toolbox; use 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)

: 2 new constructors

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