Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*
3 : * This file is part of the LibreOffice project.
4 : *
5 : * This Source Code Form is subject to the terms of the Mozilla Public
6 : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : *
9 : * This file incorporates work covered by the following license notice:
10 : *
11 : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : * contributor license agreements. See the NOTICE file distributed
13 : * with this work for additional information regarding copyright
14 : * ownership. The ASF licenses this file to you under the Apache
15 : * License, Version 2.0 (the "License"); you may not use this file
16 : * except in compliance with the License. You may obtain a copy of
17 : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : */
19 :
20 : // pricing functions add in
21 :
22 : // all of the UNO add-in technical details have been copied from
23 : // ../datefunc/datefunc.cxx
24 :
25 : #include "pricing.hxx"
26 : #include "black_scholes.hxx"
27 : #include "pricing.hrc"
28 :
29 : #include <cppuhelper/factory.hxx>
30 : #include <cppuhelper/supportsservice.hxx>
31 : #include <iostream>
32 : #include <osl/diagnose.h>
33 : #include <rtl/math.hxx>
34 : #include <rtl/ustrbuf.hxx>
35 : #include <tools/rcid.h>
36 : #include <tools/resmgr.hxx>
37 :
38 : using namespace ::com::sun::star;
39 : using namespace sca::pricing;
40 :
41 :
42 : #define ADDIN_SERVICE "com.sun.star.sheet.AddIn"
43 : #define MY_SERVICE "com.sun.star.sheet.addin.PricingFunctions"
44 : #define MY_IMPLNAME "com.sun.star.sheet.addin.PricingFunctionsImpl"
45 :
46 : #define STR_FROM_ANSI( s ) OUString( s, strlen( s ), RTL_TEXTENCODING_MS_1252 )
47 :
48 : const sal_uInt32 ScaList::nStartSize = 16;
49 : const sal_uInt32 ScaList::nIncrSize = 16;
50 :
51 60 : ScaList::ScaList() :
52 60 : pData( new void*[ nStartSize ] ),
53 : nSize( nStartSize ),
54 : nCount( 0 ),
55 120 : nCurr( 0 )
56 : {
57 60 : }
58 :
59 50 : ScaList::~ScaList()
60 : {
61 50 : delete[] pData;
62 50 : }
63 :
64 0 : void ScaList::_Grow()
65 : {
66 0 : nSize += nIncrSize;
67 :
68 0 : void** pNewData = new void*[ nSize ];
69 0 : memcpy( pNewData, pData, nCount * sizeof( void* ) );
70 :
71 0 : delete[] pData;
72 0 : pData = pNewData;
73 0 : }
74 :
75 80 : ScaStringList::~ScaStringList()
76 : {
77 80 : for( OUString* pStr = First(); pStr; pStr = Next() )
78 40 : delete pStr;
79 40 : }
80 :
81 3072 : ScaResId::ScaResId( sal_uInt16 nId, ResMgr& rResMgr ) :
82 3072 : ResId( nId, rResMgr )
83 : {
84 3072 : }
85 :
86 : #define UNIQUE false // function name does not exist in Calc
87 :
88 : #define STDPAR false // all parameters are described
89 :
90 : #define FUNCDATA( FuncName, ParamCount, Category, Double, IntPar ) \
91 : { "get" #FuncName, PRICING_FUNCNAME_##FuncName, PRICING_FUNCDESC_##FuncName, PRICING_DEFFUNCNAME_##FuncName, ParamCount, Category, Double, IntPar }
92 :
93 : const ScaFuncDataBase pFuncDataArr[] =
94 : {
95 : FUNCDATA( OptBarrier, 13, ScaCat_Finance, UNIQUE, STDPAR),
96 : FUNCDATA( OptTouch, 11, ScaCat_Finance, UNIQUE, STDPAR),
97 : FUNCDATA( OptProbHit, 6, ScaCat_Finance, UNIQUE, STDPAR),
98 : FUNCDATA( OptProbInMoney, 8, ScaCat_Finance, UNIQUE, STDPAR)
99 : };
100 :
101 : #undef FUNCDATA
102 :
103 48 : ScaFuncData::ScaFuncData( const ScaFuncDataBase& rBaseData, ResMgr& rResMgr ) :
104 : aIntName( OUString::createFromAscii( rBaseData.pIntName ) ),
105 : nUINameID( rBaseData.nUINameID ),
106 : nDescrID( rBaseData.nDescrID ),
107 : nCompListID( rBaseData.nCompListID ),
108 : nParamCount( rBaseData.nParamCount ),
109 : eCat( rBaseData.eCat ),
110 : bDouble( rBaseData.bDouble ),
111 48 : bWithOpt( rBaseData.bWithOpt )
112 : {
113 48 : ScaResStringArrLoader aArrLoader( RID_PRICING_DEFFUNCTION_NAMES, nCompListID, rResMgr );
114 48 : const ResStringArray& rArr = aArrLoader.GetStringArray();
115 :
116 96 : for( sal_uInt16 nIndex = 0; nIndex < rArr.Count(); nIndex++ )
117 96 : aCompList.Append( rArr.GetString( nIndex ) );
118 48 : }
119 :
120 80 : ScaFuncData::~ScaFuncData()
121 : {
122 80 : }
123 :
124 912 : sal_uInt16 ScaFuncData::GetStrIndex( sal_uInt16 nParam ) const
125 : {
126 912 : if( !bWithOpt )
127 912 : nParam++;
128 912 : return (nParam > nParamCount) ? (nParamCount * 2) : (nParam * 2);
129 : }
130 :
131 12 : ScaFuncDataList::ScaFuncDataList( ResMgr& rResMgr ) :
132 12 : nLast( 0xFFFFFFFF )
133 : {
134 60 : for( sal_uInt16 nIndex = 0; nIndex < SAL_N_ELEMENTS(pFuncDataArr); nIndex++ )
135 48 : Append( new ScaFuncData( pFuncDataArr[ nIndex ], rResMgr ) );
136 12 : }
137 :
138 30 : ScaFuncDataList::~ScaFuncDataList()
139 : {
140 50 : for( ScaFuncData* pFData = First(); pFData; pFData = Next() )
141 40 : delete pFData;
142 20 : }
143 :
144 1072 : const ScaFuncData* ScaFuncDataList::Get( const OUString& rProgrammaticName ) const
145 : {
146 1072 : if( aLastName == rProgrammaticName ){
147 1008 : return Get( nLast );
148 : }
149 :
150 160 : for( sal_uInt32 nIndex = 0; nIndex < Count(); nIndex++ )
151 : {
152 160 : const ScaFuncData* pCurr = Get( nIndex );
153 160 : if( pCurr->Is( rProgrammaticName ) )
154 : {
155 64 : const_cast< ScaFuncDataList* >( this )->aLastName = rProgrammaticName;
156 64 : const_cast< ScaFuncDataList* >( this )->nLast = nIndex;
157 64 : return pCurr;
158 : }
159 : }
160 0 : return NULL;
161 : }
162 :
163 960 : ScaFuncRes::ScaFuncRes( ResId& rResId, ResMgr& rResMgr, sal_uInt16 nIndex, OUString& rRet ) :
164 960 : Resource( rResId )
165 : {
166 960 : rRet = ScaResId(nIndex, rResMgr).toString();
167 960 : FreeResource();
168 960 : }
169 :
170 : // entry points for service registration / instantiation
171 12 : uno::Reference< uno::XInterface > SAL_CALL ScaPricingAddIn_CreateInstance(
172 : const uno::Reference< lang::XMultiServiceFactory >& )
173 : {
174 12 : static uno::Reference< uno::XInterface > xInst = (cppu::OWeakObject*) new ScaPricingAddIn();
175 12 : return xInst;
176 : }
177 :
178 :
179 : extern "C" {
180 :
181 12 : SAL_DLLPUBLIC_EXPORT void * SAL_CALL pricing_component_getFactory(
182 : const sal_Char * pImplName, void * pServiceManager, void * /*pRegistryKey*/ )
183 : {
184 12 : void* pRet = 0;
185 :
186 60 : if ( pServiceManager &&
187 60 : OUString::createFromAscii( pImplName ) == ScaPricingAddIn::getImplementationName_Static() )
188 : {
189 : uno::Reference< lang::XSingleServiceFactory > xFactory( cppu::createOneInstanceFactory(
190 : reinterpret_cast< lang::XMultiServiceFactory* >( pServiceManager ),
191 : ScaPricingAddIn::getImplementationName_Static(),
192 : ScaPricingAddIn_CreateInstance,
193 12 : ScaPricingAddIn::getSupportedServiceNames_Static() ) );
194 :
195 12 : if (xFactory.is())
196 : {
197 12 : xFactory->acquire();
198 12 : pRet = xFactory.get();
199 12 : }
200 : }
201 :
202 12 : return pRet;
203 : }
204 :
205 : } // extern C
206 :
207 : // "normal" service implementation
208 12 : ScaPricingAddIn::ScaPricingAddIn() :
209 : pDefLocales( NULL ),
210 : pResMgr( NULL ),
211 12 : pFuncDataList( NULL )
212 : {
213 12 : }
214 :
215 30 : ScaPricingAddIn::~ScaPricingAddIn()
216 : {
217 10 : if( pFuncDataList )
218 10 : delete pFuncDataList;
219 10 : if( pDefLocales )
220 2 : delete[] pDefLocales;
221 :
222 : // pResMgr already deleted (_all_ resource managers are deleted _before_ this dtor is called)
223 20 : }
224 :
225 : static const sal_Char* pLang[] = { "de", "en" };
226 : static const sal_Char* pCoun[] = { "DE", "US" };
227 : static const sal_uInt32 nNumOfLoc = SAL_N_ELEMENTS( pLang );
228 :
229 4 : void ScaPricingAddIn::InitDefLocales()
230 : {
231 4 : pDefLocales = new lang::Locale[ nNumOfLoc ];
232 :
233 12 : for( sal_uInt32 nIndex = 0; nIndex < nNumOfLoc; nIndex++ )
234 : {
235 8 : pDefLocales[ nIndex ].Language = OUString::createFromAscii( pLang[ nIndex ] );
236 8 : pDefLocales[ nIndex ].Country = OUString::createFromAscii( pCoun[ nIndex ] );
237 : }
238 4 : }
239 :
240 16 : const lang::Locale& ScaPricingAddIn::GetLocale( sal_uInt32 nIndex )
241 : {
242 16 : if( !pDefLocales )
243 4 : InitDefLocales();
244 :
245 16 : return (nIndex < sizeof( pLang )) ? pDefLocales[ nIndex ] : aFuncLoc;
246 : }
247 :
248 2928 : ResMgr& ScaPricingAddIn::GetResMgr() throw( uno::RuntimeException )
249 : {
250 2928 : if( !pResMgr )
251 : {
252 0 : InitData(); // try to get resource manager
253 0 : if( !pResMgr )
254 0 : throw uno::RuntimeException();
255 : }
256 2928 : return *pResMgr;
257 : }
258 :
259 12 : void ScaPricingAddIn::InitData()
260 : {
261 :
262 12 : if( pResMgr )
263 0 : delete pResMgr;
264 :
265 12 : OString aModName( "pricing" );
266 12 : pResMgr = ResMgr::CreateResMgr( aModName.getStr(), LanguageTag( aFuncLoc) );
267 :
268 12 : if( pFuncDataList )
269 0 : delete pFuncDataList;
270 :
271 12 : pFuncDataList = pResMgr ? new ScaFuncDataList( *pResMgr ) : NULL;
272 :
273 12 : if( pDefLocales )
274 : {
275 0 : delete pDefLocales;
276 0 : pDefLocales = NULL;
277 12 : }
278 12 : }
279 :
280 48 : OUString ScaPricingAddIn::GetDisplFuncStr( sal_uInt16 nResId ) throw( uno::RuntimeException )
281 : {
282 48 : return ScaResStringLoader( RID_PRICING_FUNCTION_NAMES, nResId, GetResMgr() ).GetString();
283 : }
284 :
285 960 : OUString ScaPricingAddIn::GetFuncDescrStr( sal_uInt16 nResId, sal_uInt16 nStrIndex ) throw( uno::RuntimeException )
286 : {
287 960 : OUString aRet;
288 :
289 1920 : ScaResPublisher aResPubl( ScaResId( RID_PRICING_FUNCTION_DESCRIPTIONS, GetResMgr() ) );
290 960 : ScaResId aResId( nResId, GetResMgr() );
291 960 : aResId.SetRT( RSC_RESOURCE );
292 :
293 960 : if( aResPubl.IsAvailableRes( aResId ) )
294 960 : ScaFuncRes aSubRes( aResId, GetResMgr(), nStrIndex, aRet );
295 :
296 960 : aResPubl.FreeResource();
297 1920 : return aRet;
298 : }
299 :
300 24 : OUString ScaPricingAddIn::getImplementationName_Static()
301 : {
302 24 : return OUString( MY_IMPLNAME );
303 : }
304 :
305 12 : uno::Sequence< OUString > ScaPricingAddIn::getSupportedServiceNames_Static()
306 : {
307 12 : uno::Sequence< OUString > aRet( 2 );
308 12 : OUString* pArray = aRet.getArray();
309 12 : pArray[0] = OUString( ADDIN_SERVICE );
310 12 : pArray[1] = OUString( MY_SERVICE );
311 12 : return aRet;
312 : }
313 :
314 : // XServiceName
315 12 : OUString SAL_CALL ScaPricingAddIn::getServiceName() throw( uno::RuntimeException, std::exception )
316 : {
317 : // name of specific AddIn service
318 12 : return OUString( MY_SERVICE );
319 : }
320 :
321 : // XServiceInfo
322 0 : OUString SAL_CALL ScaPricingAddIn::getImplementationName() throw( uno::RuntimeException, std::exception )
323 : {
324 0 : return getImplementationName_Static();
325 : }
326 :
327 0 : sal_Bool SAL_CALL ScaPricingAddIn::supportsService( const OUString& aServiceName ) throw( uno::RuntimeException, std::exception )
328 : {
329 0 : return cppu::supportsService(this, aServiceName);
330 : }
331 :
332 0 : uno::Sequence< OUString > SAL_CALL ScaPricingAddIn::getSupportedServiceNames() throw( uno::RuntimeException, std::exception )
333 : {
334 0 : return getSupportedServiceNames_Static();
335 : }
336 :
337 : // XLocalizable
338 12 : void SAL_CALL ScaPricingAddIn::setLocale( const lang::Locale& eLocale ) throw( uno::RuntimeException, std::exception )
339 : {
340 12 : aFuncLoc = eLocale;
341 12 : InitData(); // change of locale invalidates resources!
342 12 : }
343 :
344 0 : lang::Locale SAL_CALL ScaPricingAddIn::getLocale() throw( uno::RuntimeException, std::exception )
345 : {
346 0 : return aFuncLoc;
347 : }
348 :
349 : // function descriptions start here
350 : // XAddIn
351 0 : OUString SAL_CALL ScaPricingAddIn::getProgrammaticFuntionName( const OUString& ) throw( uno::RuntimeException, std::exception )
352 : {
353 : // not used by calc
354 : // (but should be implemented for other uses of the AddIn service)
355 0 : return OUString();
356 : }
357 :
358 48 : OUString SAL_CALL ScaPricingAddIn::getDisplayFunctionName( const OUString& aProgrammaticName ) throw( uno::RuntimeException, std::exception )
359 : {
360 48 : OUString aRet;
361 :
362 48 : const ScaFuncData* pFData = pFuncDataList->Get( aProgrammaticName );
363 48 : if( pFData )
364 : {
365 48 : aRet = GetDisplFuncStr( pFData->GetUINameID() );
366 48 : if( pFData->IsDouble() )
367 0 : aRet += STR_FROM_ANSI( "_ADD" );
368 : }
369 : else
370 : {
371 0 : aRet = STR_FROM_ANSI( "UNKNOWNFUNC_" );
372 0 : aRet += aProgrammaticName;
373 : }
374 :
375 48 : return aRet;
376 : }
377 :
378 48 : OUString SAL_CALL ScaPricingAddIn::getFunctionDescription( const OUString& aProgrammaticName ) throw( uno::RuntimeException, std::exception )
379 : {
380 48 : OUString aRet;
381 :
382 48 : const ScaFuncData* pFData = pFuncDataList->Get( aProgrammaticName );
383 48 : if( pFData )
384 48 : aRet = GetFuncDescrStr( pFData->GetDescrID(), 1 );
385 :
386 48 : return aRet;
387 : }
388 :
389 456 : OUString SAL_CALL ScaPricingAddIn::getDisplayArgumentName(
390 : const OUString& aProgrammaticName, sal_Int32 nArgument ) throw( uno::RuntimeException, std::exception )
391 : {
392 456 : OUString aRet;
393 :
394 456 : const ScaFuncData* pFData = pFuncDataList->Get( aProgrammaticName );
395 456 : if( pFData && (nArgument <= 0xFFFF) )
396 : {
397 456 : sal_uInt16 nStr = pFData->GetStrIndex( static_cast< sal_uInt16 >( nArgument ) );
398 456 : if( nStr )
399 456 : aRet = GetFuncDescrStr( pFData->GetDescrID(), nStr );
400 : else
401 0 : aRet = STR_FROM_ANSI( "internal" );
402 : }
403 :
404 456 : return aRet;
405 : }
406 :
407 456 : OUString SAL_CALL ScaPricingAddIn::getArgumentDescription(
408 : const OUString& aProgrammaticName, sal_Int32 nArgument ) throw( uno::RuntimeException, std::exception )
409 : {
410 456 : OUString aRet;
411 :
412 456 : const ScaFuncData* pFData = pFuncDataList->Get( aProgrammaticName );
413 456 : if( pFData && (nArgument <= 0xFFFF) )
414 : {
415 456 : sal_uInt16 nStr = pFData->GetStrIndex( static_cast< sal_uInt16 >( nArgument ) );
416 456 : if( nStr )
417 456 : aRet = GetFuncDescrStr( pFData->GetDescrID(), nStr + 1 );
418 : else
419 0 : aRet = STR_FROM_ANSI( "for internal use only" );
420 : }
421 :
422 456 : return aRet;
423 : }
424 :
425 48 : OUString SAL_CALL ScaPricingAddIn::getProgrammaticCategoryName(
426 : const OUString& aProgrammaticName ) throw( uno::RuntimeException, std::exception )
427 : {
428 48 : OUString aRet;
429 :
430 48 : const ScaFuncData* pFData = pFuncDataList->Get( aProgrammaticName );
431 48 : if( pFData )
432 : {
433 48 : switch( pFData->GetCategory() )
434 : {
435 0 : case ScaCat_DateTime: aRet = STR_FROM_ANSI( "Date&Time" ); break;
436 0 : case ScaCat_Text: aRet = STR_FROM_ANSI( "Text" ); break;
437 48 : case ScaCat_Finance: aRet = STR_FROM_ANSI( "Financial" ); break;
438 0 : case ScaCat_Inf: aRet = STR_FROM_ANSI( "Information" ); break;
439 0 : case ScaCat_Math: aRet = STR_FROM_ANSI( "Mathematical" ); break;
440 0 : case ScaCat_Tech: aRet = STR_FROM_ANSI( "Technical" ); break;
441 : default: // to prevent compiler warnings
442 0 : break;
443 : }
444 : }
445 :
446 48 : if( aRet.isEmpty() )
447 0 : aRet = STR_FROM_ANSI( "Add-In" );
448 48 : return aRet;
449 : }
450 :
451 0 : OUString SAL_CALL ScaPricingAddIn::getDisplayCategoryName(
452 : const OUString& aProgrammaticName ) throw( uno::RuntimeException, std::exception )
453 : {
454 0 : return getProgrammaticCategoryName( aProgrammaticName );
455 : }
456 :
457 : // XCompatibilityNames
458 16 : uno::Sequence< sheet::LocalizedName > SAL_CALL ScaPricingAddIn::getCompatibilityNames(
459 : const OUString& aProgrammaticName ) throw( uno::RuntimeException, std::exception )
460 : {
461 16 : const ScaFuncData* pFData = pFuncDataList->Get( aProgrammaticName );
462 16 : if( !pFData )
463 0 : return uno::Sequence< sheet::LocalizedName >( 0 );
464 :
465 16 : const ScaStringList& rStrList = pFData->GetCompNameList();
466 16 : sal_uInt32 nCount = rStrList.Count();
467 :
468 16 : uno::Sequence< sheet::LocalizedName > aRet( nCount );
469 16 : sheet::LocalizedName* pArray = aRet.getArray();
470 :
471 32 : for( sal_uInt32 nIndex = 0; nIndex < nCount; nIndex++ )
472 16 : pArray[ nIndex ] = sheet::LocalizedName( GetLocale( nIndex ), *rStrList.Get( nIndex ) );
473 :
474 16 : return aRet;
475 : }
476 :
477 : // actual function implementation starts here
478 : // auxillary input handling functions
479 : namespace {
480 :
481 0 : bool getinput_putcall(bs::types::PutCall& pc, const OUString& str) {
482 0 : if(str.startsWith("c")) {
483 0 : pc=bs::types::Call;
484 0 : } else if(str.startsWith("p")) {
485 0 : pc=bs::types::Put;
486 : } else {
487 0 : return false;
488 : }
489 0 : return true;
490 : }
491 :
492 0 : bool getinput_putcall(bs::types::PutCall& pc, const uno::Any& anyval) {
493 0 : OUString str;
494 0 : if(anyval.getValueTypeClass() == uno::TypeClass_STRING) {
495 0 : anyval >>= str;
496 0 : } else if(anyval.getValueTypeClass() == uno::TypeClass_VOID) {
497 0 : str="c"; // call as default
498 : } else {
499 0 : return false;
500 : }
501 0 : return getinput_putcall(pc, str);
502 : }
503 :
504 0 : bool getinput_strike(double& strike, const uno::Any& anyval) {
505 0 : if(anyval.getValueTypeClass() == uno::TypeClass_DOUBLE) {
506 0 : anyval >>= strike;
507 0 : } else if(anyval.getValueTypeClass() == uno::TypeClass_VOID) {
508 0 : strike=-1.0; // -1 as default (means not set)
509 : } else {
510 0 : return false;
511 : }
512 0 : return true;
513 : }
514 :
515 0 : bool getinput_inout(bs::types::BarrierKIO& kio, const OUString& str) {
516 0 : if(str.startsWith("i")) {
517 0 : kio=bs::types::KnockIn;
518 0 : } else if(str.startsWith("o")) {
519 0 : kio=bs::types::KnockOut;
520 : } else {
521 0 : return false;
522 : }
523 0 : return true;
524 : }
525 :
526 0 : bool getinput_barrier(bs::types::BarrierActive& cont, const OUString& str) {
527 0 : if(str.startsWith("c")) {
528 0 : cont=bs::types::Continuous;
529 0 : } else if(str.startsWith("e")) {
530 0 : cont=bs::types::Maturity;
531 : } else {
532 0 : return false;
533 : }
534 0 : return true;
535 : }
536 :
537 0 : bool getinput_fordom(bs::types::ForDom& fd, const OUString& str) {
538 0 : if(str.startsWith("f")) {
539 0 : fd=bs::types::Foreign;
540 0 : } else if(str.startsWith("d")) {
541 0 : fd=bs::types::Domestic;
542 : } else {
543 0 : return false;
544 : }
545 0 : return true;
546 : }
547 :
548 0 : bool getinput_greek(bs::types::Greeks& greek, const uno::Any& anyval) {
549 0 : OUString str;
550 0 : if(anyval.getValueTypeClass() == uno::TypeClass_STRING) {
551 0 : anyval >>= str;
552 0 : } else if(anyval.getValueTypeClass() == uno::TypeClass_VOID) {
553 0 : str="value";
554 : } else {
555 0 : return false;
556 : }
557 :
558 0 : if(str.equalsAscii("value") || str.equalsAscii("price") ||
559 0 : str.equalsAscii("v") || str.equalsAscii("p") ) {
560 0 : greek=bs::types::Value;
561 0 : } else if(str.equalsAscii("delta") || str.equalsAscii("d")) {
562 0 : greek=bs::types::Delta;
563 0 : } else if(str.equalsAscii("gamma") || str.equalsAscii("g")) {
564 0 : greek=bs::types::Gamma;
565 0 : } else if(str.equalsAscii("theta") || str.equalsAscii("t")) {
566 0 : greek=bs::types::Theta;
567 0 : } else if(str.equalsAscii("vega") || str.equalsAscii("e")) {
568 0 : greek=bs::types::Vega;
569 0 : } else if(str.equalsAscii("volga") || str.equalsAscii("o")) {
570 0 : greek=bs::types::Volga;
571 0 : } else if(str.equalsAscii("vanna") || str.equalsAscii("a")) {
572 0 : greek=bs::types::Vanna;
573 0 : } else if(str.equalsAscii("rho") || str.equalsAscii("r")) {
574 0 : greek=bs::types::Rho_d;
575 0 : } else if(str.equalsAscii("rhof") || str.equalsAscii("f")) {
576 0 : greek=bs::types::Rho_f;
577 : } else {
578 0 : return false;
579 : }
580 0 : return true;
581 : }
582 :
583 : } // namespace for auxillary functions
584 :
585 : // OPT_BARRIER(...)
586 0 : double SAL_CALL ScaPricingAddIn::getOptBarrier( double spot, double vol,
587 : double r, double rf, double T, double strike,
588 : double barrier_low, double barrier_up, double rebate,
589 : const OUString& put_call, const OUString& in_out,
590 : const OUString& barriercont, const uno::Any& greekstr ) throw( uno::RuntimeException, lang::IllegalArgumentException, std::exception )
591 : {
592 : bs::types::PutCall pc;
593 : bs::types::BarrierKIO kio;
594 : bs::types::BarrierActive bcont;
595 : bs::types::Greeks greek;
596 : // read and check input values
597 0 : if( spot<=0.0 || vol<=0.0 || T<0.0 || strike<0.0 ||
598 0 : !getinput_putcall(pc,put_call) ||
599 0 : !getinput_inout(kio,in_out) ||
600 0 : !getinput_barrier(bcont,barriercont) ||
601 0 : !getinput_greek(greek,greekstr) ){
602 0 : throw lang::IllegalArgumentException();
603 : }
604 :
605 : double fRet=bs::barrier(spot,vol,r,rf,T,strike, barrier_low,barrier_up,
606 0 : rebate,pc,kio,bcont,greek);
607 :
608 0 : RETURN_FINITE( fRet );
609 : }
610 :
611 : // OPT_TOUCH(...)
612 0 : double SAL_CALL ScaPricingAddIn::getOptTouch( double spot, double vol,
613 : double r, double rf, double T,
614 : double barrier_low, double barrier_up,
615 : const OUString& for_dom, const OUString& in_out,
616 : const OUString& barriercont, const uno::Any& greekstr ) throw( uno::RuntimeException, lang::IllegalArgumentException, std::exception )
617 : {
618 : bs::types::ForDom fd;
619 : bs::types::BarrierKIO kio;
620 : bs::types::BarrierActive bcont;
621 : bs::types::Greeks greek;
622 : // read and check input values
623 0 : if( spot<=0.0 || vol<=0.0 || T<0.0 ||
624 0 : !getinput_fordom(fd,for_dom) ||
625 0 : !getinput_inout(kio,in_out) ||
626 0 : !getinput_barrier(bcont,barriercont) ||
627 0 : !getinput_greek(greek,greekstr) ){
628 0 : throw lang::IllegalArgumentException();
629 : }
630 :
631 : double fRet=bs::touch(spot,vol,r,rf,T,barrier_low,barrier_up,
632 0 : fd,kio,bcont,greek);
633 :
634 0 : RETURN_FINITE( fRet );
635 : }
636 :
637 : // OPT_PRB_HIT(...)
638 0 : double SAL_CALL ScaPricingAddIn::getOptProbHit( double spot, double vol,
639 : double mu, double T,
640 : double barrier_low, double barrier_up ) throw( uno::RuntimeException, lang::IllegalArgumentException, std::exception )
641 : {
642 : // read and check input values
643 0 : if( spot<=0.0 || vol<=0.0 || T<0.0 ) {
644 0 : throw lang::IllegalArgumentException();
645 : }
646 :
647 0 : double fRet=bs::prob_hit(spot,vol,mu,T,barrier_low,barrier_up);
648 :
649 0 : RETURN_FINITE( fRet );
650 : }
651 :
652 : // OPT_PROB_INMONEY(...)
653 0 : double SAL_CALL ScaPricingAddIn::getOptProbInMoney( double spot, double vol,
654 : double mu, double T,
655 : double barrier_low, double barrier_up,
656 : const uno::Any& strikeval, const uno::Any& put_call ) throw( uno::RuntimeException, lang::IllegalArgumentException, std::exception )
657 : {
658 0 : bs::types::PutCall pc=bs::types::Call;
659 : double K;
660 :
661 : // read and check input values
662 0 : if( spot<=0.0 || vol<=0.0 || T<0.0 ||
663 0 : !getinput_putcall(pc,put_call) ||
664 0 : !getinput_strike(K,strikeval) ) {
665 0 : throw lang::IllegalArgumentException();
666 : }
667 :
668 0 : double fRet=bs::prob_in_money(spot,vol,mu,T,K,barrier_low,barrier_up,pc);
669 :
670 0 : RETURN_FINITE( fRet );
671 36 : }
672 :
673 :
674 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
