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