Release 4.11 drivers/gpu/drm/amd/powerplay/hwmgr/ppevvmath.h
/*
* Copyright 2015 Advanced Micro Devices, Inc.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
*
*/
#include <asm/div64.h>
#define SHIFT_AMOUNT 16
/* We multiply all original integers with 2^SHIFT_AMOUNT to get the fInt representation */
#define PRECISION 5
/* Change this value to change the number of decimal places in the final output - 5 is a good default */
#define SHIFTED_2 (2 << SHIFT_AMOUNT)
#define MAX (1 << (SHIFT_AMOUNT - 1)) - 1
/* 32767 - Might change in the future */
/* -------------------------------------------------------------------------------
* NEW TYPE - fINT
* -------------------------------------------------------------------------------
* A variable of type fInt can be accessed in 3 ways using the dot (.) operator
* fInt A;
* A.full => The full number as it is. Generally not easy to read
* A.partial.real => Only the integer portion
* A.partial.decimal => Only the fractional portion
*/
typedef union _fInt {
int full;
struct _partial {
unsigned int decimal: SHIFT_AMOUNT; /*Needs to always be unsigned*/
int real: 32 - SHIFT_AMOUNT;
}
partial;
}
fInt;
/* -------------------------------------------------------------------------------
* Function Declarations
* -------------------------------------------------------------------------------
*/
static fInt ConvertToFraction(int); /* Use this to convert an INT to a FINT */
static fInt Convert_ULONG_ToFraction(uint32_t); /* Use this to convert an uint32_t to a FINT */
static fInt GetScaledFraction(int, int); /* Use this to convert an INT to a FINT after scaling it by a factor */
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) */
static fInt fNegate(fInt); /* Returns -1 * input fInt value */
static fInt fAdd (fInt, fInt); /* Returns the sum of two fInt numbers */
static fInt fSubtract (fInt A, fInt B); /* Returns A-B - Sometimes easier than Adding negative numbers */
static fInt fMultiply (fInt, fInt); /* Returns the product of two fInt numbers */
static fInt fDivide (fInt A, fInt B); /* Returns A/B */
static fInt fGetSquare(fInt); /* Returns the square of a fInt number */
static fInt fSqrt(fInt); /* Returns the Square Root of a fInt number */
static int uAbs(int); /* Returns the Absolute value of the Int */
static int uPow(int base, int exponent); /* Returns base^exponent an INT */
static void SolveQuadracticEqn(fInt, fInt, fInt, fInt[]); /* Returns the 2 roots via the array */
static bool Equal(fInt, fInt); /* Returns true if two fInts are equal to each other */
static bool GreaterThan(fInt A, fInt B); /* Returns true if A > B */
static fInt fExponential(fInt exponent); /* Can be used to calculate e^exponent */
static fInt fNaturalLog(fInt value); /* Can be used to calculate ln(value) */
/* Fuse decoding functions
* -------------------------------------------------------------------------------------
*/
static fInt fDecodeLinearFuse(uint32_t fuse_value, fInt f_min, fInt f_range, uint32_t bitlength);
static fInt fDecodeLogisticFuse(uint32_t fuse_value, fInt f_average, fInt f_range, uint32_t bitlength);
static fInt fDecodeLeakageID (uint32_t leakageID_fuse, fInt ln_max_div_min, fInt f_min, uint32_t bitlength);
/* Internal Support Functions - Use these ONLY for testing or adding to internal functions
* -------------------------------------------------------------------------------------
* Some of the following functions take two INTs as their input - This is unsafe for a variety of reasons.
*/
static fInt Divide (int, int); /* Divide two INTs and return result as FINT */
static fInt fNegate(fInt);
static int uGetScaledDecimal (fInt); /* Internal function */
static int GetReal (fInt A); /* Internal function */
/* -------------------------------------------------------------------------------------
* TROUBLESHOOTING INFORMATION
* -------------------------------------------------------------------------------------
* 1) ConvertToFraction - InputOutOfRangeException: Only accepts numbers smaller than MAX (default: 32767)
* 2) fAdd - OutputOutOfRangeException: Output bigger than MAX (default: 32767)
* 3) fMultiply - OutputOutOfRangeException:
* 4) fGetSquare - OutputOutOfRangeException:
* 5) fDivide - DivideByZeroException
* 6) fSqrt - NegativeSquareRootException: Input cannot be a negative number
*/
/* -------------------------------------------------------------------------------------
* START OF CODE
* -------------------------------------------------------------------------------------
*/
static fInt fExponential(fInt exponent) /*Can be used to calculate e^exponent*/
{
uint32_t i;
bool bNegated = false;
fInt fPositiveOne = ConvertToFraction(1);
fInt fZERO = ConvertToFraction(0);
fInt lower_bound = Divide(78, 10000);
fInt solution = fPositiveOne; /*Starting off with baseline of 1 */
fInt error_term;
static const uint32_t k_array[11] = {55452, 27726, 13863, 6931, 4055, 2231, 1178, 606, 308, 155, 78};
static const uint32_t expk_array[11] = {2560000, 160000, 40000, 20000, 15000, 12500, 11250, 10625, 10313, 10156, 10078};
if (GreaterThan(fZERO, exponent)) {
exponent = fNegate(exponent);
bNegated = true;
}
while (GreaterThan(exponent, lower_bound)) {
for (i = 0; i < 11; i++) {
if (GreaterThan(exponent, GetScaledFraction(k_array[i], 10000))) {
exponent = fSubtract(exponent, GetScaledFraction(k_array[i], 10000));
solution = fMultiply(solution, GetScaledFraction(expk_array[i], 10000));
}
}
}
error_term = fAdd(fPositiveOne, exponent);
solution = fMultiply(solution, error_term);
if (bNegated)
solution = fDivide(fPositiveOne, solution);
return solution;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Eric Huang | 247 | 98.02% | 1 | 33.33% |
| Nils Wallménius | 5 | 1.98% | 2 | 66.67% |
| Total | 252 | 100.00% | 3 | 100.00% |
static fInt fNaturalLog(fInt value)
{
uint32_t i;
fInt upper_bound = Divide(8, 1000);
fInt fNegativeOne = ConvertToFraction(-1);
fInt solution = ConvertToFraction(0); /*Starting off with baseline of 0 */
fInt error_term;
static const uint32_t k_array[10] = {160000, 40000, 20000, 15000, 12500, 11250, 10625, 10313, 10156, 10078};
static const uint32_t logk_array[10] = {27726, 13863, 6931, 4055, 2231, 1178, 606, 308, 155, 78};
while (GreaterThan(fAdd(value, fNegativeOne), upper_bound)) {
for (i = 0; i < 10; i++) {
if (GreaterThan(value, GetScaledFraction(k_array[i], 10000))) {
value = fDivide(value, GetScaledFraction(k_array[i], 10000));
solution = fAdd(solution, GetScaledFraction(logk_array[i], 10000));
}
}
}
error_term = fAdd(fNegativeOne, value);
return (fAdd(solution, error_term));
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Eric Huang | 201 | 97.57% | 1 | 33.33% |
| Nils Wallménius | 5 | 2.43% | 2 | 66.67% |
| Total | 206 | 100.00% | 3 | 100.00% |
static fInt fDecodeLinearFuse(uint32_t fuse_value, fInt f_min, fInt f_range, uint32_t bitlength)
{
fInt f_fuse_value = Convert_ULONG_ToFraction(fuse_value);
fInt f_bit_max_value = Convert_ULONG_ToFraction((uPow(2, bitlength)) - 1);
fInt f_decoded_value;
f_decoded_value = fDivide(f_fuse_value, f_bit_max_value);
f_decoded_value = fMultiply(f_decoded_value, f_range);
f_decoded_value = fAdd(f_decoded_value, f_min);
return f_decoded_value;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Eric Huang | 75 | 98.68% | 1 | 50.00% |
| Nils Wallménius | 1 | 1.32% | 1 | 50.00% |
| Total | 76 | 100.00% | 2 | 100.00% |
static fInt fDecodeLogisticFuse(uint32_t fuse_value, fInt f_average, fInt f_range, uint32_t bitlength)
{
fInt f_fuse_value = Convert_ULONG_ToFraction(fuse_value);
fInt f_bit_max_value = Convert_ULONG_ToFraction((uPow(2, bitlength)) - 1);
fInt f_CONSTANT_NEG13 = ConvertToFraction(-13);
fInt f_CONSTANT1 = ConvertToFraction(1);
fInt f_decoded_value;
f_decoded_value = fSubtract(fDivide(f_bit_max_value, f_fuse_value), f_CONSTANT1);
f_decoded_value = fNaturalLog(f_decoded_value);
f_decoded_value = fMultiply(f_decoded_value, fDivide(f_range, f_CONSTANT_NEG13));
f_decoded_value = fAdd(f_decoded_value, f_average);
return f_decoded_value;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Eric Huang | 109 | 99.09% | 1 | 50.00% |
| Nils Wallménius | 1 | 0.91% | 1 | 50.00% |
| Total | 110 | 100.00% | 2 | 100.00% |
static fInt fDecodeLeakageID (uint32_t leakageID_fuse, fInt ln_max_div_min, fInt f_min, uint32_t bitlength)
{
fInt fLeakage;
fInt f_bit_max_value = Convert_ULONG_ToFraction((uPow(2, bitlength)) - 1);
fLeakage = fMultiply(ln_max_div_min, Convert_ULONG_ToFraction(leakageID_fuse));
fLeakage = fDivide(fLeakage, f_bit_max_value);
fLeakage = fExponential(fLeakage);
fLeakage = fMultiply(fLeakage, f_min);
return fLeakage;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Eric Huang | 77 | 98.72% | 1 | 50.00% |
| Nils Wallménius | 1 | 1.28% | 1 | 50.00% |
| Total | 78 | 100.00% | 2 | 100.00% |
static fInt ConvertToFraction(int X) /*Add all range checking here. Is it possible to make fInt a private declaration? */
{
fInt temp;
if (X <= MAX)
temp.full = (X << SHIFT_AMOUNT);
else
temp.full = 0;
return temp;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Eric Huang | 38 | 97.44% | 1 | 50.00% |
| Nils Wallménius | 1 | 2.56% | 1 | 50.00% |
| Total | 39 | 100.00% | 2 | 100.00% |
static fInt fNegate(fInt X)
{
fInt CONSTANT_NEGONE = ConvertToFraction(-1);
return (fMultiply(X, CONSTANT_NEGONE));
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Eric Huang | 27 | 96.43% | 1 | 50.00% |
| Nils Wallménius | 1 | 3.57% | 1 | 50.00% |
| Total | 28 | 100.00% | 2 | 100.00% |
static fInt Convert_ULONG_ToFraction(uint32_t X)
{
fInt temp;
if (X <= MAX)
temp.full = (X << SHIFT_AMOUNT);
else
temp.full = 0;
return temp;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Eric Huang | 37 | 97.37% | 1 | 50.00% |
| Nils Wallménius | 1 | 2.63% | 1 | 50.00% |
| Total | 38 | 100.00% | 2 | 100.00% |
static fInt GetScaledFraction(int X, int factor)
{
int times_shifted, factor_shifted;
bool bNEGATED;
fInt fValue;
times_shifted = 0;
factor_shifted = 0;
bNEGATED = false;
if (X < 0) {
X = -1*X;
bNEGATED = true;
}
if (factor < 0) {
factor = -1*factor;
bNEGATED = !bNEGATED; /*If bNEGATED = true due to X < 0, this will cover the case of negative cancelling negative */
}
if ((X > MAX) || factor > MAX) {
if ((X/factor) <= MAX) {
while (X > MAX) {
X = X >> 1;
times_shifted++;
}
while (factor > MAX) {
factor = factor >> 1;
factor_shifted++;
}
} else {
fValue.full = 0;
return fValue;
}
}
if (factor == 1)
return ConvertToFraction(X);
fValue = fDivide(ConvertToFraction(X * uPow(-1, bNEGATED)), ConvertToFraction(factor));
fValue.full = fValue.full << times_shifted;
fValue.full = fValue.full >> factor_shifted;
return fValue;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Eric Huang | 204 | 99.51% | 1 | 50.00% |
| Nils Wallménius | 1 | 0.49% | 1 | 50.00% |
| Total | 205 | 100.00% | 2 | 100.00% |
/* Addition using two fInts */
static fInt fAdd (fInt X, fInt Y)
{
fInt Sum;
Sum.full = X.full + Y.full;
return Sum;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Eric Huang | 29 | 96.67% | 1 | 50.00% |
| Nils Wallménius | 1 | 3.33% | 1 | 50.00% |
| Total | 30 | 100.00% | 2 | 100.00% |
/* Addition using two fInts */
static fInt fSubtract (fInt X, fInt Y)
{
fInt Difference;
Difference.full = X.full - Y.full;
return Difference;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Eric Huang | 29 | 96.67% | 1 | 50.00% |
| Nils Wallménius | 1 | 3.33% | 1 | 50.00% |
| Total | 30 | 100.00% | 2 | 100.00% |
static bool Equal(fInt A, fInt B)
{
if (A.full == B.full)
return true;
else
return false;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Eric Huang | 28 | 96.55% | 1 | 50.00% |
| Nils Wallménius | 1 | 3.45% | 1 | 50.00% |
| Total | 29 | 100.00% | 2 | 100.00% |
static bool GreaterThan(fInt A, fInt B)
{
if (A.full > B.full)
return true;
else
return false;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Eric Huang | 28 | 96.55% | 1 | 50.00% |
| Nils Wallménius | 1 | 3.45% | 1 | 50.00% |
| Total | 29 | 100.00% | 2 | 100.00% |
static fInt fMultiply (fInt X, fInt Y) /* Uses 64-bit integers (int64_t) */
{
fInt Product;
int64_t tempProduct;
bool X_LessThanOne, Y_LessThanOne;
X_LessThanOne = (X.partial.real == 0 && X.partial.decimal != 0 && X.full >= 0);
Y_LessThanOne = (Y.partial.real == 0 && Y.partial.decimal != 0 && Y.full >= 0);
/*The following is for a very specific common case: Non-zero number with ONLY fractional portion*/
/* TEMPORARILY DISABLED - CAN BE USED TO IMPROVE PRECISION
if (X_LessThanOne && Y_LessThanOne) {
Product.full = X.full * Y.full;
return Product
}*/
tempProduct = ((int64_t)X.full) * ((int64_t)Y.full); /*Q(16,16)*Q(16,16) = Q(32, 32) - Might become a negative number! */
tempProduct = tempProduct >> 16; /*Remove lagging 16 bits - Will lose some precision from decimal; */
Product.full = (int)tempProduct; /*The int64_t will lose the leading 16 bits that were part of the integer portion */
return Product;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Eric Huang | 117 | 98.32% | 1 | 33.33% |
| Rex Zhu | 1 | 0.84% | 1 | 33.33% |
| Nils Wallménius | 1 | 0.84% | 1 | 33.33% |
| Total | 119 | 100.00% | 3 | 100.00% |
static fInt fDivide (fInt X, fInt Y)
{
fInt fZERO, fQuotient;
int64_t longlongX, longlongY;
fZERO = ConvertToFraction(0);
if (Equal(Y, fZERO))
return fZERO;
longlongX = (int64_t)X.full;
longlongY = (int64_t)Y.full;
longlongX = longlongX << 16; /*Q(16,16) -> Q(32,32) */
div64_s64(longlongX, longlongY); /*Q(32,32) divided by Q(16,16) = Q(16,16) Back to original format */
fQuotient.full = (int)longlongX;
return fQuotient;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Eric Huang | 84 | 97.67% | 1 | 33.33% |
| Arnd Bergmann | 1 | 1.16% | 1 | 33.33% |
| Nils Wallménius | 1 | 1.16% | 1 | 33.33% |
| Total | 86 | 100.00% | 3 | 100.00% |
static int ConvertBackToInteger (fInt A) /*THIS is the function that will be used to check with the Golden settings table*/
{
fInt fullNumber, scaledDecimal, scaledReal;
scaledReal.full = GetReal(A) * uPow(10, PRECISION-1); /* DOUBLE CHECK THISSSS!!! */
scaledDecimal.full = uGetScaledDecimal(A);
fullNumber = fAdd(scaledDecimal,scaledReal);
return fullNumber.full;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Eric Huang | 58 | 98.31% | 1 | 50.00% |
| Nils Wallménius | 1 | 1.69% | 1 | 50.00% |
| Total | 59 | 100.00% | 2 | 100.00% |
static fInt fGetSquare(fInt A)
{
return fMultiply(A,A);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Eric Huang | 16 | 94.12% | 1 | 50.00% |
| Nils Wallménius | 1 | 5.88% | 1 | 50.00% |
| Total | 17 | 100.00% | 2 | 100.00% |
/* x_new = x_old - (x_old^2 - C) / (2 * x_old) */
static fInt fSqrt(fInt num)
{
fInt F_divide_Fprime, Fprime;
fInt test;
fInt twoShifted;
int seed, counter, error;
fInt x_new, x_old, C, y;
fInt fZERO = ConvertToFraction(0);
/* (0 > num) is the same as (num < 0), i.e., num is negative */
if (GreaterThan(fZERO, num) || Equal(fZERO, num))
return fZERO;
C = num;
if (num.partial.real > 3000)
seed = 60;
else if (num.partial.real > 1000)
seed = 30;
else if (num.partial.real > 100)
seed = 10;
else
seed = 2;
counter = 0;
if (Equal(num, fZERO)) /*Square Root of Zero is zero */
return fZERO;
twoShifted = ConvertToFraction(2);
x_new = ConvertToFraction(seed);
do {
counter++;
x_old.full = x_new.full;
test = fGetSquare(x_old); /*1.75*1.75 is reverting back to 1 when shifted down */
y = fSubtract(test, C); /*y = f(x) = x^2 - C; */
Fprime = fMultiply(twoShifted, x_old);
F_divide_Fprime = fDivide(y, Fprime);
x_new = fSubtract(x_old, F_divide_Fprime);
error = ConvertBackToInteger(x_new) - ConvertBackToInteger(x_old);
if (counter > 20) /*20 is already way too many iterations. If we dont have an answer by then, we never will*/
return x_new;
} while (uAbs(error) > 0);
return (x_new);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Eric Huang | 243 | 99.59% | 1 | 50.00% |
| Nils Wallménius | 1 | 0.41% | 1 | 50.00% |
| Total | 244 | 100.00% | 2 | 100.00% |
static void SolveQuadracticEqn(fInt A, fInt B, fInt C, fInt Roots[])
{
fInt *pRoots = &Roots[0];
fInt temp, root_first, root_second;
fInt f_CONSTANT10, f_CONSTANT100;
f_CONSTANT100 = ConvertToFraction(100);
f_CONSTANT10 = ConvertToFraction(10);
while(GreaterThan(A, f_CONSTANT100) || GreaterThan(B, f_CONSTANT100) || GreaterThan(C, f_CONSTANT100)) {
A = fDivide(A, f_CONSTANT10);
B = fDivide(B, f_CONSTANT10);
C = fDivide(C, f_CONSTANT10);
}
temp = fMultiply(ConvertToFraction(4), A); /* root = 4*A */
temp = fMultiply(temp, C); /* root = 4*A*C */
temp = fSubtract(fGetSquare(B), temp); /* root = b^2 - 4AC */
temp = fSqrt(temp); /*root = Sqrt (b^2 - 4AC); */
root_first = fSubtract(fNegate(B), temp); /* b - Sqrt(b^2 - 4AC) */
root_second = fAdd(fNegate(B), temp); /* b + Sqrt(b^2 - 4AC) */
root_first = fDivide(root_first, ConvertToFraction(2)); /* [b +- Sqrt(b^2 - 4AC)]/[2] */
root_first = fDivide(root_first, A); /*[b +- Sqrt(b^2 - 4AC)]/[2*A] */
root_second = fDivide(root_second, ConvertToFraction(2)); /* [b +- Sqrt(b^2 - 4AC)]/[2] */
root_second = fDivide(root_second, A); /*[b +- Sqrt(b^2 - 4AC)]/[2*A] */
*(pRoots + 0) = root_first;
*(pRoots + 1) = root_second;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Eric Huang | 240 | 99.59% | 1 | 50.00% |
| Nils Wallménius | 1 | 0.41% | 1 | 50.00% |
| Total | 241 | 100.00% | 2 | 100.00% |
/* -----------------------------------------------------------------------------
* SUPPORT FUNCTIONS
* -----------------------------------------------------------------------------
*/
/* Conversion Functions */
static int GetReal (fInt A)
{
return (A.full >> SHIFT_AMOUNT);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Eric Huang | 17 | 94.44% | 1 | 50.00% |
| Nils Wallménius | 1 | 5.56% | 1 | 50.00% |
| Total | 18 | 100.00% | 2 | 100.00% |
static fInt Divide (int X, int Y)
{
fInt A, B, Quotient;
A.full = X << SHIFT_AMOUNT;
B.full = Y << SHIFT_AMOUNT;
Quotient = fDivide(A, B);
return Quotient;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Eric Huang | 46 | 97.87% | 1 | 50.00% |
| Nils Wallménius | 1 | 2.13% | 1 | 50.00% |
| Total | 47 | 100.00% | 2 | 100.00% |
static int uGetScaledDecimal (fInt A) /*Converts the fractional portion to whole integers - Costly function */
{
int dec[PRECISION];
int i, scaledDecimal = 0, tmp = A.partial.decimal;
for (i = 0; i < PRECISION; i++) {
dec[i] = tmp / (1 << SHIFT_AMOUNT);
tmp = tmp - ((1 << SHIFT_AMOUNT)*dec[i]);
tmp *= 10;
scaledDecimal = scaledDecimal + dec[i]*uPow(10, PRECISION - 1 -i);
}
return scaledDecimal;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Eric Huang | 102 | 99.03% | 1 | 50.00% |
| Nils Wallménius | 1 | 0.97% | 1 | 50.00% |
| Total | 103 | 100.00% | 2 | 100.00% |
static int uPow(int base, int power)
{
if (power == 0)
return 1;
else
return (base)*uPow(base, power - 1);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Eric Huang | 35 | 97.22% | 1 | 50.00% |
| Nils Wallménius | 1 | 2.78% | 1 | 50.00% |
| Total | 36 | 100.00% | 2 | 100.00% |
static int uAbs(int X)
{
if (X < 0)
return (X * -1);
else
return X;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Eric Huang | 26 | 96.30% | 1 | 50.00% |
| Nils Wallménius | 1 | 3.70% | 1 | 50.00% |
| Total | 27 | 100.00% | 2 | 100.00% |
static fInt fRoundUpByStepSize(fInt A, fInt fStepSize, bool error_term)
{
fInt solution;
solution = fDivide(A, fStepSize);
solution.partial.decimal = 0; /*All fractional digits changes to 0 */
if (error_term)
solution.partial.real += 1; /*Error term of 1 added */
solution = fMultiply(solution, fStepSize);
solution = fAdd(solution, fStepSize);
return solution;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Eric Huang | 69 | 98.57% | 1 | 50.00% |
| Nils Wallménius | 1 | 1.43% | 1 | 50.00% |
| Total | 70 | 100.00% | 2 | 100.00% |
Overall Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Eric Huang | 2482 | 97.60% | 1 | 16.67% |
| Nils Wallménius | 59 | 2.32% | 3 | 50.00% |
| Rex Zhu | 1 | 0.04% | 1 | 16.67% |
| Arnd Bergmann | 1 | 0.04% | 1 | 16.67% |
| Total | 2543 | 100.00% | 6 | 100.00% |
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.