american exercise boundary computation
Locked
 
|
Hi all,
i'm new to this list and have only limited experience using quantlib, more specifically in my offtime i work on developing a java application using the (incomplete) clone jquantlib provided by Richard Gomes and his colleagues. however due jquantlib's promise to stick to the original i often look at original quantlib code & examples to improve my learning curve and become more familiar with the extensive fund of algos provided there.
currently my next milestone is the implementation of the early exercise boundary for american vanilla options. my questions now:
- is this already implemented in quantlib (currently i have not found it, maybe i missed it out)
- if not directly how would be a reasonable approach using classes / engines etc. provided by quantlib
to implement such an algorithm.
of course it would be possible to develop such from scratch but of course i'd prefer to avoid re-inventing the wheel in case reliable building blocks are already available.
thx for your support + regards
camillo
|
|
|
Hi Camillo, As you are working with Java, I am suggesting to look into the folder QuantLIb-SWIG. Under this folder you will find several sub dirs, such as Python, Java. You can use SWIG to generate Java binding under the instruction in the Java folder. There is definitely some American exercise related stuff in QuantLib project, e.g. FDAmericanEngine, MCAmericanEngine Regards, Cheng 发件人: camillo [mailto:[hidden email]] Hi all, i'm new to this list and have only limited experience using quantlib, more specifically in my offtime i work on developing a java application using the (incomplete) clone jquantlib provided by Richard Gomes and his colleagues. however due jquantlib's promise to stick to the original i often look at original quantlib code & examples to improve my learning curve and become more familiar with the extensive fund of algos provided there. currently my next milestone is the implementation of the early exercise boundary for american vanilla options. my questions now: - is this already implemented in quantlib (currently i have not found it, maybe i missed it out) - if not directly how would be a reasonable approach using classes / engines etc. provided by quantlib to implement such an algorithm. of course it would be possible to develop such from scratch but of course i'd prefer to avoid re-inventing the wheel in case reliable building blocks are already available. thx for your support + regards camillo View this message in context: american exercise boundary computation ------------------------------------------------------------------------------ Slashdot TV. Video for Nerds. Stuff that matters. http://tv.slashdot.org/ _______________________________________________ QuantLib-users mailing list [hidden email] https://lists.sourceforge.net/lists/listinfo/quantlib-users |
Re: american exercise boundary computation
|
|
In reply to this post by camillo
Hi,
you're correct, currently there's no calculation of the early exercise boundary. I'm not sure of how easy it would be to add; as Cheng mentioned, valuation is implemented with either finite differences and Monte Carlo (via the Longstaff-Schwartz method). The information could be extracted in some way from either one, but I'm guessing it won't be the easiest thing. Do you have any experience with either method? Luigi On Mon, Aug 25, 2014 at 6:02 PM, camillo <[hidden email]> wrote: > Hi all, i'm new to this list and have only limited experience using > quantlib, more specifically in my offtime i work on developing a java > application using the (incomplete) clone jquantlib provided by Richard Gomes > and his colleagues. however due jquantlib's promise to stick to the original > i often look at original quantlib code & examples to improve my learning > curve and become more familiar with the extensive fund of algos provided > there. currently my next milestone is the implementation of the early > exercise boundary for american vanilla options. my questions now: - is this > already implemented in quantlib (currently i have not found it, maybe i > missed it out) - if not directly how would be a reasonable approach using > classes / engines etc. provided by quantlib to implement such an algorithm. > of course it would be possible to develop such from scratch but of course > i'd prefer to avoid re-inventing the wheel in case reliable building blocks > are already available. thx for your support + regards camillo > ________________________________ > View this message in context: american exercise boundary computation > Sent from the quantlib-users mailing list archive at Nabble.com. > > ------------------------------------------------------------------------------ > Slashdot TV. > Video for Nerds. Stuff that matters. > http://tv.slashdot.org/ > _______________________________________________ > QuantLib-users mailing list > [hidden email] > https://lists.sourceforge.net/lists/listinfo/quantlib-users > -- <https://implementingquantlib.blogspot.com> <https://twitter.com/lballabio> ------------------------------------------------------------------------------ Slashdot TV. Video for Nerds. Stuff that matters. http://tv.slashdot.org/ _______________________________________________ QuantLib-users mailing list [hidden email] https://lists.sourceforge.net/lists/listinfo/quantlib-users |
|
|
Hi,
I wouldn't dare calling my knowledge experience; I've read some literature on MC methods thus trying to refresh what I learned during my maths studies on university many years from now. I also skimmed through the books of Wilmott/Howison/Dewynne, Joshi, Shreve, Glasserman etc. so that in principle I got a glimpse of the underlying ideas, at least enough to realize that it appears to be elaborate to implement such routines from scratch. Working mainly in Java I've been lucky enough to be able to resort to algos provided e.g. by Commons Math Apache doing the leg work for me up to now. As far as the exercise boundary computation is concerned I recently found a MatLab implementation provided by Bram van den Broek (http://www.mathworks.com/matlabcentral/fileexchange/17523-american-option-prices-and-the-optimal-exercise-boundary) which looks quite promising at first glance esp. for its simplicity which doesn't even rely on ML toolboxes (other than some Black-Scholes computation which is needed only to display some option value surface in 3D but not needed for the exercise boundary itself). However up to now I haven't have time to study it more carefully (just had a quick look and run it) but I consider a re-implementation in Java by replacing the underlying ML grid framework etc. by using routines provided by QL (resp. its incomplete clone JQuantLib). It would be interesting for me to read your opinion about it. Regards, Camillo |
| Free forum by Nabble | Edit this page |