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