use of VulatilityStructure

[Vadim Ogranovich-3]

Hi,

I have been searching for ways of representing and fitting volatility smiles
of options in QL. The closest things that I found are all sorts of
*VolatilityStructure classes. They seem to be coming from the area of fixed
income, where I am lacking the necessary background to tell whether they are
useful for my purposes. Interestingly the *VolatilityStructure classes
appear in .hpp but not in any of .cpp files.

Here are few related questions:
1. Is there any support for volatility smiles of options? This by itself is
a two-level question: a) whether there is a class that represents a smile
and b) whether there are methods that fit the smile to the current set of
option prices.

2. Are there means to incorporate time-dependent (but not stochastic)
volatility in pricing of FdDividendAmericanOption. Here the answer is
probably "yes, in principal you can" given what I have read in "The finite
difference framework" of the user manual, but I am wondering is there an
already canned solution.

2. Out of curiosity, why *VolatilityStructure classes appear in .cpp files
only?

Thanks,
Vadim

--------------------------------------------------
DISCLAIMER
This e-mail, and any attachments thereto, is intended only for use by the
addressee(s) named herein and may contain legally privileged and/or
confidential information.  If you are not the intended recipient of this
e-mail, you are hereby notified that any dissemination, distribution or
copying of this e-mail, and any attachments thereto, is strictly prohibited.
If you have received this e-mail in error, please immediately notify me and
permanently delete the original and any copy of any e-mail and any printout
thereof.

E-mail transmission cannot be guaranteed to be secure or error-free.  The
sender therefore does not accept liability for any errors or omissions in
the contents of this message which arise as a result of e-mail transmission.

NOTICE REGARDING PRIVACY AND CONFIDENTIALITY

Knight Trading Group may, at its discretion, monitor and review the content
of all e-mail communications.

[Luigi Ballabio-4]

Hi Vadim,

At 3:23 PM -0500 4/19/02, Vadim Ogranovich wrote:
>I have been searching for ways of representing and fitting volatility smiles
>of options in QL. The closest things that I found are all sorts of
>*VolatilityStructure classes.
>
>Here are few related questions:
>1. Is there any support for volatility smiles of options? This by itself is
>a two-level question: a) whether there is a class that represents a smile
>and b) whether there are methods that fit the smile to the current set of
>option prices.

I'm more familiar with fixed income than equities, but I guess that
what you would need is an OptionVolatilityStructure class to which
one can ask volatility(exerciseDate,strike). Is that so? In this
case, it could be modeled after FlatCapVolatilityStructure or
whatever the latter is called.
This would be only the interface, i.e., the abstract base class: then
one would have to implement the actual innards in derived classes.
What I mean is, the support for the smile in the interface consists
simply in the volatility() method taking the strike as a parameter.
The actual implementations in derived classes should model it.
As for (a), the answer is "not yet". As for (b), you might look at
the machinery that Sad put together for fitting volatility surfaces.
I haven't explored it yet, but I have a feeling that most of the math
is there and one has only to define the desired parametric form of
the curve.


>2. Are there means to incorporate time-dependent (but not stochastic)
>volatility in pricing of FdDividendAmericanOption. Here the answer is
>probably "yes, in principal you can" given what I have read in "The finite
>difference framework" of the user manual, but I am wondering is there an
>already canned solution.

No, not a canned one. We were thinking of it but got lost in other work to do.


>2. Out of curiosity, why *VolatilityStructure classes appear in .cpp files
>only?

You mean hpp, I guess. Quite simply, all their methods were short
enough to be declared as inline. Therefore, there was nothing to be
put in a cpp file.

Bye,
        Luigi

--