Design and implementation of algorithms

We can translate your requirements to a complete, documented, maintainable, implementation in standard C++ or Python.

When a relatively complete set of requirements exists, we are happy to offer fixed prices for the work, even for challenging/high-risk projects.

Re-implementation of algorithms

In a number of industries, algorithms are researched and designed in high-level commercial mathematical packages such as MathLab, MathCad or Mathematica. After the design stage it is often desirable to re-implement these algorithms in a vendor-neutral, lower level environment. Some of the reasons for this are that:

• It is necessary provide a more concrete, long-lived, interface to the algorithm and allow calling its implementation from a number of environments
• Vendor-neutral implementations have a longer lifetime, are more extensible and often more maintainable
• It is necessary to improve the speed of execution of the algorithm
• It is necessary to make the algorithm OS-independent in order to run it on computational clusters/grids
• Vendor licensing/support costs are prohibitive for roll-out to a very large computational cluster (e.g., 10000+ processors)

We can re-implemented the existing algorithm designs in standard C++, providing a clean interface, very long lifetime, high-performance, OS-neutrality and extensibility.

Speed optimisation of numerical algorithms

We can optimise your algorithm and implementation to improve the speed at which it executes. We can work to your requirements:

• We can preserve the exact numerical output of your algorithm
• Or, we can work to improve the approximations used in your algorithm while producing sufficiently accurate results

Our approach is to consider both the high-level structure of the algorithm and the structure of the low level implementation. We have experience in optimising code for Single-Instruction-Multiple-Data (SIMD) architectures.

This means that in almost every case, we can improve the speed of your program. Further more, when the requirements can be written down sufficiently well, we offer fixed-cost prices: you only pay if the speed improvement reaches the goal we agree in advance.

Reverse documenting implementations

In situations when there is a rapid increase in software functionality and/or rapid turnover of staff followed by periods relative inactivity, it is sometimes the case that existing implementation become insufficiently understood, for example because:

1. It is necessary to extend the functionality
2. It is necessary to explain results of the algorithm (e.g., explaining P/L, suspect pricing of financial instruments, account controlling activities, justifying hardware design decision)

In these cases, we offer the analysis of the source code of the algorithm and update of the documentation to the required level.

Advising on software engineering

One often cited reason for a poor outcome of software engineering projects is poor decision making early on in the project. There usually are number of reasons for such poor decision making:

• Lack of experience with full life-cycle software engineering
• Pressure from the management to accept overly ambitious goals
• Lack of experience of available tools, techniques
• Desire to ensure long-term continuing involvement in the project

As an outside company with extensive experience in software engineering, we can offer independent advice on the decisions made throughout the software life cycle, helping you make your project a success.

Correcting algorithms and their implementations

In cases when a known defect has escaped correction after an extensive analysis by the client, we can offer help in identifying the source of the error and its correction.