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