math Namespace Reference

for std::vector More...

Functions
uint64_t	lcmSum (const uint16_t &num)
bool	magic_number (const uint64_t &n)
uint64_t	power (uint64_t a, uint64_t b, uint64_t c)
	This function calculates a raised to exponent b under modulo c using modular exponentiation. More...
uint64_t	binomialCoeffSum (uint64_t n)

Detailed Description

for std::vector

for assert

for io operations

for std::cin and std::cout for assert

Mathematical algorithms

for assert

Mathematical algorithms

for std::cin and std::cout

Mathematical algorithms

Function Documentation

binomialCoeffSum()

uint64_t math::binomialCoeffSum

(

uint64_t

n

)

Function to calculate sum of binomial coefficients

Parameters

n

number

Returns

Sum of binomial coefficients of number

    { 
        // Calculating 2^n  
        return (1 << n); 
    }

lcmSum()

uint64_t math::lcmSum

(

const uint16_t &

num

)

Function to compute sum of euler totients in sumOfEulerTotient vector

Parameters

num	input number

Returns

int Sum of LCMs, i.e. ∑LCM(i, num) from i = 1 to num

                                         {
   
        uint64_t i=0, j=0;
        std::vector <uint64_t> eulerTotient(num+1);
        std::vector <uint64_t> sumOfEulerTotient(num+1);
   
        // storing initial values in eulerTotient vector
        for(i=1; i<=num; i++) {
            eulerTotient[i] = i;
        }
 
        // applying totient sieve  
        for(i=2; i<=num; i++) {
            if(eulerTotient[i] == i) {
                for(j=i; j<=num; j+=i) {
                    eulerTotient[j] = eulerTotient[j]/i;
                    eulerTotient[j] = eulerTotient[j]*(i-1);
                }
            }
        }
 
        // computing sum of euler totients
        for(i=1; i<=num; i++) {
            for(j=i; j <=num; j+=i) {
                sumOfEulerTotient[j] += eulerTotient[i]*i;
            }
        }
    
        return ((sumOfEulerTotient[num] + 1 ) * num) / 2;
    }

magic_number()

bool math::magic_number

(

const uint64_t &

n

)

Function to check if the given number is magic number or not.

Parameters

n	number to be checked.

Returns

if number is a magic number, returns true, else false.

                                     {
    if (n <= 0) {
        return false;
    }
    // result stores the modulus of @param n with 9
    uint64_t result = n % 9;
    // if result is 1 then the number is a magic number else not
    if (result == 1) {
        return true;
    } else {
        return false;
    }
}

power()

uint64_t math::power	(	uint64_t	a,
		uint64_t	b,
		uint64_t	c
	)

This function calculates a raised to exponent b under modulo c using modular exponentiation.

Parameters

a	integer base
b	unsigned integer exponent
c	integer modulo

Returns

a raised to power b modulo c

Initialize the answer to be returned

Update a if it is more than or equal to c

In case a is divisible by c;

If b is odd, multiply a with answer

b must be even now

b = b/2

                                                   {
    uint64_t ans = 1;  /// Initialize the answer to be returned
    a = a % c;         /// Update a if it is more than or equal to c
    if (a == 0) {
        return 0;  /// In case a is divisible by c;
    }
    while (b > 0) {
        /// If b is odd, multiply a with answer
        if (b & 1) {
            ans = ((ans % c) * (a % c)) % c;
        }
        /// b must be even now
        b = b >> 1;  /// b = b/2
        a = ((a % c) * (a % c)) % c;
    }
    return ans;
}

Here is the call graph for this function: