Re: [Quantlib-users] Help about the asian options

[Luigi B. <lui...@gm...>]

I mean that the two engines give the same price, i.e. 6.09.  I don't have
info on moment matching.

On Wed, May 25, 2022 at 6:51 PM Ashish Bansal <ash...@gm...>
wrote:

> By same price, you mean same as exchange i.e. 4.57. or same as aRA
> parameter i.e. 6.09?
>
> Any guidance on moment matching? I could not find anything online about it.
>
> Regards
> Ashish
>
> On Wed, May 25, 2022, 7:02 PM Luigi Ballabio <lui...@gm...>
> wrote:
>
>> Hi,
>>     no, the engine doesn't do moment matching.  I don't think we have
>> something ready to use for that in the library.
>> As for the accumulator: I confirm it's the sum.  If you create a virtual
>> Python environment and install the latest QuantLib in it, you can try your
>> shortened code with the other constructor for the Asian option (the one
>> taking the list of fixings).  It returns the same price.
>>
>> Luigi
>>
>>
>> On Wed, May 25, 2022 at 2:46 PM Ashish Bansal <ash...@gm...>
>> wrote:
>>
>>> Hi Luigi,
>>>
>>> One question about the QL calculation: Does QL code for the Asian option
>>> include *moment matching *of the volatility or do we need to do that
>>> before passing to the DiscAvAsOption?
>>>
>>> Regarding the code, I had attached the full code from our system in my
>>> previous email, attaching here too. The shortened version of the code,
>>> containing only the QL interaction and excluding excess processing, is also
>>> attached here. It includes the trade parameters we are using to evaluate
>>> the Asian option. Strangely, the value is coming zero with short-code but
>>> with full code in our system, we are getting the values.
>>>
>>> Following is the NPV that we are getting in our system (using full code)
>>> for our trade which has averaging period from 1st March to 31st March 2022
>>> and the market traded premium of 4.56:
>>> arithmeticRunningAccumulator  NPV
>>> 0 4.5711
>>> 1302.88 6.09
>>>
>>> Thanks in advance for help.
>>>
>>> PS: We are using QL1.17 and the vols are sourced from Reuters could be
>>> different from implied in the market traded premium.
>>>
>>> Regards,
>>> Ashish
>>>
>>> On Mon, 23 May 2022 at 22:26, Luigi Ballabio <lui...@gm...>
>>> wrote:
>>>
>>>> May you send sample code and the value of the fixings for one of those
>>>> options?  Thanks!
>>>>
>>>> Luigi
>>>>
>>>>
>>>> On Mon, May 23, 2022 at 8:32 AM Ashish Bansal <ash...@gm...>
>>>> wrote:
>>>>
>>>>> Luigi,
>>>>>
>>>>> We ran the asian code, which i sent earlier for a couple of asian
>>>>> options traded on exchange. We got prices very close to traded prices when
>>>>> we used the value of running accumulator as 1 for march option being valued
>>>>> on 17th with past fixing count as 12. But when we used the sum of past
>>>>> fixing prices i.e. 1302.88 we got a very different number like 6.09 against
>>>>> 4.57 earlier and 14.11 against 12.39 earlier.
>>>>>
>>>>> Just want to confirm if i am missing something about running
>>>>> accumulator and should it be really the sum of all past fixings?
>>>>>
>>>>> Thanks for help in advance.
>>>>> Ashish
>>>>>
>>>>> On Fri, 20 May 2022 at 14:58, Ashish Bansal <ash...@gm...>
>>>>> wrote:
>>>>>
>>>>>> Ok understood. thanks.
>>>>>>
>>>>>> On Fri, 20 May 2022 at 14:46, Luigi Ballabio <
>>>>>> lui...@gm...> wrote:
>>>>>>
>>>>>>> It would be the sum of past fixings; for three past fixings of
>>>>>>> 100.2, 101.3 and 94.6 it would be 296.1.
>>>>>>>
>>>>>>> Luigi
>>>>>>>
>>>>>>>
>>>>>>> On Thu, May 19, 2022 at 12:37 PM Ashish Bansal <
>>>>>>> ash...@gm...> wrote:
>>>>>>>
>>>>>>>> Thanks, Luigi for the suggestion. After taking the running
>>>>>>>> accumulator, we are able to generate the numbers. What exactly should be
>>>>>>>> passed here? The average price of past fixings or just 1 when the trade is
>>>>>>>> priced during averaging period?
>>>>>>>>
>>>>>>>> Thanks for help.
>>>>>>>>
>>>>>>>> Ashish
>>>>>>>>
>>>>>>>> On Wed, 18 May 2022 at 21:17, Luigi Ballabio <
>>>>>>>> lui...@gm...> wrote:
>>>>>>>>
>>>>>>>>> I don't have a 1.7 version to try it, but the check is the one at <
>>>>>>>>> https://github.com/lballabio/QuantLib/blob/QuantLib-v1.7/ql/pricingengines/asian/fdblackscholesasianengine.cpp#L51-L53>,
>>>>>>>>> suggesting that your running accumulator should be 0 (which makes sense,
>>>>>>>>> because you're using arithmetic average, i.e., a sum, and if you don't have
>>>>>>>>> any fixings yet the sum should be 0.)
>>>>>>>>> Your default seems to be 1 instead.
>>>>>>>>>
>>>>>>>>> Luigi
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> On Wed, May 18, 2022 at 5:17 PM Ashish Bansal <
>>>>>>>>> ash...@gm...> wrote:
>>>>>>>>>
>>>>>>>>>> Luigi,
>>>>>>>>>>
>>>>>>>>>> Our code is not too much but we are using deprecated functions
>>>>>>>>>> like  FDEuropeanEngine and FDAmericanEngine. Not sure if using
>>>>>>>>>> new function called FdBlackScholesVanillaEngine has any change
>>>>>>>>>> in the calculation that our code will have an impact.
>>>>>>>>>>
>>>>>>>>>> Can we use the  DiscreteAveragingAsianOption without the
>>>>>>>>>> overloaded parameter of pastfixings under 1.7?
>>>>>>>>>>
>>>>>>>>>> Ashish
>>>>>>>>>>
>>>>>>>>>> On Wed, 18 May 2022 at 20:00, Luigi Ballabio <
>>>>>>>>>> lui...@gm...> wrote:
>>>>>>>>>>
>>>>>>>>>>> Hi — it could be.   Any particular reason you're still using a
>>>>>>>>>>> version from 4 years ago?  If you have a substantial amount of code that
>>>>>>>>>>> depends on QuantLib, it might require some work to update because some
>>>>>>>>>>> methods were deprecated and then removed in the meantime; and of course
>>>>>>>>>>> you'll probably have some validation process in place when updating, so
>>>>>>>>>>> that's work too.  But on the other hand, you're missing 4 years worth of
>>>>>>>>>>> bug fixings...
>>>>>>>>>>>
>>>>>>>>>>> Luigi
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> On Wed, May 18, 2022 at 4:19 PM Ashish Bansal <
>>>>>>>>>>> ash...@gm...> wrote:
>>>>>>>>>>>
>>>>>>>>>>>> We tried again and got the same error.
>>>>>>>>>>>>
>>>>>>>>>>>> Could it be due to the old version (1.7) we are using? I see in
>>>>>>>>>>>> the release notes of Apr-2021 that the overload for past fixing was added:
>>>>>>>>>>>>
>>>>>>>>>>>>    - Added an overloaded constructor for Asian options that
>>>>>>>>>>>>    takes all past fixings and thus allows to reprice them correctly when the
>>>>>>>>>>>>    evaluation date changes (thanks to Jack Gillett).
>>>>>>>>>>>>
>>>>>>>>>>>> Ashish
>>>>>>>>>>>>
>>>>>>>>>>>> On Wed, 18 May 2022 at 19:14, Jack G <jac...@gm...>
>>>>>>>>>>>> wrote:
>>>>>>>>>>>>
>>>>>>>>>>>>> Hi Ashish,
>>>>>>>>>>>>>
>>>>>>>>>>>>> I have a better answer for you with a screenshot awaiting
>>>>>>>>>>>>> moderation as it's quite large, but in the meantime, I was able to run your
>>>>>>>>>>>>> code without problems using the python at the bottom of this email
>>>>>>>>>>>>> (although I didn't check the numbers).
>>>>>>>>>>>>>
>>>>>>>>>>>>> If there is something you're doing specifically to generate
>>>>>>>>>>>>> the error, could you please attach a minimal reproduction of it?
>>>>>>>>>>>>>
>>>>>>>>>>>>> Best,
>>>>>>>>>>>>> Jack
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> import QuantLib as ql
>>>>>>>>>>>>> from copy import deepcopy
>>>>>>>>>>>>> from datetime import datetime
>>>>>>>>>>>>> from datetime import timedelta
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> # DEFAULT_PERIODS = [ql.Period(f"{i}d") for i in range(0,31)]
>>>>>>>>>>>>> DEFAULT_PERIODS = [ql.Period("6M"), ql.Period("12M"),
>>>>>>>>>>>>> ql.Period("18M"), ql.Period("24M")]
>>>>>>>>>>>>> DEFAULT_tGRID = 100
>>>>>>>>>>>>> DEFAULT_xGRID = 100
>>>>>>>>>>>>> DEFAULT_aGRID = 50
>>>>>>>>>>>>> DEFAULT_aRA = 1  # arithmeticRunningAccumulator
>>>>>>>>>>>>> DEFAULT_PASTFIXINGS = 1
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> class AsianOptionPrice:
>>>>>>>>>>>>>     def __init__(self, **x):
>>>>>>>>>>>>>         for k, v in x.items():
>>>>>>>>>>>>>             setattr(self, k, v)
>>>>>>>>>>>>>         self.tGrid = x.get("tGrid", DEFAULT_tGRID)
>>>>>>>>>>>>>         self.xGrid = x.get("xGrid", DEFAULT_xGRID)
>>>>>>>>>>>>>         self.aGrid = x.get("aGrid", DEFAULT_aGRID)
>>>>>>>>>>>>>         self.periods = x.get("periods", DEFAULT_PERIODS)
>>>>>>>>>>>>>         self.pastFixings = x.get("pastFixings",
>>>>>>>>>>>>> DEFAULT_PASTFIXINGS)
>>>>>>>>>>>>>         self.aRA = x.get("arithmeticRunningAccumulator",
>>>>>>>>>>>>> DEFAULT_aRA)
>>>>>>>>>>>>>         self.keyList = [k for k, v in x.items()]
>>>>>>>>>>>>>         self.dist = 10**(-2)
>>>>>>>>>>>>>         self.date_format = "%d-%m-%Y"
>>>>>>>>>>>>>         self.value_date = ql.DateParser.parseFormatted(
>>>>>>>>>>>>>             self.valueDate, '%d-%m-%Y')
>>>>>>>>>>>>>         self.expiry_date = ql.DateParser.parseFormatted(
>>>>>>>>>>>>>             self.expiryDate, '%d-%m-%Y')
>>>>>>>>>>>>>         ql.Settings.instance().evaluationDate = self.value_date
>>>>>>>>>>>>>         self.exDay =
>>>>>>>>>>>>> ql.DateParser.parseFormatted(self.expiryDate, '%d-%m-%Y')
>>>>>>>>>>>>>         # Volatility input is required for running the
>>>>>>>>>>>>> computing implied volatility function. This volatility is NOT used in the
>>>>>>>>>>>>> implied volatility calculation.
>>>>>>>>>>>>>         self.vol_for_iv_calc = 0.10
>>>>>>>>>>>>>         self.IV = None
>>>>>>>>>>>>>
>>>>>>>>>>>>>     def
>>>>>>>>>>>>> generate_fixture_dates(self,start_date,end_date,period):
>>>>>>>>>>>>>         schedule = ql.MakeSchedule(start_date, end_date,
>>>>>>>>>>>>> period)
>>>>>>>>>>>>>         fixture_dates = [_date for _date in schedule if
>>>>>>>>>>>>> _date.weekday() not in [1,7]]
>>>>>>>>>>>>>         return fixture_dates
>>>>>>>>>>>>>     def asian(self):
>>>>>>>>>>>>>         """
>>>>>>>>>>>>>         arithmeticRunningAccumulator(aRA)
>>>>>>>>>>>>>         """
>>>>>>>>>>>>>         arithmeticRunningAccumulator = self.aRA
>>>>>>>>>>>>>         pastFixings = self.pastFixings
>>>>>>>>>>>>>         print(pastFixings)
>>>>>>>>>>>>>         option_type = self.optionType.lower()
>>>>>>>>>>>>>         if option_type not in ["call", "put"]:
>>>>>>>>>>>>>             raise Exception(
>>>>>>>>>>>>>                 f"Option Type is Neither Call nor Put, Option
>>>>>>>>>>>>> type is {option_type}")
>>>>>>>>>>>>>         option_type = ql.Option.Call if option_type == "call"
>>>>>>>>>>>>> else ql.Option.Put
>>>>>>>>>>>>>         strike = self.strikePrice
>>>>>>>>>>>>>         today = self.value_date
>>>>>>>>>>>>>         print(today)
>>>>>>>>>>>>>         fixingStartDate
>>>>>>>>>>>>> =ql.DateParser.parseFormatted(self.fixingStartDate, '%d-%m-%Y')
>>>>>>>>>>>>>         print("#"*40,fixingStartDate)
>>>>>>>>>>>>>         periods = self.periods
>>>>>>>>>>>>>         asianFutureFixingDates =
>>>>>>>>>>>>> self.generate_fixture_dates(fixingStartDate,self.expiry_date,ql.Period("1d"))
>>>>>>>>>>>>>         print("#"*40,asianFutureFixingDates)
>>>>>>>>>>>>>         asianExpiryDate = self.expiry_date
>>>>>>>>>>>>>         vanillaPayoff = ql.PlainVanillaPayoff(option_type,
>>>>>>>>>>>>> strike)
>>>>>>>>>>>>>         europeanExercise = ql.EuropeanExercise(asianExpiryDate)
>>>>>>>>>>>>>         arithmeticAverage = ql.Average().Arithmetic
>>>>>>>>>>>>>         discreteArithmeticAsianOption =
>>>>>>>>>>>>> ql.DiscreteAveragingAsianOption(
>>>>>>>>>>>>>             arithmeticAverage, arithmeticRunningAccumulator,
>>>>>>>>>>>>> pastFixings, asianFutureFixingDates, vanillaPayoff, europeanExercise)
>>>>>>>>>>>>>         return discreteArithmeticAsianOption
>>>>>>>>>>>>>
>>>>>>>>>>>>>     def create_arg_list(self, Option=None,
>>>>>>>>>>>>> compute_implied_vol=None, implied_vol_am_put=None):
>>>>>>>>>>>>>         '''
>>>>>>>>>>>>>             The arguments with disturbances added. Will be
>>>>>>>>>>>>> used for calculation of Greeks
>>>>>>>>>>>>>             using numerical differentiation.
>>>>>>>>>>>>>             Creating a dictionary of arguments that will be
>>>>>>>>>>>>> used for option price and greeks calculation.
>>>>>>>>>>>>>         '''
>>>>>>>>>>>>>         self.riskFreeRate = self.riskFreeRate/100
>>>>>>>>>>>>>         originalDict_ = {k: getattr(self, k) for k in
>>>>>>>>>>>>> self.keyList}
>>>>>>>>>>>>>         ListDict = []
>>>>>>>>>>>>>         for i in range(4):
>>>>>>>>>>>>>             ListDict.append(deepcopy(originalDict_))
>>>>>>>>>>>>>         ListDict[1]['riskFreeRate'] = self.riskFreeRate +
>>>>>>>>>>>>> self.dist
>>>>>>>>>>>>>         ListDict[2]['volatility'] = self.volatility + self.dist
>>>>>>>>>>>>>         ListDict[3]['expiryDate'] = (datetime.strptime(
>>>>>>>>>>>>>             self.expiryDate, self.date_format) -
>>>>>>>>>>>>> timedelta(days=1)).strftime(self.date_format)
>>>>>>>>>>>>>         print(ListDict)
>>>>>>>>>>>>>         return(ListDict)
>>>>>>>>>>>>>
>>>>>>>>>>>>>     def bs_process(self, create_process_for_iv=None,
>>>>>>>>>>>>> use_IV=None):
>>>>>>>>>>>>>         """
>>>>>>>>>>>>>         Creating the Black-Scholes process for option
>>>>>>>>>>>>> valuation.
>>>>>>>>>>>>>         """
>>>>>>>>>>>>>         riskFreeTS = ql.YieldTermStructureHandle(
>>>>>>>>>>>>>             ql.FlatForward(self.value_date, self.riskFreeRate,
>>>>>>>>>>>>> ql.Actual365Fixed()))
>>>>>>>>>>>>>         dividendTS = ql.YieldTermStructureHandle(
>>>>>>>>>>>>>             ql.FlatForward(self.value_date, 0,
>>>>>>>>>>>>> ql.Actual365Fixed()))
>>>>>>>>>>>>>         volatility =
>>>>>>>>>>>>> ql.BlackVolTermStructureHandle(ql.BlackConstantVol(
>>>>>>>>>>>>>             self.value_date, ql.NullCalendar(),
>>>>>>>>>>>>> self.volatility, ql.Actual365Fixed()))
>>>>>>>>>>>>>         initialValue =
>>>>>>>>>>>>> ql.QuoteHandle(ql.SimpleQuote(self.underlyingPrice))
>>>>>>>>>>>>>         process = ql.BlackScholesMertonProcess(
>>>>>>>>>>>>>             initialValue, dividendTS, riskFreeTS, volatility)
>>>>>>>>>>>>>         return(process)
>>>>>>>>>>>>>
>>>>>>>>>>>>>     def evaluate(self, Option=None, compute_implied_vol=None):
>>>>>>>>>>>>>         """
>>>>>>>>>>>>>         Call the relevant option based on the input.
>>>>>>>>>>>>>         """
>>>>>>>>>>>>>         self.riskFreeRate = self.riskFreeRate/100
>>>>>>>>>>>>>         res = None
>>>>>>>>>>>>>         option = AsianOptionPrice.asian(self)
>>>>>>>>>>>>>         if compute_implied_vol == True:
>>>>>>>>>>>>>             # create Black Scholes process using IV.
>>>>>>>>>>>>>             process = AsianOptionPrice.bs_process(
>>>>>>>>>>>>>                 self, create_process_for_iv=False, use_IV=True)
>>>>>>>>>>>>>             engine = ql.FdBlackScholesAsianEngine(
>>>>>>>>>>>>>                 process, tGrid=self.tGrid, xGrid=self.xGrid,
>>>>>>>>>>>>> aGrid=self.aGrid)
>>>>>>>>>>>>>             option.setPricingEngine(engine)
>>>>>>>>>>>>>             res = {'value': option.NPV(), 'impliedVolatility':
>>>>>>>>>>>>> self.IV}
>>>>>>>>>>>>>         else:
>>>>>>>>>>>>>             # Create Black Scholes process using HV.
>>>>>>>>>>>>>             process = AsianOptionPrice.bs_process(
>>>>>>>>>>>>>                 self, create_process_for_iv=False,
>>>>>>>>>>>>> use_IV=False)
>>>>>>>>>>>>>             engine = ql.FdBlackScholesAsianEngine(
>>>>>>>>>>>>>                 process, tGrid=self.tGrid, xGrid=self.xGrid,
>>>>>>>>>>>>> aGrid=self.aGrid)
>>>>>>>>>>>>>             option.setPricingEngine(engine)
>>>>>>>>>>>>>             res = {'value': option.NPV()}
>>>>>>>>>>>>>         return res
>>>>>>>>>>>>>
>>>>>>>>>>>>>     def evaluate_asian_npv(self):
>>>>>>>>>>>>>         Option = AsianOptionPrice.asian(self)
>>>>>>>>>>>>>         process = AsianOptionPrice.bs_process(
>>>>>>>>>>>>>             self, create_process_for_iv=False, use_IV=False)
>>>>>>>>>>>>>         engine = ql.FdBlackScholesAsianEngine(
>>>>>>>>>>>>>             process, tGrid=self.tGrid, xGrid=self.xGrid,
>>>>>>>>>>>>> aGrid=self.aGrid)
>>>>>>>>>>>>>         Option.setPricingEngine(engine)
>>>>>>>>>>>>>         res = Option.NPV()
>>>>>>>>>>>>>         return(res)
>>>>>>>>>>>>>
>>>>>>>>>>>>>     def calculate_greeks(self, Option=None,
>>>>>>>>>>>>> compute_implied_vol=None):
>>>>>>>>>>>>>         today = self.value_date
>>>>>>>>>>>>>         Option = AsianOptionPrice.asian(self)
>>>>>>>>>>>>>         if compute_implied_vol == True:
>>>>>>>>>>>>>             process = AsianOptionPrice.bs_process(
>>>>>>>>>>>>>                 self, create_process_for_iv=False, use_IV=True)
>>>>>>>>>>>>>         else:
>>>>>>>>>>>>>             process = AsianOptionPrice.bs_process(
>>>>>>>>>>>>>                 self, create_process_for_iv=False,
>>>>>>>>>>>>> use_IV=False)
>>>>>>>>>>>>>         engine = ql.FdBlackScholesAsianEngine(
>>>>>>>>>>>>>             process, tGrid=self.tGrid, xGrid=self.xGrid,
>>>>>>>>>>>>> aGrid=self.aGrid)
>>>>>>>>>>>>>         Option.setPricingEngine(engine)
>>>>>>>>>>>>>         option_greeks_ = {"delta": Option.delta(), "gamma":
>>>>>>>>>>>>> Option.gamma(
>>>>>>>>>>>>>         )}
>>>>>>>>>>>>>         ArgmntList = AsianOptionPrice.create_arg_list(
>>>>>>>>>>>>>             self, Option, compute_implied_vol=True,
>>>>>>>>>>>>> implied_vol_am_put=self.volatility)
>>>>>>>>>>>>>         DisturbedPrices = []
>>>>>>>>>>>>>         arg_keys = ['Price', 'PRup', 'PVup', 'PTup']
>>>>>>>>>>>>>         for i in range(4):
>>>>>>>>>>>>>             DisturbedPrices.append(eval(
>>>>>>>>>>>>>
>>>>>>>>>>>>> "AsianOptionPrice(**ArgmntList[i]).evaluate_asian_npv()"))
>>>>>>>>>>>>>             print(DisturbedPrices)
>>>>>>>>>>>>>         PricesDistrbd = dict(zip(arg_keys, DisturbedPrices))
>>>>>>>>>>>>>         Rho = (PricesDistrbd['PRup'] -
>>>>>>>>>>>>> PricesDistrbd['Price'])/(self.dist*100)
>>>>>>>>>>>>>         vega = (PricesDistrbd['PVup'] -
>>>>>>>>>>>>> PricesDistrbd['Price'])/(self.dist*100)
>>>>>>>>>>>>>         thetaDay = (PricesDistrbd['PTup'] -
>>>>>>>>>>>>> PricesDistrbd['Price'])
>>>>>>>>>>>>>         option_greeks_.update({'rho': Rho, 'vega': vega,
>>>>>>>>>>>>>  'theta': thetaDay})
>>>>>>>>>>>>>         return option_greeks_
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> settings = {
>>>>>>>>>>>>> "computeHistoricalVolatiltiy": False,
>>>>>>>>>>>>> "tenantId": "380",
>>>>>>>>>>>>> "gridPoints": 149,
>>>>>>>>>>>>> "computeImpliedVolatiltiy": False,
>>>>>>>>>>>>> "runId": 3735,
>>>>>>>>>>>>> "timeSteps": 150,
>>>>>>>>>>>>> "optionTrades": [
>>>>>>>>>>>>> {
>>>>>>>>>>>>> "underlyingPrice": 98.69,
>>>>>>>>>>>>> "refNo": "OPT-1135-GVA",
>>>>>>>>>>>>> "underlyingPriceUnit": "US cents/LB",
>>>>>>>>>>>>> "valueDate": "17-03-2022",
>>>>>>>>>>>>> "fixingStartDate":"01-05-2022",
>>>>>>>>>>>>> "pastFixings":0,
>>>>>>>>>>>>> "volatility": 0.6015,
>>>>>>>>>>>>> "openQuantity": 1,
>>>>>>>>>>>>> "strikePriceUnit": "US cents/LB",
>>>>>>>>>>>>> "optionType": "Call",
>>>>>>>>>>>>> "expiryDate": "31-05-2022",
>>>>>>>>>>>>> "exType": "asian",
>>>>>>>>>>>>> "riskFreeRate": 0.8080374999999999,
>>>>>>>>>>>>> "premium": 1,
>>>>>>>>>>>>> "portfolioId": 18209,
>>>>>>>>>>>>> "marketPremium": 11.42,
>>>>>>>>>>>>> "longShort": "Long",
>>>>>>>>>>>>> "optionInstrument": "EURO USD 1.105 Call",
>>>>>>>>>>>>> "asset": "EURO USD 1.105 Call",
>>>>>>>>>>>>> "portfolioName": "Option Trades",
>>>>>>>>>>>>> "scenarioId": 8356,
>>>>>>>>>>>>> "scenarioName": "Option Valuation - Greeks",
>>>>>>>>>>>>> "strikePrice": 95,
>>>>>>>>>>>>> "maturityInYears": 0.205479452
>>>>>>>>>>>>> }
>>>>>>>>>>>>> ],
>>>>>>>>>>>>> "userId": "5263",
>>>>>>>>>>>>> "americanOptionsEngine": "CrankNicolson"
>>>>>>>>>>>>> }
>>>>>>>>>>>>>
>>>>>>>>>>>>> opt = AsianOptionPrice(**settings["optionTrades"][0])
>>>>>>>>>>>>> opt.evaluate_asian_npv()
>>>>>>>>>>>>>
>>>>>>>>>>>>> On Wed, May 18, 2022 at 9:25 PM Ashish Bansal <
>>>>>>>>>>>>> ash...@gm...> wrote:
>>>>>>>>>>>>>
>>>>>>>>>>>>>> Hi Jack,
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Please find attached the Asian option python code and the
>>>>>>>>>>>>>> option trade payload.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Thanks for your help,
>>>>>>>>>>>>>> Regards,
>>>>>>>>>>>>>> Ashish
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> On Wed, 18 May 2022 at 12:12, Jack G <
>>>>>>>>>>>>>> jac...@gm...> wrote:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Hi Ashish,
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> I've just lifted the examples from your references directly
>>>>>>>>>>>>>>> for a discrete arithmetic Asian using the FD Asian engine and it is working
>>>>>>>>>>>>>>> for me - can you share the code you are using that breaks please?
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Best,
>>>>>>>>>>>>>>> Jack
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> On Wed, 18 May 2022, 13:55 Ashish Bansal, <
>>>>>>>>>>>>>>> ash...@gm...> wrote:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Hi all,
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Could somebody help with the asian options? We are using
>>>>>>>>>>>>>>>> FdBlackScholesAsianengine with DiscreteAveragingAsianOption. Online
>>>>>>>>>>>>>>>> references are given below. In DiscreteAveragingAsianOption, we need to
>>>>>>>>>>>>>>>> pass the past fixing which is suggested to be 0 for new trade. Whereas when
>>>>>>>>>>>>>>>> we are passing it as 0, we are getting the following error:
>>>>>>>>>>>>>>>> "QuantLib Error - Running average requires at least one
>>>>>>>>>>>>>>>> past fixing"
>>>>>>>>>>>>>>>> ref:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> https://quantlib-python-docs.readthedocs.io/en/latest/pricing_engines.html#fdblackscholesasianengine
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> https://quantlib-python-docs.readthedocs.io/en/latest/instruments/options.html?highlight=DiscreteAveragingAsianOption#ql.DiscreteAveragingAsianOption
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Queries:
>>>>>>>>>>>>>>>> 1. What is to be passed here for new trade if not 0?
>>>>>>>>>>>>>>>> 2. For trade which is mid of averaging and has few past
>>>>>>>>>>>>>>>> fixings, do we need to pass the count of past fixing or the actual rates of
>>>>>>>>>>>>>>>> the pastfixing as an array?
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Any help will be appreciated.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Thanks in advance
>>>>>>>>>>>>>>>> Ashish
>>>>>>>>>>>>>>>> _______________________________________________
>>>>>>>>>>>>>>>> QuantLib-users mailing list
>>>>>>>>>>>>>>>> Qua...@li...
>>>>>>>>>>>>>>>> https://lists.sourceforge.net/lists/listinfo/quantlib-users
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> _______________________________________________
>>>>>>>>>>>> QuantLib-users mailing list
>>>>>>>>>>>> Qua...@li...
>>>>>>>>>>>> https://lists.sourceforge.net/lists/listinfo/quantlib-users
>>>>>>>>>>>>
>>>>>>>>>>>