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