* @brief Leading zeroes in binary * @details Calculates leading zeros in 128-bit integer * @returns Integer denoting leading zeroes */

* @brief Leading zeroes in binary * @details Calculates leading zeros in 256-bit integer * @returns Integer denoting leading zeroes */

* Main algorithm for finding `FinalState`, given the `InitialState` * @param dist the heuristic finction, defined by the user * @param permi

* @brief * Iterative Dynamic Programming function * @details * Returns whether `s` can be converted to `t` with following rules: * a. Capitalize z

* @brief * Recursive Dynamic Programming function * @details * Returns whether `s` can be converted to `t` with following rules: * a. Capitalize z

* @brief Turn bit on position x to 1s * * @param x position to turn bit on * @returns void */

* @brief Adds an undirected edge from node u to node v in the tree * @param u the node where the edge is from * @param v the node where the

* @brief The main function which implements binary search * @param arr vector to be searched in * @param val value to be searched * @returns @param

* @brief Returns the total capacity of the cache * @return Total capacity of the cache */

* @brief Returns the total capacity of the cache * @return Total capacity of the cache */

* Find the centre and radius of a circle enclosing a set of points.\n * The function returns the radius of the circle and prints the coordinated of

* @brief Performs double hashing to resolve collisions * * @param key key value to apply double-hash on * @param searching `true` to check for conf

* Implements Durand Kerner iterative algorithm to compute all roots of a * polynomial. * * \param[in] coeffs coefficients of the polynomial * \par

Compute eigen values using iterative shifted QR decomposition algorithm as * follows: * 1. Use last diagonal element of A as eigen value approximati

* @brief returns whether the cache is empty or not * @return true if the cache is empty, false otherwise. */

* @brief This function gives the value of f(x) for given x. * @param x value for which we have to find value of f(x). * @return value of f(x) for gi

define \f$f(x)\f$ to find root for */

* @brief Recursively returns the vertex's parent at the root of the tree * @param parent the array that will be checked * @param v vertex to find pa

* @brief Find the component where following node belongs to * @param val parent of val should be found * @return parent of val */

* @brief Checks if the stack is full * * @return true if the stack is full, false otherwise */

* @brief wrapper interface * * @param n number of pairs of parentheses * @return all well-formed pattern of parentheses */

* @param[in] root of the tree * @return difference between height of left and right subtree */

* @brief Function that perfoms depth first search algorithm on graph * and calculated the number of connected components. * * @param adj adjacency

* Convert clock cycle difference to time in seconds * * \param[in] start_t start clock * \param[in] end_t end clock * \returns time difference in

* Convert clock cycle difference to time in seconds * * \param[in] start_t start clock * \param[in] end_t end clock * \returns time difference in

* @brief Get the minima of a function in the given interval. To get the maxima, * simply negate the function. The golden ratio used here is:\f[ * k=

* @brief Get the real root of a function in the given interval. * * @param f function to get root for * @param lim_a lower limit of search window

* @brief Returns the current state of the board */

* The function determines if there is a hamilton's cycle in the graph * * @param routes nxn boolean matrix of \f$[i, j]\f$ where \f$[i, j]\f$ is `tr

* @brief Compute the hash of a value for current chain * * @param x value to compute modulus of * @return modulus of `x` * @note d

* @brief Function imod * Calculates the modular inverse of x with respect to y, x^{-1} \mod y * @param x number * @param y number * @returns the m

* @brief This function must be called after the tree adjacency list and * node values are populated The function initializes the required *

* @brief inorder() function that will perform the inorder traversal * recursively, and return the resultant vector that contain the inorder * traver

List insert a new value at head in list */

* @brief Compute an approximation of an integral using Monte Carlo integration * @details The integration domain [a,b] is given by the pdf. * The pd

* @brief The inverse cumulative distribution function * @details This functions answers the question: Up to how many trials are * needed to

* This function checks if the string passed consists * of only digits. * @param s To be checked if s contains only integers * @returns true if ther

* @brief checks if the queue has no elements * @return true if the queue is empty, false otherwise */

* @brief Check if the sequence is magic * @param s working memory for the sequence * @returns true if it's a magic sequence * @returns false if it'

* @brief Check if pat is prefix of str. * * @param str pointer to some part of the input text. * @param pat the searched pattern. * @param len len

* @brief The main function implements Karatsuba's algorithm for fast * multiplication * @param str1 the input string 1 * @param str2 the input stri

* Apply incremental algorithm with updating neighborhood and learning * rates on all samples in the given datset. * * \param[in] X data set * \par

* Apply incremental algorithm with updating neighborhood and learning rates * on all samples in the given datset. * * \param[in] X data set * \par

* @brief Rotates the bits of a 32-bit unsigned integer * @param n Integer to rotate * @param rotate How many bits for the rotation * @return uint32

* @brief prints given tree in the LevelOrder * @param[in] root of the tree */

Performs linear probing to resolve collisions * @param key key value to hash * @return hash value of the key */

* @brief computes the length of the longest common string created from input * strings * @details has O(str_a.size()*str_b.size()) time and memory c

* @brief postorder function that will perform the postorder traversal * recursively, and return the result vector that contain the postorder * trave

* @brief preorder function that will perform the preorder traversal * recursively, and return the resultant vector that contain the preorder * trave

* @brief The probability density function * @details As we use the first definition of the geometric series (1), * we are doing k - 1 failed

push byte to stack variable

* @brief query function * @param beg begin of the interval to sum * @param end end of the interval to sum * @returns sum of the range [beg, end]

* @brief Make a range query from node label l to node label r * @param l node label where the path starts * @param r node label where the pa

* @brief Queries the sparse table for the value of the interval [l, r] * (i.e. from l to r inclusive). * @param l the left index of the rang

* @brief To remove the element from the list * @param val element that will be removed * @returns void */

* Reverses the Binary Tree */

* @brief the Runge Kutta method finds the value of integration of a function in * the given limits. the lower limit of integration as the initial val

* @brief Tests the sampling method of the geometric distribution * @details Draws 1000000 random samples and estimates mean and variance * These sho

* Save a given n-dimensional data martix to file. * * \param[in] fname filename to save in (gets overwriten without confirmation) * \param[in] X ma

* @brief Set the values for all the nodes * @param node_val a vector of size n, with all the node values where, n is * the number of nodes

Display the towers */

* @brief Function to sieve out the primes * @details * This function finds all the primes between 2 and N using the Sieve of * Eratosthenes algorit

* @brief The standard deviation of a geometrically distributed random * variable X * @returns \sigma = \sqrt{V[X]} */

* @brief The stoogeSort() function is used for sorting the array. * @param L - vector of values (int) to be sorted in in place (ascending order) *

Wrapper to run tests using both recursive and iterative implementations. * The checks are only valid in debug builds due to the use of `assert()` *

* Test implementation of shell_sort on float arrays by comparing results * against std::qsort. */

* Test implementation of shell_sort on integer arrays by comparing results * against std::qsort. */

* @brief Function to get the topological sort of the graph * @param g Graph object * @returns A vector containing the topological order of nodes */

* @brief Update the value at a node * @param p the node to be udpated * @param v the update value * @returns void */

* function returns the integer value stored in the link. * @returns the integer value stored in the link. */

* @brief Function that checks if the string passed in param can be * segmented into the strings present in the vector. * In others words, it checks

* @brief Constructs the initial segment tree * * @param arr input to construct the tree out of * @param segtree the segment tree * @param

* @brief FastFourierTransform is a recursive function which returns list of * complex numbers * @param p List of Coefficents in form of complex nu

* @brief Get leftmose child of the current node * @return the leftmost child */

* @brief Get max item (rightmost) in the current node * @return max item */