Proof of Concept

An expert assessment of the impact that AD would bring to your modeling, and business function, giving you the confidence to move forward with an AD investment strategy.

NAG AD experts collaborate with you to integrate an AD solution into your models. We provide assistance in evaluating the effectiveness of the solution, supporting you in demonstrating the impact of your investment.

During implementation, NAG’s AD Consultant Developers will work with you on: ​

• Success metrics ​
• Design support​
• Debugging​
• Performance tuning​
• Handling library dependencies ​
• Selecting features​

Support

With NAG there are no delays to projects and you can have maximum confidence in your operations. Our experts are always on hand to make sure you are safe in the knowledge that there will always be someone ready to help you.​

NAG will provide troubleshooting telephone, email, or video call support on API and features, triaging bugs and fixing them, and “general advice” on AD to a level which ensures the customer gets the best out of the dco/c++.​

Training

Take advantage of the NAG world-class developers and their expert knowledge to train your teams to work with dco/c++ in the most effective way for your business. Our comprehensive training ensures best practices are used and dco/c++ is implemented in the most efficient way and is designed with your specific needs in mind.

What’s new in dco/c++ 4.3

• Enhancement of the codegen feature by introduction of active integers with support for conditions.
• Compile time of generated codes improved by better supporting loops.
• Implementation of experimental debugging feature to detect control flow divergence for finite difference computations.

What’s new in dco/c++ 4.2 

• Enhanced usability through increased cmath function coverage: std::cbrt, std::copysign, std::exp2, std::log2, std::scalbn, std::scalbln, std::fpclassify, std::isgreater, std::isgreaterequal, std::isless, std::islessequal, std::islessgreater, std::isunordered, std::lrint, std::llrint, std::llround, std::nearbyint, std::rint, std::signbit.
• Requirements on codegen loosened: registration of inputs now possible anywhere in the code.
• Enhanced usability through type trait for retrieving the vector length from a dco/c++ type.

What’s new in dco/c++ 4.1

• New data type ‘dco::multi_mode’: This release brings a new data type that can combine arbitrary dco/c++ functionality in one go. It is intended to reduce the number of required instantiations of the underlying code. This reduces the complexity of the build system and leads to an expected reduction in compilation times. With this type, you can, e.g., record a tape and, at the same time, propagate vector tangents.
• API update for Jacobian preaccumulator and the local gradient functionality (factory methods).
• More precise information on memory consumption enabled by new enum (`dco::size_of_e`).
• Enhanced debugging capabilities: Beside writing the tape in csv- or dot-format, we now enable to print the tape to a stream in a human-readable format.

What’s new in dco/c++ 4.0

• Code generation: A hybrid technology that combines the efficiency of source transformation with the flexibility and ease of use of an operator overloading tool, with support for primal, tangent and adjoint code. This supports all combinations of scalar and vector modes for computing first and higher derivatives.
• The use of source transformation gives two advantages: in the transformation step and in the compilation step. In the transformation step, they can implement optimisations based on properties of the underlying differentiation rules. In addition, in the compilation step, the built-in optimisation passes of steadily advancing compilers are simply inherited. Showstoppers usually: Applicability and maintainability. 
• dco/c++ 4.0 uses overloading techniques to generate a representation of the program in memory, and unparse the various modes (primal, tangent, adjoint) into a C++ file. The dynamic nature of this approach (building the representation at run time) introduces an important constraint on the code to be differentiated – the control flow is not allowed to depend on input data. We overcome this constraint for branches with smart use of modern C++ features such as lambda expressions, in combination with classical elements from the preprocessor.
• Support for std::ldexp and std::frexp.
• Aligned memory allocation by default. In some circumstances, this leads to more efficient memory access for vectorized operations.
• Requires C++17 now.