* @brief A Test to check an simple case * @returns void */

< Use the BinaryTree * @brief A Test to check an edge case (single element reversal) */

* @brief A Test to check an edge case (two empty arrays) * @returns void */

Test implementation for 10! Result must be 3628800. * @returns True if test pass else False */

* Function for testing the sum_of_digits() function with a * first test case of 119765 and assert statement. */

* @brief Self test 1 - using 3x3 randomly generated key * * @param text string to encrypt and decrypt */

* test function to compute eigen values of a 2x2 matrix * \f[\begin{bmatrix} * 5 & 7\\ * 7 & 11 * \end{bmatrix}\f] * which are approximately, {15

* Test LU decomposition * \todo better ways to self-check a matrix output? */

* @brief Test function to find minima for the function * \f$f(x)= (x-2)^2\f$ * in the interval \f$[1,5]\f$ * \n Expected result = 2 */

* Self test the algorithm by checking the roots for \f$x^2+4=0\f$ to which the * roots are \f$0 \pm 2i\f$ */

* @brief Test function to find root for the function * \f$f(x)= (x-2)^2\f$ * in the interval \f$[1,5]\f$ * \n Expected result = 2 */

* test function to predict points in a 2D coordinate system above the line * \f$x+3y=-1\f$ as +1 and others as -1. * Note that each point is defined

Test that creates a random set of points distributed in 4 clusters in * 3D space and trains an SOM that finds the topological pattern. The following

Test that creates a random set of points distributed *near* the locus * of the [Lamniscate of * Gerono](https://en.wikipedia.org/wiki/Lemniscate_of_

Test case: result should be: * \n Circle with * \n radius 1.4142135623730951 * \n centre at (1.0, 1.0) */

* @brief Test the computed postorder with the actual postorder. * @param binaryTree instance of BinaryTree class * @param root head/root node of a

* @brief 2nd test-case * @returns void */

* @brief Self-test implementation #2 * @returns void *******************************************************************************/

* @brief Function to test sorting algorithm, one element * @returns void */

* @brief Self-implementations, 2nd test * @returns void */

* @brief Self-implementations, 2nd test * @returns void */

* @brief simple test to insert continuous number of range [0, n), and print * the tree * @param n upper bound of the range number to insert */

* this test is testing if ::hamilton_cycle returns `false` for * \n graph:<pre> * 1 -> 2 -> 3 * | * V * 4</pre> * @return Non

* @brief A Test to check a few values * @returns void */

* @brief A Test to check an edge case (one empty array) * @returns void */

* @brief A Test to check an empty vector * @returns void */

* @brief A Test to check an empty vector * @returns void */

* @brief A Test to check an edge case (NULL root element) */

* @brief A Test to check an edge case (one empty array) * @returns void */

Test implementation for 100! The result is the 156 digit number: * ``` * 9332621544394415268169923885626670049071596826438162146859296389521759 * 9

* Function for testing the sum_of_digits() function with a * second test case of -12256 and assert statement. */

* @brief Self test 2 - using 8x8 randomly generated key * * @param text string to encrypt and decrypt */

* test function to compute eigen values of a 2x2 matrix * \f[\begin{bmatrix} * -4& 4& 2& 0& -3\\ * 4& -4& 4& -3& -1\\ * 2& 4& 4& 3& -3\\ * 0& -3&

* Test determinant computation using LU decomposition */

* @brief Test function to find *maxima* for the function * \f$f(x)= x^{\frac{1}{x}}\f$ * in the interval \f$[-2,10]\f$ * \n Expected result: \f$e\a

* Self test the algorithm by checking the roots for \f$0.015625x^3-1=0\f$ to * which the roots are \f$(4+0i),\,(-2\pm3.464i)\f$ */

* @brief Test function to find root for the function * \f$f(x)= x^{\frac{1}{x}}\f$ * in the interval \f$[-2,10]\f$ * \n Expected result: \f$e\appro

* test function to predict points in a 3D coordinate system lying within the * sphere of radius 1 and centre at origin as +1 and others as -1. Note t

Test that creates a random set of points distributed in eight clusters in * 3D space and trains an SOM that finds the topological pattern. The follow

Test that creates a random set of points distributed in six clusters in * 3D space. The following * [CSV](https://en.wikipedia.org/wiki/Comma-separa

Test case: result should be: * \n Circle with * \n radius 1.821078397711709 * \n centre at (2.142857142857143, 1.7857142857142856) * @todo This te

* @brief Test the computed inorder with the actual inorder. * @param binaryTree instance of BinaryTree class * @param root head/root node of a tre

* @brief 3rd test-case * @returns void */

* @brief Self-test implementation #3 * @returns void *******************************************************************************/

* @brief Function to test sorting algorithm, repeating elements * @returns void */

* this test is testing if ::hamilton_cycle returns `true` for * clique with 4 vertices * @return None */

* @brief A Test to check an input array * @returns void */

* @brief A Test to check correct functionality with a simple test case * @returns void */

* @brief A Test to check an invalid shift value * @returns void */

* @brief A Test to check an invalid shift value * @returns void */

* @brief A Test to check correct reversal of a Binary Tree */

* @brief A Test to check correct functionality with a simple test case * @returns void */

* @brief Test function to find *maxima* for the function * \f$f(x)= \cos x\f$ * in the interval \f$[0,12]\f$ * \n Expected result: \f$\pi\approx 3.

* @brief Test function to find *maxima* for the function * \f$f(x)= \cos x\f$ * in the interval \f$[0,12]\f$ * \n Expected result: \f$\pi\approx 3.

* @brief Test the computed preorder with the actual preorder on negative value. * @param binaryTree instance of BinaryTree class * @param root hea

* @brief A Test to check using a specific Node as the starting point * @returns void */

* @brief A Test to check correct functionality with duplicate values * @returns void */

* @brief A Test to check a very large input * @returns void */

* @brief A Test to check a very large input * @returns void */

* @brief A Test to check correct functionality with duplicate values * @returns void */

* @brief Test the computed postorder with the actual postorder on negative * value. * @param binaryTree instance of BinaryTree class * @param ro

* @brief A Test to check an empty list * @returns void */

* @brief A Test to check correct functionality with a harder test case * @returns void */

* @brief A Test to check a shift of zero * @returns void */

* @brief A Test to check a shift of zero * @returns void */

* @brief A Test to check correct functionality with a harder test case * @returns void */

* @brief Test the computed inorder with the actual inorder on negative value. * @param binaryTree instance of BinaryTree class * @param root head/

* @brief A Test to check correct functionality with an array sorted using * std::sort * @returns void */

* @brief A Test to check correct functionality with an array sorted using * std::sort * @returns void */

* @brief A simple test case * The assert statement will check expected hist and miss to resultant hits and * miss * @returns void * */

* Test implementations * @returns none */

* Test function 1 with unsorted array * {8, 3, 2, 7, 4, 6, 8} * @returns none */

* @brief A test case contains hits more than cache size * The assert statement will check expected hist and miss to resultant hits and * miss * @re

* Second test implementations * @returns void */

* Test function 2 with unsorted array * {802, 630, 20, 745, 52, 300, 612, 932, 78, 187} * @returns none */

Creates a random set of points distributed in four clusters in * 3D space with centroids at the points * * \f$(0,5, 0.5, 0.5)\f$ * * \f$(0,5,-0.5,

* @brief A simple test case * The assert statement will check expected hist and miss to resultant hits and * miss * @returns void * */

* Third test implementations * @returns void */

* Test function 1 with unsorted array * {11,13,12,14} * @returns none */

Creates a random set of points distributed in six clusters in * 3D space with centroids at the points * * \f${0.5, 0.5, 0.5}\f$ * * \f${0.5, 0.5, -

Creates a random set of points distributed in four clusters in * 3D space with centroids at the points * * \f$(0,5, 0.5, 0.5)\f$ * * \f$(0,5,-0.5,

Creates a random set of points distributed in four clusters in * 3D space with centroids at the points * * \f$(0,5, 0.5, 0.5)\f$ * * \f$(0,5,-0.5,