Hi,
I'm trying to understand how the finite-differences American Options
pricing in QuantLib works. Specifically, I've been looking into the
FDDivdendAmericanEngine class but am having a bit of trouble
understanding the algorithm on a high level because of the multiple
levels of inheritance. As I understand it, it implements a Crank
-Nicolson fully centered finite difference method by iterating backwards
in time over a grid of prices, but please correct me if I'm wrong. Note
that I've just been running this class as it's used in the
quanlib-benchmark program.
My main questions involve how the dimensions of the grid are determined:
- How are the number of price levels determined? (They seem to be fixed
at 100 in the benchmark).
- How are the time-steps of the grid determined? Mu understanding is
that these methods typically use constant time steps, but the quantlib
implementation seems to vary them. I determined this by looking in
rollbackImpl() found in finitedifferencemodel.hpp. I don't fully
understand why rollback() gets called multiple times with a subset of
the steps as opposed to calling it once with all steps.
I couldn't find any documentation that describes the algorithms used in
QuantLib, but if it exists please point me to it. Any help you can
provide me in terms of understanding the high-level or my specific
implementation questions would be greatly appreciated. Thanks in advance,
Kyle
-------------------------------------------------------------------------
This SF.Net email is sponsored by the Moblin Your Move Developer's challenge
Build the coolest Linux based applications with Moblin SDK & win great prizes
Grand prize is a trip for two to an Open Source event anywhere in the world
http://moblin-contest.org/redirect.php?banner_id=100&url=/_______________________________________________
QuantLib-dev mailing list
[hidden email]
https://lists.sourceforge.net/lists/listinfo/quantlib-dev
Locked
