* @brief Function printMessage * Responsible for printing the auxiliary message * @param msg msg with board */

Fucntion to calculate min of values a and b

* The function will create a polynomial * @param poly stores the address of the polynomial being created * @param coef contains the coefficient of t

* This function returns the length the Vector. * @params Vector* (a pointer to the Vector struct) * @returns: int */

* @param n index of number in Fibonacci sequence * @returns nth value of fibonacci sequence for all n >= 0 */

* @brief Testing helper function * @param regex the regular expression to be used * @param string the string to match against * @param expected exp

* \brief Helper function to generate a random number in a given interval. * \details * \n Steps: * 1. `r1 = rand() % 100` gets a random number betw

* Helper function to generate a random number in a given interval. * \n Steps: * 1. `r1 = rand() % 100` gets a random number between 0 and 99 * 2.

* @brief adds a transition rule to a NFA * @param nfa target NFA * @param rule the rule to be added * @param loc which state this rule should be ad

* @brief creates and initializes a transition rule * @param state transition target * @param c transition condition * @returns pointer to the newly

* @brief Converts the given binary number * to its equivalent decimal number/value. * @param number The binary number to be converted * @returns Th

* function to display matrix on stdout */

* The function will display the polynomial * @param poly first term of the polynomial to be displayed * @returns none */

* @brief Frees memory space * @param poly first term of polynomial * @returns void */

* @brief Prints one character on screen * @param s character to be printed on the screen */

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

* @brief blake2b mixing function G * * Shuffles values in block v depending on * provided indeces a, b, c, and d. x and y * are also mixed into th

* Function: exponential_search * \brief algorithm that search the index of the given item * \details recursive function that take an array and quick

* @brief Function printsTray * Responsible for printing the visual board for the user * @param mat Matrix * @param stage game step */

* Push data onto the stack. */

* Operator to print the weights of the model * @param ada model for which the values to print * @returns pointer to a NULL terminated string of form

* the function take a string and return an integer * \param[out] str pointer to a char address */

Function that returns the pointer to (x, y, z) ^th location in the * linear 3D array given by: * \f[ * X_{i,j,k} = i\times M\times N + j\times N +

* @brief Used to get the size of the Stack or the number of elements present in * the Stack. * * @param ptr Stack pointer * @return int size of st

* @brief Tests a given string * * @param s string to be tested * @param a value of key.a * @param b value of key.b * * @returns void */

* @brief decimal_to_anybase ensure the validity of the parameters and convert any unsigned integers into any ascii positive base * @param nb to conve

* @brief To insert a new process in the queue * @param root pointer to the head of the queue * @param id process ID * @param at arrival time * @pa

* @brief helper function to determine whether a character should be * considered a character literal * @param ch the character to be tested

* Pop data from the stack */

* @brief Function positionBoat * Responsible for placing the boats on the board, according to the size. * @param mat board * @param boat boat */

* @brief Function printPositioning * Responsible for printing messages for positioning boats on the board; of * player 1 and 2 * @param Player numb

* Create the distance matrix or * [U-matrix](https://en.wikipedia.org/wiki/U-matrix) from the trained weights * and save to disk. * * \param [in]

* @brief utility function to create a subString * @param str target string * @param begin starting index, inclusive * @param end ending index, incl

* @brief Convert roman numeral symbol to a decimal value helper function * @param symbol Roman numeral char * @returns Integer of decimal value for

check if vertex is valid in a graph

* predict the output of the model for given set of features * * \param[in] ada adaline model to predict * \param[in] x input vector * \param[out]

This function does Binary search for `x` in `i`-th row from `j_low` to * `j_high`. * @param mat 2D matrix to search within * @param i row to search

* @brief Function to graph (x,y) points on the OpenGL graphics window. * * @param x array containing absicca of points (must be pre-allocated) * @p

* @brief The function that will return current size of list * * @param head start pointer of list * @return int size of list */

* @brief perform one single check on the result of the algorithm with provided * parameters and expected output * * @param a first paramater for Eu

* @brief Self-test implementations * @returns void */

* Compute the norm a vector. * @f[\lVert\vec{a}\rVert = \sqrt{\vec{a}\cdot\vec{a}} @f] * @param[in] a input vector * @returns norm of the given vec

Push an element into the stack */

* @brief 32-bit Adler algorithm implementation * * @param s NULL terminated ASCII string to hash * @return 32-bit hash result */

* @brief Self-test implementations * @returns void */

* @brief blake2b hash function * * This is the front-end function that sets up the argument for BLAKE2B(). * * @param message the message to be ha

* create a textual form of complex number * \param[in] x point at which to evaluate the polynomial * \returns pointer to converted string */

* @brief 32-bit CRC algorithm implementation * * @param s NULL terminated ASCII string to hash * @return 32-bit hash result */

* @brief Create a list node * @param data the data that the node initialises with * @return ListNode* pointer to the new

Return the number of vertices that v is connected to

* @brief Deletion by position into the list function * @param list a doubly linked List * @param pos a position into the list for value

* @brief DJB2 algorithm implementation * * @param s NULL terminated string to hash * @return 64-bit hash result */

* @brief Determines the nth Fibonacci term * @param number - n in "nth term" and it can't be negative as well as zero * @return nth term in unsigned

* @brief Find index of or value in an array * * @param [in,out] p array to search and update * @param x value to search * @return value at the ind

A utility function to find set of an element i (uses path compression technique)

* Note: The returned array must be malloced, assume caller calls free(). */

* This function get the item at the specified index of the Vector. * @params Vector* (a pointer to the Vector struct) * @params int (the index t

adler_32 hash

/////////////////////////////////////////////////////////////

* @brief Insertion by position into the list function * @param list a doubly linked List * @param value a value to be inserted into the l

* Check given number whether is palindrome number or not * @param number number to check * @return `true` if given number is palindrome number * @r

Check if the given number is prime */

Left Rotate

* @brief Update table by placing an `X` * * @param m location to place `X` * * @returns None */

* @brief Function to pop from the stack * @returns popped character */

Right Rotate

* @brief SDBM algorithm implementation * * @param s NULL terminated string to hash * @return 64-bit hash result */

* @brief Root-finding method for a continuous function given two points * @param x0 One of the starting secant points * @param x1 One of the startin

* Query the segment tree * This function helps in range query of segment tree * This function assumes that the given range is valid * Performs the

* @brief Utility function to search for an element in the array and return the index of the element * @details * The so-called "sentinel" is to use

* This function sets an item at the specified index of the Vector. * @params Vector* (a pointer to the Vector struct) * @params int (the index t