Please note: This page has been retired.

You can find current information from the links below

If you need to buy a license for this specific version, please contact us for availability and pricing.

Other information on this page is shown for historical reference only and may have changed considerably since.

Progeneric .NET Template Library (NTL) Features:

• Building software components that will take advantage of multi/many core hardware is much easier using this library.
• New and enhanced algorithms that have a sequential and parallel version (Search vs. PSearch, Transform vs. PTransform, etc.).
• Industrial strength 32-bit and 64-bit containers (Vector32 vs. Vector64, etc.) that coexist in the same environment allowing easy transition to 64-bit Operating Systems.
• Very large persistent containers (FVector32, FVector64, etc.) that can be used as a data repository for your applications.  The limit for the containers is practically your computer memory or hard drive space.
• Extending the library to work with your components is a very easy task; you only need to satisfy a few abstract sets of requirements.
• Isolating the programmer from the complexity of the library implementation (e.g. dealing with threads, locking, allocators, etc.). The library occasionally exposes more advanced features to use only when the library is extended beyond expectations.
• Allowing other tools (e.g. Microsoft LINQ, PLINQ) to work with the library containers by implementing required interfaces.
• Easy to integrate with your software products; just add a reference to the library and you are ready to go.

Progeneric .NET Template Library (NTL) provides containers, iterators, algorithms and function objects (functors) with the following design principles:

• Algorithms manipulate data but are not aware of containers.
• Containers store data but are not aware of algorithms.
• Algorithms and containers interact through iterators.
• Function objects (functors) are the main method of policy parameterization.
• Algorithms are totally decoupled from containers. Adding an algorithm doesn't require you to rewrite any containers.

Some of the common aspects of using this library are:

• It is parallel. Many components take advantage of multi/many core hardware and scale linearly with the number of cores.
• It is extensible and designed to interoperate with your custom components. Using it effectively means extending it.
• It is customizable without inheritance. New iterators need only to satisfy an abstract set of requirements.
• Abstraction does not mean inefficiency. Generic algorithms are as efficient as if they had been written for one specific data type.
• Abstract requirements enforced through a precise set of interfaces are central to these libraries. The generic components provide a new way to think about programming; they achieve abstraction without loss of efficiency.

Reasons to choose Progeneric .NET Template Library (NTL)
Writing parallel software is essential for taking advantage of modern multi/many core computers. It is a tedious task to write high performance, reliable software that executes sequentially. Introducing parallelism to an already complex task can really become a burden on your development and test resources. Remember that the best sequential algorithm may not be the best parallel algorithm, and with parallelism, you also start introducing non-determinism, race conditions, synchronization overheads, etc. These issues just increase development and testing overheads.

The NTL library introduces many parallel algorithms and methods that are very easy to use and fully tested. This library achieves high performance by reducing sharing (especially write sharing) of data across parallelism boundaries to avoid cache coherence overheads and by reducing synchronization overheads. The design was optimized by repeating the tuning and iterating process many times and measuring the progress. Progeneric have written tens of thousands of test cases and thousands of benchmark tests in order to achieve high performance without sacrificing the quality.

It is important to emphasize that Progeneric did not focus only on the parallel code. The libraries have many innovations in every aspect of the software construction, starting with better design and finishing with very high (99%) structural coverage.