?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Avoid potential negative array index access to cached text.
[LibreOffice.git] / scaddins / source / analysis / analysishelper.cxx
blobdfd41f953d29339278c23281d9401236836a4660
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 <com/sun/star/util/Date.hpp>
21 #include <com/sun/star/util/XNumberFormatTypes.hpp>
22 #include <com/sun/star/util/NumberFormatter.hpp>
23
24 #include <string.h>
25 #include <stdio.h>
26 #include <o3tl/any.hxx>
27 #include <rtl/math.hxx>
28 #include <algorithm>
29 #include <cmath>
30 #include <memory>
31
32 #include "analysisdefs.hxx"
33 #include "analysishelper.hxx"
34 #include <analysis.hrc>
35 #include <strings.hrc>
36 #include "deffuncname.hxx"
37
38 using namespace ::com::sun::star;
39 using namespace sca::analysis;
40
41 #define UNIQUE false // function name does not exist in Calc
42 #define DOUBLE true // function name exists in Calc
43
44 #define STDPAR false // all parameters are described
45 #define INTPAR true // first parameter is internal
46
47 #define FUNCDATA( FUNCNAME, DBL, OPT, NUMOFPAR, CAT ) \
48 { "get" #FUNCNAME, ANALYSIS_FUNCNAME_##FUNCNAME, ANALYSIS_##FUNCNAME, DBL, OPT, ANALYSIS_DEFFUNCNAME_##FUNCNAME, NUMOFPAR, CAT, nullptr }
49
50 #define FUNCDATAS( FUNCNAME, DBL, OPT, NUMOFPAR, CAT, SUFFIX ) \
51 { "get" #FUNCNAME, ANALYSIS_FUNCNAME_##FUNCNAME, ANALYSIS_##FUNCNAME, DBL, OPT, ANALYSIS_DEFFUNCNAME_##FUNCNAME, NUMOFPAR, CAT, SUFFIX }
52
53 const FuncDataBase pFuncDatas[] =
54 {
55 // UNIQUE or INTPAR or
56 // function name DOUBLE STDPAR # of param category
57 FUNCDATA( Workday, UNIQUE, INTPAR, 3, FDCategory::DateTime ),
58 FUNCDATA( Yearfrac, UNIQUE, INTPAR, 3, FDCategory::DateTime ),
59 FUNCDATA( Edate, UNIQUE, INTPAR, 2, FDCategory::DateTime ),
60 FUNCDATAS( Weeknum, DOUBLE, INTPAR, 2, FDCategory::DateTime, "_EXCEL2003" ),
61 FUNCDATA( Eomonth, UNIQUE, INTPAR, 2, FDCategory::DateTime ),
62 FUNCDATAS( Networkdays, DOUBLE, INTPAR, 3, FDCategory::DateTime, "_EXCEL2003" ),
63 FUNCDATA( Iseven, DOUBLE, STDPAR, 1, FDCategory::Inf ),
64 FUNCDATA( Isodd, DOUBLE, STDPAR, 1, FDCategory::Inf ),
65 FUNCDATA( Multinomial, UNIQUE, STDPAR, 1, FDCategory::Math ),
66 FUNCDATA( Seriessum, UNIQUE, STDPAR, 4, FDCategory::Math ),
67 FUNCDATA( Quotient, UNIQUE, STDPAR, 2, FDCategory::Math ),
68 FUNCDATA( Mround, UNIQUE, STDPAR, 2, FDCategory::Math ),
69 FUNCDATA( Sqrtpi, UNIQUE, STDPAR, 1, FDCategory::Math ),
70 FUNCDATA( Randbetween, UNIQUE, STDPAR, 2, FDCategory::Math ),
71 FUNCDATAS( Gcd, DOUBLE, INTPAR, 1, FDCategory::Math, "_EXCEL2003" ),
72 FUNCDATAS( Lcm, DOUBLE, INTPAR, 1, FDCategory::Math, "_EXCEL2003" ),
73 FUNCDATA( Besseli, UNIQUE, STDPAR, 2, FDCategory::Tech ),
74 FUNCDATA( Besselj, UNIQUE, STDPAR, 2, FDCategory::Tech ),
75 FUNCDATA( Besselk, UNIQUE, STDPAR, 2, FDCategory::Tech ),
76 FUNCDATA( Bessely, UNIQUE, STDPAR, 2, FDCategory::Tech ),
77 FUNCDATA( Bin2Oct, UNIQUE, INTPAR, 2, FDCategory::Tech ),
78 FUNCDATA( Bin2Dec, UNIQUE, STDPAR, 1, FDCategory::Tech ),
79 FUNCDATA( Bin2Hex, UNIQUE, INTPAR, 2, FDCategory::Tech ),
80 FUNCDATA( Oct2Bin, UNIQUE, INTPAR, 2, FDCategory::Tech ),
81 FUNCDATA( Oct2Dec, UNIQUE, STDPAR, 1, FDCategory::Tech ),
82 FUNCDATA( Oct2Hex, UNIQUE, INTPAR, 2, FDCategory::Tech ),
83 FUNCDATA( Dec2Bin, UNIQUE, INTPAR, 2, FDCategory::Tech ),
84 FUNCDATA( Dec2Hex, UNIQUE, INTPAR, 2, FDCategory::Tech ),
85 FUNCDATA( Dec2Oct, UNIQUE, INTPAR, 2, FDCategory::Tech ),
86 FUNCDATA( Hex2Bin, UNIQUE, INTPAR, 2, FDCategory::Tech ),
87 FUNCDATA( Hex2Dec, UNIQUE, STDPAR, 1, FDCategory::Tech ),
88 FUNCDATA( Hex2Oct, UNIQUE, INTPAR, 2, FDCategory::Tech ),
89 FUNCDATA( Delta, UNIQUE, INTPAR, 2, FDCategory::Tech ),
90 FUNCDATA( Erf, UNIQUE, INTPAR, 2, FDCategory::Tech ),
91 FUNCDATA( Erfc, UNIQUE, STDPAR, 1, FDCategory::Tech ),
92 FUNCDATA( Gestep, UNIQUE, INTPAR, 2, FDCategory::Tech ),
93 FUNCDATA( Factdouble, UNIQUE, STDPAR, 1, FDCategory::Tech ),
94 FUNCDATA( Imabs, UNIQUE, STDPAR, 1, FDCategory::Tech ),
95 FUNCDATA( Imaginary, UNIQUE, STDPAR, 1, FDCategory::Tech ),
96 FUNCDATA( Impower, UNIQUE, STDPAR, 2, FDCategory::Tech ),
97 FUNCDATA( Imargument, UNIQUE, STDPAR, 1, FDCategory::Tech ),
98 FUNCDATA( Imcos, UNIQUE, STDPAR, 1, FDCategory::Tech ),
99 FUNCDATA( Imdiv, UNIQUE, STDPAR, 2, FDCategory::Tech ),
100 FUNCDATA( Imexp, UNIQUE, STDPAR, 1, FDCategory::Tech ),
101 FUNCDATA( Imconjugate, UNIQUE, STDPAR, 1, FDCategory::Tech ),
102 FUNCDATA( Imln, UNIQUE, STDPAR, 1, FDCategory::Tech ),
103 FUNCDATA( Imlog10, UNIQUE, STDPAR, 1, FDCategory::Tech ),
104 FUNCDATA( Imlog2, UNIQUE, STDPAR, 1, FDCategory::Tech ),
105 FUNCDATA( Improduct, UNIQUE, INTPAR, 2, FDCategory::Tech ),
106 FUNCDATA( Imreal, UNIQUE, STDPAR, 1, FDCategory::Tech ),
107 FUNCDATA( Imsin, UNIQUE, STDPAR, 1, FDCategory::Tech ),
108 FUNCDATA( Imsub, UNIQUE, STDPAR, 2, FDCategory::Tech ),
109 FUNCDATA( Imsqrt, UNIQUE, STDPAR, 1, FDCategory::Tech ),
110 FUNCDATA( Imsum, UNIQUE, INTPAR, 1, FDCategory::Tech ),
111 FUNCDATA( Imtan, UNIQUE, STDPAR, 1, FDCategory::Tech ),
112 FUNCDATA( Imsec, UNIQUE, STDPAR, 1, FDCategory::Tech ),
113 FUNCDATA( Imcsc, UNIQUE, STDPAR, 1, FDCategory::Tech ),
114 FUNCDATA( Imcot, UNIQUE, STDPAR, 1, FDCategory::Tech ),
115 FUNCDATA( Imsinh, UNIQUE, STDPAR, 1, FDCategory::Tech ),
116 FUNCDATA( Imcosh, UNIQUE, STDPAR, 1, FDCategory::Tech ),
117 FUNCDATA( Imsech, UNIQUE, STDPAR, 1, FDCategory::Tech ),
118 FUNCDATA( Imcsch, UNIQUE, STDPAR, 1, FDCategory::Tech ),
119 FUNCDATA( Complex, UNIQUE, STDPAR, 3, FDCategory::Tech ),
120 FUNCDATA( Convert, UNIQUE, STDPAR, 3, FDCategory::Tech ),
121 FUNCDATA( Amordegrc, UNIQUE, INTPAR, 7, FDCategory::Finance ),
122 FUNCDATA( Amorlinc, UNIQUE, INTPAR, 7, FDCategory::Finance ),
123 FUNCDATA( Accrint, UNIQUE, INTPAR, 7, FDCategory::Finance ),
124 FUNCDATA( Accrintm, UNIQUE, INTPAR, 5, FDCategory::Finance ),
125 FUNCDATA( Received, UNIQUE, INTPAR, 5, FDCategory::Finance ),
126 FUNCDATA( Disc, UNIQUE, INTPAR, 5, FDCategory::Finance ),
127 FUNCDATA( Duration, UNIQUE, INTPAR, 6, FDCategory::Finance ),
128 FUNCDATA( Effect, DOUBLE, STDPAR, 2, FDCategory::Finance ),
129 FUNCDATA( Cumprinc, DOUBLE, STDPAR, 6, FDCategory::Finance ),
130 FUNCDATA( Cumipmt, DOUBLE, STDPAR, 6, FDCategory::Finance ),
131 FUNCDATA( Price, UNIQUE, INTPAR, 7, FDCategory::Finance ),
132 FUNCDATA( Pricedisc, UNIQUE, INTPAR, 5, FDCategory::Finance ),
133 FUNCDATA( Pricemat, UNIQUE, INTPAR, 6, FDCategory::Finance ),
134 FUNCDATA( Mduration, UNIQUE, INTPAR, 6, FDCategory::Finance ),
135 FUNCDATA( Nominal, DOUBLE, STDPAR, 2, FDCategory::Finance ),
136 FUNCDATA( Dollarfr, UNIQUE, STDPAR, 2, FDCategory::Finance ),
137 FUNCDATA( Dollarde, UNIQUE, STDPAR, 2, FDCategory::Finance ),
138 FUNCDATA( Yield, UNIQUE, INTPAR, 7, FDCategory::Finance ),
139 FUNCDATA( Yielddisc, UNIQUE, INTPAR, 5, FDCategory::Finance ),
140 FUNCDATA( Yieldmat, UNIQUE, INTPAR, 6, FDCategory::Finance ),
141 FUNCDATA( Tbilleq, UNIQUE, INTPAR, 3, FDCategory::Finance ),
142 FUNCDATA( Tbillprice, UNIQUE, INTPAR, 3, FDCategory::Finance ),
143 FUNCDATA( Tbillyield, UNIQUE, INTPAR, 3, FDCategory::Finance ),
144 FUNCDATA( Oddfprice, UNIQUE, INTPAR, 9, FDCategory::Finance ),
145 FUNCDATA( Oddfyield, UNIQUE, INTPAR, 9, FDCategory::Finance ),
146 FUNCDATA( Oddlprice, UNIQUE, INTPAR, 8, FDCategory::Finance ),
147 FUNCDATA( Oddlyield, UNIQUE, INTPAR, 8, FDCategory::Finance ),
148 FUNCDATA( Xirr, UNIQUE, INTPAR, 3, FDCategory::Finance ),
149 FUNCDATA( Xnpv, UNIQUE, STDPAR, 3, FDCategory::Finance ),
150 FUNCDATA( Intrate, UNIQUE, INTPAR, 5, FDCategory::Finance ),
151 FUNCDATA( Coupncd, UNIQUE, INTPAR, 4, FDCategory::Finance ),
152 FUNCDATA( Coupdays, UNIQUE, INTPAR, 4, FDCategory::Finance ),
153 FUNCDATA( Coupdaysnc, UNIQUE, INTPAR, 4, FDCategory::Finance ),
154 FUNCDATA( Coupdaybs, UNIQUE, INTPAR, 4, FDCategory::Finance ),
155 FUNCDATA( Couppcd, UNIQUE, INTPAR, 4, FDCategory::Finance ),
156 FUNCDATA( Coupnum, UNIQUE, INTPAR, 4, FDCategory::Finance ),
157 FUNCDATA( Fvschedule, UNIQUE, STDPAR, 2, FDCategory::Finance )
158 };
159 #undef FUNCDATA
160
161 namespace sca::analysis {
162
163 sal_uInt16 DaysInMonth( sal_uInt16 nMonth, sal_uInt16 nYear )
164 {
165 if( (nMonth == 2) && IsLeapYear( nYear ) )
166 return 29;
167 static const sal_uInt16 aDaysInMonth[] = { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
168 return aDaysInMonth[ nMonth ];
169 }
170
171
172 /**
173 * Convert a date to a count of days starting from 01/01/0001
174 *
175 * The internal representation of a Date used in this Addin
176 * is the number of days between 01/01/0001 and the date
177 * this function converts a Day , Month, Year representation
178 * to this internal Date value.
179 *
180 */
181
182 sal_Int32 DateToDays( sal_uInt16 nDay, sal_uInt16 nMonth, sal_uInt16 nYear )
183 {
184 sal_Int32 nDays = (static_cast<sal_Int32>(nYear)-1) * 365;
185 nDays += ((nYear-1) / 4) - ((nYear-1) / 100) + ((nYear-1) / 400);
186
187 for( sal_uInt16 i = 1; i < nMonth; i++ )
188 nDays += DaysInMonth(i,nYear);
189 nDays += nDay;
190
191 return nDays;
192 }
193
194
195 /**
196 * Convert a count of days starting from 01/01/0001 to a date
197 *
198 * The internal representation of a Date used in this Addin
199 * is the number of days between 01/01/0001 and the date
200 * this function converts this internal Date value
201 * to a Day , Month, Year representation of a Date.
202 *
203 */
204
205 void DaysToDate( sal_Int32 nDays, sal_uInt16& rDay, sal_uInt16& rMonth, sal_uInt16& rYear )
206 {
207 if( nDays < 0 )
208 throw lang::IllegalArgumentException();
209
210 sal_Int32 nTempDays;
211 sal_Int32 i = 0;
212 bool bCalc;
213
214 do
215 {
216 nTempDays = nDays;
217 rYear = static_cast<sal_uInt16>((nTempDays / 365) - i);
218 nTempDays -= (static_cast<sal_Int32>(rYear) -1) * 365;
219 nTempDays -= (( rYear -1) / 4) - (( rYear -1) / 100) + ((rYear -1) / 400);
220 bCalc = false;
221 if ( nTempDays < 1 )
222 {
223 i++;
224 bCalc = true;
225 }
226 else
227 {
228 if ( nTempDays > 365 )
229 {
230 if ( (nTempDays != 366) || !IsLeapYear( rYear ) )
231 {
232 i--;
233 bCalc = true;
234 }
235 }
236 }
237 }
238 while ( bCalc );
239
240 rMonth = 1;
241 while ( nTempDays > DaysInMonth( rMonth, rYear ) )
242 {
243 nTempDays -= DaysInMonth( rMonth, rYear );
244 rMonth++;
245 }
246 rDay = static_cast<sal_uInt16>(nTempDays);
247 }
248
249
250 /**
251 * Get the null date used by the spreadsheet document
252 *
253 * The internal representation of a Date used in this Addin
254 * is the number of days between 01/01/0001 and the date
255 * this function returns this internal Date value for the document null date
256 *
257 */
258
259 sal_Int32 GetNullDate( const uno::Reference< beans::XPropertySet >& xOpt )
260 {
261 if( xOpt.is() )
262 {
263 try
264 {
265 uno::Any aAny = xOpt->getPropertyValue( "NullDate" );
266 util::Date aDate;
267 if( aAny >>= aDate )
268 return DateToDays( aDate.Day, aDate.Month, aDate.Year );
269 }
270 catch( uno::Exception& )
271 {
272 }
273 }
274
275 // no null date available -> no calculations possible
276 throw uno::RuntimeException();
277 }
278
279
280 sal_Int32 GetDiffDate360(
281 sal_uInt16 nDay1, sal_uInt16 nMonth1, sal_uInt16 nYear1, bool bLeapYear1,
282 sal_uInt16 nDay2, sal_uInt16 nMonth2, sal_uInt16 nYear2,
283 bool bUSAMethod )
284 {
285 if( nDay1 == 31 )
286 nDay1--;
287 else if( bUSAMethod && ( nMonth1 == 2 && ( nDay1 == 29 || ( nDay1 == 28 && !bLeapYear1 ) ) ) )
288 nDay1 = 30;
289
290 if( nDay2 == 31 )
291 {
292 if( bUSAMethod && nDay1 != 30 )
293 {
294 nDay2 = 1;
295 if( nMonth2 == 12 )
296 {
297 nYear2++;
298 nMonth2 = 1;
299 }
300 else
301 nMonth2++;
302 }
303 else
304 nDay2 = 30;
305 }
306
307 return nDay2 + nMonth2 * 30 + nYear2 * 360 - nDay1 - nMonth1 * 30 - nYear1 * 360;
308 }
309
310
311 sal_Int32 GetDiffDate360( sal_Int32 nNullDate, sal_Int32 nDate1, sal_Int32 nDate2, bool bUSAMethod )
312 {
313 nDate1 += nNullDate;
314 nDate2 += nNullDate;
315
316 sal_uInt16 nDay1, nMonth1, nYear1, nDay2, nMonth2, nYear2;
317
318 DaysToDate( nDate1, nDay1, nMonth1, nYear1 );
319 DaysToDate( nDate2, nDay2, nMonth2, nYear2 );
320
321 return GetDiffDate360( nDay1, nMonth1, nYear1, IsLeapYear( nYear1 ), nDay2, nMonth2, nYear2, bUSAMethod );
322 }
323
324
325 sal_Int32 GetDaysInYears( sal_uInt16 nYear1, sal_uInt16 nYear2 )
326 {
327 sal_uInt16 nLeaps = 0;
328 for( sal_uInt16 n = nYear1 ; n <= nYear2 ; n++ )
329 {
330 if( IsLeapYear( n ) )
331 nLeaps++;
332 }
333
334 sal_uInt32 nSum = 1;
335 nSum += nYear2;
336 nSum -= nYear1;
337 nSum *= 365;
338 nSum += nLeaps;
339
340 return nSum;
341 }
342
343
344 sal_Int32 GetDiffDate( sal_Int32 nNullDate, sal_Int32 nStartDate, sal_Int32 nEndDate, sal_Int32 nMode,
345 sal_Int32* pOptDaysIn1stYear )
346 {
347 bool bNeg = nStartDate > nEndDate;
348
349 if( bNeg )
350 std::swap( nStartDate, nEndDate );
351
352 sal_Int32 nRet;
353
354 switch( nMode )
355 {
356 case 0: // 0=USA (NASD) 30/360
357 case 4: // 4=Europe 30/360
358 {
359 sal_uInt16 nD1, nM1, nY1, nD2, nM2, nY2;
360
361 nStartDate += nNullDate;
362 nEndDate += nNullDate;
363
364 DaysToDate( nStartDate, nD1, nM1, nY1 );
365 DaysToDate( nEndDate, nD2, nM2, nY2 );
366
367 bool bLeap = IsLeapYear( nY1 );
368 sal_Int32 nDays, nMonths;
369
370 nMonths = nM2 - nM1;
371 nDays = nD2 - nD1;
372
373 nMonths += ( nY2 - nY1 ) * 12;
374
375 nRet = nMonths * 30 + nDays;
376 if( nMode == 0 && nM1 == 2 && nM2 != 2 && nY1 == nY2 )
377 nRet -= bLeap? 1 : 2;
378
379 if( pOptDaysIn1stYear )
380 *pOptDaysIn1stYear = 360;
381 }
382 break;
383 case 1: // 1=exact/exact
384 if( pOptDaysIn1stYear )
385 {
386 sal_uInt16 nD, nM, nY;
387
388 DaysToDate( nStartDate + nNullDate, nD, nM, nY );
389
390 *pOptDaysIn1stYear = IsLeapYear( nY )? 366 : 365;
391 }
392 nRet = nEndDate - nStartDate;
393 break;
394 case 2: // 2=exact/360
395 nRet = nEndDate - nStartDate;
396 if( pOptDaysIn1stYear )
397 *pOptDaysIn1stYear = 360;
398 break;
399 case 3: //3=exact/365
400 nRet = nEndDate - nStartDate;
401 if( pOptDaysIn1stYear )
402 *pOptDaysIn1stYear = 365;
403 break;
404 default:
405 throw lang::IllegalArgumentException();
406 }
407
408 return bNeg? -nRet : nRet;
409 }
410
411
412 double GetYearDiff( sal_Int32 nNullDate, sal_Int32 nStartDate, sal_Int32 nEndDate, sal_Int32 nMode )
413 {
414 sal_Int32 nDays1stYear;
415 sal_Int32 nTotalDays = GetDiffDate( nNullDate, nStartDate, nEndDate, nMode, &nDays1stYear );
416
417 return double( nTotalDays ) / double( nDays1stYear );
418 }
419
420
421 sal_Int32 GetDaysInYear( sal_Int32 nNullDate, sal_Int32 nDate, sal_Int32 nMode )
422 {
423 switch( nMode )
424 {
425 case 0: // 0=USA (NASD) 30/360
426 case 2: // 2=exact/360
427 case 4: // 4=Europe 30/360
428 return 360;
429 case 1: // 1=exact/exact
430 {
431 sal_uInt16 nD, nM, nY;
432 nDate += nNullDate;
433 DaysToDate( nDate, nD, nM, nY );
434 return IsLeapYear( nY )? 366 : 365;
435 }
436 case 3: //3=exact/365
437 return 365;
438 default:
439 throw lang::IllegalArgumentException();
440 }
441 }
442
443
444 // tdf69569 making code compliant with change request for ODFF1.2 par 4.11.7.7
445 /**
446 * Function GetYearFrac implements YEARFRAC as defined in:
447 * Open Document Format for Office Applications version 1.2 Part 2, par. 6.10.24
448 * The calculations are defined in:
449 * Open Document Format for Office Applications version 1.2 Part 2, par. 4.11.7
450 */
451 double GetYearFrac( sal_Int32 nNullDate, sal_Int32 nStartDate, sal_Int32 nEndDate, sal_Int32 nMode )
452 {
453 if( nStartDate == nEndDate )
454 return 0.0; // nothing to do...
455
456 if( nStartDate > nEndDate )
457 std::swap( nStartDate, nEndDate );
458
459 sal_Int32 nDate1 = nStartDate + nNullDate;
460 sal_Int32 nDate2 = nEndDate + nNullDate;
461
462 sal_uInt16 nDay1, nDay2;
463 sal_uInt16 nMonth1, nMonth2;
464 sal_uInt16 nYear1, nYear2;
465
466 DaysToDate( nDate1, nDay1, nMonth1, nYear1 );
467 DaysToDate( nDate2, nDay2, nMonth2, nYear2 );
468
469 // calculate days between nDate1 and nDate2
470 sal_Int32 nDayDiff;
471 switch( nMode )
472 {
473 case 0: // 0=USA (NASD) 30/360
474 if ( nDay1 == 31 )
475 {
476 nDay1--;
477 }
478 if ( nDay1 == 30 && nDay2 == 31 )
479 {
480 nDay2--;
481 }
482 else
483 {
484 if ( nMonth1 == 2 && nDay1 == ( IsLeapYear( nYear1 ) ? 29 : 28 ) )
485 {
486 nDay1 = 30;
487 if ( nMonth2 == 2 && nDay2 == ( IsLeapYear( nYear2 ) ? 29 : 28 ) )
488 {
489 nDay2 = 30;
490 }
491 }
492 }
493 nDayDiff = ( nYear2 - nYear1 ) * 360 + ( nMonth2 - nMonth1 ) * 30 + ( nDay2 - nDay1 );
494 break;
495 case 1: // 1=exact/exact
496 case 2: // 2=exact/360
497 case 3: // 3=exact/365
498 nDayDiff = nDate2 - nDate1;
499 break;
500 case 4: // 4=Europe 30/360
501 if ( nDay1 == 31 )
502 {
503 nDay1--;
504 }
505 if ( nDay2 == 31 )
506 {
507 nDay2--;
508 }
509 nDayDiff = ( nYear2 - nYear1 ) * 360 + ( nMonth2 - nMonth1 ) * 30 + ( nDay2 - nDay1 );
510 break;
511 default:
512 throw lang::IllegalArgumentException();
513 }
514
515 //calculate days in year
516 double nDaysInYear;
517 switch( nMode )
518 {
519 case 0: // 0=USA (NASD) 30/360
520 case 2: // 2=exact/360
521 case 4: // 4=Europe 30/360
522 nDaysInYear = 360;
523 break;
524 case 1: // 1=exact/exact
525 {
526 const bool isYearDifferent = ( nYear1 != nYear2 );
527 // ODFv1.2 part 2 section 4.11.7.7.7
528 if ( isYearDifferent &&
529 ( ( nYear2 != nYear1 + 1 ) ||
530 ( nMonth1 < nMonth2 ) ||
531 ( nMonth1 == nMonth2 && nDay1 < nDay2 ) ) )
532 {
533 // return average of days in year between nDate1 and nDate2, inclusive
534 sal_Int32 nDayCount = 0;
535 for ( sal_uInt16 i = nYear1; i <= nYear2; i++ )
536 nDayCount += ( IsLeapYear( i ) ? 366 : 365 );
537
538 nDaysInYear = static_cast<double>(nDayCount) / static_cast<double>( nYear2 - nYear1 + 1 );
539 }
540 else
541 {
542 // as a consequence, !isYearDifferent or
543 // nYear2 == nYear + 1 and (nMonth1 > nMonth2 or
544 // (nMonth1 == nMonth2 and nDay1 >= nDay2))
545 assert( ( !isYearDifferent ||
546 ( nYear1 + 1 == nYear2 &&
547 ( nMonth1 > nMonth2 ||
548 ( nMonth1 == nMonth2 || nDay1 >= nDay2 ) ) ) ) );
549
550 // ODFv1.2 part 2 section 4.11.7.7.8 (CHANGE REQUEST PENDING, see tdf6959)
551 if ( !isYearDifferent && IsLeapYear( nYear1 ) )
552 {
553 nDaysInYear = 366;
554 }
555 else
556 {
557 // ODFv1.2 part 2 section 4.11.7.7.9/10 (CHANGE REQUEST PENDING, see tdf69569)
558 // we need to determine whether there is a 29 February
559 // between nDate1 (inclusive) and nDate2 (inclusive)
560 // the case of nYear1 == nYear2 is adequately tested in previous test
561 if( isYearDifferent &&
562 ( ( IsLeapYear( nYear1 ) &&
563 ( ( nMonth1 < 2 ) || ( ( nMonth1 == 2 ) && ( nDay1 <= 29 ) ) ) ) ||
564 ( IsLeapYear( nYear2 ) &&
565 ( nMonth2 > 2 || ( ( nMonth2 == 2 ) && ( nDay2 == 29 ) ) ) ) ) )
566 {
567 nDaysInYear = 366;
568 }
569 else
570 {
571 nDaysInYear = 365;
572 }
573 }
574 }
575 }
576 break;
577 case 3: // 3=exact/365
578 nDaysInYear = 365;
579 break;
580 // coverity[dead_error_begin] - following conditions exist to avoid compiler warning
581 default:
582 throw lang::IllegalArgumentException();
583 }
584
585 return double( nDayDiff ) / nDaysInYear;
586 }
587
588 double BinomialCoefficient( double n, double k )
589 {
590 // This method is a copy of BinomKoeff()
591 // found in sc/source/core/tool/interpr3.cxx
592
593 double nVal = 0.0;
594 k = ::rtl::math::approxFloor(k);
595 if (n < k)
596 nVal = 0.0;
597 else if (k == 0.0)
598 nVal = 1.0;
599 else
600 {
601 nVal = n/k;
602 n--;
603 k--;
604 while (k > 0.0)
605 {
606 nVal *= n/k;
607 k--;
608 n--;
609 }
610 }
611 return nVal;
612 }
613
614 double GetGcd( double f1, double f2 )
615 {
616 double f = fmod( f1, f2 );
617 while( f > 0.0 )
618 {
619 f1 = f2;
620 f2 = f;
621 f = fmod( f1, f2 );
622 }
623
624 return f2;
625 }
626
627
628 double ConvertToDec( const OUString& aStr, sal_uInt16 nBase, sal_uInt16 nCharLim )
629 {
630 if ( nBase < 2 || nBase > 36 )
631 throw lang::IllegalArgumentException();
632
633 sal_uInt32 nStrLen = aStr.getLength();
634 if( nStrLen > nCharLim )
635 throw lang::IllegalArgumentException();
636 else if( !nStrLen )
637 return 0.0;
638
639 double fVal = 0.0;
640
641 const sal_Unicode* p = aStr.getStr();
642
643 sal_uInt16 nFirstDig = 0;
644 bool bFirstDig = true;
645 double fBase = nBase;
646
647 while ( *p )
648 {
649 sal_uInt16 n;
650
651 if( '0' <= *p && *p <= '9' )
652 n = *p - '0';
653 else if( 'A' <= *p && *p <= 'Z' )
654 n = 10 + ( *p - 'A' );
655 else if ( 'a' <= *p && *p <= 'z' )
656 n = 10 + ( *p - 'a' );
657 else
658 n = nBase;
659
660 if( n >= nBase )
661 throw lang::IllegalArgumentException(); // illegal char!
662
663 if( bFirstDig )
664 {
665 bFirstDig = false;
666 nFirstDig = n;
667 }
668 fVal = fVal * fBase + double( n );
669
670 p++;
671
672 }
673
674 if( nStrLen == nCharLim && !bFirstDig && (nFirstDig >= nBase / 2) )
675 { // handling negative values
676 fVal = ( pow( double( nBase ), double( nCharLim ) ) - fVal ); // complement
677 fVal *= -1.0;
678 }
679
680 return fVal;
681 }
682
683
684 static char GetMaxChar( sal_uInt16 nBase )
685 {
686 const char* const c = "--123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
687 return c[ nBase ];
688 }
689
690
691 OUString ConvertFromDec( double fNum, double fMin, double fMax, sal_uInt16 nBase,
692 sal_Int32 nPlaces, sal_Int32 nMaxPlaces, bool bUsePlaces )
693 {
694 fNum = ::rtl::math::approxFloor( fNum );
695 fMin = ::rtl::math::approxFloor( fMin );
696 fMax = ::rtl::math::approxFloor( fMax );
697
698 if( fNum < fMin || fNum > fMax || ( bUsePlaces && ( nPlaces <= 0 || nPlaces > nMaxPlaces ) ) )
699 throw lang::IllegalArgumentException();
700
701 sal_Int64 nNum = static_cast< sal_Int64 >( fNum );
702 bool bNeg = nNum < 0;
703 if( bNeg )
704 nNum = sal_Int64( pow( double( nBase ), double( nMaxPlaces ) ) ) + nNum;
705
706 OUString aRet(OUString::number(nNum, nBase).toAsciiUpperCase());
707
708
709 if( bUsePlaces )
710 {
711 sal_Int32 nLen = aRet.getLength();
712 if( !bNeg && nLen > nPlaces )
713 {
714 throw lang::IllegalArgumentException();
715 }
716 else if( ( bNeg && nLen < nMaxPlaces ) || ( !bNeg && nLen < nPlaces ) )
717 {
718 sal_Int32 nLeft = nPlaces - nLen;
719 std::unique_ptr<char[]> p( new char[ nLeft + 1 ] );
720 memset( p.get(), bNeg ? GetMaxChar( nBase ) : '0', nLeft );
721 p[ nLeft ] = 0x00;
722 aRet = OUString( p.get(), nLeft, RTL_TEXTENCODING_MS_1252 ) + aRet;
723 }
724 }
725
726 return aRet;
727 }
728
729 double Erf( double x )
730 {
731 return std::erf(x);
732 }
733
734 double Erfc( double x )
735 {
736 return std::erfc(x);
737 }
738
739 static bool IsNum( sal_Unicode c )
740 {
741 return c >= '0' && c <= '9';
742 }
743
744
745 static bool IsComma( sal_Unicode c )
746 {
747 return c == '.' || c == ',';
748 }
749
750
751 static bool IsExpStart( sal_Unicode c )
752 {
753 return c == 'e' || c == 'E';
754 }
755
756
757 static bool IsImagUnit( sal_Unicode c )
758 {
759 return c == 'i' || c == 'j';
760 }
761
762
763 static sal_uInt16 GetVal( sal_Unicode c )
764 {
765 return sal_uInt16( c - '0' );
766 }
767
768
769 bool ParseDouble( const sal_Unicode*& rp, double& rRet )
770 {
771 double fInt = 0.0;
772 double fFrac = 0.0;
773 double fMult = 0.1; // multiplier to multiply digits with, when adding fractional ones
774 sal_Int32 nExp = 0;
775 sal_Int32 nMaxExp = 307;
776 sal_uInt16 nDigCnt = 18; // max. number of digits to read in, rest doesn't matter
777
778 enum State { S_End = 0, S_Sign, S_IntStart, S_Int, S_IgnoreIntDigs, S_Frac, S_IgnoreFracDigs, S_ExpSign, S_Exp };
779
780 State eS = S_Sign;
781
782 bool bNegNum = false;
783 bool bNegExp = false;
784
785 const sal_Unicode* p = rp;
786 sal_Unicode c;
787
788 while( eS )
789 {
790 c = *p;
791 switch( eS )
792 {
793 case S_Sign:
794 if( IsNum( c ) )
795 {
796 fInt = GetVal( c );
797 nDigCnt--;
798 eS = S_Int;
799 }
800 else if( c == '-' )
801 {
802 bNegNum = true;
803 eS = S_IntStart;
804 }
805 else if( c == '+' )
806 eS = S_IntStart;
807 else if( IsComma( c ) )
808 eS = S_Frac;
809 else
810 return false;
811 break;
812 case S_IntStart:
813 if( IsNum( c ) )
814 {
815 fInt = GetVal( c );
816 nDigCnt--;
817 eS = S_Int;
818 }
819 else if( IsComma( c ) )
820 eS = S_Frac;
821 else if( IsImagUnit( c ) )
822 {
823 rRet = 0.0;
824 return true;
825 }
826 else
827 return false;
828 break;
829 case S_Int:
830 if( IsNum( c ) )
831 {
832 fInt *= 10.0;
833 fInt += double( GetVal( c ) );
834 nDigCnt--;
835 if( !nDigCnt )
836 eS = S_IgnoreIntDigs;
837 }
838 else if( IsComma( c ) )
839 eS = S_Frac;
840 else if( IsExpStart( c ) )
841 eS = S_ExpSign;
842 else
843 eS = S_End;
844 break;
845 case S_IgnoreIntDigs:
846 if( IsNum( c ) )
847 nExp++; // just multiply num with 10... ;-)
848 else if( IsComma( c ) )
849 eS = S_Frac;
850 else if( IsExpStart( c ) )
851 eS = S_ExpSign;
852 else
853 eS = S_End;
854 break;
855 case S_Frac:
856 if( IsNum( c ) )
857 {
858 fFrac += double( GetVal( c ) ) * fMult;
859 nDigCnt--;
860 if( nDigCnt )
861 fMult *= 0.1;
862 else
863 eS = S_IgnoreFracDigs;
864 }
865 else if( IsExpStart( c ) )
866 eS = S_ExpSign;
867 else
868 eS = S_End;
869 break;
870 case S_IgnoreFracDigs:
871 if( IsExpStart( c ) )
872 eS = S_ExpSign;
873 else if( !IsNum( c ) )
874 eS = S_End;
875 break;
876 case S_ExpSign:
877 if( IsNum( c ) )
878 {
879 nExp = GetVal( c );
880 eS = S_Exp;
881 }
882 else if( c == '-' )
883 {
884 bNegExp = true;
885 eS = S_Exp;
886 }
887 else if( c != '+' )
888 eS = S_End;
889 break;
890 case S_Exp:
891 if( IsNum( c ) )
892 {
893 nExp *= 10;
894 nExp += GetVal( c );
895 if( nExp > nMaxExp )
896 return false;
897 }
898 else
899 eS = S_End;
900 break;
901 // coverity[dead_error_begin] - following conditions exist to avoid compiler warning
902 case S_End:
903 break;
904 }
905
906 p++;
907 }
908
909 p--; // set pointer back to last
910 rp = p;
911
912 fInt += fFrac;
913
914 if (fInt != 0.0) // exact check; log10(0.0) may entail a pole error
915 {
916 sal_Int32 nLog10 = sal_Int32( log10( fInt ) );
917
918 if( bNegExp )
919 nExp = -nExp;
920
921 if( nLog10 + nExp > nMaxExp )
922 return false;
923
924 fInt = ::rtl::math::pow10Exp( fInt, nExp );
925 }
926
927 if( bNegNum )
928 fInt = -fInt;
929
930 rRet = fInt;
931
932 return true;
933 }
934
935
936 OUString GetString( double f, bool bLeadingSign, sal_uInt16 nMaxDig )
937 {
938 const int nBuff = 256;
939 char aBuff[ nBuff + 1 ];
940 const char* pFormStr = bLeadingSign? "%+.*g" : "%.*g";
941 int nLen = snprintf( aBuff, nBuff, pFormStr, int( nMaxDig ), f );
942 // you never know which underlying implementation you get ...
943 aBuff[nBuff] = 0;
944 if ( nLen < 0 || nLen > nBuff )
945 nLen = strlen( aBuff );
946
947 OUString aRet( aBuff, nLen, RTL_TEXTENCODING_MS_1252 );
948
949 return aRet;
950 }
951
952
953 double GetAmordegrc( sal_Int32 nNullDate, double fCost, sal_Int32 nDate, sal_Int32 nFirstPer,
954 double fRestVal, double fPer, double fRate, sal_Int32 nBase )
955 {
956 sal_uInt32 nPer = sal_uInt32( fPer );
957 double fUsePer = 1.0 / fRate;
958 double fAmorCoeff;
959
960 if( fUsePer < 3.0 )
961 fAmorCoeff = 1.0;
962 else if( fUsePer < 5.0 )
963 fAmorCoeff = 1.5;
964 else if( fUsePer <= 6.0 )
965 fAmorCoeff = 2.0;
966 else
967 fAmorCoeff = 2.5;
968
969 fRate *= fAmorCoeff;
970 double fNRate = ::rtl::math::round( GetYearFrac( nNullDate, nDate, nFirstPer, nBase ) * fRate * fCost );
971 fCost -= fNRate;
972 double fRest = fCost - fRestVal; // aboriginal cost - residual value - sum of all write-downs
973
974 for( sal_uInt32 n = 0 ; n < nPer ; n++ )
975 {
976 fNRate = ::rtl::math::round( fRate * fCost );
977 fRest -= fNRate;
978
979 if( fRest < 0.0 )
980 {
981 switch( nPer - n )
982 {
983 case 0:
984 case 1:
985 return ::rtl::math::round( fCost * 0.5 );
986 default:
987 return 0.0;
988 }
989 }
990
991 fCost -= fNRate;
992 }
993
994 return fNRate;
995 }
996
997
998 double GetAmorlinc( sal_Int32 nNullDate, double fCost, sal_Int32 nDate, sal_Int32 nFirstPer,
999 double fRestVal, double fPer, double fRate, sal_Int32 nBase )
1000 {
1001 sal_uInt32 nPer = sal_uInt32( fPer );
1002 double fOneRate = fCost * fRate;
1003 double fCostDelta = fCost - fRestVal;
1004 double f0Rate = GetYearFrac( nNullDate, nDate, nFirstPer, nBase ) * fRate * fCost;
1005 sal_uInt32 nNumOfFullPeriods = sal_uInt32( ( fCost - fRestVal - f0Rate) / fOneRate );
1006
1007 double fResult = 0.0;
1008 if( nPer == 0 )
1009 fResult = f0Rate;
1010 else if( nPer <= nNumOfFullPeriods )
1011 fResult = fOneRate;
1012 else if( nPer == nNumOfFullPeriods + 1 )
1013 fResult = fCostDelta - fOneRate * nNumOfFullPeriods - f0Rate;
1014
1015 if ( fResult > 0.0 )
1016 return fResult;
1017 else
1018 return 0.0;
1019 }
1020
1021
1022 double GetDuration( sal_Int32 nNullDate, sal_Int32 nSettle, sal_Int32 nMat, double fCoup,
1023 double fYield, sal_Int32 nFreq, sal_Int32 nBase )
1024 {
1025 double fYearfrac = GetYearFrac( nNullDate, nSettle, nMat, nBase );
1026 double fNumOfCoups = GetCoupnum( nNullDate, nSettle, nMat, nFreq, nBase );
1027 double fDur = 0.0;
1028 const double f100 = 100.0;
1029 fCoup *= f100 / double( nFreq ); // fCoup is used as cash flow
1030 fYield /= nFreq;
1031 fYield += 1.0;
1032
1033 double nDiff = fYearfrac * nFreq - fNumOfCoups;
1034
1035 double t;
1036
1037 for( t = 1.0 ; t < fNumOfCoups ; t++ )
1038 fDur += ( t + nDiff ) * fCoup / pow( fYield, t + nDiff );
1039
1040 fDur += ( fNumOfCoups + nDiff ) * ( fCoup + f100 ) / pow( fYield, fNumOfCoups + nDiff );
1041
1042 double p = 0.0;
1043 for( t = 1.0 ; t < fNumOfCoups ; t++ )
1044 p += fCoup / pow( fYield, t + nDiff );
1045
1046 p += ( fCoup + f100 ) / pow( fYield, fNumOfCoups + nDiff );
1047
1048 fDur /= p;
1049 fDur /= double( nFreq );
1050
1051 return fDur;
1052 }
1053
1054
1055 double GetYieldmat( sal_Int32 nNullDate, sal_Int32 nSettle, sal_Int32 nMat, sal_Int32 nIssue,
1056 double fRate, double fPrice, sal_Int32 nBase )
1057 {
1058 double fIssMat = GetYearFrac( nNullDate, nIssue, nMat, nBase );
1059 double fIssSet = GetYearFrac( nNullDate, nIssue, nSettle, nBase );
1060 double fSetMat = GetYearFrac( nNullDate, nSettle, nMat, nBase );
1061
1062 double y = 1.0 + fIssMat * fRate;
1063 y /= fPrice / 100.0 + fIssSet * fRate;
1064 y--;
1065 y /= fSetMat;
1066
1067 return y;
1068 }
1069
1070
1071 double GetOddfprice( sal_Int32 /*nNullDate*/, sal_Int32 /*nSettle*/, sal_Int32 /*nMat*/, sal_Int32 /*nIssue*/,
1072 sal_Int32 /*nFirstCoup*/, double /*fRate*/, double /*fYield*/, double /*fRedemp*/, sal_Int32 /*nFreq*/,
1073 sal_Int32 /*nBase*/ )
1074 {
1075 // If you change this to not unconditionally throw, the
1076 // SAL_WNOUNREACHABLE_CODE_PUSH/POP around the caller in
1077 // financial.cxx can be removed.
1078 throw uno::RuntimeException();
1079 }
1080
1081
1082 double getYield_( sal_Int32 nNullDate, sal_Int32 nSettle, sal_Int32 nMat, double fCoup, double fPrice,
1083 double fRedemp, sal_Int32 nFreq, sal_Int32 nBase )
1084 {
1085 double fRate = fCoup;
1086 double fPriceN = 0.0;
1087 double fYield1 = 0.0;
1088 double fYield2 = 1.0;
1089 double fPrice1 = getPrice_( nNullDate, nSettle, nMat, fRate, fYield1, fRedemp, nFreq, nBase );
1090 double fPrice2 = getPrice_( nNullDate, nSettle, nMat, fRate, fYield2, fRedemp, nFreq, nBase );
1091 double fYieldN = ( fYield2 - fYield1 ) * 0.5;
1092
1093 for( sal_uInt32 nIter = 0 ; nIter < 100 && !rtl::math::approxEqual(fPriceN, fPrice) ; nIter++ )
1094 {
1095 fPriceN = getPrice_( nNullDate, nSettle, nMat, fRate, fYieldN, fRedemp, nFreq, nBase );
1096
1097 if( rtl::math::approxEqual(fPrice, fPrice1) )
1098 return fYield1;
1099 else if( rtl::math::approxEqual(fPrice, fPrice2) )
1100 return fYield2;
1101 else if( rtl::math::approxEqual(fPrice, fPriceN) )
1102 return fYieldN;
1103 else if( fPrice < fPrice2 )
1104 {
1105 fYield2 *= 2.0;
1106 fPrice2 = getPrice_( nNullDate, nSettle, nMat, fRate, fYield2, fRedemp, nFreq, nBase );
1107
1108 fYieldN = ( fYield2 - fYield1 ) * 0.5;
1109 }
1110 else
1111 {
1112 if( fPrice < fPriceN )
1113 {
1114 fYield1 = fYieldN;
1115 fPrice1 = fPriceN;
1116 }
1117 else
1118 {
1119 fYield2 = fYieldN;
1120 fPrice2 = fPriceN;
1121 }
1122
1123 fYieldN = fYield2 - ( fYield2 - fYield1 ) * ( ( fPrice - fPrice2 ) / ( fPrice1 - fPrice2 ) );
1124 }
1125 }
1126
1127 if( fabs( fPrice - fPriceN ) > fPrice / 100.0 )
1128 throw lang::IllegalArgumentException(); // result not precise enough
1129
1130 return fYieldN;
1131 }
1132
1133
1134 double getPrice_( sal_Int32 nNullDate, sal_Int32 nSettle, sal_Int32 nMat, double fRate, double fYield,
1135 double fRedemp, sal_Int32 nFreq, sal_Int32 nBase )
1136 {
1137 double fFreq = nFreq;
1138
1139 double fE = GetCoupdays( nNullDate, nSettle, nMat, nFreq, nBase );
1140 double fDSC_E = GetCoupdaysnc( nNullDate, nSettle, nMat, nFreq, nBase ) / fE;
1141 double fN = GetCoupnum( nNullDate, nSettle, nMat, nFreq, nBase );
1142 double fA = GetCoupdaybs( nNullDate, nSettle, nMat, nFreq, nBase );
1143
1144 double fRet = fRedemp / ( pow( 1.0 + fYield / fFreq, fN - 1.0 + fDSC_E ) );
1145 fRet -= 100.0 * fRate / fFreq * fA / fE;
1146
1147 double fT1 = 100.0 * fRate / fFreq;
1148 double fT2 = 1.0 + fYield / fFreq;
1149
1150 for( double fK = 0.0 ; fK < fN ; fK++ )
1151 fRet += fT1 / pow( fT2, fK + fDSC_E );
1152
1153 return fRet;
1154 }
1155
1156
1157 double GetOddfyield( sal_Int32 /*nNullDate*/, sal_Int32 /*nSettle*/, sal_Int32 /*nMat*/, sal_Int32 /*nIssue*/,
1158 sal_Int32 /*nFirstCoup*/, double /*fRate*/, double /*fPrice*/, double /*fRedemp*/, sal_Int32 /*nFreq*/,
1159 sal_Int32 /*nBase*/ )
1160 {
1161 // If you change this to not unconditionally throw, the
1162 // SAL_WNOUNREACHABLE_CODE_PUSH/POP around the caller in
1163 // financial.cxx can be removed.
1164 throw uno::RuntimeException();
1165 }
1166
1167
1168 double GetOddlprice( sal_Int32 nNullDate, sal_Int32 nSettle, sal_Int32 nMat, sal_Int32 nLastCoup,
1169 double fRate, double fYield, double fRedemp, sal_Int32 nFreq, sal_Int32 nBase )
1170 {
1171 double fFreq = double( nFreq );
1172 double fDCi = GetYearFrac( nNullDate, nLastCoup, nMat, nBase ) * fFreq;
1173 double fDSCi = GetYearFrac( nNullDate, nSettle, nMat, nBase ) * fFreq;
1174 double fAi = GetYearFrac( nNullDate, nLastCoup, nSettle, nBase ) * fFreq;
1175
1176 double p = fRedemp + fDCi * 100.0 * fRate / fFreq;
1177 p /= fDSCi * fYield / fFreq + 1.0;
1178 p -= fAi * 100.0 * fRate / fFreq;
1179
1180 return p;
1181 }
1182
1183
1184 double GetOddlyield( sal_Int32 nNullDate, sal_Int32 nSettle, sal_Int32 nMat, sal_Int32 nLastCoup,
1185 double fRate, double fPrice, double fRedemp, sal_Int32 nFreq, sal_Int32 nBase )
1186 {
1187 double fFreq = double( nFreq );
1188 double fDCi = GetYearFrac( nNullDate, nLastCoup, nMat, nBase ) * fFreq;
1189 double fDSCi = GetYearFrac( nNullDate, nSettle, nMat, nBase ) * fFreq;
1190 double fAi = GetYearFrac( nNullDate, nLastCoup, nSettle, nBase ) * fFreq;
1191
1192 double y = fRedemp + fDCi * 100.0 * fRate / fFreq;
1193 y /= fPrice + fAi * 100.0 * fRate / fFreq;
1194 y--;
1195 y *= fFreq / fDSCi;
1196
1197 return y;
1198 }
1199
1200
1201 double GetPmt( double fRate, double fNper, double fPv, double fFv, sal_Int32 nPayType )
1202 {
1203 double fPmt;
1204 if( fRate == 0.0 )
1205 fPmt = ( fPv + fFv ) / fNper;
1206 else
1207 {
1208 double fTerm = pow( 1.0 + fRate, fNper );
1209 if( nPayType > 0 )
1210 fPmt = ( fFv * fRate / ( fTerm - 1.0 ) + fPv * fRate / ( 1.0 - 1.0 / fTerm ) ) / ( 1.0 + fRate );
1211 else
1212 fPmt = fFv * fRate / ( fTerm - 1.0 ) + fPv * fRate / ( 1.0 - 1.0 / fTerm );
1213 }
1214
1215 return -fPmt;
1216 }
1217
1218
1219 double GetFv( double fRate, double fNper, double fPmt, double fPv, sal_Int32 nPayType )
1220 {
1221 double fFv;
1222 if( fRate == 0.0 )
1223 fFv = fPv + fPmt * fNper;
1224 else
1225 {
1226 double fTerm = pow( 1.0 + fRate, fNper );
1227 if( nPayType > 0 )
1228 fFv = fPv * fTerm + fPmt * ( 1.0 + fRate ) * ( fTerm - 1.0 ) / fRate;
1229 else
1230 fFv = fPv * fTerm + fPmt * ( fTerm - 1.0 ) / fRate;
1231 }
1232
1233 return -fFv;
1234 }
1235
1236 // financial functions COUP***
1237
1238 // COUPPCD: find last coupon date before settlement (can be equal to settlement)
1239 /// @throws css::lang::IllegalArgumentException
1240 static void lcl_GetCouppcd( ScaDate& rDate, const ScaDate& rSettle, const ScaDate& rMat, sal_Int32 nFreq )
1241 {
1242 rDate = rMat;
1243 rDate.setYear( rSettle.getYear() );
1244 if( rDate < rSettle )
1245 rDate.addYears( 1 );
1246 while( rDate > rSettle )
1247 rDate.addMonths( -12 / nFreq );
1248 }
1249
1250 double GetCouppcd( sal_Int32 nNullDate, sal_Int32 nSettle, sal_Int32 nMat, sal_Int32 nFreq, sal_Int32 nBase )
1251 {
1252 if( nSettle >= nMat || isFreqInvalid(nFreq) )
1253 throw lang::IllegalArgumentException();
1254
1255 ScaDate aDate;
1256 lcl_GetCouppcd( aDate, ScaDate( nNullDate, nSettle, nBase ), ScaDate( nNullDate, nMat, nBase ), nFreq );
1257 return aDate.getDate( nNullDate );
1258 }
1259
1260 // COUPNCD: find first coupon date after settlement (is never equal to settlement)
1261 /// @throws css::lang::IllegalArgumentException
1262 static void lcl_GetCoupncd( ScaDate& rDate, const ScaDate& rSettle, const ScaDate& rMat, sal_Int32 nFreq )
1263 {
1264 rDate = rMat;
1265 rDate.setYear( rSettle.getYear() );
1266 if( rDate > rSettle )
1267 rDate.addYears( -1 );
1268 while( rDate <= rSettle )
1269 rDate.addMonths( 12 / nFreq );
1270 }
1271
1272 double GetCoupncd( sal_Int32 nNullDate, sal_Int32 nSettle, sal_Int32 nMat, sal_Int32 nFreq, sal_Int32 nBase )
1273 {
1274 if( nSettle >= nMat || isFreqInvalid(nFreq) )
1275 throw lang::IllegalArgumentException();
1276
1277 ScaDate aDate;
1278 lcl_GetCoupncd( aDate, ScaDate( nNullDate, nSettle, nBase ), ScaDate( nNullDate, nMat, nBase ), nFreq );
1279 return aDate.getDate( nNullDate );
1280 }
1281
1282 // COUPDAYBS: get day count: coupon date before settlement <-> settlement
1283 double GetCoupdaybs( sal_Int32 nNullDate, sal_Int32 nSettle, sal_Int32 nMat, sal_Int32 nFreq, sal_Int32 nBase )
1284 {
1285 if( nSettle >= nMat || isFreqInvalid(nFreq) )
1286 throw lang::IllegalArgumentException();
1287
1288 ScaDate aSettle( nNullDate, nSettle, nBase );
1289 ScaDate aDate;
1290 lcl_GetCouppcd( aDate, aSettle, ScaDate( nNullDate, nMat, nBase ), nFreq );
1291 return ScaDate::getDiff( aDate, aSettle );
1292 }
1293
1294 // COUPDAYSNC: get day count: settlement <-> coupon date after settlement
1295 double GetCoupdaysnc( sal_Int32 nNullDate, sal_Int32 nSettle, sal_Int32 nMat, sal_Int32 nFreq, sal_Int32 nBase )
1296 {
1297 if( nSettle >= nMat || isFreqInvalid(nFreq) )
1298 throw lang::IllegalArgumentException();
1299
1300 if( (nBase != 0) && (nBase != 4) )
1301 {
1302 ScaDate aSettle( nNullDate, nSettle, nBase );
1303 ScaDate aDate;
1304 lcl_GetCoupncd( aDate, aSettle, ScaDate( nNullDate, nMat, nBase ), nFreq );
1305 return ScaDate::getDiff( aSettle, aDate );
1306 }
1307 return GetCoupdays( nNullDate, nSettle, nMat, nFreq, nBase ) - GetCoupdaybs( nNullDate, nSettle, nMat, nFreq, nBase );
1308 }
1309
1310 // COUPDAYS: get day count: coupon date before settlement <-> coupon date after settlement
1311 double GetCoupdays( sal_Int32 nNullDate, sal_Int32 nSettle, sal_Int32 nMat, sal_Int32 nFreq, sal_Int32 nBase )
1312 {
1313 if( nSettle >= nMat || isFreqInvalid(nFreq) )
1314 throw lang::IllegalArgumentException();
1315
1316 if( nBase == 1 )
1317 {
1318 ScaDate aDate;
1319 lcl_GetCouppcd( aDate, ScaDate( nNullDate, nSettle, nBase ), ScaDate( nNullDate, nMat, nBase ), nFreq );
1320 ScaDate aNextDate( aDate );
1321 aNextDate.addMonths( 12 / nFreq );
1322 return ScaDate::getDiff( aDate, aNextDate );
1323 }
1324 return static_cast< double >( GetDaysInYear( 0, 0, nBase ) ) / nFreq;
1325 }
1326
1327 // COUPNUM: get count of coupon dates
1328 double GetCoupnum( sal_Int32 nNullDate, sal_Int32 nSettle, sal_Int32 nMat, sal_Int32 nFreq, sal_Int32 nBase )
1329 {
1330 if( nSettle >= nMat || isFreqInvalid(nFreq) )
1331 throw lang::IllegalArgumentException();
1332
1333 ScaDate aMat( nNullDate, nMat, nBase );
1334 ScaDate aDate;
1335 lcl_GetCouppcd( aDate, ScaDate( nNullDate, nSettle, nBase ), aMat, nFreq );
1336 sal_uInt16 nMonths = (aMat.getYear() - aDate.getYear()) * 12 + aMat.getMonth() - aDate.getMonth();
1337 return static_cast< double >( nMonths * nFreq / 12 );
1338 }
1339
1340 FuncData::FuncData(const FuncDataBase& r) :
1341 aIntName( OUString::createFromAscii( r.pIntName ) ),
1342 pUINameID( r.pUINameID ),
1343 pDescrID( r.pDescrID ),
1344 bDouble( r.bDouble ),
1345 bWithOpt( r.bWithOpt ),
1346 nParam( r.nNumOfParams ),
1347 eCat( r.eCat )
1348 {
1349 if (r.pSuffix)
1350 aSuffix = OUString::createFromAscii(r.pSuffix);
1351
1352 aCompList.resize(2);
1353 aCompList[0] = OUString(r.pCompListID[0], strlen(r.pCompListID[0]), RTL_TEXTENCODING_UTF8);
1354 aCompList[1] = OUString(r.pCompListID[1], strlen(r.pCompListID[1]), RTL_TEXTENCODING_UTF8);
1355 }
1356
1357 sal_uInt16 FuncData::GetStrIndex( sal_uInt16 nParamNum ) const
1358 {
1359 if( !bWithOpt )
1360 nParamNum++;
1361
1362 if( nParamNum > nParam )
1363 return nParam * 2;
1364 else
1365 return nParamNum * 2;
1366 }
1367
1368 void InitFuncDataList(FuncDataList& rList)
1369 {
1370 for(const auto & rFuncData : pFuncDatas)
1371 rList.push_back(FuncData(rFuncData));
1372 }
1373
1374 SortedIndividualInt32List::SortedIndividualInt32List()
1375 {
1376 }
1377
1378
1379 SortedIndividualInt32List::~SortedIndividualInt32List()
1380 {
1381 }
1382
1383
1384 void SortedIndividualInt32List::Insert( sal_Int32 nDay )
1385 {
1386 sal_uInt32 nIndex = Count();
1387 while( nIndex )
1388 {
1389 nIndex--;
1390 sal_Int32 nRef = Get( nIndex );
1391 if( nDay == nRef )
1392 return;
1393 else if( nDay > nRef )
1394 {
1395 maVector.insert( maVector.begin() + nIndex + 1, nDay );
1396 return;
1397 }
1398 }
1399 maVector.insert( maVector.begin(), nDay );
1400 }
1401
1402
1403 void SortedIndividualInt32List::Insert( sal_Int32 nDay, sal_Int32 nNullDate, bool bInsertOnWeekend )
1404 {
1405 if( !nDay )
1406 return;
1407
1408 nDay += nNullDate;
1409 if( bInsertOnWeekend || (GetDayOfWeek( nDay ) < 5) )
1410 Insert( nDay );
1411 }
1412
1413
1414 void SortedIndividualInt32List::Insert(
1415 double fDay, sal_Int32 nNullDate, bool bInsertOnWeekend )
1416 {
1417 if( (fDay < -2147483648.0) || (fDay > 2147483649.0) )
1418 throw lang::IllegalArgumentException();
1419 Insert( static_cast< sal_Int32 >( fDay ), nNullDate, bInsertOnWeekend );
1420 }
1421
1422
1423 bool SortedIndividualInt32List::Find( sal_Int32 nVal ) const
1424 {
1425 sal_uInt32 nE = Count();
1426
1427 if( !nE || nVal < Get( 0 ) || nVal > Get( nE - 1 ) )
1428 return false;
1429
1430 // linear search
1431
1432 for( sal_uInt32 n = 0 ; n < nE ; n++ )
1433 {
1434 sal_Int32 nRef = Get( n );
1435
1436 if( nRef == nVal )
1437 return true;
1438 else if( nRef > nVal )
1439 return false;
1440 }
1441 return false;
1442 }
1443
1444
1445 void SortedIndividualInt32List::InsertHolidayList(
1446 const ScaAnyConverter& rAnyConv,
1447 const uno::Any& rHolAny,
1448 sal_Int32 nNullDate,
1449 bool bInsertOnWeekend )
1450 {
1451 double fDay;
1452 if( rAnyConv.getDouble( fDay, rHolAny ) )
1453 Insert( fDay, nNullDate, bInsertOnWeekend );
1454 }
1455
1456
1457 void SortedIndividualInt32List::InsertHolidayList(
1458 ScaAnyConverter& rAnyConv,
1459 const uno::Reference< beans::XPropertySet >& xOptions,
1460 const uno::Any& rHolAny,
1461 sal_Int32 nNullDate )
1462 {
1463 rAnyConv.init( xOptions );
1464 if( rHolAny.getValueTypeClass() == uno::TypeClass_SEQUENCE )
1465 {
1466 uno::Sequence< uno::Sequence< uno::Any > > aAnySeq;
1467 if( !(rHolAny >>= aAnySeq) )
1468 throw lang::IllegalArgumentException();
1469
1470 for( const uno::Sequence< uno::Any >& rSubSeq : std::as_const(aAnySeq) )
1471 {
1472 for( const uno::Any& rAny : rSubSeq )
1473 InsertHolidayList( rAnyConv, rAny, nNullDate, false/*bInsertOnWeekend*/ );
1474 }
1475 }
1476 else
1477 InsertHolidayList( rAnyConv, rHolAny, nNullDate, false/*bInsertOnWeekend*/ );
1478 }
1479
1480
1481 void ScaDoubleList::Append(
1482 const uno::Sequence< uno::Sequence< double > >& rValueSeq )
1483 {
1484 for( const uno::Sequence< double >& rSubSeq : rValueSeq )
1485 {
1486 for( const double fValue : rSubSeq )
1487 Append( fValue );
1488 }
1489 }
1490
1491
1492 void ScaDoubleList::Append(
1493 const uno::Sequence< uno::Sequence< sal_Int32 > >& rValueSeq )
1494 {
1495 for( const uno::Sequence< sal_Int32 >& rSubSeq : rValueSeq )
1496 {
1497 for( const sal_Int32 nValue : rSubSeq )
1498 Append( nValue );
1499 }
1500 }
1501
1502 void ScaDoubleList::Append(
1503 const ScaAnyConverter& rAnyConv,
1504 const uno::Any& rAny,
1505 bool bIgnoreEmpty )
1506 {
1507 if( auto s = o3tl::tryAccess<
1508 css::uno::Sequence<css::uno::Sequence<css::uno::Any>>>(rAny) )
1509 Append( rAnyConv, *s, bIgnoreEmpty );
1510 else
1511 {
1512 double fValue;
1513 if( rAnyConv.getDouble( fValue, rAny ) )
1514 Append( fValue );
1515 else if( !bIgnoreEmpty )
1516 Append( 0.0 );
1517 }
1518 }
1519
1520
1521 void ScaDoubleList::Append(
1522 const ScaAnyConverter& rAnyConv,
1523 const uno::Sequence< uno::Any >& rAnySeq,
1524 bool bIgnoreEmpty )
1525 {
1526 for( const uno::Any& rAny : rAnySeq )
1527 Append( rAnyConv, rAny, bIgnoreEmpty );
1528 }
1529
1530
1531 void ScaDoubleList::Append(
1532 const ScaAnyConverter& rAnyConv,
1533 const uno::Sequence< uno::Sequence< uno::Any > >& rAnySeq,
1534 bool bIgnoreEmpty )
1535 {
1536 for( const uno::Sequence< uno::Any >& rArray : rAnySeq )
1537 Append( rAnyConv, rArray, bIgnoreEmpty );
1538 }
1539
1540 void ScaDoubleList::Append(
1541 ScaAnyConverter& rAnyConv,
1542 const uno::Reference< beans::XPropertySet >& xOpt,
1543 const uno::Sequence< uno::Any >& rAnySeq )
1544 {
1545 rAnyConv.init( xOpt );
1546 Append( rAnyConv, rAnySeq, true/*bIgnoreEmpty*/ );
1547 }
1548
1549
1550 bool ScaDoubleList::CheckInsert( double ) const
1551 {
1552 return true;
1553 }
1554
1555
1556 bool ScaDoubleListGT0::CheckInsert( double fValue ) const
1557 {
1558 if( fValue < 0.0 )
1559 throw lang::IllegalArgumentException();
1560 return fValue > 0.0;
1561 }
1562
1563
1564 bool ScaDoubleListGE0::CheckInsert( double fValue ) const
1565 {
1566 if( fValue < 0.0 )
1567 throw lang::IllegalArgumentException();
1568 return true;
1569 }
1570
1571
1572 Complex::Complex( const OUString& rStr )
1573 {
1574 if( !ParseString( rStr, *this ) )
1575 throw lang::IllegalArgumentException();
1576 }
1577
1578
1579 inline bool Complex::IsImagUnit( sal_Unicode c )
1580 {
1581 return c == 'i' || c == 'j';
1582 }
1583
1584 bool Complex::ParseString( const OUString& rStr, Complex& rCompl )
1585 {
1586 rCompl.c = '\0'; // do not force a symbol, if only real part present
1587
1588 const sal_Unicode* pStr = rStr.getStr();
1589
1590 if( IsImagUnit( *pStr ) && rStr.getLength() == 1)
1591 {
1592 rCompl.r = 0.0;
1593 rCompl.i = 1.0;
1594 rCompl.c = *pStr;
1595 return true;
1596 }
1597
1598 double f;
1599
1600 if( !ParseDouble( pStr, f ) )
1601 return false;
1602
1603 switch( *pStr )
1604 {
1605 case '-': // imag part follows
1606 case '+':
1607 {
1608 double r = f;
1609 if( IsImagUnit( pStr[ 1 ] ) )
1610 {
1611 rCompl.c = pStr[ 1 ];
1612 if( pStr[ 2 ] == 0 )
1613 {
1614 rCompl.r = f;
1615 rCompl.i = ( *pStr == '+' )? 1.0 : -1.0;
1616 return true;
1617 }
1618 }
1619 else if( ParseDouble( pStr, f ) && IsImagUnit( *pStr ) )
1620 {
1621 rCompl.c = *pStr;
1622 pStr++;
1623 if( *pStr == 0 )
1624 {
1625 rCompl.r = r;
1626 rCompl.i = f;
1627 return true;
1628 }
1629 }
1630 }
1631 break;
1632 case 'j':
1633 case 'i':
1634 rCompl.c = *pStr;
1635 pStr++;
1636 if( *pStr == 0 )
1637 {
1638 rCompl.i = f;
1639 rCompl.r = 0.0;
1640 return true;
1641 }
1642 break;
1643 case 0: // only real-part
1644 rCompl.r = f;
1645 rCompl.i = 0.0;
1646 return true;
1647 }
1648
1649 return false;
1650 }
1651
1652
1653 OUString Complex::GetString() const
1654 {
1655 finiteOrThrow(r);
1656 finiteOrThrow(i);
1657 OUStringBuffer aRet;
1658
1659 bool bHasImag = i != 0.0;
1660 bool bHasReal = !bHasImag || (r != 0.0);
1661
1662 if( bHasReal )
1663 aRet.append(::GetString( r, false ));
1664 if( bHasImag )
1665 {
1666 if( i == 1.0 )
1667 {
1668 if( bHasReal )
1669 aRet.append('+');
1670 }
1671 else if( i == -1.0 )
1672 aRet.append('-');
1673 else
1674 aRet.append(::GetString( i, bHasReal ));
1675 aRet.append((c != 'j') ? 'i' : 'j');
1676 }
1677
1678 return aRet.makeStringAndClear();
1679 }
1680
1681
1682 double Complex::Arg() const
1683 {
1684 if( r == 0.0 && i == 0.0 )
1685 throw lang::IllegalArgumentException();
1686
1687 double phi = acos( r / Abs() );
1688
1689 if( i < 0.0 )
1690 phi = -phi;
1691
1692 return phi;
1693 }
1694
1695
1696 void Complex::Power( double fPower )
1697 {
1698 if( r == 0.0 && i == 0.0 )
1699 {
1700 if( fPower <= 0 )
1701 throw lang::IllegalArgumentException();
1702 r = i = 0.0;
1703 return;
1704 }
1705
1706 double p, phi;
1707
1708 p = Abs();
1709
1710 phi = acos( r / p );
1711 if( i < 0.0 )
1712 phi = -phi;
1713
1714 p = pow( p, fPower );
1715 phi *= fPower;
1716
1717 r = cos( phi ) * p;
1718 i = sin( phi ) * p;
1719 }
1720
1721
1722 void Complex::Sqrt()
1723 {
1724 static const double fMultConst = M_SQRT1_2;
1725 double p = Abs();
1726 double i_ = sqrt( p - r ) * fMultConst;
1727
1728 r = sqrt( p + r ) * fMultConst;
1729 i = ( i < 0.0 )? -i_ : i_;
1730 }
1731
1732
1733 void Complex::Sin()
1734 {
1735 if( !::rtl::math::isValidArcArg( r ) )
1736 throw lang::IllegalArgumentException();
1737
1738 if( i )
1739 {
1740 double r_;
1741
1742 r_ = sin( r ) * cosh( i );
1743 i = cos( r ) * sinh( i );
1744 r = r_;
1745 }
1746 else
1747 r = sin( r );
1748 }
1749
1750
1751 void Complex::Cos()
1752 {
1753 if( !::rtl::math::isValidArcArg( r ) )
1754 throw lang::IllegalArgumentException();
1755
1756 if( i )
1757 {
1758 double r_;
1759
1760 r_ = cos( r ) * cosh( i );
1761 i = -( sin( r ) * sinh( i ) );
1762 r = r_;
1763 }
1764 else
1765 r = cos( r );
1766 }
1767
1768
1769 void Complex::Div( const Complex& z )
1770 {
1771 if( z.r == 0 && z.i == 0 )
1772 throw lang::IllegalArgumentException();
1773
1774 double a1 = r;
1775 double a2 = z.r;
1776 double b1 = i;
1777 double b2 = z.i;
1778
1779 double f = 1.0 / ( a2 * a2 + b2 * b2 );
1780
1781 r = ( a1 * a2 + b1 * b2 ) * f;
1782 i = ( a2 * b1 - a1 * b2 ) * f;
1783
1784 if( !c ) c = z.c;
1785 }
1786
1787
1788 void Complex::Exp()
1789 {
1790 double fE = exp( r );
1791 r = fE * cos( i );
1792 i = fE * sin( i );
1793 }
1794
1795
1796 void Complex::Ln()
1797 {
1798 if( r == 0.0 && i == 0.0 )
1799 throw lang::IllegalArgumentException();
1800
1801 double fAbs = Abs();
1802 bool bNegi = i < 0.0;
1803
1804 i = acos( r / fAbs );
1805
1806 if( bNegi )
1807 i = -i;
1808
1809 r = log( fAbs );
1810 }
1811
1812
1813 void Complex::Log10()
1814 {
1815 Ln();
1816 Mult( M_LOG10E );
1817 }
1818
1819
1820 void Complex::Log2()
1821 {
1822 Ln();
1823 Mult( M_LOG2E );
1824 }
1825
1826
1827 void Complex::Tan()
1828 {
1829 if ( i )
1830 {
1831 if( !::rtl::math::isValidArcArg( 2.0 * r ) )
1832 throw lang::IllegalArgumentException();
1833 double fScale =1.0 / ( cos( 2.0 * r ) + cosh( 2.0 * i ));
1834 r = sin( 2.0 * r ) * fScale;
1835 i = sinh( 2.0 * i ) * fScale;
1836 }
1837 else
1838 {
1839 if( !::rtl::math::isValidArcArg( r ) )
1840 throw lang::IllegalArgumentException();
1841 r = tan( r );
1842 }
1843 }
1844
1845
1846 void Complex::Sec()
1847 {
1848 if( i )
1849 {
1850 if( !::rtl::math::isValidArcArg( 2 * r ) )
1851 throw lang::IllegalArgumentException();
1852 double fScale = 1.0 / (cosh( 2.0 * i) + cos ( 2.0 * r));
1853 double r_;
1854 r_ = 2.0 * cos( r ) * cosh( i ) * fScale;
1855 i = 2.0 * sin( r ) * sinh( i ) * fScale;
1856 r = r_;
1857 }
1858 else
1859 {
1860 if( !::rtl::math::isValidArcArg( r ) )
1861 throw lang::IllegalArgumentException();
1862 r = 1.0 / cos( r );
1863 }
1864 }
1865
1866
1867 void Complex::Csc()
1868 {
1869 if( i )
1870 {
1871 if( !::rtl::math::isValidArcArg( 2 * r ) )
1872 throw lang::IllegalArgumentException();
1873 double fScale = 1.0 / (cosh( 2.0 * i) - cos ( 2.0 * r));
1874 double r_;
1875 r_ = 2.0 * sin( r ) * cosh( i ) * fScale;
1876 i = -2.0 * cos( r ) * sinh( i ) * fScale;
1877 r = r_;
1878 }
1879 else
1880 {
1881 if( !::rtl::math::isValidArcArg( r ) )
1882 throw lang::IllegalArgumentException();
1883 r = 1.0 / sin( r );
1884 }
1885 }
1886
1887
1888 void Complex::Cot()
1889 {
1890 if ( i )
1891 {
1892 if( !::rtl::math::isValidArcArg( 2.0 * r ) )
1893 throw lang::IllegalArgumentException();
1894 double fScale =1.0 / ( cosh( 2.0 * i ) - cos( 2.0 * r ) );
1895 r = sin( 2.0 * r ) * fScale;
1896 i = - ( sinh( 2.0 * i ) * fScale );
1897 }
1898 else
1899 {
1900 if( !::rtl::math::isValidArcArg( r ) )
1901 throw lang::IllegalArgumentException();
1902 r = 1.0 / tan( r );
1903 }
1904 }
1905
1906
1907 void Complex::Sinh()
1908 {
1909 if( !::rtl::math::isValidArcArg( r ) )
1910 throw lang::IllegalArgumentException();
1911
1912 if( i )
1913 {
1914 double r_;
1915 r_ = sinh( r ) * cos( i );
1916 i = cosh( r ) * sin( i );
1917 r = r_;
1918 }
1919 else
1920 r = sinh( r );
1921 }
1922
1923
1924 void Complex::Cosh()
1925 {
1926 if( !::rtl::math::isValidArcArg( r ) )
1927 throw lang::IllegalArgumentException();
1928
1929 if( i )
1930 {
1931 double r_;
1932 r_ = cosh( r ) * cos( i );
1933 i = sinh( r ) * sin( i );
1934 r = r_;
1935 }
1936 else
1937 r = cosh( r );
1938 }
1939
1940
1941 void Complex::Sech()
1942 {
1943 if ( i )
1944 {
1945 if( !::rtl::math::isValidArcArg( 2.0 * r ) )
1946 throw lang::IllegalArgumentException();
1947 double fScale =1.0 / ( cosh( 2.0 * r ) + cos( 2.0 * i ));
1948 double r_;
1949 r_ = 2.0 * cosh( r ) * cos( i ) * fScale;
1950 i = - (2.0 * sinh( r ) * sin( i ) * fScale );
1951 r = r_ ;
1952 }
1953 else
1954 {
1955 if( !::rtl::math::isValidArcArg( r ) )
1956 throw lang::IllegalArgumentException();
1957 r = 1.0 / cosh( r );
1958 }
1959 }
1960
1961
1962 void Complex::Csch()
1963 {
1964 if ( i )
1965 {
1966 if( !::rtl::math::isValidArcArg( 2.0 * r ) )
1967 throw lang::IllegalArgumentException();
1968 double fScale =1.0 / ( cosh( 2.0 * r ) - cos( 2.0 * i ));
1969 double r_;
1970 r_ = 2.0 * sinh( r ) * cos( i ) * fScale;
1971 i = - ( 2.0 * cosh( r ) * sin( i ) * fScale );
1972 r = r_ ;
1973 }
1974 else
1975 {
1976 if( !::rtl::math::isValidArcArg( r ) )
1977 throw lang::IllegalArgumentException();
1978 r = 1.0 / sinh( r );
1979 }
1980 }
1981
1982
1983 ComplexList::~ComplexList()
1984 {
1985 }
1986
1987
1988 void ComplexList::Append( const uno::Sequence< uno::Sequence< OUString > >& r )
1989 {
1990 for( const uno::Sequence< OUString >& rList : r )
1991 {
1992 for( const OUString& rStr : rList )
1993 {
1994 if( !rStr.isEmpty() )
1995 Append( Complex( rStr ) );
1996 }
1997 }
1998 }
1999
2000
2001 void ComplexList::Append( const uno::Sequence< uno::Any >& aMultPars )
2002 {
2003 for( const uno::Any& r : aMultPars )
2004 {
2005 switch( r.getValueTypeClass() )
2006 {
2007 case uno::TypeClass_VOID: break;
2008 case uno::TypeClass_STRING:
2009 {
2010 auto pStr = o3tl::forceAccess<OUString>(r);
2011
2012 if( !pStr->isEmpty() )
2013 Append( Complex( *pStr ) );
2014 }
2015 break;
2016 case uno::TypeClass_DOUBLE:
2017 Append( Complex( *o3tl::forceAccess<double>(r), 0.0 ) );
2018 break;
2019 case uno::TypeClass_SEQUENCE:
2020 {
2021 uno::Sequence< uno::Sequence< uno::Any > > aValArr;
2022 if( !(r >>= aValArr) )
2023 throw lang::IllegalArgumentException();
2024
2025 for( const uno::Sequence< uno::Any >& rArr : std::as_const(aValArr) )
2026 Append( rArr );
2027 }
2028 break;
2029 default:
2030 throw lang::IllegalArgumentException();
2031 }
2032 }
2033 }
2034
2035 ConvertData::ConvertData(const char p[], double fC, ConvertDataClass e, bool bPrefSupport)
2036 : fConst(fC)
2037 , aName(p, strlen(p), RTL_TEXTENCODING_MS_1252)
2038 , eClass(e)
2039 , bPrefixSupport(bPrefSupport)
2040 {
2041 }
2042
2043 ConvertData::~ConvertData()
2044 {
2045 }
2046
2047 sal_Int16 ConvertData::GetMatchingLevel( const OUString& rRef ) const
2048 {
2049 OUString aStr = rRef;
2050 sal_Int32 nLen = rRef.getLength();
2051 sal_Int32 nIndex = rRef.lastIndexOf( '^' );
2052 if( nIndex > 0 && nIndex == ( nLen - 2 ) )
2053 aStr = aStr.subView( 0, nLen - 2 ) + OUStringChar( aStr[ nLen - 1 ] );
2054 if( aName == aStr )
2055 return 0;
2056 else
2057 {
2058 const sal_Unicode* p = aStr.getStr();
2059
2060 nLen = aStr.getLength();
2061 bool bPref = bPrefixSupport;
2062 bool bOneChar = (bPref && nLen > 1 && (aName == p + 1));
2063 if (bOneChar || (bPref && nLen > 2 && (aName == p + 2) &&
2064 *p == 'd' && *(p+1) == 'a'))
2065 {
2066 sal_Int16 n;
2067 switch( *p )
2068 {
2069 case 'y': n = -24; break; // yocto
2070 case 'z': n = -21; break; // zepto
2071 case 'a': n = -18; break;
2072 case 'f': n = -15; break;
2073 case 'p': n = -12; break;
2074 case 'n': n = -9; break;
2075 case 'u': n = -6; break;
2076 case 'm': n = -3; break;
2077 case 'c': n = -2; break;
2078 case 'd':
2079 {
2080 if ( bOneChar )
2081 n = -1; // deci
2082 else
2083 n = 1; // deca
2084 }
2085 break;
2086 case 'e': n = 1; break;
2087 case 'h': n = 2; break;
2088 case 'k': n = 3; break;
2089 case 'M': n = 6; break;
2090 case 'G': n = 9; break;
2091 case 'T': n = 12; break;
2092 case 'P': n = 15; break;
2093 case 'E': n = 18; break;
2094 case 'Z': n = 21; break; // zetta
2095 case 'Y': n = 24; break; // yotta
2096 default:
2097 n = INV_MATCHLEV;
2098 }
2099
2100 // We could weed some nonsense out, ODFF doesn't say so though.
2101 #if 0
2102 if (n < 0 && Class() == CDC_Information)
2103 n = INV_MATCHLEV; // milli-bits doesn't make sense
2104 #endif
2105
2106 //! <HACK> "cm3" is not 10^-2 m^3 but 10^-6 m^3 !!! ------------------
2107 if( n != INV_MATCHLEV )
2108 {
2109 sal_Unicode cLast = p[ aStr.getLength() - 1 ];
2110 if( cLast == '2' )
2111 n *= 2;
2112 else if( cLast == '3' )
2113 n *= 3;
2114 }
2115 //! </HACK> -------------------------------------------------------------------
2116
2117 return n;
2118 }
2119 else if ( nLen > 2 && ( aName == p + 2 ) && ( Class() == CDC_Information ) )
2120 {
2121 const sal_Unicode* pStr = aStr.getStr();
2122 if ( *(pStr + 1) != 'i')
2123 return INV_MATCHLEV;
2124 sal_Int16 n;
2125 switch( *pStr )
2126 {
2127 case 'k': n = 10; break;
2128 case 'M': n = 20; break;
2129 case 'G': n = 30; break;
2130 case 'T': n = 40; break;
2131 case 'P': n = 50; break;
2132 case 'E': n = 60; break;
2133 case 'Z': n = 70; break;
2134 case 'Y': n = 80; break;
2135 default:
2136 n = INV_MATCHLEV;
2137 }
2138 return n;
2139 }
2140 else
2141 return INV_MATCHLEV;
2142 }
2143 }
2144
2145
2146 double ConvertData::Convert(
2147 double f, const ConvertData& r, sal_Int16 nLevFrom, sal_Int16 nLevTo ) const
2148 {
2149 if( Class() != r.Class() )
2150 throw lang::IllegalArgumentException();
2151
2152 bool bBinFromLev = ( nLevFrom > 0 && ( nLevFrom % 10 ) == 0 );
2153 bool bBinToLev = ( nLevTo > 0 && ( nLevTo % 10 ) == 0 );
2154
2155 if ( Class() == CDC_Information && ( bBinFromLev || bBinToLev ) )
2156 {
2157 if ( bBinFromLev && bBinToLev )
2158 {
2159 nLevFrom = sal::static_int_cast<sal_Int16>( nLevFrom - nLevTo );
2160 f *= r.fConst / fConst;
2161 if( nLevFrom )
2162 f *= pow( 2.0, nLevFrom );
2163 }
2164 else if ( bBinFromLev )
2165 f *= ( r.fConst / fConst ) * ( pow( 2.0, nLevFrom ) / pow( 10.0, nLevTo ) );
2166 else
2167 f *= ( r.fConst / fConst ) * ( pow( 10.0, nLevFrom ) / pow( 2.0, nLevTo ) );
2168 return f;
2169 }
2170
2171 nLevFrom = sal::static_int_cast<sal_Int16>( nLevFrom - nLevTo ); // effective level
2172
2173 f *= r.fConst / fConst;
2174
2175 if( nLevFrom )
2176 f = ::rtl::math::pow10Exp( f, nLevFrom );
2177
2178 return f;
2179 }
2180
2181
2182 double ConvertData::ConvertFromBase( double f, sal_Int16 n ) const
2183 {
2184 return ::rtl::math::pow10Exp( f * fConst, -n );
2185 }
2186
2187 ConvertDataLinear::~ConvertDataLinear()
2188 {
2189 }
2190
2191 double ConvertDataLinear::Convert(
2192 double f, const ConvertData& r, sal_Int16 nLevFrom, sal_Int16 nLevTo ) const
2193 {
2194 if( Class() != r.Class() )
2195 throw lang::IllegalArgumentException();
2196 return r.ConvertFromBase( ConvertToBase( f, nLevFrom ), nLevTo );
2197 }
2198
2199
2200 double ConvertDataLinear::ConvertToBase( double f, sal_Int16 n ) const
2201 {
2202 if( n )
2203 f = ::rtl::math::pow10Exp( f, n );
2204
2205 f /= fConst;
2206 f -= fOffs;
2207
2208 return f;
2209 }
2210
2211
2212 double ConvertDataLinear::ConvertFromBase( double f, sal_Int16 n ) const
2213 {
2214 f += fOffs;
2215 f *= fConst;
2216
2217 if( n )
2218 f = ::rtl::math::pow10Exp( f, -n );
2219
2220 return f;
2221 }
2222
2223
2224 ConvertDataList::ConvertDataList()
2225 {
2226 #define NEWD(str,unit,cl) maVector.emplace_back(new ConvertData(str,unit,cl))
2227 #define NEWDP(str,unit,cl) maVector.emplace_back(new ConvertData(str,unit,cl,true))
2228 #define NEWL(str,unit,offs,cl) maVector.emplace_back(new ConvertDataLinear(str,unit,offs,cl))
2229 #define NEWLP(str,unit,offs,cl) maVector.emplace_back(new ConvertDataLinear(str,unit,offs,cl,true))
2230
2231 // *** are extra and not standard Excel Analysis Addin!
2232
2233 // MASS: 1 Gram is...
2234 NEWDP( "g", 1.0000000000000000E00, CDC_Mass ); // Gram
2235 NEWD( "sg", 6.8522050005347800E-05, CDC_Mass ); // Pieces
2236 NEWD( "lbm", 2.2046229146913400E-03, CDC_Mass ); // Pound (commercial weight)
2237 NEWDP( "u", 6.0221370000000000E23, CDC_Mass ); // U (atomic mass)
2238 NEWD( "ozm", 3.5273971800362700E-02, CDC_Mass ); // Ounce (commercial weight)
2239 NEWD( "stone", 1.574730e-04, CDC_Mass ); // *** Stone
2240 NEWD( "ton", 1.102311e-06, CDC_Mass ); // *** Ton
2241 NEWD( "grain", 1.543236E01, CDC_Mass ); // *** Grain
2242 NEWD( "pweight", 7.054792E-01, CDC_Mass ); // *** Pennyweight
2243 NEWD( "hweight", 1.968413E-05, CDC_Mass ); // *** Hundredweight
2244 NEWD( "shweight", 2.204623E-05, CDC_Mass ); // *** Shorthundredweight
2245 NEWD( "brton", 9.842065E-07, CDC_Mass ); // *** Gross Registered Ton
2246 NEWD( "cwt", 2.2046226218487758E-05, CDC_Mass ); // U.S. (short) hundredweight
2247 NEWD( "shweight", 2.2046226218487758E-05, CDC_Mass ); // U.S. (short) hundredweight also
2248 NEWD( "uk_cwt", 1.9684130552221213E-05, CDC_Mass ); // Imperial hundredweight
2249 NEWD( "lcwt", 1.9684130552221213E-05, CDC_Mass ); // Imperial hundredweight also
2250 NEWD( "hweight", 1.9684130552221213E-05, CDC_Mass ); // Imperial hundredweight also
2251 NEWD( "uk_ton", 9.8420652761106063E-07, CDC_Mass ); // Imperial ton
2252 NEWD( "LTON", 9.8420652761106063E-07, CDC_Mass ); // Imperial ton also
2253
2254 // LENGTH: 1 Meter is...
2255 NEWDP( "m", 1.0000000000000000E00, CDC_Length ); // Meter
2256 NEWD( "mi", 6.2137119223733397E-04, CDC_Length ); // Britsh Mile 6,21371192237333969617434184363e-4
2257 NEWD( "Nmi", 5.3995680345572354E-04, CDC_Length ); // Nautical Mile 5,39956803455723542116630669546e-4
2258 NEWD( "in", 3.9370078740157480E01, CDC_Length ); // Inch 39,37007874015748031496062992126
2259 NEWD( "ft", 3.2808398950131234E00, CDC_Length ); // Foot 3,2808398950131233595800524934383
2260 NEWD( "yd", 1.0936132983377078E00, CDC_Length ); // Yard 1,0936132983377077865266841644794
2261 NEWDP( "ang", 1.0000000000000000E10, CDC_Length ); // Angstrom
2262 NEWD( "Pica", 2.8346456692913386E03, CDC_Length ); // Pica Point (1/72 Inch) 2834,6456692913385826771653543307
2263 NEWD( "picapt", 2.8346456692913386E03, CDC_Length ); // Pica Point (1/72 Inch) 2834,6456692913385826771653543307
2264 NEWD( "pica", 2.36220472441E02, CDC_Length ); // pica (1/6 Inch)
2265 NEWD( "ell", 8.748906E-01, CDC_Length ); // *** Ell
2266 NEWDP( "parsec", 3.240779E-17, CDC_Length ); // *** Parsec
2267 NEWDP( "pc", 3.240779E-17, CDC_Length ); // *** Parsec also
2268 NEWDP( "lightyear", 1.0570234557732930E-16, CDC_Length ); // *** Light Year
2269 NEWDP( "ly", 1.0570234557732930E-16, CDC_Length ); // *** Light Year also
2270 NEWD( "survey_mi", 6.2136994949494949E-04, CDC_Length ); // U.S. survey mile
2271
2272 // TIME: 1 Second is...
2273 NEWD( "yr", 3.1688087814028950E-08, CDC_Time ); // Year
2274 NEWD( "day", 1.1574074074074074E-05, CDC_Time ); // Day
2275 NEWD( "d", 1.1574074074074074E-05, CDC_Time ); // Day also
2276 NEWD( "hr", 2.7777777777777778E-04, CDC_Time ); // Hour
2277 NEWD( "mn", 1.6666666666666667E-02, CDC_Time ); // Minute
2278 NEWD( "min", 1.6666666666666667E-02, CDC_Time ); // Minute also
2279 NEWDP( "sec", 1.0000000000000000E00, CDC_Time ); // Second
2280 NEWDP( "s", 1.0000000000000000E00, CDC_Time ); // Second also
2281
2282 // PRESSURE: 1 Pascal is...
2283 NEWDP( "Pa", 1.0000000000000000E00, CDC_Pressure ); // Pascal
2284 NEWDP( "atm", 9.8692329999819300E-06, CDC_Pressure ); // Atmosphere
2285 NEWDP( "at", 9.8692329999819300E-06, CDC_Pressure ); // Atmosphere also
2286 NEWDP( "mmHg", 7.5006170799862700E-03, CDC_Pressure ); // mm Hg (Mercury)
2287 NEWD( "Torr", 7.5006380000000000E-03, CDC_Pressure ); // *** Torr
2288 NEWD( "psi", 1.4503770000000000E-04, CDC_Pressure ); // *** Psi
2289
2290 // FORCE: 1 Newton is...
2291 NEWDP( "N", 1.0000000000000000E00, CDC_Force ); // Newton
2292 NEWDP( "dyn", 1.0000000000000000E05, CDC_Force ); // Dyn
2293 NEWDP( "dy", 1.0000000000000000E05, CDC_Force ); // Dyn also
2294 NEWD( "lbf", 2.24808923655339E-01, CDC_Force ); // Pound-Force
2295 NEWDP( "pond", 1.019716E02, CDC_Force ); // *** Pond
2296
2297 // ENERGY: 1 Joule is...
2298 NEWDP( "J", 1.0000000000000000E00, CDC_Energy ); // Joule
2299 NEWDP( "e", 1.0000000000000000E07, CDC_Energy ); // Erg -> https://en.wikipedia.org/wiki/Erg
2300 NEWDP( "c", 2.3900624947346700E-01, CDC_Energy ); // Thermodynamical Calorie
2301 NEWDP( "cal", 2.3884619064201700E-01, CDC_Energy ); // Calorie
2302 NEWDP( "eV", 6.2414570000000000E18, CDC_Energy ); // Electronvolt
2303 NEWDP( "ev", 6.2414570000000000E18, CDC_Energy ); // Electronvolt also
2304 NEWD( "HPh", 3.7250611111111111E-07, CDC_Energy ); // Horsepower Hours
2305 NEWD( "hh", 3.7250611111111111E-07, CDC_Energy ); // Horsepower Hours also
2306 NEWDP( "Wh", 2.7777777777777778E-04, CDC_Energy ); // Watt Hours
2307 NEWDP( "wh", 2.7777777777777778E-04, CDC_Energy ); // Watt Hours also
2308 NEWD( "flb", 2.37304222192651E01, CDC_Energy ); // Foot Pound
2309 NEWD( "BTU", 9.4781506734901500E-04, CDC_Energy ); // British Thermal Unit
2310 NEWD( "btu", 9.4781506734901500E-04, CDC_Energy ); // British Thermal Unit also
2311
2312 // POWER: 1 Watt is...
2313 NEWDP( "W", 1.0000000000000000E00, CDC_Power ); // Watt
2314 NEWDP( "w", 1.0000000000000000E00, CDC_Power ); // Watt also
2315 NEWD( "HP", 1.341022E-03, CDC_Power ); // Horsepower
2316 NEWD( "h", 1.341022E-03, CDC_Power ); // Horsepower also
2317 NEWD( "PS", 1.359622E-03, CDC_Power ); // *** German Pferdestaerke
2318
2319 // MAGNETISM: 1 Tesla is...
2320 NEWDP( "T", 1.0000000000000000E00, CDC_Magnetism ); // Tesla
2321 NEWDP( "ga", 1.0000000000000000E04, CDC_Magnetism ); // Gauss
2322
2323 // TEMPERATURE: 1 Kelvin is...
2324 NEWL( "C", 1.0000000000000000E00, -2.7315000000000000E02, CDC_Temperature ); // Celsius
2325 NEWL( "cel", 1.0000000000000000E00, -2.7315000000000000E02, CDC_Temperature ); // Celsius also
2326 NEWL( "F", 1.8000000000000000E00, -2.5537222222222222E02, CDC_Temperature ); // Fahrenheit
2327 NEWL( "fah", 1.8000000000000000E00, -2.5537222222222222E02, CDC_Temperature ); // Fahrenheit also
2328 NEWLP( "K", 1.0000000000000000E00, +0.0000000000000000E00, CDC_Temperature ); // Kelvin
2329 NEWLP( "kel", 1.0000000000000000E00, +0.0000000000000000E00, CDC_Temperature ); // Kelvin also
2330 NEWL( "Reau", 8.0000000000000000E-01, -2.7315000000000000E02, CDC_Temperature ); // *** Reaumur
2331 NEWL( "Rank", 1.8000000000000000E00, +0.0000000000000000E00, CDC_Temperature ); // *** Rankine
2332
2333 // VOLUME: 1 Liter is...
2334 NEWD( "tsp", 2.0288413621105798E02, CDC_Volume ); // US teaspoon 1/768 gallon
2335 NEWD( "tbs", 6.7628045403685994E01, CDC_Volume ); // US tablespoon 1/256 gallon
2336 NEWD( "oz", 3.3814022701842997E01, CDC_Volume ); // Ounce Liquid 1/128 gallon
2337 NEWD( "cup", 4.2267528377303746E00, CDC_Volume ); // Cup 1/16 gallon
2338 NEWD( "pt", 2.1133764188651873E00, CDC_Volume ); // US Pint 1/8 gallon
2339 NEWD( "us_pt", 2.1133764188651873E00, CDC_Volume ); // US Pint also
2340 NEWD( "uk_pt", 1.7597539863927023E00, CDC_Volume ); // UK Pint 1/8 imperial gallon
2341 NEWD( "qt", 1.0566882094325937E00, CDC_Volume ); // Quart 1/4 gallon
2342 NEWD( "gal", 2.6417205235814842E-01, CDC_Volume ); // Gallon 1/3.785411784
2343 NEWDP( "l", 1.0000000000000000E00, CDC_Volume ); // Liter
2344 NEWDP( "L", 1.0000000000000000E00, CDC_Volume ); // Liter also
2345 NEWDP( "lt", 1.0000000000000000E00, CDC_Volume ); // Liter also
2346 NEWDP( "m3", 1.0000000000000000E-03, CDC_Volume ); // *** Cubic Meter
2347 NEWD( "mi3", 2.3991275857892772E-13, CDC_Volume ); // *** Cubic Britsh Mile
2348 NEWD( "Nmi3", 1.5742621468581148E-13, CDC_Volume ); // *** Cubic Nautical Mile
2349 NEWD( "in3", 6.1023744094732284E01, CDC_Volume ); // *** Cubic Inch
2350 NEWD( "ft3", 3.5314666721488590E-02, CDC_Volume ); // *** Cubic Foot
2351 NEWD( "yd3", 1.3079506193143922E-03, CDC_Volume ); // *** Cubic Yard
2352 NEWDP( "ang3", 1.0000000000000000E27, CDC_Volume ); // *** Cubic Angstrom
2353 NEWD( "Pica3", 2.2776990435870636E07, CDC_Volume ); // *** Cubic Pica Point (1/72 inch)
2354 NEWD( "picapt3", 2.2776990435870636E07, CDC_Volume ); // *** Cubic Pica Point (1/72 inch)
2355 NEWD( "pica3", 1.31811287245E04, CDC_Volume ); // *** Cubic Pica (1/6 inch)
2356 NEWD( "barrel", 6.2898107704321051E-03, CDC_Volume ); // *** Barrel (=42gal)
2357 NEWD( "bushel", 2.837759E-02, CDC_Volume ); // *** Bushel
2358 NEWD( "regton", 3.531467E-04, CDC_Volume ); // *** Register ton
2359 NEWD( "GRT", 3.531467E-04, CDC_Volume ); // *** Register ton also
2360 NEWD( "Schooner", 2.3529411764705882E00, CDC_Volume ); // *** austr. Schooner
2361 NEWD( "Middy", 3.5087719298245614E00, CDC_Volume ); // *** austr. Middy
2362 NEWD( "Glass", 5.0000000000000000E00, CDC_Volume ); // *** austr. Glass
2363 NEWD( "Sixpack", 0.5, CDC_Volume ); // ***
2364 NEWD( "Humpen", 2.0, CDC_Volume ); // ***
2365 NEWD( "ly3", 1.1810108125623799E-51, CDC_Volume ); // *** Cubic light-year
2366 NEWD( "MTON", 1.4125866688595436E00, CDC_Volume ); // *** Measurement ton
2367 NEWD( "tspm", 2.0000000000000000E02, CDC_Volume ); // *** Modern teaspoon
2368 NEWD( "uk_gal", 2.1996924829908779E-01, CDC_Volume ); // U.K. / Imperial gallon 1/4.54609
2369 NEWD( "uk_qt", 8.7987699319635115E-01, CDC_Volume ); // U.K. / Imperial quart 1/4 imperial gallon
2370
2371 // 1 Square Meter is...
2372 NEWDP( "m2", 1.0000000000000000E00, CDC_Area ); // *** Square Meter
2373 NEWD( "mi2", 3.8610215854244585E-07, CDC_Area ); // *** Square Britsh Mile
2374 NEWD( "Nmi2", 2.9155334959812286E-07, CDC_Area ); // *** Square Nautical Mile
2375 NEWD( "in2", 1.5500031000062000E03, CDC_Area ); // *** Square Inch
2376 NEWD( "ft2", 1.0763910416709722E01, CDC_Area ); // *** Square Foot
2377 NEWD( "yd2", 1.1959900463010803E00, CDC_Area ); // *** Square Yard
2378 NEWDP( "ang2", 1.0000000000000000E20, CDC_Area ); // *** Square Angstrom
2379 NEWD( "Pica2", 8.0352160704321409E06, CDC_Area ); // *** Square Pica Point (1/72 inch)
2380 NEWD( "picapt2", 8.0352160704321409E06, CDC_Area ); // *** Square Pica Point (1/72 inch)
2381 NEWD( "pica2", 5.58001116002232E04, CDC_Area ); // *** Square Pica (1/6 inch)
2382 NEWD( "Morgen", 4.0000000000000000E-04, CDC_Area ); // *** Morgen
2383 NEWDP( "ar", 1.000000E-02, CDC_Area ); // *** Ar
2384 NEWD( "acre", 2.471053815E-04, CDC_Area ); // *** Acre
2385 NEWD( "uk_acre", 2.4710538146716534E-04, CDC_Area ); // *** International acre
2386 NEWD( "us_acre", 2.4710439304662790E-04, CDC_Area ); // *** U.S. survey/statute acre
2387 NEWD( "ly2", 1.1172985860549147E-32, CDC_Area ); // *** Square Light-year
2388 NEWD( "ha", 1.000000E-04, CDC_Area ); // *** Hectare
2389
2390 // SPEED: 1 Meter per Second is...
2391 NEWDP( "m/s", 1.0000000000000000E00, CDC_Speed ); // *** Meters per Second
2392 NEWDP( "m/sec", 1.0000000000000000E00, CDC_Speed ); // *** Meters per Second also
2393 NEWDP( "m/h", 3.6000000000000000E03, CDC_Speed ); // *** Meters per Hour
2394 NEWDP( "m/hr", 3.6000000000000000E03, CDC_Speed ); // *** Meters per Hour also
2395 NEWD( "mph", 2.2369362920544023E00, CDC_Speed ); // *** Britsh Miles per Hour
2396 NEWD( "kn", 1.9438444924406048E00, CDC_Speed ); // *** Knot = Nautical Miles per Hour
2397 NEWD( "admkn", 1.9438446603753486E00, CDC_Speed ); // *** Admiralty Knot
2398 NEWD( "ludicrous speed", 2.0494886343432328E-14, CDC_Speed ); // ***
2399 NEWD( "ridiculous speed", 4.0156958471424288E-06, CDC_Speed); // ***
2400
2401 // INFORMATION: 1 Bit is...
2402 NEWDP( "bit", 1.00E00, CDC_Information); // *** Bit
2403 NEWDP( "byte", 1.25E-01, CDC_Information); // *** Byte
2404 }
2405
2406
2407 ConvertDataList::~ConvertDataList()
2408 {
2409 }
2410
2411
2412 double ConvertDataList::Convert( double fVal, const OUString& rFrom, const OUString& rTo )
2413 {
2414 ConvertData* pFrom = nullptr;
2415 ConvertData* pTo = nullptr;
2416 bool bSearchFrom = true;
2417 bool bSearchTo = true;
2418 sal_Int16 nLevelFrom = 0;
2419 sal_Int16 nLevelTo = 0;
2420
2421 for( const auto& rItem : maVector )
2422 {
2423 ConvertData* p = rItem.get();
2424 if( bSearchFrom )
2425 {
2426 sal_Int16 n = p->GetMatchingLevel( rFrom );
2427 if( n != INV_MATCHLEV )
2428 {
2429 if( n )
2430 { // only first match for partial equality rulz a little bit more
2431 pFrom = p;
2432 nLevelFrom = n;
2433 }
2434 else
2435 { // ... but exact match rulz most
2436 pFrom = p;
2437 bSearchFrom = false;
2438 nLevelFrom = n;
2439 }
2440 }
2441 }
2442
2443 if( bSearchTo )
2444 {
2445 sal_Int16 n = p->GetMatchingLevel( rTo );
2446 if( n != INV_MATCHLEV )
2447 {
2448 if( n )
2449 { // only first match for partial equality rulz a little bit more
2450 pTo = p;
2451 nLevelTo = n;
2452 }
2453 else
2454 { // ... but exact match rulz most
2455 pTo = p;
2456 bSearchTo = false;
2457 nLevelTo = n;
2458 }
2459 }
2460 }
2461
2462 if( !bSearchFrom && !bSearchTo )
2463 break;
2464 }
2465
2466 if( !pFrom || !pTo )
2467 throw lang::IllegalArgumentException();
2468
2469 return pFrom->Convert( fVal, *pTo, nLevelFrom, nLevelTo );
2470 }
2471
2472
2473 ScaDate::ScaDate() :
2474 nOrigDay( 1 ),
2475 nDay( 1 ),
2476 nMonth( 1 ),
2477 nYear( 1900 ),
2478 bLastDayMode( true ),
2479 bLastDay( false ),
2480 b30Days( false ),
2481 bUSMode( false )
2482 {
2483 }
2484
2485 ScaDate::ScaDate( sal_Int32 nNullDate, sal_Int32 nDate, sal_Int32 nBase )
2486 {
2487 DaysToDate( nNullDate + nDate, nOrigDay, nMonth, nYear );
2488 bLastDayMode = (nBase != 5);
2489 bLastDay = (nOrigDay >= ::DaysInMonth( nMonth, nYear ));
2490 b30Days = (nBase == 0) || (nBase == 4);
2491 bUSMode = (nBase == 0);
2492 setDay();
2493 }
2494
2495 ScaDate::ScaDate( const ScaDate& rCopy ) :
2496 nOrigDay( rCopy.nOrigDay ),
2497 nDay( rCopy.nDay ),
2498 nMonth( rCopy.nMonth ),
2499 nYear( rCopy.nYear ),
2500 bLastDayMode( rCopy.bLastDayMode ),
2501 bLastDay( rCopy.bLastDay ),
2502 b30Days( rCopy.b30Days ),
2503 bUSMode( rCopy.bUSMode )
2504 {
2505 }
2506
2507 ScaDate& ScaDate::operator=( const ScaDate& rCopy )
2508 {
2509 if( this != &rCopy )
2510 {
2511 nOrigDay = rCopy.nOrigDay;
2512 nDay = rCopy.nDay;
2513 nMonth = rCopy.nMonth;
2514 nYear = rCopy.nYear;
2515 bLastDayMode = rCopy.bLastDayMode;
2516 bLastDay = rCopy.bLastDay;
2517 b30Days = rCopy.b30Days;
2518 bUSMode = rCopy.bUSMode;
2519 }
2520 return *this;
2521 }
2522
2523 void ScaDate::setDay()
2524 {
2525 if( b30Days )
2526 {
2527 // 30-days-mode: set nDay to 30 if original was last day in month
2528 nDay = std::min( nOrigDay, static_cast< sal_uInt16 >( 30 ) );
2529 if( bLastDay || (nDay >= ::DaysInMonth( nMonth, nYear )) )
2530 nDay = 30;
2531 }
2532 else
2533 {
2534 // set nDay to last day in this month if original was last day
2535 sal_uInt16 nLastDay = ::DaysInMonth( nMonth, nYear );
2536 nDay = bLastDay ? nLastDay : std::min( nOrigDay, nLastDay );
2537 }
2538 }
2539
2540 sal_Int32 ScaDate::getDaysInMonthRange( sal_uInt16 nFrom, sal_uInt16 nTo ) const
2541 {
2542 if( nFrom > nTo )
2543 return 0;
2544
2545 sal_Int32 nRet = 0;
2546 if( b30Days )
2547 nRet = (nTo - nFrom + 1) * 30;
2548 else
2549 {
2550 for( sal_uInt16 nMonthIx = nFrom; nMonthIx <= nTo; ++nMonthIx )
2551 nRet += getDaysInMonth( nMonthIx );
2552 }
2553 return nRet;
2554 }
2555
2556 sal_Int32 ScaDate::getDaysInYearRange( sal_uInt16 nFrom, sal_uInt16 nTo ) const
2557 {
2558 if( nFrom > nTo )
2559 return 0;
2560
2561 return b30Days ? ((nTo - nFrom + 1) * 360) : ::GetDaysInYears( nFrom, nTo );
2562 }
2563
2564 void ScaDate::doAddYears( sal_Int32 nYearCount )
2565 {
2566 sal_Int32 nNewYear = nYearCount + nYear;
2567 if( (nNewYear < 0) || (nNewYear > 0x7FFF) )
2568 throw lang::IllegalArgumentException();
2569 nYear = static_cast< sal_uInt16 >( nNewYear );
2570 }
2571
2572 void ScaDate::addMonths( sal_Int32 nMonthCount )
2573 {
2574 sal_Int32 nNewMonth = nMonthCount + nMonth;
2575 if( nNewMonth > 12 )
2576 {
2577 --nNewMonth;
2578 doAddYears( nNewMonth / 12 );
2579 nMonth = static_cast< sal_uInt16 >( nNewMonth % 12 ) + 1;
2580 }
2581 else if( nNewMonth < 1 )
2582 {
2583 doAddYears( nNewMonth / 12 - 1 );
2584 nMonth = static_cast< sal_uInt16 >( nNewMonth % 12 + 12 );
2585 }
2586 else
2587 nMonth = static_cast< sal_uInt16 >( nNewMonth );
2588 setDay();
2589 }
2590
2591 sal_Int32 ScaDate::getDate( sal_Int32 nNullDate ) const
2592 {
2593 sal_uInt16 nLastDay = ::DaysInMonth( nMonth, nYear );
2594 sal_uInt16 nRealDay = (bLastDayMode && bLastDay) ? nLastDay : std::min( nLastDay, nOrigDay );
2595 return ::DateToDays( nRealDay, nMonth, nYear ) - nNullDate;
2596 }
2597
2598 sal_Int32 ScaDate::getDiff( const ScaDate& rFrom, const ScaDate& rTo )
2599 {
2600 if( rFrom > rTo )
2601 return getDiff( rTo, rFrom );
2602
2603 sal_Int32 nDiff = 0;
2604 ScaDate aFrom( rFrom );
2605 ScaDate aTo( rTo );
2606
2607 if( rTo.b30Days )
2608 {
2609 // corrections for base 0 (US NASD)
2610 if( rTo.bUSMode )
2611 {
2612 if( ((rFrom.nMonth == 2) || (rFrom.nDay < 30)) && (aTo.nOrigDay == 31) )
2613 aTo.nDay = 31;
2614 else if( (aTo.nMonth == 2) && aTo.bLastDay )
2615 aTo.nDay = ::DaysInMonth( 2, aTo.nYear );
2616 }
2617 // corrections for base 4 (Europe)
2618 else
2619 {
2620 if( (aFrom.nMonth == 2) && (aFrom.nDay == 30) )
2621 aFrom.nDay = ::DaysInMonth( 2, aFrom.nYear );
2622 if( (aTo.nMonth == 2) && (aTo.nDay == 30) )
2623 aTo.nDay = ::DaysInMonth( 2, aTo.nYear );
2624 }
2625 }
2626
2627 if( (aFrom.nYear < aTo.nYear) || ((aFrom.nYear == aTo.nYear) && (aFrom.nMonth < aTo.nMonth)) )
2628 {
2629 // move aFrom to 1st day of next month
2630 nDiff = aFrom.getDaysInMonth() - aFrom.nDay + 1;
2631 aFrom.nOrigDay = aFrom.nDay = 1;
2632 aFrom.bLastDay = false;
2633 aFrom.addMonths( 1 );
2634
2635 if( aFrom.nYear < aTo.nYear )
2636 {
2637 // move aFrom to 1st day of next year
2638 nDiff += aFrom.getDaysInMonthRange( aFrom.nMonth, 12 );
2639 aFrom.addMonths( 13 - aFrom.nMonth );
2640
2641 // move aFrom to 1st day of this year
2642 nDiff += aFrom.getDaysInYearRange( aFrom.nYear, aTo.nYear - 1 );
2643 aFrom.addYears( aTo.nYear - aFrom.nYear );
2644 }
2645
2646 // move aFrom to 1st day of this month
2647 nDiff += aFrom.getDaysInMonthRange( aFrom.nMonth, aTo.nMonth - 1 );
2648 aFrom.addMonths( aTo.nMonth - aFrom.nMonth );
2649 }
2650 // finally add remaining days in this month
2651 nDiff += aTo.nDay - aFrom.nDay;
2652 return std::max<sal_Int32>(nDiff, 0);
2653 }
2654
2655 bool ScaDate::operator<( const ScaDate& rCmp ) const
2656 {
2657 if( nYear != rCmp.nYear )
2658 return nYear < rCmp.nYear;
2659 if( nMonth != rCmp.nMonth )
2660 return nMonth < rCmp.nMonth;
2661 if( nDay != rCmp.nDay )
2662 return nDay < rCmp.nDay;
2663 if( bLastDay || rCmp.bLastDay )
2664 return !bLastDay && rCmp.bLastDay;
2665 return nOrigDay < rCmp.nOrigDay;
2666 }
2667
2668
2669 ScaAnyConverter::ScaAnyConverter( const uno::Reference< uno::XComponentContext >& xContext )
2670 : nDefaultFormat(0)
2671 , bHasValidFormat(false)
2672 {
2673 xFormatter = util::NumberFormatter::create(xContext);
2674 }
2675
2676 ScaAnyConverter::~ScaAnyConverter()
2677 {
2678 }
2679
2680 void ScaAnyConverter::init( const uno::Reference< beans::XPropertySet >& xPropSet )
2681 {
2682 // try to get default number format
2683 bHasValidFormat = false;
2684 if( !xFormatter.is() )
2685 return;
2686
2687 // get XFormatsSupplier from outer XPropertySet
2688 uno::Reference< util::XNumberFormatsSupplier > xFormatsSupp( xPropSet, uno::UNO_QUERY );
2689 if( !xFormatsSupp.is() )
2690 return;
2691
2692 // get XNumberFormatTypes from XNumberFormatsSupplier to get standard index
2693 uno::Reference< util::XNumberFormats > xFormats( xFormatsSupp->getNumberFormats() );
2694 uno::Reference< util::XNumberFormatTypes > xFormatTypes( xFormats, uno::UNO_QUERY );
2695 if( xFormatTypes.is() )
2696 {
2697 lang::Locale eLocale;
2698 nDefaultFormat = xFormatTypes->getStandardIndex( eLocale );
2699 xFormatter->attachNumberFormatsSupplier( xFormatsSupp );
2700 bHasValidFormat = true;
2701 }
2702 }
2703
2704 double ScaAnyConverter::convertToDouble( const OUString& rString ) const
2705 {
2706 double fValue = 0.0;
2707 if( bHasValidFormat )
2708 {
2709 try
2710 {
2711 fValue = xFormatter->convertStringToNumber( nDefaultFormat, rString );
2712 }
2713 catch( uno::Exception& )
2714 {
2715 throw lang::IllegalArgumentException();
2716 }
2717 }
2718 else
2719 {
2720 rtl_math_ConversionStatus eStatus;
2721 sal_Int32 nEnd;
2722 fValue = ::rtl::math::stringToDouble( rString, '.', ',', &eStatus, &nEnd );
2723 if( (eStatus != rtl_math_ConversionStatus_Ok) || (nEnd < rString.getLength()) )
2724 throw lang::IllegalArgumentException();
2725 }
2726 return fValue;
2727 }
2728
2729 bool ScaAnyConverter::getDouble(
2730 double& rfResult,
2731 const uno::Any& rAny ) const
2732 {
2733 rfResult = 0.0;
2734 bool bContainsVal = true;
2735 switch( rAny.getValueTypeClass() )
2736 {
2737 case uno::TypeClass_VOID:
2738 bContainsVal = false;
2739 break;
2740 case uno::TypeClass_DOUBLE:
2741 rAny >>= rfResult;
2742 break;
2743 case uno::TypeClass_STRING:
2744 {
2745 auto pString = o3tl::forceAccess< OUString >( rAny );
2746 if( !pString->isEmpty() )
2747 rfResult = convertToDouble( *pString );
2748 else
2749 bContainsVal = false;
2750 }
2751 break;
2752 default:
2753 throw lang::IllegalArgumentException();
2754 }
2755 return bContainsVal;
2756 }
2757
2758 bool ScaAnyConverter::getDouble(
2759 double& rfResult,
2760 const uno::Reference< beans::XPropertySet >& xPropSet,
2761 const uno::Any& rAny )
2762 {
2763 init( xPropSet );
2764 return getDouble( rfResult, rAny );
2765 }
2766
2767 double ScaAnyConverter::getDouble(
2768 const uno::Reference< beans::XPropertySet >& xPropSet,
2769 const uno::Any& rAny,
2770 double fDefault )
2771 {
2772 double fResult;
2773 if( !getDouble( fResult, xPropSet, rAny ) )
2774 fResult = fDefault;
2775 return fResult;
2776 }
2777
2778 bool ScaAnyConverter::getInt32(
2779 sal_Int32& rnResult,
2780 const uno::Reference< beans::XPropertySet >& xPropSet,
2781 const uno::Any& rAny )
2782 {
2783 double fResult;
2784 bool bContainsVal = getDouble( fResult, xPropSet, rAny );
2785 if( (fResult <= -2147483649.0) || (fResult >= 2147483648.0) )
2786 throw lang::IllegalArgumentException();
2787
2788 rnResult = static_cast< sal_Int32 >( fResult );
2789 return bContainsVal;
2790 }
2791
2792 sal_Int32 ScaAnyConverter::getInt32(
2793 const uno::Reference< beans::XPropertySet >& xPropSet,
2794 const uno::Any& rAny,
2795 sal_Int32 nDefault )
2796 {
2797 sal_Int32 nResult;
2798 if( !getInt32( nResult, xPropSet, rAny ) )
2799 nResult = nDefault;
2800 return nResult;
2801 }
2802
2803 }
2804
2805 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE