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