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