SmallVectorUnitTest.cpp File Reference

#include <iostream>
#include <cstdlib>
#include <cmath>
#include "Math/SmallVector.h"
#include "Logger.h"

Functions
int	main (int argc, char *argv[])

Function Documentation

main()

int main	(	int argc	,
		char *	argv[]
	)

{
    //(operator[], operator() and size() don't have a stand-alone test, but are used throughout the test in multiple assertions
 
    //various constructors
    double data[] = {1., 2., 3.};
    SmallVector<0> x0;
    SmallVector<1> x1, y1(x1);
    SmallVector<3> fromArray(data);
    SmallVector<4> destroy, convenient({5.,6.,8.,9.});
    data[0] = 4;
    logger.assert_always(x0.size() == 0, "Constructor creates a vector of the wrong size");
    logger.assert_always(x1.size() == 1, "Constructor creates a vector of the wrong size");
    logger.assert_always(y1.size() == 1, "Constructor creates a vector of the wrong size");
    logger.assert_always(y1 == x1, "Copied array does not pass equality test");
    logger.assert_always(std::abs(y1[0] - x1[0]) < 1e-12, "Copy constructor does not copy values");
    logger.assert_always(destroy.size() == 4, "Constructor creates a vector of the wrong size");
    logger.assert_always(convenient.size() == 4, "Constructor creates a vector of the wrong size");
    logger.assert_always(fromArray.size() == 3, "Constructor creates a vector of the wrong size");
    destroy[2] = 4;
    SmallVector<4> moved(std::move(destroy));
    logger.assert_always(moved.size() == 4, "Constructor creates a vector of the wrong size");
    logger.assert_always(std::abs(moved[2] - 4.) < 1e-12, "Constructor from array does not copy!");
    logger.assert_always(std::abs(fromArray(0) - 1.) < 1e-12, "Constructor from array does not copy!");
    logger.assert_always(std::abs(fromArray(1) - 2.) < 1e-12, "Constructor from array does not copy!");
    logger.assert_always(std::abs(fromArray[2] - 3.) < 1e-12, "Constructor from array does not copy!");
    logger.assert_always(std::abs(convenient[0] - 5.) < 1e-12, "Initializer list constructor does not copy!");
    logger.assert_always(std::abs(convenient[1] - 6.) < 1e-12, "Initializer list constructor does not copy!");
    logger.assert_always(std::abs(convenient[2] - 8.) < 1e-12, "Initializer list constructor does not copy!");
    logger.assert_always(std::abs(convenient[3] - 9.) < 1e-12, "Initializer list constructor does not copy!");
    SmallVector<4> assigned = moved;
    logger.assert_always(assigned.size() == 4, "Constructor creates a vector of the wrong size");
    logger.assert_always(std::abs(assigned[2] - 4.) < 1e-12, "Constructor from array does not copy!");
    destroy = convenient;
    logger.assert_always(destroy.size() == 4, "Assignment operator creates a vector of the wrong size");
    logger.assert_always(std::abs(convenient(0) - 5.) < 1e-12, "Assignment operator from array does not copy!");
    logger.assert_always(std::abs(convenient[1] - 6.) < 1e-12, "Assignment operator from array does not copy!");
    logger.assert_always(std::abs(convenient(2) - 8.) < 1e-12, "Assignment operator from array does not copy!");
    logger.assert_always(std::abs(convenient(3) - 9.) < 1e-12, "Assignment operator from array does not copy!");
 
    SmallVector<2> p2 = {{0.8, 1.8}};
    SmallVector<2> pc2;
    SmallVector<2> pv2 = {{0.8, 0.8}};
    SmallVector<2> pw2 = {{1.8, 1.8}};
    SmallVector<2> px2 = {{1.8, 0.8}};
    SmallVector<2> py2 = {{0.6, 0.7}};
    const SmallVector<2> pr2 = pc2 = p2;
    logger.assert_always(pr2.size() == 2, "Constructor creates a vector of the wrong size");
    logger.assert_always(pc2.size() == 2, "Constructor creates a vector of the wrong size");
    for (std::size_t i = 0; i < 2; ++i)
    {
        logger.assert_always((std::abs(pc2[i] - 0.8 - i) < 1e-12), "assignment operator");
        logger.assert_always((std::abs(pr2[i] - 0.8 - i) < 1e-12), "assignment operator");
    }
    logger.assert_always((pr2 == pc2 && pc2 == pr2 && pc2 == p2 && !(pr2 == pv2 || pv2 == pr2 || p2 == pv2)), "equality operator");
    logger.assert_always(!(pr2 == pw2 || pw2 == pr2 || p2 == pw2 || pr2 == px2 || px2 == pr2 || p2 == px2 || pr2 == py2 || py2 == pr2 || p2 == py2), "equality operator");
    pc2 += p2;
    for (std::size_t i = 0; i < 2; ++i)
    {
        logger.assert_always((std::abs(pc2[i] - 1.6 - 2 * i) < 1e-12), "increment operator");
    }
    pc2 -= pv2;
    for (std::size_t i = 0; i < 2; ++i)
    {
        logger.assert_always((std::abs(pc2[i] - 0.8 - 2 * i) < 1e-12), "decrement operator");
    }
    pc2 *= 4.;
    for (std::size_t i = 0; i < 2; ++i)
    {
        logger.assert_always((std::abs(pc2[i] - 3.2 - 8 * i) < 1e-12), "multiply operator");
    }
    for (std::size_t i = 0; i < 2; ++i)
    {
        logger.assert_always((std::abs((pc2 * -0.25)[i] + 0.8 + 2 * i) < 1e-12), "multiplication");
    }
    for (std::size_t i = 0; i < 2; ++i)
    {
        logger.assert_always((std::abs((pc2 + pv2)[i] - 4. - 8 * i) < 1e-12), "addition");
    }
    for (std::size_t i = 0; i < 2; ++i)
    {
        logger.assert_always((std::abs((pv2 - pc2)[i] + 2.4 + 8 * i) < 1e-12), "subtraction");
    }
    for (std::size_t i = 0; i < 2; ++i)
    {
        logger.assert_always((std::abs((-pc2)[i] + 3.2 + 8 * i) < 1e-12), "unary -");
    }
    for (std::size_t i = 0; i < 2; ++i)
    {
        logger.assert_always((std::abs((0.25 * pc2)[i] - 0.8 - 2 * i) < 1e-12), "left multiplication");
    }
    logger.assert_always((std::abs((pv2 * pc2) - 1.44 * 8) < 1e-12), "in-product");
    pc2 /= 4.;
    for (std::size_t i = 0; i < 2; ++i)
    {
        logger.assert_always((std::abs(pc2[i] - 0.8 - 2 * i) < 1e-12), "divide operator");
    }
    for (std::size_t i = 0; i < 2; ++i)
    {
        logger.assert_always((std::abs((pc2 / -0.25)[i] + 3.2 + 8 * i) < 1e-12), "division");
    }
    pc2.axpy(-3., p2);
    for (std::size_t i = 0; i < 2; ++i)
    {
        logger.assert_always((std::abs(pc2[i] + 1.6 + i) < 1e-12), "combined multiply and addition (y = ax + y)");
    }
 
    x0.data();
 
    SmallVector<4> magicCopy(convenient.data());
    logger.assert_always(std::abs(magicCopy(0) - 5.) < 1e-12, "Assignment operator from array does not copy!");
    logger.assert_always(std::abs(magicCopy(1) - 6.) < 1e-12, "Assignment operator from array does not copy!");
    logger.assert_always(std::abs(magicCopy(2) - 8.) < 1e-12, "Assignment operator from array does not copy!");
    logger.assert_always(std::abs(magicCopy(3) - 9.) < 1e-12, "Assignment operator from array does not copy!");
    convenient.data()[3] = 2.;
    logger.assert_always(std::abs(magicCopy(3) - 9.) < 1e-12, "Assignment operator from array does not copy!");
    logger.assert_always(std::abs(convenient(3) - 2.) < 1e-12, "Assignment operator from array does not copy!");
 
 
    logger(INFO, "%%", pc2, convenient);
    return 0;
}

References SmallVector< numberOfRows >::axpy(), SmallVector< numberOfRows >::data(), constants::i, INFO, logger, and SmallVector< numberOfRows >::size().