* Update weights of the SOM using Kohonen algorithm * * \param[in] X data point * \param[in,out] W weights matrix * \param[in,out] D temporary vec

return data variance computed till last sample */

* @brief Parameterized constructor for AyStarSearch * @param initial denoting initial state of the puzzle * @param final denoting final stat

indicator whether list is sorted or not * @brief Search an element in the list using binarySearch. * @param dataArr list * @param first poin

* @brief BitSet class constructor * @param initSize amount of blocks, each contain sizeof(std::size_t) bits */

* @brief Creates an empty CircularLinkedList. */

* \brief Complex Constructor which initialises our complex number. * \details * Complex Constructor which initialises the complex number whi

* Constructor of given class * * @param pointList list of all points in the space * @param n number of points i

* @brief Function recursively deletes the substring character by * character iterating through the string to be deleted. It traverses till the * e

* @brief Recursive release the tree * @param tree root node of the tree to delete */

* Constructor for neural_network::layers::DenseLayer class * @param neurons number of neurons * @param activation activation function for la

* @brief Default constructor for the DigitSeparation class. */

* @brief Default constructor for EightPuzzle */

* @brief Get the max item of the tree * @param tree the tree we will get item from * @return max item of the tree */

* @brief Get the min item of the tree * @param tree the tree we will get item from * @return min item of the tree */

* @brief Constructs a graph * @param V number of vertices of the graph */

* @brief Constructor that initializes the graph on creation * @param size number of vertices of the graph */

* @brief Constructor for the Graph class * @param nodes Number of nodes in the graph */

* \brief Populate the adjacency list for each vertex in the graph. * Assumes that evey edge is a pair of valid vertex indices. * * @par

Constructs a graph with V vertices and E edges

Constructs a graph with V vertices and E edges

* @brief Constructor for initialization * @param m is the number of vertices on left side of Bipartite Graph * @param n is the number of vertices on

* @brief Class parameterized constructor. Resizes the and initilizes the * data members. * @param nodes the total number of nodes in the tre

* @brief Default constructor */

* @brief A insert implementation of post-merge * @param item item to insert */

* @brief A insert implementation of pre-split * @param item item to insert */

* @brief Construct a new Knn object. * @details Using lazy-learning approch, just holds in memory the dataset. * @param X attributes vector

* @brief Constructor, Initialize with minFreq and _capacity. * @param _capacity Total capacity of the cache. */

* @brief Constructor, Initialize the head and tail pointers to nullptr and * initialize the _capacity of the cache * @param _capacity Total

* @brief Constructor, Initialize thee LRU class with page frame. * @param pf Page frame or total size of cache. * */

* @brief Do the actual left rotate operation * * Given parent node, and the pivot item index, the left rotate operation is * uniquely identified. T

* @brief Search an element using linear search * @param dataArr list * @param val element that will be searched * @return index of elem

< pointer to the next node

* \brief Stores the tree and precomputs "up lifts". * @param tree_ rooted tree. */

* @brief Merge the item at index of the parent node, and its left and right * child * * the left and right child node must be 2-node. The 3 items w

* @brief A helper function used during post-merge insert * * When the inserting leads to overflow, it will split the node to 1 parent * and 2 child

* @brief Merge node to a not-full target node * * Since the target node is not-full, no overflow will happen. So we have * nothing to return. * *

Constructor: Builds a heap from a given array a[] of given size * \param[in] capacity initial heap capacity */

A recursive method to heapify a subtree with the root at given index * This method assumes that the subtrees are already heapified */

* Constructor for queue. */

* @brief constructs an NCRModuloP object allowing to compute (nCr)%p for * inputs from 0 to size */

To store layers * Private Constructor for class NeuralNetwork. This constructor * is used internally to load model. * @param config vector c

* Creates node with provided key, level and value * @param key is number that is used for comparision * @param level is the maximum level no

* @brief Node constructor * @param item the first value we insert to the node */

< The Node's successor * @brief Creates a new Node with some initial data * @param _data Value of Node */

< The Node's right child * @brief Creates a new Node with some initial data */

construct a point * \param [in] a absicca (default = 0.0) * \param [in] b ordinate (default = 0.0) */

* @brief Print the tree to a dot file. You can convert it to picture with * graphviz * @param ofs output file stream to print to * @param node curr

* @brief Main function implement the pre-merge remove operation * @param node the tree to remove item from * @param item item to remove * @return t

* @brief Do the actual right rotate operation * * Given parent node, and the pivot item index, the right rotate operation * is uniquely identified.

* \brief Constructs the tree by calculating parent for every vertex. * Assumes a valid description of a tree is provided. * * @param un

* @brief Class parameterized constructor. Resizes the and initilizes the * data members. * @param nodes the total number of nodes in the tre

* @brief Function to display the 3 suggestions with highest frequency * of search hits * @param suggestions a max heap that contains pairs of (fre

* Skip List constructor. Initializes header, start * Node for searching in the list */

* @brief A helper solution: launches when a solution for AyStarSearch * is found * @param FinalState the pointer to the obtained final state

* @brief Split a 4-node to 1 parent and 2 children, and return the parent * node * @param node the node to split, it must be a 4-node * @return spl

* @brief Constructs a new Stack object * * @param size Maximum size of the stack */

* @brief Recursive function to suggest all the entries of trie * which have a given common prefix * @param new_root pointer pointing to the node c

* @brief Recursive function to suggest most frequently * searched entries of trie which have a given common prefix * @param new_root pointer point

< The number of copies per node * @brief Initialization */

* @brief Class parameterized constructor, resizes the and initializes the * data members * @param nodes the total number of nodes in the tre

< Constructor

constructor to initialise the root of the trie.

* @brief A handy function to try if we can do a left rotate to the target * node * * Given two node, the parent and the target child, the left rota

* @brief A handy function to try if we can do a right rotate to the target * node * * Given two node, the parent and the target child, the right ro

* @brief Constructs a WindowedMedian object * @param windowSize Sliding window size */

* @brief Get integer from given string. * @details Create an integer from a given string * @param str integer string, can be hexadecimal (st

* @brief Erase a value from the specified subtree (internal method) * @param x Erase from the subtree of node x (Usually x=root) * @param k

* @brief Find the KTH largest value (internal method) * @param x Query the subtree of node x (Usually x=root) * @param k The queried rank

* @brief Query the rank of specified element (internal method) * @param x Query the subtree of node x (Usually x=root) * @param k The querie

* @brief Insert a value into the specified subtree (internal method) * @param x Insert into the subtree of node x (Usually x=root) * @param