scaddins/source/analysis/analysis.cxx

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