Advanced equity options portfolio management (sorting, selecting, grouping trades and pricing those that are selected or grouped in any currency). This also includes requesting all the first and second order 'Greek' risk values for all the double-valued input parameters.

For all exotic option pricers (over 40) we provide all the Greeks (1st and 2nd) for ALL the parameters. We even provide a derivative matrix so that you can see all second order (including cross derivatives).

For all exotic option pricers (over 40) we provide solving for ANY double valued parameter. Not just solving for the implied volatility. You can choose from any of the six solver algorithms.

Our library actually creates objects that return string keys. These keys are then passed to other functions in order to either build other objects or to request information. Thus our functions act like a kind of LEGO type construction. This sets us apart from most financial tools where all the parameters are passed into one function and thus all the parameters need to be processed. By building your pricer via objects, you generate faster pricers.

It's the same concept as building a car. You attach 3 or 4 wheel objects, 2, 4 or 5 door objects, 3, 4 or 5 seat objects etc. With this type of construction you can build yourself a customised car object. You do not build a car object by acquiring a lump of metal and then carving out your car object (a single function). This carving out method is the approach that most Excel financial functions are based on. If a change is needed in the future, one has to create a version #2 of the function (carve out a new car object). Via the building blocks method, you simply create a new object to cater for the extended or replaced feature and use this object instead of the previous one.

We provide two types of functions within out library. Functions that create objects internally (object functions) and functions that request information from created object functions (request functions).
Both type of function can take input from other object functions thus you may have an object function that is dependant on several object functions.

Most of the trade object functions are smart objects in that once built, if you execute a request function (request for information) against the object function, it may either simply retrieve the requested value(s) or force the object function to update itself before retrieving the information.

For example, if object function 'A' is dependant (attached) to a yieldcurve object function 'B' and you execute a request function 'C' against the object function 'A' then one of the following may happen :

1. If the yieldcurve object 'B' has been updated (real-time data) *BUT* you have not updated or rebuilt the object function 'A' that depends on this yieldcurve object 'B', then when the request function 'C' is executed the object function 'A' will search through it's dependant list, find that the yieldcurve object 'B' has changed and then update itself satisfying the request function.
2. If the yieldcurve object 'B' has been updated (real-time data) and you have also updated or rebuilt the object function 'A' that depends on this yieldcurve object 'B', then when the request function 'C' is executed the object function 'A' will search through it's dependant list, find that the yieldcurve object 'B' has *NOT* changed and then simply satisfy the request function.

However not all the objects have this updating functionality built in and so when building objects where you wish to use this updating functionality, we suggest that you test this feature within your setup by constructing scenarios similar to the one described above.

We provide low level Monte Carlo functions, thus if we do not implement a monte-carlo financial function that you need, we give you the tools to generate random paths that you can then apply your payoff against.

Most (Excel) financial pricing systems do not support the notion of objects and thus a lot of the grunt work has to be done within Excel itself.

For example risk management of interest rate products. Typically to view sensitivities against all the points on a yieldCurve a spreadsheet builder would have to write a macro that bumps each point and reprices the deal (even if the deal is not sensitive to the bumped point).

Because we make use of smart objects, our interest rate risk engine can not only determine which points on the yieldcurve (or volatility curves) are sensitive to the trade(s), but we can compute these sensitivities internally and report the results in various ways (sensitivity, 3M, 5Y and 10Y principal equivalent (hedge Notional)). In addition we support the computation of DELTA, GAMMA, VEGA and VOLGA for interest rate structures. These results (because they are computationally expensive to produce) can be saved to an XML file for later retrieval and querying.

Advanced yieldCurve strippers that can strip Deposits, Futures, Swaps and cross-currency Basis Swaps (against the dollar) all at the same time. This provides both a discounting and fixing curve in one object.
Thus you can construct yieldcurve strippers for any of the following scenarios :

1. Strips out a curve where one fixes and discounts at LIBOR
2. Strips out a curve where one fixes at LIBOR and discounts at LIBOR+X
3. Strips out a curve where one fixes at LIBOR+X and discounts at LIBOR
4. Strips out a curve where one fixes at LIBOR+X and discounts at LIBOR+Y

You can easily simulate points #2, #3 and #4 above by using two different curves, but you lose the dynamics between the fixing and discounting curves and this is especially important when risk-management is involved.
The introduction of cross-currency Basis Swaps (against the dollar) helps use produce curves #2 and #4 above
The introduction of currency Basis Swaps (same currency) helps use produce curves #3 and #4 above. The Basis swaps curve are attached to Index objects. Index objects determine the characteristics of an interest rate fixing.

Read FpML files and uses either any of the 400+ FpML query functions that have already been pre-programmed for retrieving FpML nodes or apply your own XPath queries. You can even apply XPath queries to any loaded XML file (currently, we do not support namespaces with XML files).

We provide several GENERIC PRICING frameworks.
For Monte-Carlo deals, we provide tools to generate random paths of Equity/FX/Commodity instruments or Interest rate fixings and thus you can price your own exotic payoff that does not depend on American features.
In addition, given a time-dependant user customised payoff grid, one can price almost any type of customised deal not programmed within the library. We provide generic pricing frameworks for

• Monte Carlo (Unlimited correlated equity/FX/Commodity underlying)
• Monte Carlo (One interest rate underlying via a HullWhite process)
• Monte Carlo (One interest rate underlying via a Libor Market Model process)
• Binomial Tree (One equity/FX/Commodity underlying)
• PDE (One equity/FX/Commodity underlying)
• Trinomial Tree (One interest rate underlying via HullWhite or Black-Karasinski process)

The API (application programmer's interface) libraries are meant to be used for embedding into your own programs so that you can take advantage of advanced financial functionality that large major commercial banks themselves use.
You can manipulate these libraries via the following languages : Visual C++, Visual Basic #6, C++.NET, VB.NET, C#, J# and Java on the Windows operating system (Windows NT 4.0 Workstation, Windows 2000 Professional, Windows XP Home and Windows XP Professional).

The libraries are not to be used within a server environment where more than one client connections are made to the libraries at the same time for pricing. The server versions are under development.