* @brief Function validEntryLineColumn * Responsible for validating entries, for positioning boats * @param line matrix row * @param column matrix

* Compute dot product of two vectors of equal lengths * * If \f$\vec{a}=\left[a_0,a_1,a_2,...,a_L\right]\f$ and * \f$\vec{b}=\left[b_0,b_1,b_1,...,

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

Push an element into top of the list */

Convert list to array */

Print all elements in the stack */

* Update the weights of the model using supervised learning for an array of * vectors. * * \param[in] ada adaline model to train * \param[in] X ar

Boyer Moore Search algorithm */

* @brief To calculate the average completion time of all the processes * @param root pointer to the head of the queue * @returns float average compl

* @brief Convert celsius to Fahrenheit * @param celsius Temperature in degrees celsius double * @returns Double of temperature in degrees Fahrenheit

* @brief Closes the file after reading or writing * @param file pointer to the file to be closed * @returns void */

* @brief helper function to determine an element's presence in an array * @param states target array * @param len length of the target array * @par

* @brief Function to convert infix expression to postfix expression * @param inf the input infix expression * @returns output postfix expression */

* @brief Create list function, a new list containing one node will be created * @param value a value to be saved into the first list node

delete dynamically allocated memory * \param[in] ada model from which the memory is to be freed. */

* @brief recursively destroys a NFA * @param nfa pointer to the object to be deleted * @returns void */

Function to display square matrix */

* Obtain the dot product of two 3D vectors. * @f[ * \vec{a}\cdot\vec{b}=a_xb_x + a_yb_y + a_zb_z * @f] * @param[in] a first vector * @param[in] b

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

* @brief Ends program due to an error * @param errorMessage the error message to be printed * @returns void */

--------------------------------------------------------------------------*/

* @brief Continuous function for which we want to find the root * @param x Real input variable * @returns The evaluation result of the function usin

* @brief Continuous function for which we want to find the root * @param x Real input variable * @returns The evaluation result of the function usin

Returns the id of triplet which the point (i, j) belongs to

* 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

* This function initilaizes the vector and gives it a size of 1 * and initializes the first index to 0. * @params Vector* (a pointer to the Vector s

* Converts an integer value to a null-terminated string using the specified * base and stores the result in the array given by str parameter. * @par

* Returns 1 if stack is empty, returns 0 if not empty. */

* @brief The function is used to check whether the stack is empty or not and * return true or false accordingly. * * @param ptr Stack pointer * @r

* @brief Function to join * @param [in,out] p array to join in * @param x value or index to join to * @param y value or index to join from */

* @brief Implement Jump-search algorithm * * @param [in] arr Array to search within * @param x value to search for * @param n length of array * @

* 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 To length process queue * @param root pointer to the head of the queue * @returns int total length of the queue */

* min_printf is the function same as printf * @param fmt format of string * @param ... arguments passed according to the format */

Naive Pattern Search algorithm (brute force way) */

Create a new node

* Default constructor * \param[in] num_features number of features present * \param[in] eta learning rate (optional, default=0.1) * \returns new ad

* @brief Convert octal number to hexadecimal number * dynamically allocated memory needs to be freed by the calling the function free * @param octal

* @brief To retrieve or fetch the first element of the Stack or the element * present at the top of the Stack. * * @param ptr Stack pointer * @ret

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

* @brief pop function * @param *p : used as a pointer variable of stack * @returns x or \0 on exit */

* @brief Function printMessageScore * Responsible for printing the score messages * @param pts1 player 1 score * @param pts2 player 2 score */

* @details * The algorithm here is to first convert the number into * string and then reverse it be passing it to reverse_str function * and then

Kabin-Karp algorithm for pattern searching d: radix-d notation. Ex. number from 0->9, d = 10 q: prime number for hashing */

* @brief Converts roman numerals into a decimal number * @param input Input roman numeral as a C-string * @returns The converted number in decimal f

* @brief Apply the ROT13 cipher * @param s contains the string to be processed */

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

* Returns the size of the stack. */

* @brief Swapped two numbers using pointer * @param first pointer of first number * @param second pointer of second number */

* @brief moves a NFA forward * @param nfa target NFA * @param input the character to be fed into the NFA * @returns void */

* @brief compression function F * * Securely mixes the values in block m into * the state vector h. Value at v[14] is also * inverted if this is t

Initial list */

Utility function to get the maximum value in ar[]

insert an int at end of queue

Pop an element out of the stack */

Return size of the stack */

* @brief Function to get top of the stack * @returns top of stack */

Creates a unidirectional graph

* @brief addMemInfo function add a memory allocation in the memoryInfo list. * @details This function creates a new element and add it on top of the

* @brief adds a state to a NFA * @param nfa target NFA * @param state the NFA state to be added * @returns void */

* @brief Adds word (node) to the correct position in tree * @param word word to be inserted in to the tree * @param currentNode node which is being

* Function that allocates memory to add another * digit at the MSB */

Recursive implementation * \param[in] arr array to search * \param l left index of search range * \param r right index of search range * \param x

Iterative implementation * \param[in] arr array to search * \param l left index of search range * \param r right index of search range * \param x

* @brief Root-finding method for a continuous function given two values with * opposite signs * @param x_left Lower endpoint value of the interval

* @brief calculates the value of x or y and push those into the small 'queues' * * @details Both x and y are found by taking their value from 2 iter

* @brief Implementation of win conditon checker for 'X' or 'O' whenever the table is updated * * @returns -1: if 'X' won * @returns -2: if 'O' won

Allocate memory for the entire graph structure

Memory for a graph node

Allocate memory for a node