scaddins/source/analysis/analysis.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: analysis.cxx,v $
  10  * $Revision: 1.46.20.1 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 #include "analysis.hxx"
  32
  33 #include <cppuhelper/factory.hxx>
  34 #include <osl/diagnose.h>
  35 #include <rtl/ustrbuf.hxx>
  36 #include <rtl/math.hxx>
  37 #include <string.h>
  38
  39 #include <tools/resmgr.hxx>
  40 #include <tools/rcid.h>
  41 #include "analysis.hrc"
  42 #include "bessel.hxx"
  43
  44 #define ADDIN_SERVICE                           "com.sun.star.sheet.AddIn"
  45 #define MY_SERVICE                                      "com.sun.star.sheet.addin.Analysis"
  46 #define MY_IMPLNAME                                     "com.sun.star.sheet.addin.AnalysisImpl"
  47
  48 using namespace                 ::rtl;
  49 using namespace                 ::com::sun::star;
  50
  51 //------------------------------------------------------------------
  52 //
  53 //      entry points for service registration / instantiation
  54 //
  55 //------------------------------------------------------------------
  56
  57 extern "C" {
  58
  59
  60 void SAL_CALL component_getImplementationEnvironment( const sal_Char** ppEnvTypeName, uno_Environment** /*ppEnv*/ )
  61 {
  62     *ppEnvTypeName = CPPU_CURRENT_LANGUAGE_BINDING_NAME;
  63 }
  64
  65
  66 sal_Bool SAL_CALL component_writeInfo( void* /*pServiceManager*/, registry::XRegistryKey* pRegistryKey )
  67 {
  68     if( pRegistryKey )
  69     {
  70         try
  71         {
  72             STRING                                                      aImpl = STRFROMASCII( "/" );
  73             aImpl += AnalysisAddIn::getImplementationName_Static();
  74             aImpl += STRFROMASCII( "/UNO/SERVICES" );
  75
  76             REF( registry::XRegistryKey )       xNewKey(
  77                 reinterpret_cast< registry::XRegistryKey* >( pRegistryKey )->createKey( aImpl ) );
  78
  79             SEQ( STRING )                                       aSequ = AnalysisAddIn::getSupportedServiceNames_Static();
  80             const STRING*                                       pArray = aSequ.getConstArray();
  81
  82             for( sal_Int32 i = 0 ; i < aSequ.getLength() ; i++ )
  83                 xNewKey->createKey( pArray[ i ] );
  84
  85             return sal_True;
  86         }
  87         catch( registry::InvalidRegistryException& )
  88         {
  89             OSL_ENSURE( sal_False, "### InvalidRegistryException!" );
  90         }
  91     }
  92     return sal_False;
  93 }
  94
  95
  96 void* SAL_CALL component_getFactory( const sal_Char* pImplName, void* pServiceManager, void* /*pRegistryKey*/ )
  97 {
  98     void*                                                                       pRet = 0;
  99
 100     if( pServiceManager && STRING::createFromAscii( pImplName ) == AnalysisAddIn::getImplementationName_Static() )
 101     {
 102         REF( lang::XSingleServiceFactory )      xFactory( cppu::createOneInstanceFactory(
 103                 reinterpret_cast< lang::XMultiServiceFactory* >( pServiceManager ),
 104                 AnalysisAddIn::getImplementationName_Static(),
 105                 AnalysisAddIn_CreateInstance,
 106                 AnalysisAddIn::getSupportedServiceNames_Static() ) );
 107
 108         if( xFactory.is() )
 109         {
 110             xFactory->acquire();
 111             pRet = xFactory.get();
 112         }
 113     }
 114
 115     return pRet;
 116 }
 117
 118
 119 }       // extern C
 120
 121
 122
 123
 124 //------------------------------------------------------------------------
 125 //
 126 //      "normal" service implementation
 127 //
 128 //------------------------------------------------------------------------
 129
 130
 131 ResMgr& AnalysisAddIn::GetResMgr( void ) THROWDEF_RTE
 132 {
 133     if( !pResMgr )
 134     {
 135         InitData();             // try to get resource manager
 136
 137         if( !pResMgr )
 138             THROW_RTE;
 139     }
 140
 141     return *pResMgr;
 142 }
 143
 144
 145 STRING AnalysisAddIn::GetDisplFuncStr( sal_uInt16 nFuncNum ) THROWDEF_RTE
 146 {
 147     return String( AnalysisRscStrLoader( RID_ANALYSIS_FUNCTION_NAMES, nFuncNum, GetResMgr() ).GetString() );
 148 }
 149
 150
 151 class AnalysisResourcePublisher : public Resource
 152 {
 153 public:
 154                     AnalysisResourcePublisher( const AnalysisResId& rId ) : Resource( rId ) {}
 155     BOOL                        IsAvailableRes( const ResId& rId ) const { return Resource::IsAvailableRes( rId ); }
 156     void                        FreeResource() { Resource::FreeResource(); }
 157 };
 158
 159
 160 class AnalysisFuncRes : public Resource
 161 {
 162 public:
 163     AnalysisFuncRes( ResId& rRes, ResMgr& rResMgr, sal_uInt16 nInd, STRING& rRet );
 164 };
 165
 166
 167 AnalysisFuncRes::AnalysisFuncRes( ResId& rRes, ResMgr& rResMgr, sal_uInt16 nInd, STRING& rRet ) : Resource( rRes )
 168 {
 169     rRet = String( AnalysisResId( nInd, rResMgr ) );
 170
 171     FreeResource();
 172 }
 173
 174
 175 STRING AnalysisAddIn::GetFuncDescrStr( sal_uInt16 nResId, sal_uInt16 nStrIndex ) THROWDEF_RTE
 176 {
 177     STRING                                              aRet;
 178     AnalysisResourcePublisher   aResPubl( AnalysisResId( RID_ANALYSIS_FUNCTION_DESCRIPTIONS, GetResMgr() ) );
 179     AnalysisResId                               aRes( nResId, GetResMgr() );
 180     aRes.SetRT( RSC_RESOURCE );
 181     if( aResPubl.IsAvailableRes( aRes ) )
 182     {
 183         AnalysisFuncRes                 aSubRes( aRes, GetResMgr(), nStrIndex, aRet );
 184     }
 185
 186     aResPubl.FreeResource();
 187
 188     return aRet;
 189 }
 190
 191
 192 void AnalysisAddIn::InitData( void )
 193 {
 194     if( pResMgr )
 195         delete pResMgr;
 196
 197     OString                             aModName( "analysis" );
 198     pResMgr = ResMgr::CreateResMgr( ( const sal_Char* ) aModName,
 199                                         aFuncLoc );
 200
 201     if( pFD )
 202         delete pFD;
 203
 204     if( pResMgr )
 205         pFD = new FuncDataList( *pResMgr );
 206     else
 207         pFD = NULL;
 208
 209     if( pDefLocales )
 210     {
 211         delete pDefLocales;
 212         pDefLocales = NULL;
 213     }
 214 }
 215
 216
 217 AnalysisAddIn::AnalysisAddIn( const uno::Reference< lang::XMultiServiceFactory >& xServiceFact ) :
 218     pDefLocales( NULL ),
 219     pFD( NULL ),
 220     pFactDoubles( NULL ),
 221     pCDL( NULL ),
 222     pResMgr( NULL ),
 223     aAnyConv( xServiceFact )
 224 {
 225 }
 226
 227
 228 AnalysisAddIn::~AnalysisAddIn()
 229 {
 230     if( pFD )
 231         delete pFD;
 232
 233     if( pFactDoubles )
 234         delete[] pFactDoubles;
 235
 236     if( pCDL )
 237         delete pCDL;
 238
 239 //      if( pResMgr )                   no delete, because _all_ resource managers are deleted _before_ this dtor is called
 240 //              delete pResMgr;
 241
 242     if( pDefLocales )
 243         delete[] pDefLocales;
 244 }
 245
 246
 247 sal_Int32 AnalysisAddIn::getDateMode(
 248         const uno::Reference< beans::XPropertySet >& xPropSet,
 249         const uno::Any& rAny ) throw( uno::RuntimeException, lang::IllegalArgumentException )
 250 {
 251     sal_Int32 nMode = aAnyConv.getInt32( xPropSet, rAny, 0 );
 252     if( (nMode < 0) || (nMode > 4) )
 253         throw lang::IllegalArgumentException();
 254     return nMode;
 255 }
 256
 257
 258
 259 //-----------------------------------------------------------------------------
 260
 261
 262 #define MAXFACTDOUBLE   300
 263
 264 double AnalysisAddIn::FactDouble( sal_Int32 nNum ) THROWDEF_RTE_IAE
 265 {
 266     if( nNum < 0 || nNum > MAXFACTDOUBLE )
 267         THROW_IAE;
 268
 269     if( !pFactDoubles )
 270     {
 271         pFactDoubles = new double[ MAXFACTDOUBLE + 1 ];
 272
 273         pFactDoubles[ 0 ] = 1.0;        // by default
 274
 275         double          fOdd = 1.0;
 276         double          fEven = 2.0;
 277
 278         pFactDoubles[ 1 ] = fOdd;
 279         pFactDoubles[ 2 ] = fEven;
 280
 281         sal_Bool        bOdd = sal_True;
 282
 283         for( sal_uInt16 nCnt = 3 ; nCnt <= MAXFACTDOUBLE ; nCnt++ )
 284         {
 285             if( bOdd )
 286             {
 287                 fOdd *= nCnt;
 288                 pFactDoubles[ nCnt ] = fOdd;
 289             }
 290             else
 291             {
 292                 fEven *= nCnt;
 293                 pFactDoubles[ nCnt ] = fEven;
 294             }
 295
 296             bOdd = !bOdd;
 297
 298         }
 299     }
 300
 301     return pFactDoubles[ nNum ];
 302 }
 303
 304
 305 STRING AnalysisAddIn::getImplementationName_Static()
 306 {
 307     return STRFROMASCII( MY_IMPLNAME );
 308 }
 309
 310
 311 SEQ( STRING ) AnalysisAddIn::getSupportedServiceNames_Static()
 312 {
 313     SEQ( STRING )       aRet(2);
 314     STRING*                     pArray = aRet.getArray();
 315     pArray[0] = STRFROMASCII( ADDIN_SERVICE );
 316     pArray[1] = STRFROMASCII( MY_SERVICE );
 317     return aRet;
 318 }
 319
 320
 321 REF( uno::XInterface ) SAL_CALL AnalysisAddIn_CreateInstance(
 322         const uno::Reference< lang::XMultiServiceFactory >& xServiceFact )
 323 {
 324     static uno::Reference< uno::XInterface > xInst = (cppu::OWeakObject*) new AnalysisAddIn( xServiceFact );
 325     return xInst;
 326 }
 327
 328
 329 // XServiceName
 330
 331 STRING SAL_CALL AnalysisAddIn::getServiceName() THROWDEF_RTE
 332 {
 333     // name of specific AddIn service
 334     return STRFROMASCII( MY_SERVICE );
 335 }
 336
 337
 338 // XServiceInfo
 339
 340 STRING SAL_CALL AnalysisAddIn::getImplementationName() THROWDEF_RTE
 341 {
 342     return getImplementationName_Static();
 343 }
 344
 345
 346 sal_Bool SAL_CALL AnalysisAddIn::supportsService( const STRING& aName ) THROWDEF_RTE
 347 {
 348     return aName.compareToAscii( ADDIN_SERVICE ) == 0 || aName.compareToAscii( MY_SERVICE ) == 0;
 349 }
 350
 351
 352 SEQ( STRING ) SAL_CALL AnalysisAddIn::getSupportedServiceNames() THROWDEF_RTE
 353 {
 354     return getSupportedServiceNames_Static();
 355 }
 356
 357
 358 // XLocalizable
 359
 360 void SAL_CALL AnalysisAddIn::setLocale( const lang::Locale& eLocale ) THROWDEF_RTE
 361 {
 362     aFuncLoc = eLocale;
 363
 364     InitData();         // change of locale invalidates resources!
 365 }
 366
 367 lang::Locale SAL_CALL AnalysisAddIn::getLocale() THROWDEF_RTE
 368 {
 369     return aFuncLoc;
 370 }
 371
 372
 373 // XAddIn
 374
 375 STRING SAL_CALL AnalysisAddIn::getProgrammaticFuntionName( const STRING& ) THROWDEF_RTE
 376 {
 377     //  not used by calc
 378     //  (but should be implemented for other uses of the AddIn service)
 379
 380     return STRING();
 381 }
 382
 383
 384 STRING SAL_CALL AnalysisAddIn::getDisplayFunctionName( const STRING& aProgrammaticName ) THROWDEF_RTE
 385 {
 386     STRING                      aRet;
 387
 388     const FuncData*     p = pFD->Get( aProgrammaticName );
 389     if( p )
 390     {
 391         aRet = GetDisplFuncStr( p->GetUINameID() );
 392         if( p->IsDouble() )
 393             aRet += STRFROMANSI( "_ADD" );
 394     }
 395     else
 396     {
 397         aRet = STRFROMANSI( "UNKNOWNFUNC_" );
 398         aRet += aProgrammaticName;
 399     }
 400
 401     return aRet;
 402 }
 403
 404
 405 STRING SAL_CALL AnalysisAddIn::getFunctionDescription( const STRING& aProgrammaticName ) THROWDEF_RTE
 406 {
 407     STRING                      aRet;
 408
 409     const FuncData*     p = pFD->Get( aProgrammaticName );
 410     if( p )
 411         aRet = GetFuncDescrStr( p->GetDescrID(), 1 );
 412
 413     return aRet;
 414 }
 415
 416
 417 STRING SAL_CALL AnalysisAddIn::getDisplayArgumentName( const STRING& aName, sal_Int32 nArg ) THROWDEF_RTE
 418 {
 419     STRING                      aRet;
 420
 421     const FuncData*     p = pFD->Get( aName );
 422     if( p && nArg <= 0xFFFF )
 423     {
 424         sal_uInt16      nStr = p->GetStrIndex( sal_uInt16( nArg ) );
 425         if( nStr /*&& nStr < 4*/ )
 426             aRet = GetFuncDescrStr( p->GetDescrID(), nStr );
 427         else
 428             aRet = STRFROMANSI( "internal" );
 429     }
 430
 431     return aRet;
 432 }
 433
 434
 435 STRING SAL_CALL AnalysisAddIn::getArgumentDescription( const STRING& aName, sal_Int32 nArg ) THROWDEF_RTE
 436 {
 437     STRING                      aRet;
 438
 439     const FuncData*     p = pFD->Get( aName );
 440     if( p && nArg <= 0xFFFF )
 441     {
 442         sal_uInt16      nStr = p->GetStrIndex( sal_uInt16( nArg ) );
 443         if( nStr /*&& nStr < 4*/ )
 444             aRet = GetFuncDescrStr( p->GetDescrID(), nStr + 1 );
 445         else
 446             aRet = STRFROMANSI( "for internal use only" );
 447     }
 448
 449     return aRet;
 450 }
 451
 452
 453 static const char*      pDefCatName = "Add-In";
 454
 455
 456 STRING SAL_CALL AnalysisAddIn::getProgrammaticCategoryName( const STRING& aName ) THROWDEF_RTE
 457 {
 458     //  return non-translated strings
 459 //      return STRFROMASCII( "Add-In" );
 460     const FuncData*             p = pFD->Get( aName );
 461     STRING                              aRet;
 462     if( p )
 463     {
 464         const sal_Char* pStr;
 465
 466         switch( p->GetCategory() )
 467         {
 468             case FDCat_DateTime:        pStr = "Date&Time";                     break;
 469             case FDCat_Finance:         pStr = "Financial";                     break;
 470             case FDCat_Inf:                     pStr = "Information";           break;
 471             case FDCat_Math:            pStr = "Mathematical";          break;
 472             case FDCat_Tech:            pStr = "Technical";                     break;
 473             default:
 474                                     pStr = pDefCatName;                 break;
 475         }
 476
 477         aRet = STRFROMASCII( pStr );
 478     }
 479     else
 480         aRet = STRFROMASCII( pDefCatName );
 481
 482     return aRet;
 483 }
 484
 485
 486 STRING SAL_CALL AnalysisAddIn::getDisplayCategoryName( const STRING& aProgrammaticFunctionName ) THROWDEF_RTE
 487 {
 488     //  return translated strings, not used for predefined categories
 489 //      return STRFROMASCII( "Add-In" );
 490     const FuncData*             p = pFD->Get( aProgrammaticFunctionName );
 491     STRING                              aRet;
 492     if( p )
 493     {
 494         const sal_Char* pStr;
 495
 496         switch( p->GetCategory() )
 497         {
 498             case FDCat_DateTime:        pStr = "Date&Time";                     break;
 499             case FDCat_Finance:         pStr = "Financial";                     break;
 500             case FDCat_Inf:                     pStr = "Information";           break;
 501             case FDCat_Math:            pStr = "Mathematical";          break;
 502             case FDCat_Tech:            pStr = "Technical";                     break;
 503             default:
 504                                     pStr = pDefCatName;                 break;
 505         }
 506
 507         aRet = STRFROMASCII( pStr );
 508     }
 509     else
 510         aRet = STRFROMASCII( pDefCatName );
 511
 512     return aRet;
 513 }
 514
 515
 516 static const sal_Char*          pLang[] = { "de", "en" };
 517 static const sal_Char*          pCoun[] = { "DE", "US" };
 518 static const sal_uInt32         nNumOfLoc = sizeof( pLang ) / sizeof( sal_Char* );
 519
 520
 521 void AnalysisAddIn::InitDefLocales( void )
 522 {
 523     pDefLocales = new CSS::lang::Locale[ nNumOfLoc ];
 524
 525     for( sal_uInt32 n = 0 ; n < nNumOfLoc ; n++ )
 526     {
 527         pDefLocales[ n ].Language = STRING::createFromAscii( pLang[ n ] );
 528         pDefLocales[ n ].Country = STRING::createFromAscii( pCoun[ n ] );
 529     }
 530 }
 531
 532
 533 inline const CSS::lang::Locale& AnalysisAddIn::GetLocale( sal_uInt32 nInd )
 534 {
 535     if( !pDefLocales )
 536         InitDefLocales();
 537
 538     if( nInd < sizeof( pLang ) )
 539         return pDefLocales[ nInd ];
 540     else
 541         return aFuncLoc;
 542 }
 543
 544
 545 SEQofLocName SAL_CALL AnalysisAddIn::getCompatibilityNames( const STRING& aProgrammaticName ) THROWDEF_RTE
 546 {
 547     const FuncData*                             p = pFD->Get( aProgrammaticName );
 548
 549     if( !p )
 550         return SEQofLocName( 0 );
 551
 552     const StringList&                   r = p->GetCompNameList();
 553     sal_uInt32                                  nCount = r.Count();
 554
 555     SEQofLocName                                aRet( nCount );
 556
 557     CSS::sheet::LocalizedName*  pArray = aRet.getArray();
 558
 559     for( sal_uInt32 n = 0 ; n < nCount ; n++ )
 560     {
 561         pArray[ n ] = CSS::sheet::LocalizedName( GetLocale( n ), *r.Get( n ) );
 562     }
 563
 564     return aRet;
 565 }
 566
 567
 568 // XAnalysis
 569
 570 /*double SAL_CALL AnalysisAddIn::get_Test( constREFXPS&,
 571     sal_Int32 nMode, double f1, double f2, double f3 ) THROWDEF_RTE
 572 {
 573     return _Test( nMode, f1, f2, f3 );
 574 }*/
 575
 576
 577 /**
 578  * Workday
 579  */
 580
 581 sal_Int32 SAL_CALL AnalysisAddIn::getWorkday( constREFXPS& xOptions,
 582     sal_Int32 nDate, sal_Int32 nDays, const ANY& aHDay ) THROWDEF_RTE_IAE
 583 {
 584     if( !nDays )
 585         return nDate;
 586
 587     sal_Int32                                   nNullDate = GetNullDate( xOptions );
 588
 589     SortedIndividualInt32List   aSrtLst;
 590
 591     aSrtLst.InsertHolidayList( aAnyConv, xOptions, aHDay, nNullDate, sal_False );
 592
 593     sal_Int32                                   nActDate = nDate + nNullDate;
 594
 595     if( nDays > 0 )
 596     {
 597         if( GetDayOfWeek( nActDate ) == 5 )
 598             // when starting on Saturday, assuming we're starting on Sunday to get the jump over the weekend
 599             nActDate++;
 600
 601         while( nDays )
 602         {
 603             nActDate++;
 604
 605             if( GetDayOfWeek( nActDate ) < 5 )
 606             {
 607                 if( !aSrtLst.Find( nActDate ) )
 608                     nDays--;
 609             }
 610             else
 611                 nActDate++;             // jump over weekend
 612         }
 613     }
 614     else
 615     {
 616         if( GetDayOfWeek( nActDate ) == 6 )
 617             // when starting on Sunday, assuming we're starting on Saturday to get the jump over the weekend
 618             nActDate--;
 619
 620         while( nDays )
 621         {
 622             nActDate--;
 623
 624             if( GetDayOfWeek( nActDate ) < 5 )
 625             {
 626                 if( !aSrtLst.Find( nActDate ) )
 627                     nDays++;
 628             }
 629             else
 630                 nActDate--;             // jump over weekend
 631         }
 632     }
 633
 634     return nActDate - nNullDate;
 635 }
 636
 637
 638 /**
 639  * Yearfrac
 640  */
 641
 642 double SAL_CALL AnalysisAddIn::getYearfrac( constREFXPS& xOpt,
 643     sal_Int32 nStartDate, sal_Int32 nEndDate, const ANY& rMode ) THROWDEF_RTE_IAE
 644 {
 645     double fRet = GetYearFrac( xOpt, nStartDate, nEndDate, getDateMode( xOpt, rMode ) );
 646     RETURN_FINITE( fRet );
 647 }
 648
 649
 650 sal_Int32 SAL_CALL AnalysisAddIn::getEdate( constREFXPS& xOpt, sal_Int32 nStartDate, sal_Int32 nMonths ) THROWDEF_RTE_IAE
 651 {
 652     sal_Int32 nNullDate = GetNullDate( xOpt );
 653     ScaDate aDate( nNullDate, nStartDate, 5 );
 654     aDate.addMonths( nMonths );
 655     return aDate.getDate( nNullDate );
 656 }
 657
 658
 659 sal_Int32 SAL_CALL AnalysisAddIn::getWeeknum( constREFXPS& xOpt, sal_Int32 nDate, sal_Int32 nMode ) THROWDEF_RTE_IAE
 660 {
 661     nDate += GetNullDate( xOpt );
 662
 663     sal_uInt16  nDay, nMonth, nYear;
 664     DaysToDate( nDate, nDay, nMonth, nYear );
 665
 666     sal_Int32   nFirstInYear = DateToDays( 1, 1, nYear );
 667     sal_uInt16  nFirstDayInYear = GetDayOfWeek( nFirstInYear );
 668
 669     return ( nDate - nFirstInYear + ( ( nMode == 1 )? ( nFirstDayInYear + 1 ) % 7 : nFirstDayInYear ) ) / 7 + 1;
 670 }
 671
 672
 673 sal_Int32 SAL_CALL AnalysisAddIn::getEomonth( constREFXPS& xOpt, sal_Int32 nDate, sal_Int32 nMonths ) THROWDEF_RTE_IAE
 674 {
 675     sal_Int32   nNullDate = GetNullDate( xOpt );
 676     nDate += nNullDate;
 677     sal_uInt16  nDay, nMonth, nYear;
 678     DaysToDate( nDate, nDay, nMonth, nYear );
 679
 680     sal_Int32   nNewMonth = nMonth + nMonths;
 681
 682     if( nNewMonth > 12 )
 683     {
 684         nYear = sal::static_int_cast<sal_uInt16>( nYear + ( nNewMonth / 12 ) );
 685         nNewMonth %= 12;
 686     }
 687     else if( nNewMonth < 1 )
 688     {
 689         nNewMonth = -nNewMonth;
 690         nYear = sal::static_int_cast<sal_uInt16>( nYear - ( nNewMonth / 12 ) );
 691         nYear--;
 692         nNewMonth %= 12;
 693         nNewMonth = 12 - nNewMonth;
 694     }
 695
 696     return DateToDays( DaysInMonth( sal_uInt16( nNewMonth ), nYear ), sal_uInt16( nNewMonth ), nYear ) - nNullDate;
 697 }
 698
 699
 700 sal_Int32 SAL_CALL AnalysisAddIn::getNetworkdays( constREFXPS& xOpt,
 701         sal_Int32 nStartDate, sal_Int32 nEndDate, const ANY& aHDay ) THROWDEF_RTE_IAE
 702 {
 703     sal_Int32                                   nNullDate = GetNullDate( xOpt );
 704
 705     SortedIndividualInt32List   aSrtLst;
 706
 707     aSrtLst.InsertHolidayList( aAnyConv, xOpt, aHDay, nNullDate, sal_False );
 708
 709     sal_Int32                                   nActDate = nStartDate + nNullDate;
 710     sal_Int32                                   nStopDate = nEndDate + nNullDate;
 711     sal_Int32                                   nCnt = 0;
 712
 713     if( nActDate <= nStopDate )
 714     {
 715         while( nActDate <= nStopDate )
 716         {
 717             if( GetDayOfWeek( nActDate ) < 5 && !aSrtLst.Find( nActDate ) )
 718                 nCnt++;
 719
 720             nActDate++;
 721         }
 722     }
 723     else
 724     {
 725         while( nActDate >= nStopDate )
 726         {
 727             if( GetDayOfWeek( nActDate ) < 5 && !aSrtLst.Find( nActDate ) )
 728                 nCnt--;
 729
 730             nActDate--;
 731         }
 732     }
 733
 734     return nCnt;
 735 }
 736
 737
 738 sal_Int32 SAL_CALL AnalysisAddIn::getIseven( sal_Int32 nVal ) THROWDEF_RTE_IAE
 739 {
 740     return ( nVal & 0x00000001 )? 0 : 1;
 741 }
 742
 743
 744 sal_Int32 SAL_CALL AnalysisAddIn::getIsodd( sal_Int32 nVal ) THROWDEF_RTE_IAE
 745 {
 746     return ( nVal & 0x00000001 )? 1 : 0;
 747 }
 748
 749 double SAL_CALL
 750 AnalysisAddIn::getMultinomial( constREFXPS& xOpt, const SEQSEQ( sal_Int32 )& aVLst,
 751                                const SEQ( uno::Any )& aOptVLst ) THROWDEF_RTE_IAE
 752 {
 753     ScaDoubleListGE0 aValList;
 754
 755     aValList.Append( aVLst );
 756     aValList.Append( aAnyConv, xOpt, aOptVLst );
 757
 758     if( aValList.Count() == 0 )
 759         return 0.0;
 760
 761     sal_Int32 nZ = 0;
 762     double    fN = 1.0;
 763
 764     for( const double *p = aValList.First(); p; p = aValList.Next() )
 765     {
 766         double fInt = (*p >= 0.0) ? rtl::math::approxFloor( *p ) : rtl::math::approxCeil( *p );
 767         if ( fInt < 0.0 || fInt > 170.0 )
 768             THROW_IAE;
 769         sal_Int32 n = static_cast< sal_Int32 >( fInt );
 770         if( n > 0 )
 771         {
 772             nZ += n;
 773             fN *= Fak( n );
 774         }
 775     }
 776
 777     if( nZ > 170 )
 778         THROW_IAE;
 779
 780     double fRet = Fak( nZ ) / fN;
 781     RETURN_FINITE( fRet );
 782 }
 783
 784
 785 double SAL_CALL AnalysisAddIn::getSeriessum( double fX, double fN, double fM, const SEQSEQ( double )& aCoeffList ) THROWDEF_RTE_IAE
 786 {
 787     double                                                      fRet = 0.0;
 788
 789     // #i32269# 0^0 is undefined, Excel returns #NUM! error
 790     if( fX == 0.0 && fN == 0 )
 791         THROW_RTE;
 792
 793     if( fX != 0.0 )
 794     {
 795         sal_Int32               n1, n2;
 796         sal_Int32               nE1 = aCoeffList.getLength();
 797         sal_Int32               nE2;
 798         //sal_Int32             nZ = 0;
 799
 800         for( n1 = 0 ; n1 < nE1 ; n1++ )
 801         {
 802             const SEQ( double )&        rList = aCoeffList[ n1 ];
 803             nE2 = rList.getLength();
 804             const double*                       pList = rList.getConstArray();
 805
 806             for( n2 = 0 ; n2 < nE2 ; n2++ )
 807             {
 808                 fRet += pList[ n2 ] * pow( fX, fN );
 809
 810                 fN += fM;
 811             }
 812         }
 813     }
 814
 815     RETURN_FINITE( fRet );
 816 }
 817
 818
 819 double SAL_CALL AnalysisAddIn::getQuotient( double fNum, double fDenom ) THROWDEF_RTE_IAE
 820 {
 821     double fRet;
 822     if( (fNum < 0) != (fDenom < 0) )
 823         fRet = ::rtl::math::approxCeil( fNum / fDenom );
 824     else
 825         fRet = ::rtl::math::approxFloor( fNum / fDenom );
 826     RETURN_FINITE( fRet );
 827 }
 828
 829
 830 double SAL_CALL AnalysisAddIn::getMround( double fNum, double fMult ) THROWDEF_RTE_IAE
 831 {
 832     if( fMult == 0.0 )
 833         return fMult;
 834
 835     double fRet = fMult * ::rtl::math::round( fNum / fMult );
 836     RETURN_FINITE( fRet );
 837 }
 838
 839
 840 double SAL_CALL AnalysisAddIn::getSqrtpi( double fNum ) THROWDEF_RTE_IAE
 841 {
 842     double fRet = sqrt( fNum * PI );
 843     RETURN_FINITE( fRet );
 844 }
 845
 846
 847 double SAL_CALL AnalysisAddIn::getRandbetween( double fMin, double fMax ) THROWDEF_RTE_IAE
 848 {
 849     fMin = ::rtl::math::round( fMin, 0, rtl_math_RoundingMode_Up );
 850     fMax = ::rtl::math::round( fMax, 0, rtl_math_RoundingMode_Up );
 851     if( fMin > fMax )
 852         THROW_IAE;
 853
 854     // fMax -> range
 855     double fRet = fMax - fMin + 1.0;
 856     fRet *= rand();
 857     fRet /= (RAND_MAX + 1.0);
 858     fRet += fMin;
 859     fRet = floor( fRet );   // simple floor is sufficient here
 860     RETURN_FINITE( fRet );
 861 }
 862
 863
 864 double SAL_CALL AnalysisAddIn::getGcd( constREFXPS& xOpt, const SEQSEQ( double )& aVLst, const SEQ( uno::Any )& aOptVLst ) THROWDEF_RTE_IAE
 865 {
 866     ScaDoubleListGT0 aValList;
 867
 868     aValList.Append( aVLst );
 869     aValList.Append( aAnyConv, xOpt, aOptVLst );
 870
 871     if( aValList.Count() == 0 )
 872         return 0.0;
 873
 874     const double*       p = aValList.First();
 875     double                      f = *p;
 876
 877     p = aValList.Next();
 878
 879     while( p )
 880     {
 881         f = GetGcd( *p, f );
 882         p = aValList.Next();
 883     }
 884
 885     RETURN_FINITE( f );
 886 }
 887
 888
 889 double SAL_CALL AnalysisAddIn::getLcm( constREFXPS& xOpt, const SEQSEQ( double )& aVLst, const SEQ( uno::Any )& aOptVLst ) THROWDEF_RTE_IAE
 890 {
 891     ScaDoubleListGE0 aValList;
 892
 893     aValList.Append( aVLst );
 894     aValList.Append( aAnyConv, xOpt, aOptVLst );
 895
 896     if( aValList.Count() == 0 )
 897         return 0.0;
 898
 899     const double*       p = aValList.First();
 900     double                      f = *p;
 901
 902     if( f == 0.0 )
 903         return f;
 904
 905     p = aValList.Next();
 906
 907     while( p )
 908     {
 909         double          fTmp = *p;
 910         if( f == 0.0 )
 911             return f;
 912         else
 913             f = fTmp * f / GetGcd( fTmp, f );
 914         p = aValList.Next();
 915     }
 916
 917     RETURN_FINITE( f );
 918 }
 919
 920
 921 double SAL_CALL AnalysisAddIn::getBesseli( double fNum, sal_Int32 nOrder ) THROWDEF_RTE_IAE
 922 {
 923     double fRet = sca::analysis::BesselI( fNum, nOrder );
 924     RETURN_FINITE( fRet );
 925 }
 926
 927
 928 double SAL_CALL AnalysisAddIn::getBesselj( double fNum, sal_Int32 nOrder ) THROWDEF_RTE_IAE
 929 {
 930     double fRet = sca::analysis::BesselJ( fNum, nOrder );
 931     RETURN_FINITE( fRet );
 932 }
 933
 934
 935 double SAL_CALL AnalysisAddIn::getBesselk( double fNum, sal_Int32 nOrder ) THROWDEF_RTE_IAE
 936 {
 937     if( nOrder < 0 || fNum <= 0.0 )
 938         THROW_IAE;
 939
 940     double fRet = sca::analysis::BesselK( fNum, nOrder );
 941     RETURN_FINITE( fRet );
 942 }
 943
 944
 945 double SAL_CALL AnalysisAddIn::getBessely( double fNum, sal_Int32 nOrder ) THROWDEF_RTE_IAE
 946 {
 947     if( nOrder < 0 || fNum <= 0.0 )
 948         THROW_IAE;
 949
 950 //      return yn( nOrder, fNum );
 951     double fRet = sca::analysis::BesselY( fNum, nOrder );
 952     RETURN_FINITE( fRet );
 953 }
 954
 955
 956 const double    SCA_MAX2        = 511.0;            // min. val for binary numbers (9 bits + sign)
 957 const double    SCA_MIN2        = -SCA_MAX2-1.0;    // min. val for binary numbers (9 bits + sign)
 958 const double    SCA_MAX8        = 536870911.0;      // max. val for octal numbers (29 bits + sign)
 959 const double    SCA_MIN8        = -SCA_MAX8-1.0;    // min. val for octal numbers (29 bits + sign)
 960 const double    SCA_MAX16       = 549755813888.0;   // max. val for hexadecimal numbers (39 bits + sign)
 961 const double    SCA_MIN16       = -SCA_MAX16-1.0;   // min. val for hexadecimal numbers (39 bits + sign)
 962 const sal_Int32 SCA_MAXPLACES   = 10;               // max. number of places
 963
 964
 965 STRING SAL_CALL AnalysisAddIn::getBin2Oct( constREFXPS& xOpt, const STRING& aNum, const ANY& rPlaces ) THROWDEF_RTE_IAE
 966 {
 967     double fVal = ConvertToDec( aNum, 2, SCA_MAXPLACES );
 968     sal_Int32 nPlaces = 0;
 969     sal_Bool bUsePlaces = aAnyConv.getInt32( nPlaces, xOpt, rPlaces );
 970     return ConvertFromDec( fVal, SCA_MIN8, SCA_MAX8, 8, nPlaces, SCA_MAXPLACES, bUsePlaces );
 971 }
 972
 973
 974 double SAL_CALL AnalysisAddIn::getBin2Dec( const STRING& aNum ) THROWDEF_RTE_IAE
 975 {
 976     double fRet = ConvertToDec( aNum, 2, SCA_MAXPLACES );
 977     RETURN_FINITE( fRet );
 978 }
 979
 980
 981 STRING SAL_CALL AnalysisAddIn::getBin2Hex( constREFXPS& xOpt, const STRING& aNum, const ANY& rPlaces ) THROWDEF_RTE_IAE
 982 {
 983     double fVal = ConvertToDec( aNum, 2, SCA_MAXPLACES );
 984     sal_Int32 nPlaces = 0;
 985     sal_Bool bUsePlaces = aAnyConv.getInt32( nPlaces, xOpt, rPlaces );
 986     return ConvertFromDec( fVal, SCA_MIN16, SCA_MAX16, 16, nPlaces, SCA_MAXPLACES, bUsePlaces );
 987 }
 988
 989
 990 STRING SAL_CALL AnalysisAddIn::getOct2Bin( constREFXPS& xOpt, const STRING& aNum, const ANY& rPlaces ) THROWDEF_RTE_IAE
 991 {
 992     double fVal = ConvertToDec( aNum, 8, SCA_MAXPLACES );
 993     sal_Int32 nPlaces = 0;
 994     sal_Bool bUsePlaces = aAnyConv.getInt32( nPlaces, xOpt, rPlaces );
 995     return ConvertFromDec( fVal, SCA_MIN2, SCA_MAX2, 2, nPlaces, SCA_MAXPLACES, bUsePlaces );
 996 }
 997
 998
 999 double SAL_CALL AnalysisAddIn::getOct2Dec( const STRING& aNum ) THROWDEF_RTE_IAE
1000 {
1001     double fRet = ConvertToDec( aNum, 8, SCA_MAXPLACES );
1002     RETURN_FINITE( fRet );
1003 }
1004
1005
1006 STRING SAL_CALL AnalysisAddIn::getOct2Hex( constREFXPS& xOpt, const STRING& aNum, const ANY& rPlaces ) THROWDEF_RTE_IAE
1007 {
1008     double fVal = ConvertToDec( aNum, 8, SCA_MAXPLACES );
1009     sal_Int32 nPlaces = 0;
1010     sal_Bool bUsePlaces = aAnyConv.getInt32( nPlaces, xOpt, rPlaces );
1011     return ConvertFromDec( fVal, SCA_MIN16, SCA_MAX16, 16, nPlaces, SCA_MAXPLACES, bUsePlaces );
1012 }
1013
1014
1015 STRING SAL_CALL AnalysisAddIn::getDec2Bin( constREFXPS& xOpt, sal_Int32 nNum, const ANY& rPlaces ) THROWDEF_RTE_IAE
1016 {
1017     sal_Int32 nPlaces = 0;
1018     sal_Bool bUsePlaces = aAnyConv.getInt32( nPlaces, xOpt, rPlaces );
1019     return ConvertFromDec( nNum, SCA_MIN2, SCA_MAX2, 2, nPlaces, SCA_MAXPLACES, bUsePlaces );
1020 }
1021
1022
1023 STRING SAL_CALL AnalysisAddIn::getDec2Oct( constREFXPS& xOpt, sal_Int32 nNum, const ANY& rPlaces ) THROWDEF_RTE_IAE
1024 {
1025     sal_Int32 nPlaces = 0;
1026     sal_Bool bUsePlaces = aAnyConv.getInt32( nPlaces, xOpt, rPlaces );
1027     return ConvertFromDec( nNum, SCA_MIN8, SCA_MAX8, 8, nPlaces, SCA_MAXPLACES, bUsePlaces );
1028 }
1029
1030
1031 STRING SAL_CALL AnalysisAddIn::getDec2Hex( constREFXPS& xOpt, double fNum, const ANY& rPlaces ) THROWDEF_RTE_IAE
1032 {
1033     sal_Int32 nPlaces = 0;
1034     sal_Bool bUsePlaces = aAnyConv.getInt32( nPlaces, xOpt, rPlaces );
1035     return ConvertFromDec( fNum, SCA_MIN16, SCA_MAX16, 16, nPlaces, SCA_MAXPLACES, bUsePlaces );
1036 }
1037
1038
1039 STRING SAL_CALL AnalysisAddIn::getHex2Bin( constREFXPS& xOpt, const STRING& aNum, const ANY& rPlaces ) THROWDEF_RTE_IAE
1040 {
1041     double fVal = ConvertToDec( aNum, 16, SCA_MAXPLACES );
1042     sal_Int32 nPlaces = 0;
1043     sal_Bool bUsePlaces = aAnyConv.getInt32( nPlaces, xOpt, rPlaces );
1044     return ConvertFromDec( fVal, SCA_MIN2, SCA_MAX2, 2, nPlaces, SCA_MAXPLACES, bUsePlaces );
1045 }
1046
1047
1048 double SAL_CALL AnalysisAddIn::getHex2Dec( const STRING& aNum ) THROWDEF_RTE_IAE
1049 {
1050     double fRet = ConvertToDec( aNum, 16, SCA_MAXPLACES );
1051     RETURN_FINITE( fRet );
1052 }
1053
1054
1055 STRING SAL_CALL AnalysisAddIn::getHex2Oct( constREFXPS& xOpt, const STRING& aNum, const ANY& rPlaces ) THROWDEF_RTE_IAE
1056 {
1057     double fVal = ConvertToDec( aNum, 16, SCA_MAXPLACES );
1058     sal_Int32 nPlaces = 0;
1059     sal_Bool bUsePlaces = aAnyConv.getInt32( nPlaces, xOpt, rPlaces );
1060     return ConvertFromDec( fVal, SCA_MIN8, SCA_MAX8, 8, nPlaces, SCA_MAXPLACES, bUsePlaces );
1061 }
1062
1063
1064 sal_Int32 SAL_CALL AnalysisAddIn::getDelta( constREFXPS& xOpt, double fNum1, const ANY& rNum2 ) THROWDEF_RTE_IAE
1065 {
1066     return fNum1 == aAnyConv.getDouble( xOpt, rNum2, 0.0 );
1067 }
1068
1069
1070 double SAL_CALL AnalysisAddIn::getErf( constREFXPS& xOpt, double fLL, const ANY& rUL ) THROWDEF_RTE_IAE
1071 {
1072     double fUL, fRet;
1073     sal_Bool bContainsValue = aAnyConv.getDouble( fUL, xOpt, rUL );
1074
1075     fRet = bContainsValue ? (Erf( fUL ) - Erf( fLL )) : Erf( fLL );
1076     RETURN_FINITE( fRet );
1077 }
1078
1079
1080 double SAL_CALL AnalysisAddIn::getErfc( double f ) THROWDEF_RTE_IAE
1081 {
1082     double fRet = Erfc( f );
1083     RETURN_FINITE( fRet );
1084 }
1085
1086
1087 sal_Int32 SAL_CALL AnalysisAddIn::getGestep( constREFXPS& xOpt, double fNum, const ANY& rStep ) THROWDEF_RTE_IAE
1088 {
1089     return fNum >= aAnyConv.getDouble( xOpt, rStep, 0.0 );
1090 }
1091
1092
1093 double SAL_CALL AnalysisAddIn::getFactdouble( sal_Int32 nNum ) THROWDEF_RTE_IAE
1094 {
1095     double fRet = FactDouble( nNum );
1096     RETURN_FINITE( fRet );
1097 }
1098
1099
1100 double SAL_CALL AnalysisAddIn::getImabs( const STRING& aNum ) THROWDEF_RTE_IAE
1101 {
1102     double fRet = Complex( aNum ).Abs();
1103     RETURN_FINITE( fRet );
1104 }
1105
1106
1107 double SAL_CALL AnalysisAddIn::getImaginary( const STRING& aNum ) THROWDEF_RTE_IAE
1108 {
1109     double fRet = Complex( aNum ).Imag();
1110     RETURN_FINITE( fRet );
1111 }
1112
1113
1114 STRING SAL_CALL AnalysisAddIn::getImpower( const STRING& aNum, double f ) THROWDEF_RTE_IAE
1115 {
1116     Complex             z( aNum );
1117
1118     z.Power( f );
1119
1120     return z.GetString();
1121 }
1122
1123
1124 double SAL_CALL AnalysisAddIn::getImargument( const STRING& aNum ) THROWDEF_RTE_IAE
1125 {
1126     double fRet = Complex( aNum ).Arg();
1127     RETURN_FINITE( fRet );
1128 }
1129
1130
1131 STRING SAL_CALL AnalysisAddIn::getImcos( const STRING& aNum ) THROWDEF_RTE_IAE
1132 {
1133     Complex             z( aNum );
1134
1135     z.Cos();
1136
1137     return z.GetString();
1138 }
1139
1140
1141 STRING SAL_CALL AnalysisAddIn::getImdiv( const STRING& aDivid, const STRING& aDivis ) THROWDEF_RTE_IAE
1142 {
1143     Complex             z( aDivid );
1144
1145     z.Div( Complex( aDivis ) );
1146
1147     return z.GetString();
1148 }
1149
1150
1151 STRING SAL_CALL AnalysisAddIn::getImexp( const STRING& aNum ) THROWDEF_RTE_IAE
1152 {
1153     Complex             z( aNum );
1154
1155     z.Exp();
1156
1157     return z.GetString();
1158 }
1159
1160
1161 STRING SAL_CALL AnalysisAddIn::getImconjugate( const STRING& aNum ) THROWDEF_RTE_IAE
1162 {
1163     Complex             z( aNum );
1164
1165     z.Conjugate();
1166
1167     return z.GetString();
1168 }
1169
1170
1171 STRING SAL_CALL AnalysisAddIn::getImln( const STRING& aNum ) THROWDEF_RTE_IAE
1172 {
1173     Complex             z( aNum );
1174
1175     z.Ln();
1176
1177     return z.GetString();
1178 }
1179
1180
1181 STRING SAL_CALL AnalysisAddIn::getImlog10( const STRING& aNum ) THROWDEF_RTE_IAE
1182 {
1183     Complex             z( aNum );
1184
1185     z.Log10();
1186
1187     return z.GetString();
1188 }
1189
1190
1191 STRING SAL_CALL AnalysisAddIn::getImlog2( const STRING& aNum ) THROWDEF_RTE_IAE
1192 {
1193     Complex             z( aNum );
1194
1195     z.Log2();
1196
1197     return z.GetString();
1198 }
1199
1200
1201 STRING SAL_CALL AnalysisAddIn::getImproduct( constREFXPS&, const SEQSEQ( STRING )& aNum1, const SEQ( uno::Any )& aNL ) THROWDEF_RTE_IAE
1202 {
1203     ComplexList         z_list;
1204
1205     z_list.Append( aNum1, AH_IgnoreEmpty );
1206     z_list.Append( aNL, AH_IgnoreEmpty );
1207
1208     const Complex*      p = z_list.First();
1209
1210     if( !p )
1211         return Complex( 0 ).GetString();
1212
1213     Complex                     z( *p );
1214
1215     for( p = z_list.Next() ; p ; p = z_list.Next() )
1216         z.Mult( *p );
1217
1218     return z.GetString();
1219 }
1220
1221
1222 double SAL_CALL AnalysisAddIn::getImreal( const STRING& aNum ) THROWDEF_RTE_IAE
1223 {
1224     double fRet = Complex( aNum ).Real();
1225     RETURN_FINITE( fRet );
1226 }
1227
1228
1229 STRING SAL_CALL AnalysisAddIn::getImsin( const STRING& aNum ) THROWDEF_RTE_IAE
1230 {
1231     Complex             z( aNum );
1232
1233     z.Sin();
1234
1235     return z.GetString();
1236 }
1237
1238
1239 STRING SAL_CALL AnalysisAddIn::getImsub( const STRING& aNum1, const STRING& aNum2 ) THROWDEF_RTE_IAE
1240 {
1241     Complex             z( aNum1 );
1242
1243     z.Sub( Complex( aNum2 ) );
1244
1245     return z.GetString();
1246 }
1247
1248
1249 STRING SAL_CALL AnalysisAddIn::getImsum( constREFXPS&, const SEQSEQ( STRING )& aNum1, const SEQ( CSS::uno::Any )& aFollowingPars ) THROWDEF_RTE_IAE
1250 {
1251     ComplexList         z_list;
1252
1253     z_list.Append( aNum1, AH_IgnoreEmpty );
1254     z_list.Append( aFollowingPars, AH_IgnoreEmpty );
1255
1256     const Complex*      p = z_list.First();
1257
1258     if( !p )
1259         return Complex( 0 ).GetString();
1260
1261     Complex                     z( *p );
1262
1263     for( p = z_list.Next() ; p ; p = z_list.Next() )
1264         z.Add( *p );
1265
1266     return z.GetString();
1267 }
1268
1269
1270 STRING SAL_CALL AnalysisAddIn::getImsqrt( const STRING& aNum ) THROWDEF_RTE_IAE
1271 {
1272     Complex             z( aNum );
1273
1274 //      z.Power( 0.5 );
1275     z.Sqrt();
1276
1277     return z.GetString();
1278 }
1279
1280
1281 STRING SAL_CALL AnalysisAddIn::getComplex( double fR, double fI, const ANY& rSuff ) THROWDEF_RTE_IAE
1282 {
1283     sal_Bool    bi;
1284
1285     switch( rSuff.getValueTypeClass() )
1286     {
1287         case uno::TypeClass_VOID:
1288             bi = sal_True;
1289             break;
1290         case uno::TypeClass_STRING:
1291             {
1292             const STRING*       pSuff = ( const STRING* ) rSuff.getValue();
1293             bi = pSuff->compareToAscii( "i" ) == 0 || pSuff->getLength() == 0;
1294             if( !bi && pSuff->compareToAscii( "j" ) != 0 )
1295                 THROW_IAE;
1296             }
1297             break;
1298         default:
1299             THROW_IAE;
1300     }
1301
1302     return Complex( fR, fI, bi ? 'i' : 'j' ).GetString();
1303 }
1304
1305
1306 double SAL_CALL AnalysisAddIn::getConvert( double f, const STRING& aFU, const STRING& aTU ) THROWDEF_RTE_IAE
1307 {
1308     if( !pCDL )
1309         pCDL = new ConvertDataList();
1310
1311     double fRet = pCDL->Convert( f, aFU, aTU );
1312     RETURN_FINITE( fRet );
1313 }
1314
1315