File: | dev/pci/drm/amd/pm/powerplay/hwmgr/ppevvmath.h |
Warning: | line 339, column 2 Value stored to 'Y_LessThanOne' is never read |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
1 | /* |
2 | * Copyright 2015 Advanced Micro Devices, Inc. |
3 | * |
4 | * Permission is hereby granted, free of charge, to any person obtaining a |
5 | * copy of this software and associated documentation files (the "Software"), |
6 | * to deal in the Software without restriction, including without limitation |
7 | * the rights to use, copy, modify, merge, publish, distribute, sublicense, |
8 | * and/or sell copies of the Software, and to permit persons to whom the |
9 | * Software is furnished to do so, subject to the following conditions: |
10 | * |
11 | * The above copyright notice and this permission notice shall be included in |
12 | * all copies or substantial portions of the Software. |
13 | * |
14 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
15 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
16 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL |
17 | * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR |
18 | * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, |
19 | * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR |
20 | * OTHER DEALINGS IN THE SOFTWARE. |
21 | * |
22 | */ |
23 | #include <asm/div64.h> |
24 | |
25 | #define SHIFT_AMOUNT16 16 /* We multiply all original integers with 2^SHIFT_AMOUNT to get the fInt representation */ |
26 | |
27 | #define PRECISION5 5 /* Change this value to change the number of decimal places in the final output - 5 is a good default */ |
28 | |
29 | #define SHIFTED_2(2 << 16) (2 << SHIFT_AMOUNT16) |
30 | #define PPMAX(1 << (16 - 1)) - 1 (1 << (SHIFT_AMOUNT16 - 1)) - 1 /* 32767 - Might change in the future */ |
31 | |
32 | /* ------------------------------------------------------------------------------- |
33 | * NEW TYPE - fINT |
34 | * ------------------------------------------------------------------------------- |
35 | * A variable of type fInt can be accessed in 3 ways using the dot (.) operator |
36 | * fInt A; |
37 | * A.full => The full number as it is. Generally not easy to read |
38 | * A.partial.real => Only the integer portion |
39 | * A.partial.decimal => Only the fractional portion |
40 | */ |
41 | typedef union _fInt { |
42 | int full; |
43 | struct _partial { |
44 | unsigned int decimal: SHIFT_AMOUNT16; /*Needs to always be unsigned*/ |
45 | int real: 32 - SHIFT_AMOUNT16; |
46 | } partial; |
47 | } fInt; |
48 | |
49 | /* ------------------------------------------------------------------------------- |
50 | * Function Declarations |
51 | * ------------------------------------------------------------------------------- |
52 | */ |
53 | static fInt ConvertToFraction(int); /* Use this to convert an INT to a FINT */ |
54 | static fInt Convert_ULONG_ToFraction(uint32_t); /* Use this to convert an uint32_t to a FINT */ |
55 | static fInt GetScaledFraction(int, int); /* Use this to convert an INT to a FINT after scaling it by a factor */ |
56 | static int ConvertBackToInteger(fInt); /* Convert a FINT back to an INT that is scaled by 1000 (i.e. last 3 digits are the decimal digits) */ |
57 | |
58 | static fInt fNegate(fInt); /* Returns -1 * input fInt value */ |
59 | static fInt fAdd (fInt, fInt); /* Returns the sum of two fInt numbers */ |
60 | static fInt fSubtract (fInt A, fInt B); /* Returns A-B - Sometimes easier than Adding negative numbers */ |
61 | static fInt fMultiply (fInt, fInt); /* Returns the product of two fInt numbers */ |
62 | static fInt fDivide (fInt A, fInt B); /* Returns A/B */ |
63 | static fInt fGetSquare(fInt); /* Returns the square of a fInt number */ |
64 | static fInt fSqrt(fInt); /* Returns the Square Root of a fInt number */ |
65 | |
66 | static int uAbs(int); /* Returns the Absolute value of the Int */ |
67 | static int uPow(int base, int exponent); /* Returns base^exponent an INT */ |
68 | |
69 | static void SolveQuadracticEqn(fInt, fInt, fInt, fInt[]); /* Returns the 2 roots via the array */ |
70 | static bool_Bool Equal(fInt, fInt); /* Returns true if two fInts are equal to each other */ |
71 | static bool_Bool GreaterThan(fInt A, fInt B); /* Returns true if A > B */ |
72 | |
73 | static fInt fExponential(fInt exponent); /* Can be used to calculate e^exponent */ |
74 | static fInt fNaturalLog(fInt value); /* Can be used to calculate ln(value) */ |
75 | |
76 | /* Fuse decoding functions |
77 | * ------------------------------------------------------------------------------------- |
78 | */ |
79 | static fInt fDecodeLinearFuse(uint32_t fuse_value, fInt f_min, fInt f_range, uint32_t bitlength); |
80 | static fInt fDecodeLogisticFuse(uint32_t fuse_value, fInt f_average, fInt f_range, uint32_t bitlength); |
81 | static fInt fDecodeLeakageID (uint32_t leakageID_fuse, fInt ln_max_div_min, fInt f_min, uint32_t bitlength); |
82 | |
83 | /* Internal Support Functions - Use these ONLY for testing or adding to internal functions |
84 | * ------------------------------------------------------------------------------------- |
85 | * Some of the following functions take two INTs as their input - This is unsafe for a variety of reasons. |
86 | */ |
87 | static fInt Divide (int, int); /* Divide two INTs and return result as FINT */ |
88 | static fInt fNegate(fInt); |
89 | |
90 | static int uGetScaledDecimal (fInt); /* Internal function */ |
91 | static int GetReal (fInt A); /* Internal function */ |
92 | |
93 | /* ------------------------------------------------------------------------------------- |
94 | * TROUBLESHOOTING INFORMATION |
95 | * ------------------------------------------------------------------------------------- |
96 | * 1) ConvertToFraction - InputOutOfRangeException: Only accepts numbers smaller than MAX (default: 32767) |
97 | * 2) fAdd - OutputOutOfRangeException: Output bigger than MAX (default: 32767) |
98 | * 3) fMultiply - OutputOutOfRangeException: |
99 | * 4) fGetSquare - OutputOutOfRangeException: |
100 | * 5) fDivide - DivideByZeroException |
101 | * 6) fSqrt - NegativeSquareRootException: Input cannot be a negative number |
102 | */ |
103 | |
104 | /* ------------------------------------------------------------------------------------- |
105 | * START OF CODE |
106 | * ------------------------------------------------------------------------------------- |
107 | */ |
108 | static fInt fExponential(fInt exponent) /*Can be used to calculate e^exponent*/ |
109 | { |
110 | uint32_t i; |
111 | bool_Bool bNegated = false0; |
112 | |
113 | fInt fPositiveOne = ConvertToFraction(1); |
114 | fInt fZERO = ConvertToFraction(0); |
115 | |
116 | fInt lower_bound = Divide(78, 10000); |
117 | fInt solution = fPositiveOne; /*Starting off with baseline of 1 */ |
118 | fInt error_term; |
119 | |
120 | static const uint32_t k_array[11] = {55452, 27726, 13863, 6931, 4055, 2231, 1178, 606, 308, 155, 78}; |
121 | static const uint32_t expk_array[11] = {2560000, 160000, 40000, 20000, 15000, 12500, 11250, 10625, 10313, 10156, 10078}; |
122 | |
123 | if (GreaterThan(fZERO, exponent)) { |
124 | exponent = fNegate(exponent); |
125 | bNegated = true1; |
126 | } |
127 | |
128 | while (GreaterThan(exponent, lower_bound)) { |
129 | for (i = 0; i < 11; i++) { |
130 | if (GreaterThan(exponent, GetScaledFraction(k_array[i], 10000))) { |
131 | exponent = fSubtract(exponent, GetScaledFraction(k_array[i], 10000)); |
132 | solution = fMultiply(solution, GetScaledFraction(expk_array[i], 10000)); |
133 | } |
134 | } |
135 | } |
136 | |
137 | error_term = fAdd(fPositiveOne, exponent); |
138 | |
139 | solution = fMultiply(solution, error_term); |
140 | |
141 | if (bNegated) |
142 | solution = fDivide(fPositiveOne, solution); |
143 | |
144 | return solution; |
145 | } |
146 | |
147 | static fInt fNaturalLog(fInt value) |
148 | { |
149 | uint32_t i; |
150 | fInt upper_bound = Divide(8, 1000); |
151 | fInt fNegativeOne = ConvertToFraction(-1); |
152 | fInt solution = ConvertToFraction(0); /*Starting off with baseline of 0 */ |
153 | fInt error_term; |
154 | |
155 | static const uint32_t k_array[10] = {160000, 40000, 20000, 15000, 12500, 11250, 10625, 10313, 10156, 10078}; |
156 | static const uint32_t logk_array[10] = {27726, 13863, 6931, 4055, 2231, 1178, 606, 308, 155, 78}; |
157 | |
158 | while (GreaterThan(fAdd(value, fNegativeOne), upper_bound)) { |
159 | for (i = 0; i < 10; i++) { |
160 | if (GreaterThan(value, GetScaledFraction(k_array[i], 10000))) { |
161 | value = fDivide(value, GetScaledFraction(k_array[i], 10000)); |
162 | solution = fAdd(solution, GetScaledFraction(logk_array[i], 10000)); |
163 | } |
164 | } |
165 | } |
166 | |
167 | error_term = fAdd(fNegativeOne, value); |
168 | |
169 | return (fAdd(solution, error_term)); |
170 | } |
171 | |
172 | static fInt fDecodeLinearFuse(uint32_t fuse_value, fInt f_min, fInt f_range, uint32_t bitlength) |
173 | { |
174 | fInt f_fuse_value = Convert_ULONG_ToFraction(fuse_value); |
175 | fInt f_bit_max_value = Convert_ULONG_ToFraction((uPow(2, bitlength)) - 1); |
176 | |
177 | fInt f_decoded_value; |
178 | |
179 | f_decoded_value = fDivide(f_fuse_value, f_bit_max_value); |
180 | f_decoded_value = fMultiply(f_decoded_value, f_range); |
181 | f_decoded_value = fAdd(f_decoded_value, f_min); |
182 | |
183 | return f_decoded_value; |
184 | } |
185 | |
186 | |
187 | static fInt fDecodeLogisticFuse(uint32_t fuse_value, fInt f_average, fInt f_range, uint32_t bitlength) |
188 | { |
189 | fInt f_fuse_value = Convert_ULONG_ToFraction(fuse_value); |
190 | fInt f_bit_max_value = Convert_ULONG_ToFraction((uPow(2, bitlength)) - 1); |
191 | |
192 | fInt f_CONSTANT_NEG13 = ConvertToFraction(-13); |
193 | fInt f_CONSTANT1 = ConvertToFraction(1); |
194 | |
195 | fInt f_decoded_value; |
196 | |
197 | f_decoded_value = fSubtract(fDivide(f_bit_max_value, f_fuse_value), f_CONSTANT1); |
198 | f_decoded_value = fNaturalLog(f_decoded_value); |
199 | f_decoded_value = fMultiply(f_decoded_value, fDivide(f_range, f_CONSTANT_NEG13)); |
200 | f_decoded_value = fAdd(f_decoded_value, f_average); |
201 | |
202 | return f_decoded_value; |
203 | } |
204 | |
205 | static fInt fDecodeLeakageID (uint32_t leakageID_fuse, fInt ln_max_div_min, fInt f_min, uint32_t bitlength) |
206 | { |
207 | fInt fLeakage; |
208 | fInt f_bit_max_value = Convert_ULONG_ToFraction((uPow(2, bitlength)) - 1); |
209 | |
210 | fLeakage = fMultiply(ln_max_div_min, Convert_ULONG_ToFraction(leakageID_fuse)); |
211 | fLeakage = fDivide(fLeakage, f_bit_max_value); |
212 | fLeakage = fExponential(fLeakage); |
213 | fLeakage = fMultiply(fLeakage, f_min); |
214 | |
215 | return fLeakage; |
216 | } |
217 | |
218 | static fInt ConvertToFraction(int X) /*Add all range checking here. Is it possible to make fInt a private declaration? */ |
219 | { |
220 | fInt temp; |
221 | |
222 | if (X <= PPMAX(1 << (16 - 1)) - 1) |
223 | temp.full = (X << SHIFT_AMOUNT16); |
224 | else |
225 | temp.full = 0; |
226 | |
227 | return temp; |
228 | } |
229 | |
230 | static fInt fNegate(fInt X) |
231 | { |
232 | fInt CONSTANT_NEGONE = ConvertToFraction(-1); |
233 | return (fMultiply(X, CONSTANT_NEGONE)); |
234 | } |
235 | |
236 | static fInt Convert_ULONG_ToFraction(uint32_t X) |
237 | { |
238 | fInt temp; |
239 | |
240 | if (X <= PPMAX(1 << (16 - 1)) - 1) |
241 | temp.full = (X << SHIFT_AMOUNT16); |
242 | else |
243 | temp.full = 0; |
244 | |
245 | return temp; |
246 | } |
247 | |
248 | static fInt GetScaledFraction(int X, int factor) |
249 | { |
250 | int times_shifted, factor_shifted; |
251 | bool_Bool bNEGATED; |
252 | fInt fValue; |
253 | |
254 | times_shifted = 0; |
255 | factor_shifted = 0; |
256 | bNEGATED = false0; |
257 | |
258 | if (X < 0) { |
259 | X = -1*X; |
260 | bNEGATED = true1; |
261 | } |
262 | |
263 | if (factor < 0) { |
264 | factor = -1*factor; |
265 | bNEGATED = !bNEGATED; /*If bNEGATED = true due to X < 0, this will cover the case of negative cancelling negative */ |
266 | } |
267 | |
268 | if ((X > PPMAX(1 << (16 - 1)) - 1) || factor > PPMAX(1 << (16 - 1)) - 1) { |
269 | if ((X/factor) <= PPMAX(1 << (16 - 1)) - 1) { |
270 | while (X > PPMAX(1 << (16 - 1)) - 1) { |
271 | X = X >> 1; |
272 | times_shifted++; |
273 | } |
274 | |
275 | while (factor > PPMAX(1 << (16 - 1)) - 1) { |
276 | factor = factor >> 1; |
277 | factor_shifted++; |
278 | } |
279 | } else { |
280 | fValue.full = 0; |
281 | return fValue; |
282 | } |
283 | } |
284 | |
285 | if (factor == 1) |
286 | return ConvertToFraction(X); |
287 | |
288 | fValue = fDivide(ConvertToFraction(X * uPow(-1, bNEGATED)), ConvertToFraction(factor)); |
289 | |
290 | fValue.full = fValue.full << times_shifted; |
291 | fValue.full = fValue.full >> factor_shifted; |
292 | |
293 | return fValue; |
294 | } |
295 | |
296 | /* Addition using two fInts */ |
297 | static fInt fAdd (fInt X, fInt Y) |
298 | { |
299 | fInt Sum; |
300 | |
301 | Sum.full = X.full + Y.full; |
302 | |
303 | return Sum; |
304 | } |
305 | |
306 | /* Addition using two fInts */ |
307 | static fInt fSubtract (fInt X, fInt Y) |
308 | { |
309 | fInt Difference; |
310 | |
311 | Difference.full = X.full - Y.full; |
312 | |
313 | return Difference; |
314 | } |
315 | |
316 | static bool_Bool Equal(fInt A, fInt B) |
317 | { |
318 | if (A.full == B.full) |
319 | return true1; |
320 | else |
321 | return false0; |
322 | } |
323 | |
324 | static bool_Bool GreaterThan(fInt A, fInt B) |
325 | { |
326 | if (A.full > B.full) |
327 | return true1; |
328 | else |
329 | return false0; |
330 | } |
331 | |
332 | static fInt fMultiply (fInt X, fInt Y) /* Uses 64-bit integers (int64_t) */ |
333 | { |
334 | fInt Product; |
335 | int64_t tempProduct; |
336 | bool_Bool X_LessThanOne, Y_LessThanOne; |
337 | |
338 | X_LessThanOne = (X.partial.real == 0 && X.partial.decimal != 0 && X.full >= 0); |
339 | Y_LessThanOne = (Y.partial.real == 0 && Y.partial.decimal != 0 && Y.full >= 0); |
Value stored to 'Y_LessThanOne' is never read | |
340 | |
341 | /*The following is for a very specific common case: Non-zero number with ONLY fractional portion*/ |
342 | /* TEMPORARILY DISABLED - CAN BE USED TO IMPROVE PRECISION |
343 | |
344 | if (X_LessThanOne && Y_LessThanOne) { |
345 | Product.full = X.full * Y.full; |
346 | return Product |
347 | }*/ |
348 | |
349 | tempProduct = ((int64_t)X.full) * ((int64_t)Y.full); /*Q(16,16)*Q(16,16) = Q(32, 32) - Might become a negative number! */ |
350 | tempProduct = tempProduct >> 16; /*Remove lagging 16 bits - Will lose some precision from decimal; */ |
351 | Product.full = (int)tempProduct; /*The int64_t will lose the leading 16 bits that were part of the integer portion */ |
352 | |
353 | return Product; |
354 | } |
355 | |
356 | static fInt fDivide (fInt X, fInt Y) |
357 | { |
358 | fInt fZERO, fQuotient; |
359 | int64_t longlongX, longlongY; |
360 | |
361 | fZERO = ConvertToFraction(0); |
362 | |
363 | if (Equal(Y, fZERO)) |
364 | return fZERO; |
365 | |
366 | longlongX = (int64_t)X.full; |
367 | longlongY = (int64_t)Y.full; |
368 | |
369 | longlongX = longlongX << 16; /*Q(16,16) -> Q(32,32) */ |
370 | |
371 | div64_s64(longlongX, longlongY); /*Q(32,32) divided by Q(16,16) = Q(16,16) Back to original format */ |
372 | |
373 | fQuotient.full = (int)longlongX; |
374 | return fQuotient; |
375 | } |
376 | |
377 | static int ConvertBackToInteger (fInt A) /*THIS is the function that will be used to check with the Golden settings table*/ |
378 | { |
379 | fInt fullNumber, scaledDecimal, scaledReal; |
380 | |
381 | scaledReal.full = GetReal(A) * uPow(10, PRECISION5-1); /* DOUBLE CHECK THISSSS!!! */ |
382 | |
383 | scaledDecimal.full = uGetScaledDecimal(A); |
384 | |
385 | fullNumber = fAdd(scaledDecimal,scaledReal); |
386 | |
387 | return fullNumber.full; |
388 | } |
389 | |
390 | static fInt fGetSquare(fInt A) |
391 | { |
392 | return fMultiply(A,A); |
393 | } |
394 | |
395 | /* x_new = x_old - (x_old^2 - C) / (2 * x_old) */ |
396 | static fInt fSqrt(fInt num) |
397 | { |
398 | fInt F_divide_Fprime, Fprime; |
399 | fInt test; |
400 | fInt twoShifted; |
401 | int seed, counter, error; |
402 | fInt x_new, x_old, C, y; |
403 | |
404 | fInt fZERO = ConvertToFraction(0); |
405 | |
406 | /* (0 > num) is the same as (num < 0), i.e., num is negative */ |
407 | |
408 | if (GreaterThan(fZERO, num) || Equal(fZERO, num)) |
409 | return fZERO; |
410 | |
411 | C = num; |
412 | |
413 | if (num.partial.real > 3000) |
414 | seed = 60; |
415 | else if (num.partial.real > 1000) |
416 | seed = 30; |
417 | else if (num.partial.real > 100) |
418 | seed = 10; |
419 | else |
420 | seed = 2; |
421 | |
422 | counter = 0; |
423 | |
424 | if (Equal(num, fZERO)) /*Square Root of Zero is zero */ |
425 | return fZERO; |
426 | |
427 | twoShifted = ConvertToFraction(2); |
428 | x_new = ConvertToFraction(seed); |
429 | |
430 | do { |
431 | counter++; |
432 | |
433 | x_old.full = x_new.full; |
434 | |
435 | test = fGetSquare(x_old); /*1.75*1.75 is reverting back to 1 when shifted down */ |
436 | y = fSubtract(test, C); /*y = f(x) = x^2 - C; */ |
437 | |
438 | Fprime = fMultiply(twoShifted, x_old); |
439 | F_divide_Fprime = fDivide(y, Fprime); |
440 | |
441 | x_new = fSubtract(x_old, F_divide_Fprime); |
442 | |
443 | error = ConvertBackToInteger(x_new) - ConvertBackToInteger(x_old); |
444 | |
445 | if (counter > 20) /*20 is already way too many iterations. If we dont have an answer by then, we never will*/ |
446 | return x_new; |
447 | |
448 | } while (uAbs(error) > 0); |
449 | |
450 | return (x_new); |
451 | } |
452 | |
453 | static void SolveQuadracticEqn(fInt A, fInt B, fInt C, fInt Roots[]) |
454 | { |
455 | fInt *pRoots = &Roots[0]; |
456 | fInt temp, root_first, root_second; |
457 | fInt f_CONSTANT10, f_CONSTANT100; |
458 | |
459 | f_CONSTANT100 = ConvertToFraction(100); |
460 | f_CONSTANT10 = ConvertToFraction(10); |
461 | |
462 | while(GreaterThan(A, f_CONSTANT100) || GreaterThan(B, f_CONSTANT100) || GreaterThan(C, f_CONSTANT100)) { |
463 | A = fDivide(A, f_CONSTANT10); |
464 | B = fDivide(B, f_CONSTANT10); |
465 | C = fDivide(C, f_CONSTANT10); |
466 | } |
467 | |
468 | temp = fMultiply(ConvertToFraction(4), A); /* root = 4*A */ |
469 | temp = fMultiply(temp, C); /* root = 4*A*C */ |
470 | temp = fSubtract(fGetSquare(B), temp); /* root = b^2 - 4AC */ |
471 | temp = fSqrt(temp); /*root = Sqrt (b^2 - 4AC); */ |
472 | |
473 | root_first = fSubtract(fNegate(B), temp); /* b - Sqrt(b^2 - 4AC) */ |
474 | root_second = fAdd(fNegate(B), temp); /* b + Sqrt(b^2 - 4AC) */ |
475 | |
476 | root_first = fDivide(root_first, ConvertToFraction(2)); /* [b +- Sqrt(b^2 - 4AC)]/[2] */ |
477 | root_first = fDivide(root_first, A); /*[b +- Sqrt(b^2 - 4AC)]/[2*A] */ |
478 | |
479 | root_second = fDivide(root_second, ConvertToFraction(2)); /* [b +- Sqrt(b^2 - 4AC)]/[2] */ |
480 | root_second = fDivide(root_second, A); /*[b +- Sqrt(b^2 - 4AC)]/[2*A] */ |
481 | |
482 | *(pRoots + 0) = root_first; |
483 | *(pRoots + 1) = root_second; |
484 | } |
485 | |
486 | /* ----------------------------------------------------------------------------- |
487 | * SUPPORT FUNCTIONS |
488 | * ----------------------------------------------------------------------------- |
489 | */ |
490 | |
491 | /* Conversion Functions */ |
492 | static int GetReal (fInt A) |
493 | { |
494 | return (A.full >> SHIFT_AMOUNT16); |
495 | } |
496 | |
497 | static fInt Divide (int X, int Y) |
498 | { |
499 | fInt A, B, Quotient; |
500 | |
501 | A.full = X << SHIFT_AMOUNT16; |
502 | B.full = Y << SHIFT_AMOUNT16; |
503 | |
504 | Quotient = fDivide(A, B); |
505 | |
506 | return Quotient; |
507 | } |
508 | |
509 | static int uGetScaledDecimal (fInt A) /*Converts the fractional portion to whole integers - Costly function */ |
510 | { |
511 | int dec[PRECISION5]; |
512 | int i, scaledDecimal = 0, tmp = A.partial.decimal; |
513 | |
514 | for (i = 0; i < PRECISION5; i++) { |
515 | dec[i] = tmp / (1 << SHIFT_AMOUNT16); |
516 | tmp = tmp - ((1 << SHIFT_AMOUNT16)*dec[i]); |
517 | tmp *= 10; |
518 | scaledDecimal = scaledDecimal + dec[i]*uPow(10, PRECISION5 - 1 -i); |
519 | } |
520 | |
521 | return scaledDecimal; |
522 | } |
523 | |
524 | static int uPow(int base, int power) |
525 | { |
526 | if (power == 0) |
527 | return 1; |
528 | else |
529 | return (base)*uPow(base, power - 1); |
530 | } |
531 | |
532 | static int uAbs(int X) |
533 | { |
534 | if (X < 0) |
535 | return (X * -1); |
536 | else |
537 | return X; |
538 | } |
539 | |
540 | static fInt fRoundUpByStepSize(fInt A, fInt fStepSize, bool_Bool error_term) |
541 | { |
542 | fInt solution; |
543 | |
544 | solution = fDivide(A, fStepSize); |
545 | solution.partial.decimal = 0; /*All fractional digits changes to 0 */ |
546 | |
547 | if (error_term) |
548 | solution.partial.real += 1; /*Error term of 1 added */ |
549 | |
550 | solution = fMultiply(solution, fStepSize); |
551 | solution = fAdd(solution, fStepSize); |
552 | |
553 | return solution; |
554 | } |
555 |