Удалить 'CMakeLists.txt.user'

CMakeLists.txt

@@ -35,7 +35,7 @@ option(STD_IOSTREAM "Building with std iostream operators support" OFF)
 option(INTROSPECTION "Build with introspection" OFF)
 option(LIB "System install" ON)
 option(STATIC_LIB OFF)
-option(TESTS "Build tests and perform their before install step" OFF)
+option(TESTS "Build tests and perform their before install step" ON)
 set(PIP_UTILS 1)
 if(LIBPROJECT)
     set(PIP_UTILS ${UTILS})
@@ -77,7 +77,7 @@ set(PIP_SRC_DIRS ${PIP_SRC_MAIN}
     ${PIP_SRC_IO_UTILS}
     ${PIP_SRC_CONCURRENT}
     ${PIP_SRC_CLOUD}
-)
+    )
 set(PIP_LIBS_TARGETS pip)
 set(LIBS_MAIN)
 set(LIBS_STATUS)
@@ -85,7 +85,10 @@ set(HDRS)
 set(PHDRS)
 
 if (TESTS)
-	set(PIP_SRC_CONCURRENT_TEST "lib/concurrent/test")
+    include(DownloadGTest)
+    set(PIP_CONCURRENT_TEST "lib/concurrent/test")
+    set(PIP_SRC_MATH_TEST "lib/main/math/test")
+    set(PIP_SRC_CORE_TEST "lib/main/core/test")
 endif()
 
 if (DEFINED ENV{QNX_HOST} OR PIP_FREERTOS)
@@ -210,11 +213,17 @@ gather_src("${PIP_SRC_IO_UTILS}" CPP_LIB_IO_UTILS HDRS PHDRS)
 # Concurrent lib
 gather_src("${PIP_SRC_CONCURRENT}" CPP_LIB_CONCURRENT HDRS PHDRS)
 
-gather_src("${PIP_SRC_CONCURRENT_TEST}" CPP_CONCURRENT_TEST HDRS PHDRS)
+gather_src("${PIP_CONCURRENT_TEST}" CPP_CONCURRENT_TEST HDRS PHDRS)
 
 # Cloud lib
 gather_src("${PIP_SRC_CLOUD}" CPP_LIB_CLOUD HDRS PHDRS)
 
+#Math test lib
+gather_src("${PIP_SRC_MATH_TEST}" CPP_MATH_TEST HDRS PHDRS)
+
+#Core test lib
+gather_src("${PIP_SRC_CORE_TEST}" CPP_CORE_TEST HDRS PHDRS)
+
 if(PIP_FREERTOS)
     add_definitions(-DPIP_FREERTOS)
     set(ICU OFF)
@@ -272,12 +281,6 @@ else()
     message(STATUS "Building PIP release version")
 endif()
 
-if (TESTS)
-	include(DownloadGTest)
-	set(CONCURRENT_TESTS 1) #"Enable tests for concurrent library"
-else()
-	set(CONCURRENT_TESTS 0)
-endif()
 
 # Check if std::iostream operators support
 if(STD_IOSTREAM)
@@ -315,37 +318,37 @@ if ((NOT DEFINED _PIP_SAVED_DEFS) OR (NOT "x${_PIP_SAVED_DEFS}" STREQUAL "x${_PI
     if (NOT "x${_PIP_DEFS}" STREQUAL "x")
         file(APPEND ${_PIP_DEFS_FILE} "#ifndef ${_PIP_DEFS}\n#  define ${_PIP_DEFS}\n#endif\n")
         endif()
-endif()
-list(APPEND HDRS ${_PIP_DEFS_FILE})
-#message("${_PIP_DEFS_CHANGED}")
+    endif()
+    list(APPEND HDRS ${_PIP_DEFS_FILE})
+    #message("${_PIP_DEFS_CHANGED}")
 
 
-# Check if RT timers exists
-if(PIP_TIMER_RT_0 AND PIP_TIMER_RT_1 AND PIP_TIMER_RT_2)
+    # Check if RT timers exists
+    if(PIP_TIMER_RT_0 AND PIP_TIMER_RT_1 AND PIP_TIMER_RT_2)
         add_definitions(-DPIP_TIMER_RT)
         message(STATUS "Building PIP with timers: Thread, ThreadRT, Pool")
-else()
+    else()
         message(STATUS "Building PIP with timers: Thread, Pool")
-endif()
+    endif()
 
 
 
-# Add main library
-if(APPLE)
+    # Add main library
+    if(APPLE)
         add_definitions(-D_FILE_OFFSET_BITS=64 -D_LARGEFILE64_SOURCE)
-endif()
-if ((NOT DEFINED LIBPROJECT) AND (DEFINED ANDROID_PLATFORM))
+    endif()
+    if ((NOT DEFINED LIBPROJECT) AND (DEFINED ANDROID_PLATFORM))
         include_directories(${ANDROID_SYSTEM_LIBRARY_PATH}/usr/include)
         #message("${ANDROID_SYSTEM_LIBRARY_PATH}/usr/include")
         #message("${ANDROID_NDK}/sysroot/usr/include")
-endif()
-if(NOT PIP_FREERTOS)
-if(WIN32)
+    endif()
+    if(NOT PIP_FREERTOS)
+        if(WIN32)
             if(${C_COMPILER} STREQUAL "cl.exe")
             else()
                 list(APPEND LIBS_MAIN ws2_32 iphlpapi psapi cfgmgr32 setupapi)
             endif()
-else()
+        else()
             list(APPEND LIBS_MAIN dl)
             if(DEFINED ENV{QNX_HOST})
                 list(APPEND LIBS_MAIN socket)
@@ -354,12 +357,12 @@ else()
                     list(APPEND LIBS_MAIN pthread util)
                 endif()
             endif()
-endif()
-endif()
-set(PIP_LIBS)
-if(PIP_FREERTOS)
+        endif()
+    endif()
+    set(PIP_LIBS)
+    if(PIP_FREERTOS)
         set(PIP_LIBS ${LIBS_MAIN})
-else()
+    else()
         foreach(LIB_ ${LIBS_MAIN})
             find_library(${LIB_}_FOUND ${LIB_})
             if(${LIB_}_FOUND)
@@ -367,31 +370,31 @@ else()
                 list(APPEND PIP_LIBS ${${LIB_}_FOUND})
             endif()
         endforeach()
-endif()
-list(APPEND LIBS_STATUS ${LIBS_MAIN})
-import_version(pip PIP)
-if(WIN32)
+    endif()
+    list(APPEND LIBS_STATUS ${LIBS_MAIN})
+    import_version(pip PIP)
+    if(WIN32)
         make_rc(pip _RC)
         add_definitions(-DPSAPI_VERSION=1)
         add_library(pip ${PIP_LIB_TYPE} ${CPP_LIB_MAIN} ${HDRS} ${PHDRS} ${_RC})
         if(${C_COMPILER} STREQUAL "cl.exe")
             set(CMAKE_CXX_FLAGS "/O2 /Ob2 /Ot /W0")
         endif()
-else()
+    else()
         set(${CMAKE_CXX_FLAGS} "${CMAKE_CXX_FLAGS} -fPIC")
         if(DEFINED ENV{QNX_HOST} OR PIP_FREERTOS)
             set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -ftemplate-depth-32")
         else()
         endif()
         add_library(pip ${PIP_LIB_TYPE} ${CPP_LIB_MAIN})
-endif()
-set(CMAKE_C_FLAGS "${CMAKE_CXX_FLAGS}")
-include(GenerateExportHeader)
-generate_export_header(pip)
-list(APPEND HDRS "${CMAKE_CURRENT_BINARY_DIR}/pip_export.h")
-target_link_libraries(pip ${PIP_LIBS})
+    endif()
+    set(CMAKE_C_FLAGS "${CMAKE_CXX_FLAGS}")
+    include(GenerateExportHeader)
+    generate_export_header(pip)
+    list(APPEND HDRS "${CMAKE_CURRENT_BINARY_DIR}/pip_export.h")
+    target_link_libraries(pip ${PIP_LIBS})
 
-if (NOT CROSSTOOLS)
+    if (NOT CROSSTOOLS)
         if (NOT PIP_FREERTOS)
             # Check if USB is supported
             find_library(usb_FOUND usb SHARED)
@@ -595,13 +598,26 @@ if (NOT CROSSTOOLS)
             list(APPEND PIP_LIBS_TARGETS pip_concurrent)
 
             # Enable build tests for concurrent module
-		if(CONCURRENT_TESTS)
+            if(PIP_CONCURRENT_TEST)
                 add_executable(pip_concurrent_test ${CPP_CONCURRENT_TEST})
                 target_link_libraries(pip_concurrent_test gtest_main gmock_main pip_concurrent)
                 add_test(NAME pip_concurrent_test COMMAND tests)
                 add_custom_target(pip_concurrent_test_perform ALL COMMAND pip_concurrent_test)
             endif()
 
+            if(PIP_SRC_MATH_TEST)
+                add_executable(pip_math_test ${CPP_MATH_TEST})
+                target_link_libraries(pip_math_test gtest_main gmock_main PIP)
+                add_test(NAME pip_math_test COMMAND tests)
+                #add_custom_target(pip_math_test_perform ALL COMMAND pip_math_test)
+            endif()
+
+            if(PIP_SRC_CORE_TEST)
+                add_executable(pip_core_test ${CPP_CORE_TEST})
+                target_link_libraries(pip_core_test gtest_main gmock_main PIP)
+                add_test(NAME pip_core_test COMMAND tests)
+                #add_custom_target(pip_core_test_perform ALL COMMAND pip_core_test)
+            endif()
 
             # Build cloud library if crypt enabled
             if(sodium_FOUND)
@@ -646,11 +662,11 @@ if (NOT CROSSTOOLS)
             list(APPEND PIP_LIBS_TARGETS pip_compress)
 
         endif()
-endif()
+    endif()
 
-# Install
-# Check if system or local install will be used (to system install use "-DLIB=" argument of cmake)
-if(LIB)
+    # Install
+    # Check if system or local install will be used (to system install use "-DLIB=" argument of cmake)
+    if(LIB)
         if(WIN32)
             if(MINGW)
                 if (NOT CROSSTOOLS)
@@ -679,7 +695,7 @@ if(LIB)
         message(STATUS "Install ${PROJECT_NAME} to system \"${CMAKE_INSTALL_PREFIX}\"")
         file(GLOB CMAKES "cmake/*.cmake" "cmake/*.in" "cmake/android_debug.keystore")
         install(FILES ${CMAKES} DESTINATION ${CMAKE_ROOT}/Modules)
-else()
+    else()
         if(NOT PIP_FREERTOS)
             if(WIN32)
                 install(TARGETS ${PIP_LIBS_TARGETS} RUNTIME DESTINATION bin)
@@ -690,16 +706,16 @@ else()
             install(FILES ${HDRS} DESTINATION include/pip)
             message(STATUS "Install ${PROJECT_NAME} to local \"bin\", \"lib\" and \"include\"")
         endif()
-endif()
+    endif()
 
-if(NOT PIP_FREERTOS)
+    if(NOT PIP_FREERTOS)
 
-# Auxiliary
+        # Auxiliary
         if (NOT CROSSTOOLS)
             add_subdirectory("${PIP_SRC_MAIN}/auxiliary/piterminal")
         endif()
 
-# Utils
+        # Utils
         add_subdirectory("utils/code_model_generator")
         add_subdirectory("utils/resources_compiler")
         add_subdirectory("utils/deploy_tool")
@@ -714,29 +730,29 @@ if(NOT PIP_FREERTOS)
             endif()
         endif()
 
-endif()
+    endif()
 
 
-# Libraries messages
-message(STATUS "Building PIP modules: ${PIP_LIBS_TARGETS}")
-if(DEFINED LIBPROJECT)
+    # Libraries messages
+    message(STATUS "Building PIP modules: ${PIP_LIBS_TARGETS}")
+    if(DEFINED LIBPROJECT)
         set(PIP_LIBS_TARGETS ${PIP_LIBS_TARGETS} PARENT_SCOPE)
         list(APPEND _ALL_TARGETS ${PIP_LIBS_TARGETS})
         set(_ALL_TARGETS ${_ALL_TARGETS} PARENT_SCOPE)
-endif()
-if(NOT PIP_FREERTOS)
+    endif()
+    if(NOT PIP_FREERTOS)
         foreach(LIB_ ${LIBS_STATUS})
             message(STATUS "Library ${LIB_} -> " ${${LIB_}_FOUND})
             if(NOT ${LIB_}_FOUND)
                 message(WARNING "Library ${LIB_} not found, please install it")
             endif()
         endforeach()
-endif()
+    endif()
 
-#
-# Build Documentation
-#
-if ((NOT PIP_FREERTOS) AND (NOT CROSSTOOLS))
+    #
+    # Build Documentation
+    #
+    if ((NOT PIP_FREERTOS) AND (NOT CROSSTOOLS))
         include(PIPDocumentation)
         find_package(Doxygen)
         if(DOXYGEN_FOUND)
@@ -760,5 +776,5 @@ if ((NOT PIP_FREERTOS) AND (NOT CROSSTOOLS))
             add_documentation(doc doc/Doxyfile.in)
             install(DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/doc/html DESTINATION ../share/doc/pip COMPONENT doc EXCLUDE_FROM_ALL OPTIONAL)
         endif()
-endif()
+    endif()
 

lib/main/core/test/pistringTest.cpp

@@ -0,0 +1,10 @@
+#include "gtest/gtest.h"
+#include "pistring.h"
+
+using namespace  std;
+
+PIString str;
+
+TEST(PIString_Tests, operator){
+    ASSERT_TRUE(true);
+}

lib/main/math/test/testpimathmatrix.cpp

@@ -0,0 +1,936 @@
+#include "gtest/gtest.h"
+#include "pimathmatrix.h"
+
+using namespace  std;
+
+PIMathMatrix<double> origMatr;
+
+TEST(PIMathMatrix_Test, identity)
+{
+    PIMathMatrix<double> matrix;
+    int i;
+    double d;
+    bool a, b;
+    matrix = origMatr.identity(3, 3);
+    d = matrix.determinant();
+    for(i = 0; i < 3; i++)
+    {
+        if(matrix[i][i] == 1.0)
+        {
+            b = true;
+        }
+        else
+        {
+            b = false;
+            break;
+        }
+    }
+    if(d == 1.0)
+    {
+        a = true;
+    }
+    else
+    {
+        a = false;
+    }
+    ASSERT_TRUE(a && b);
+}
+
+TEST(PIMathMatrix_Test, matrixRow)
+{
+    PIMathMatrix<double> matrix;
+    PIMathVector<double> vector;
+    uint i;
+    bool b;
+    vector.resize(3, 3.0);
+    vector.fill(5.0);
+    matrix = origMatr.matrixRow(vector);
+    for(i = 0; i < vector.size(); i++)
+    {
+        if(matrix[0][i] == 5.0)
+        {
+            b = true;
+        }
+        else
+        {
+            b = false;
+            break;
+        }
+    }
+    ASSERT_TRUE(b);
+}
+
+TEST(PIMathMatrix_Test, matrixCol)
+{
+    PIMathMatrix<double> matrix;
+    PIMathVector<double> vector;
+    uint i;
+    bool b;
+    vector.resize(3, 3.0);
+    vector.fill(5.0);
+    matrix = origMatr.matrixCol(vector);
+    for(i = 0; i < vector.size(); i++)
+    {
+        if(matrix[i][0] == 5.0)
+        {
+            b = true;
+        }
+        else
+        {
+            b = false;
+            break;
+        }
+    }
+    ASSERT_TRUE(b);
+}
+
+TEST(PIMathMatrix_Test, setCol)
+{
+    PIMathMatrix<double> matrix;
+    PIMathVector<double> vector;
+    uint i;
+    bool b;
+    vector.resize(3, 3.0);
+    vector.fill(5.0);
+    matrix = origMatr.matrixCol(vector);
+    vector.fill(10.0);
+    matrix.setCol(0, vector);
+    for(i = 0; i < vector.size(); i++)
+    {
+        if(matrix[i][0] == 10.0)
+        {
+            b = true;
+        }
+        else
+        {
+            b = false;
+            break;
+        }
+    }
+    ASSERT_TRUE(b);
+}
+
+TEST(PIMathMatrix_Test, setRow)
+{
+    PIMathMatrix<double> matrix;
+    PIMathVector<double> vector;
+    uint i;
+    bool b;
+    vector.resize(3, 3.0);
+    vector.fill(5.0);
+    matrix = origMatr.matrixRow(vector);
+    vector.fill(10.0);
+    matrix.setRow(0, vector);
+    for(i = 0; i < vector.size(); i++)
+    {
+        if(matrix[0][i] == 10.0)
+        {
+            b = true;
+        }
+        else
+        {
+            b = false;
+            break;
+        }
+    }
+    ASSERT_TRUE(b);
+}
+
+TEST(PIMathMatrix_Test, swapCols)
+{
+    PIMathMatrix<double> matrix1;
+    PIMathVector<double> vector;
+    uint i1 = 0; uint i2 = 1;
+    double a1[3], a2[3], a3[3];
+    double b1[3], b2[3], b3[3];
+    bool b;
+    vector.resize(3, 3.0);
+    vector.at(0) = 3.0;
+    vector.at(1) = 6.0;
+    vector.at(2) = 8.0;
+    matrix1 = origMatr.identity(3, 3);
+    matrix1.setCol(0, vector);
+    vector.at(0) = 2.0;
+    vector.at(1) = 1.0;
+    vector.at(2) = 4.0;
+    matrix1.setCol(1, vector);
+    vector.at(0) = 6.0;
+    vector.at(1) = 2.0;
+    vector.at(2) = 5.0;
+    matrix1.setCol(2, vector);
+    for(int i = 0; i < 3; i++)
+    {
+        a1[i] = matrix1.element(i, 0);
+        a2[i] = matrix1.element(i, 1);
+        a3[i] = matrix1.element(i, 2);
+    }
+    matrix1.swapCols(i1, i2);
+    for(int i = 0; i < 3; i++)
+    {
+        b1[i] = matrix1.element(i, 0);
+        b2[i] = matrix1.element(i, 1);
+        b3[i] = matrix1.element(i, 2);
+    }
+    if((memcmp(a1, b2, sizeof(b1)) == 0) && (memcmp(a2, b1, sizeof(b1)) == 0) && (memcmp(a3, b3, sizeof(b1)) == 0))
+    {
+        b = true;
+    }
+    else
+    {
+        b = false;
+    }
+    ASSERT_TRUE(b);
+}
+
+TEST(PIMathMatrix_Test, swapRows)
+{
+    PIMathMatrix<double> matrix1;
+    PIMathVector<double> vector;
+    uint i1 = 0; uint i2 = 1;
+    double a1[3], a2[3], a3[3];
+    double b1[3], b2[3], b3[3];
+    bool b;
+    vector.resize(3, 3.0);
+    vector.at(0) = 3.0;
+    vector.at(1) = 6.0;
+    vector.at(2) = 8.0;
+    matrix1 = origMatr.identity(3, 3);
+    matrix1.setCol(0, vector);
+    vector.at(0) = 2.0;
+    vector.at(1) = 1.0;
+    vector.at(2) = 4.0;
+    matrix1.setCol(1, vector);
+    vector.at(0) = 6.0;
+    vector.at(1) = 2.0;
+    vector.at(2) = 5.0;
+    matrix1.setCol(2, vector);
+    for(int i = 0; i < 3; i++)
+    {
+        a1[i] = matrix1.element(0, i);
+        a2[i] = matrix1.element(1, i);
+        a3[i] = matrix1.element(2, i);
+    }
+    matrix1.swapRows(i1, i2);
+    for(int i = 0; i < 3; i++)
+    {
+        b1[i] = matrix1.element(0, i);
+        b2[i] = matrix1.element(1, i);
+        b3[i] = matrix1.element(2, i);
+    }
+    if((memcmp(a1, b2, sizeof(b1)) == 0) && (memcmp(a2, b1, sizeof(b1)) == 0) && (memcmp(a3, b3, sizeof(b1)) == 0))
+    {
+        b = true;
+    }
+    else
+    {
+        b = false;
+    }
+    ASSERT_TRUE(b);
+}
+TEST(PIMathMatrix_Test, fill)
+{
+    PIMathMatrix<double> matrix;
+    int i = 0;
+    int j = 0;
+    int k = 0;
+    bool b;
+    matrix = origMatr.identity(3, 3);
+    matrix.fill(5.0);
+    while(i < 9)
+    {
+        if(k < 3)
+        {
+            if(matrix.element(j,k) == 5.0)
+            {
+                b = true;
+            }
+            else
+            {
+                b = false;
+                break;
+            }
+            k++;
+            if(k == 3)
+            {
+                j++;
+                k = 0;
+            }
+        }
+        i++;
+    }
+    ASSERT_TRUE(b);
+}
+
+TEST(PIMathMatrix_Test, isSquare)
+{
+
+    PIMathMatrix<double> matrix1;
+    PIMathMatrix<double> matrix2;
+    bool b;
+    matrix1 = origMatr.identity(3,3);
+    matrix2 = origMatr.identity(4,3);
+    if((matrix1.isSquare() == true) && (matrix2.isSquare() == false))
+    {
+        b = true;
+    }
+    else
+    {
+        b = false;
+    }
+    ASSERT_TRUE(b);
+}
+
+TEST(PIMathMatrix_Test, isIdentity)
+{
+    PIMathMatrix<double> matrix1;
+    PIMathMatrix<double> matrix2;
+    bool b;
+    matrix1 = origMatr.identity(3,3);
+    matrix2 = origMatr.identity(3,3);
+    matrix2.fill(3.932);
+    if((matrix1.isIdentity() == true) && (matrix2.isIdentity() == false))
+    {
+        b = true;
+    }
+    else
+    {
+        b = false;
+    }
+    ASSERT_TRUE(b);
+}
+
+TEST(PIMathMatrix_Test, isNull)
+{
+    PIMathMatrix<double> matrix1;
+    PIMathMatrix<double> matrix2;
+    bool b;
+    matrix1 = origMatr.identity(3,3);
+    matrix2 = origMatr.identity(3,3);
+    matrix1.fill(0.0);
+    matrix2.fill(3.932);
+    if((matrix1.isNull() == true) && (matrix2.isNull() == false))
+    {
+        b = true;
+    }
+    else
+    {
+        b = false;
+    }
+    ASSERT_TRUE(b);
+}
+
+TEST(PIMathMatrix_Test, isValid)
+{
+    PIMathMatrix<double> matrix1;
+    PIMathMatrix<double> matrix2;
+    bool b;
+    matrix1 = origMatr.identity(3,3);
+    if((matrix1.isValid() == true) && (matrix2.isValid() == false))
+    {
+        b = true;
+    }
+    else
+    {
+        b = false;
+    }
+    ASSERT_TRUE(b);
+}
+
+TEST(PIMathMatrix_Test, operator_Assignment)
+{
+    PIMathMatrix<double> matrix1;
+    PIMathMatrix<double> matrix2;
+    int i = 0;
+    int j = 0;
+    int k = 0;
+    bool b;
+    matrix1 = origMatr.identity(3,3);
+    matrix2 = origMatr.identity(3,3);
+    matrix2.fill(6.72);
+    matrix1 = matrix2;
+    while(i < 9)
+    {
+        if(k < 3)
+        {
+            if(matrix1.element(j,k) == 6.72)
+            {
+                b = true;
+            }
+            else
+            {
+                b = false;
+                break;
+            }
+            k++;
+            if(k == 3)
+            {
+                j++;
+                k = 0;
+            }
+        }
+        i++;
+    }
+    ASSERT_TRUE(b);
+}
+
+TEST(PIMathMatrix_Test, operator_Equal)
+{
+    PIMathMatrix<double> matrix1;
+    PIMathMatrix<double> matrix2;
+    PIMathMatrix<double> matrix3;
+    PIMathVector<double> vector;
+    bool b;
+    matrix1 = origMatr.identity(3,3);
+    matrix2 = origMatr.identity(3,3);
+    matrix3 = origMatr.identity(3,3);
+    vector.resize(3, 3.0);
+    vector.at(0) = 3.0;
+    vector.at(1) = 6.0;
+    vector.at(2) = 8.0;
+    matrix1.setCol(0, vector);
+    matrix2.setCol(0, vector);
+    matrix3.setCol(0, vector);
+    vector.at(0) = 2.0;
+    vector.at(1) = 1.0;
+    vector.at(2) = 4.0;
+    matrix1.setCol(1, vector);
+    matrix2.setCol(1, vector);
+    matrix3.setCol(1, vector);
+    vector.at(0) = 6.0;
+    vector.at(1) = 2.0;
+    vector.at(2) = 5.0;
+    matrix1.setCol(2, vector);
+    matrix2.setCol(2, vector);
+    vector.at(0) = 566.0;
+    vector.at(1) = 564.0;
+    vector.at(2) = 543.0;
+    matrix3.setCol(2, vector);
+    if(((matrix1 == matrix2) == true) && ((matrix1 == matrix3) == false))
+    {
+        b = true;
+    }
+    else
+    {
+        b = false;
+    }
+    ASSERT_TRUE(b);
+}
+
+TEST(PIMathMatrix_Test, operator_Not_Equal)
+{
+    PIMathMatrix<double> matrix1;
+    PIMathMatrix<double> matrix2;
+    PIMathMatrix<double> matrix3;
+    PIMathVector<double> vector;
+    bool b;
+    matrix1 = origMatr.identity(3,3);
+    matrix2 = origMatr.identity(3,3);
+    matrix3 = origMatr.identity(3,3);
+    vector.resize(3, 3.0);
+    vector.at(0) = 3.0;
+    vector.at(1) = 6.0;
+    vector.at(2) = 8.0;
+    matrix1.setCol(0, vector);
+    matrix2.setCol(0, vector);
+    matrix3.setCol(0, vector);
+    vector.at(0) = 2.0;
+    vector.at(1) = 1.0;
+    vector.at(2) = 4.0;
+    matrix1.setCol(1, vector);
+    matrix2.setCol(1, vector);
+    matrix3.setCol(1, vector);
+    vector.at(0) = 6.0;
+    vector.at(1) = 2.0;
+    vector.at(2) = 5.0;
+    matrix1.setCol(2, vector);
+    matrix2.setCol(2, vector);
+    vector.at(0) = 566.0;
+    vector.at(1) = 564.0;
+    vector.at(2) = 543.0;
+    matrix3.setCol(2, vector);
+    if(((matrix1 != matrix2) == false) && ((matrix1 != matrix3) == true))
+    {
+        b = true;
+    }
+    else
+    {
+        b = false;
+    }
+    ASSERT_TRUE(b);
+}
+
+TEST(PIMathMatrix_Test, operator_Addition_Aassignment)
+{
+    PIMathMatrix<double> matrix1;
+    PIMathMatrix<double> matrix2;
+    bool b;
+    int i = 0;
+    int j = 0;
+    int k = 0;
+    matrix1 = origMatr.identity(3,3);
+    matrix2 = origMatr.identity(3,3);
+    matrix2.fill(6.72);
+    matrix1.fill(1.0);
+    matrix1 += matrix2;
+    while(i < 9)
+    {
+        if(k < 3)
+        {
+            if(matrix1.element(j,k) == 7.72)
+            {
+                b = true;
+            }
+            else
+            {
+                b = false;
+                break;
+            }
+            k++;
+            if(k == 3)
+            {
+                j++;
+                k = 0;
+            }
+        }
+        i++;
+    }
+    ASSERT_TRUE(b);
+}
+
+TEST(PIMathMatrix_Test, operator_Subtraction_Assignment)
+{
+    PIMathMatrix<double> matrix1;
+    PIMathMatrix<double> matrix2;
+    bool b;
+    int i = 0;
+    int j = 0;
+    int k = 0;
+    matrix1 = origMatr.identity(3,3);
+    matrix2 = origMatr.identity(3,3);
+    matrix2.fill(6.72);
+    matrix1.fill(1.0);
+    matrix1 -= matrix2;
+    while(i < 9)
+    {
+        if(k < 3)
+        {
+            if(matrix1.element(j,k) == -5.72)
+            {
+                b = true;
+            }
+            else
+            {
+                b = false;
+                break;
+            }
+            k++;
+            if(k == 3)
+            {
+                j++;
+                k = 0;
+            }
+        }
+        i++;
+    }
+    ASSERT_TRUE(b);
+}
+
+TEST(PIMathMatrix_Test, operator_Multiplication_Assignment)
+{
+    PIMathMatrix<double> matrix1;
+    bool b;
+    int i = 0;
+    int j = 0;
+    int k = 0;
+    matrix1 = origMatr.identity(3,3);
+    matrix1.fill(6.72);
+    matrix1 *= 2.0;
+    while(i < 9)
+    {
+        if(k < 3)
+        {
+            if(matrix1.element(j,k) == 13.44)
+            {
+                b = true;
+            }
+            else
+            {
+                b = false;
+                break;
+            }
+            k++;
+            if(k == 3)
+            {
+                j++;
+                k = 0;
+            }
+        }
+        i++;
+    }
+    ASSERT_TRUE(b);
+}
+
+TEST(PIMathMatrix_Test, operator_Division_Assignment)
+{
+    PIMathMatrix<double> matrix1;
+    bool b;
+    int i = 0;
+    int j = 0;
+    int k = 0;
+    matrix1 = origMatr.identity(3,3);
+    matrix1.fill(6.72);
+    matrix1 /= 2.0;
+    while(i < 9)
+    {
+        if(k < 3)
+        {
+            if(matrix1.element(j,k) == 3.36)
+            {
+                b = true;
+            }
+            else
+            {
+                b = false;
+                break;
+            }
+            k++;
+            if(k == 3)
+            {
+                j++;
+                k = 0;
+            }
+        }
+        i++;
+    }
+    ASSERT_TRUE(b);
+}
+
+TEST(PIMathMatrix_Test, operator_Addition)
+{
+    PIMathMatrix<double> matrix1;
+    PIMathMatrix<double> matrix2;
+    bool b;
+    int i = 0;
+    int j = 0;
+    int k = 0;
+    matrix1 = origMatr.identity(3,3);
+    matrix2 = origMatr.identity(3,3);
+    matrix1.fill(6.72);
+    matrix2.fill(8.28);
+    while(i < 9)
+    {
+        if(k < 3)
+        {
+            if((matrix1+matrix2).element(j,k) == 15.0)
+            {
+                b = true;
+            }
+            else
+            {
+                b = false;
+                break;
+            }
+            k++;
+            if(k == 3)
+            {
+                j++;
+                k = 0;
+            }
+        }
+        i++;
+    }
+    ASSERT_TRUE(b);
+}
+
+TEST(PIMathMatrix_Test, operator_Subtraction)
+{
+    PIMathMatrix<double> matrix1;
+    PIMathMatrix<double> matrix2;
+    bool b;
+    matrix1 = origMatr.identity(3, 3);
+    matrix2 = origMatr.identity(3, 3);
+    origMatr.fill(8.0);
+    matrix1.fill(8.28);
+    origMatr = origMatr - matrix1;
+    matrix2.fill(-0.28);
+    if(origMatr == matrix2)
+    {
+        b = true;
+    }
+    else
+    {
+        b = false;
+    }
+    ASSERT_TRUE(b);
+}
+
+TEST(PIMathMatrix_Test, operator_Multiplication)
+{
+    PIMathMatrix<double> matrix1;
+    PIMathMatrix<double> matrix2;
+    bool b;
+    int i = 0;
+    int j = 0;
+    int k = 0;
+    matrix1 = origMatr.identity(3,3);
+    matrix2 = origMatr.identity(3,3);
+    matrix1.fill(6.72);
+    matrix2 = matrix1*4.0;
+    while(i < 9)
+    {
+        if(k < 3)
+        {
+            if(matrix2.element(j,k) == 26.88)
+            {
+                b = true;
+            }
+            else
+            {
+                b = false;
+                break;
+            }
+            k++;
+            if(k == 3)
+            {
+                j++;
+                k = 0;
+            }
+        }
+        i++;
+    }
+    ASSERT_TRUE(b);
+}
+TEST(PIMathMatrix_Test, operator_Division)
+{
+    PIMathMatrix<double> matrix1;
+    PIMathMatrix<double> matrix2;
+    bool b;
+    int i = 0;
+    int j = 0;
+    int k = 0;
+    matrix1 = origMatr.identity(3,3);
+    matrix2 = origMatr.identity(3,3);
+    matrix1.fill(6.72);
+    matrix2 = matrix1/4.0;
+    while(i < 9)
+    {
+        if(k < 3)
+        {
+            if(matrix2.element(j,k) == 1.68)
+            {
+                b = true;
+            }
+            else
+            {
+                b = false;
+                break;
+            }
+            k++;
+            if(k == 3)
+            {
+                j++;
+                k = 0;
+            }
+        }
+        i++;
+    }
+    ASSERT_TRUE(b);
+}
+
+TEST(PIMathMatrix_Test, determinant)
+{
+    double d;
+    double i = 59.0;
+    PIMathMatrix<double> matrix;
+    PIMathVector<double> vector;
+    vector.resize(3, 3.0);
+    vector.at(0) = 3.0;
+    vector.at(1) = 6.0;
+    vector.at(2) = 8.0;
+    matrix = origMatr.identity(3, 3);
+    matrix.setCol(0, vector);
+    vector.at(0) = 2.0;
+    vector.at(1) = 1.0;
+    vector.at(2) = 4.0;
+    matrix.setCol(1, vector);
+    vector.at(0) = 6.0;
+    vector.at(1) = 2.0;
+    vector.at(2) = 5.0;
+    matrix.setCol(2, vector);
+    d = matrix.determinant();
+    ASSERT_DOUBLE_EQ(d, i);
+}
+
+TEST(PIMathMatrix_Test, trace)
+{
+    double t;
+    double i = 9.0;
+    PIMathMatrix<double> matrix;
+    PIMathVector<double> vector;
+    vector.resize(3, 3.0);
+    vector.at(0) = 3.0;
+    vector.at(1) = 6.0;
+    vector.at(2) = 8.0;
+    matrix = origMatr.identity(3, 3);
+    matrix.setCol(0, vector);
+    vector.at(0) = 2.0;
+    vector.at(1) = 1.0;
+    vector.at(2) = 4.0;
+    matrix.setCol(1, vector);
+    vector.at(0) = 6.0;
+    vector.at(1) = 2.0;
+    vector.at(2) = 5.0;
+    matrix.setCol(2, vector);
+    t = matrix.trace();
+    ASSERT_DOUBLE_EQ(t, i);
+}
+
+TEST(PIMathMatrix_Test, toUpperTriangular)
+{
+    double d1, d2 = 1;
+    int i;
+    PIMathMatrix<double> matrix;
+    PIMathVector<double> vector;
+    vector.resize(3, 3.0);
+    vector.at(0) = 3.0;
+    vector.at(1) = 6.0;
+    vector.at(2) = 8.0;
+    matrix = origMatr.identity(3, 3);
+    matrix.setCol(0, vector);
+    vector.at(0) = 2.0;
+    vector.at(1) = 1.0;
+    vector.at(2) = 4.0;
+    matrix.setCol(1, vector);
+    vector.at(0) = 6.0;
+    vector.at(1) = 2.0;
+    vector.at(2) = 5.0;
+    matrix.setCol(2, vector);
+    d1 = matrix.determinant();
+    matrix.toUpperTriangular();
+    for(i = 0; i < 3; i++)
+    {
+        d2 = d2 * matrix.element(i, i);
+    }
+    ASSERT_DOUBLE_EQ(d1, d2);
+}
+
+TEST(PIMathMatrix_Test, invert)
+{
+    double d1, d2;
+    bool b;
+    PIMathMatrix<double> matrix1;
+    PIMathMatrix<double> matrix2;
+    PIMathMatrix<double> matrix3;
+    PIMathMatrix<double> matrix4;
+    PIMathVector<double> vector;
+    vector.resize(3, 3.0);
+    vector.at(0) = 3.0;
+    vector.at(1) = 6.0;
+    vector.at(2) = 8.0;
+    matrix1 = origMatr.identity(3, 3);
+    matrix1.setCol(0, vector);
+    vector.at(0) = 2.0;
+    vector.at(1) = 1.0;
+    vector.at(2) = 4.0;
+    matrix1.setCol(1, vector);
+    vector.at(0) = 6.0;
+    vector.at(1) = 2.0;
+    vector.at(2) = 5.0;
+    matrix1.setCol(2, vector);
+    d1 = matrix1.determinant();
+    matrix2 = matrix1;
+    matrix2.invert();
+    d2 = matrix2.determinant();
+    matrix3 = origMatr.identity(3, 3);
+    matrix4 = origMatr.identity(3, 3);
+    matrix4.invert();
+    if((matrix3 == matrix4) && (round((1/d1)*10000)/10000 == round(d2*10000)/10000))
+    {
+        b = true;
+    }
+    else
+    {
+        b = false;
+    }
+    ASSERT_TRUE(b);
+}
+
+TEST(PIMathMatrix_Test, inverted)
+{
+    double d1, d2;
+    bool b;
+    PIMathMatrix<double> matrix1;
+    PIMathMatrix<double> matrix2;
+    PIMathMatrix<double> matrix3;
+    PIMathMatrix<double> matrix4;
+    PIMathVector<double> vector;
+    vector.resize(3, 3.0);
+    vector.at(0) = 3.0;
+    vector.at(1) = 6.0;
+    vector.at(2) = 8.0;
+    matrix1 = origMatr.identity(3, 3);
+    matrix1.setCol(0, vector);
+    vector.at(0) = 2.0;
+    vector.at(1) = 1.0;
+    vector.at(2) = 4.0;
+    matrix1.setCol(1, vector);
+    vector.at(0) = 6.0;
+    vector.at(1) = 2.0;
+    vector.at(2) = 5.0;
+    matrix1.setCol(2, vector);
+    d1 = matrix1.determinant();
+    matrix2 = matrix1;
+    matrix1 = matrix2.invert();
+    d2 = matrix1.determinant();
+    matrix3 = origMatr.identity(3, 3);
+    matrix4 = origMatr.identity(3, 3);
+    matrix3 = matrix4.invert();
+    if((matrix3 == matrix4) && (round((1/d1)*10000)/10000 == round(d2*10000)/10000))
+    {
+        b = true;
+    }
+    else
+    {
+        b = false;
+    }
+    ASSERT_TRUE(b);
+}
+
+TEST(PIMathMatrix_Test, transposed)
+{
+    double d1, d2;
+    bool b;
+    PIMathMatrix<double> matrix1;
+    PIMathMatrix<double> matrix2;
+    PIMathMatrix<double> matrix3;
+    PIMathVector<double> vector;
+    vector.resize(3, 3.0);
+    vector.at(0) = 3.0;
+    vector.at(1) = 6.0;
+    vector.at(2) = 8.0;
+    matrix1 = origMatr.identity(3, 3);
+    matrix1.setCol(0, vector);
+    vector.at(0) = 2.0;
+    vector.at(1) = 1.0;
+    vector.at(2) = 4.0;
+    matrix1.setCol(1, vector);
+    vector.at(0) = 6.0;
+    vector.at(1) = 2.0;
+    vector.at(2) = 5.0;
+    matrix1.setCol(2, vector);
+    d1 = matrix1.determinant();
+    matrix2 = matrix1.transposed();
+    d2 = matrix2.determinant();
+    matrix3 = matrix2.transposed();
+    if((d1 == d2) && (matrix1 == matrix3))
+    {
+        b = true;
+    }
+    else
+    {
+        b = false;
+    }
+    ASSERT_TRUE(b);
+}
+
+

lib/main/math/test/testpimathmatrixt.cpp

@@ -0,0 +1,991 @@
+#include "gtest/gtest.h"
+#include "pimathmatrix.h"
+
+const uint rows = 3;
+const uint cols = 3;
+PIMathMatrixT<rows, cols, double> matr;
+PIMathVectorT<rows, double> vect;
+
+TEST(PIMathMatrixT_Test, identity)
+{
+    PIMathMatrixT<rows, cols, double> matrix;
+    double d;
+    double i = 1.0;
+    bool a;
+    bool output;
+    matrix = matr.identity();
+    d = matrix.determinant();
+    uint j;
+    for(j = 0; j < cols; j++)
+    {
+        if(matrix.at(i, i) == 1.0) a = true;
+        else
+        {
+            a = false;
+            break;
+        }
+    }
+    if((i == d) && (a == true)){
+        output = true;
+    }
+    else{
+        output = false;
+    }
+    ASSERT_TRUE(output);
+}
+
+TEST(PIMathMatrixT_Test, at)
+{
+    uint i;
+    bool b;
+    PIMathMatrixT<rows, cols, double> matrix1;
+    PIMathMatrixT<rows, cols, double> matrix2;
+    matrix1 = matr.identity();
+    matrix2 = matr.identity();
+    for(i = 0; i < rows; i++)
+    {
+        if(matrix1.at(i,i) == 1.0)
+        {
+            b = true;
+        }
+        else
+        {
+            b = false;
+            break;
+        }
+    }
+    ASSERT_TRUE(b);
+}
+TEST(PIMathMatrixT_Test, filled)
+{
+    PIMathMatrixT<rows, cols, double> matrix1;
+    PIMathMatrixT<rows, cols, double> matrix2;
+    double g = 1.0;
+    matrix2 = matr.fill(g);
+    uint j = 0, i = 0;
+    for(i = 0; i < cols; i++)
+    {
+        for(j = 0; j < rows; j++)
+        {
+            matrix1.at(j,i) = g;
+        }
+    }
+    ASSERT_TRUE(matrix2 == matrix1);
+}
+
+TEST(PIMathMatrixT_Test, cols)
+{
+    ASSERT_EQ(cols,matr.cols());
+}
+
+TEST(PIMathMatrixT_Test, rows)
+{
+    ASSERT_EQ(rows,matr.rows());
+}
+
+TEST(PIMathMatrixT_Test, col)
+{
+    uint i;
+    uint g = 2;
+    bool b;
+    matr.at(0,0) = 3;
+    matr.at(0,1) = 6;
+    matr.at(0,2) = 8;
+    matr.at(1,0) = 2;
+    matr.at(1,1) = 1;
+    matr.at(1,2) = 4;
+    matr.at(2,0) = 6;
+    matr.at(2,1) = 2;
+    matr.at(2,2) = 5;
+    vect = matr.col(g);
+    for(i = 0; i < matr.cols(); i++)
+    {
+        if(matr.at(i,g) == vect.at(i))
+        {
+            b = true;
+        }
+        else
+        {
+            b = false;
+            break;
+        }
+    }
+    ASSERT_TRUE(b);
+}
+
+TEST(PIMathMatrixT_Test, row)
+{
+    uint i;
+    uint g = 2;
+    bool b;
+    matr.at(0,0) = 3;
+    matr.at(0,1) = 6;
+    matr.at(0,2) = 8;
+    matr.at(1,0) = 2;
+    matr.at(1,1) = 1;
+    matr.at(1,2) = 4;
+    matr.at(2,0) = 6;
+    matr.at(2,1) = 2;
+    matr.at(2,2) = 5;
+    vect = matr.row(g);
+    for(i = 0; i < matr.rows(); i++)
+    {
+        if(matr.at(g,i) == vect.at(i))
+        {
+            b = true;
+        }
+        else
+        {
+            b = false;
+            break;
+        }
+    }
+    ASSERT_TRUE(b);
+}
+
+TEST(PIMathMatrixT_Test, setCol)
+{
+    vect.at(0) = 1.0;
+    vect.at(1) = 3.0;
+    vect.at(2) = 5.0;
+    uint g = 1;
+    uint i = 0;
+    bool b;
+    matr.setCol(g, vect);
+    for(i = 0; i < vect.size(); i++)
+    {
+        if(matr.at(i,g) == vect.at(i))
+        {
+            b = true;
+        }
+        else
+        {
+            b = false;
+            break;
+        }
+    }
+    ASSERT_TRUE(b);
+}
+
+TEST(PIMathMatrixT_Test, setRow)
+{
+    vect.at(0) = 1.0;
+    vect.at(1) = 3.0;
+    vect.at(2) = 5.0;
+    uint g = 1;
+    uint i = 0;
+    bool b;
+    matr.setRow(g, vect);
+    for(i = 0; i < vect.size(); i++)
+    {
+        if(matr.at(g,i) == vect.at(i))
+        {
+            b = true;
+        }
+        else
+        {
+            b = false;
+            break;
+        }
+    }
+    ASSERT_TRUE(b);
+}
+
+TEST(PIMathMatrixT_Test, swapCols)
+{
+    PIMathVectorT<rows, double> before_Vect1;
+    PIMathVectorT<rows, double> before_Vect2;
+    PIMathVectorT<rows, double> after_Vect1;
+    PIMathVectorT<rows, double> after_Vect2;
+    int g1 = 1, g2 = 2;
+    bool b;
+    matr.at(0,0) = 3;
+    matr.at(0,1) = 6;
+    matr.at(0,2) = 8;
+    matr.at(1,0) = 2;
+    matr.at(1,1) = 1;
+    matr.at(1,2) = 4;
+    matr.at(2,0) = 6;
+    matr.at(2,1) = 2;
+    matr.at(2,2) = 5;
+    before_Vect1 = matr.col(g1);
+    before_Vect2 = matr.col(g2);
+    matr.swapCols(g1,g2);
+    after_Vect1 = matr.col(g1);
+    after_Vect2 = matr.col(g2);
+    if((before_Vect1 == after_Vect2) && (before_Vect2 == after_Vect1))
+    {
+        b = true;
+    }
+    else
+    {
+        b = false;
+    }
+    ASSERT_TRUE(b);
+}
+
+TEST(PIMathMatrixT_Test, swapRows)
+{
+    PIMathVectorT<rows, double> before_Vect1;
+    PIMathVectorT<rows, double> before_Vect2;
+    PIMathVectorT<rows, double> after_Vect1;
+    PIMathVectorT<rows, double> after_Vect2;
+    int g1 = 1, g2 = 2;
+    bool b;
+    matr.at(0,0) = 3;
+    matr.at(0,1) = 6;
+    matr.at(0,2) = 8;
+    matr.at(1,0) = 2;
+    matr.at(1,1) = 1;
+    matr.at(1,2) = 4;
+    matr.at(2,0) = 6;
+    matr.at(2,1) = 2;
+    matr.at(2,2) = 5;
+    before_Vect1 = matr.row(g1);
+    before_Vect2 = matr.row(g2);
+    matr.swapRows(g1,g2);
+    after_Vect1 = matr.row(g1);
+    after_Vect2 = matr.row(g2);
+    if((before_Vect1 == after_Vect2) && (before_Vect2 == after_Vect1))
+    {
+        b = true;
+    }
+    else
+    {
+        b = false;
+    }
+    ASSERT_TRUE(b);
+}
+
+TEST(PIMathMatrixT_Test, fill)
+{
+    PIMathMatrixT<rows, cols, double> matrix1;
+    double g = 1.0;
+    matr.fill(g);
+    uint j = 0, i = 0;
+    for(i = 0; i < cols; i++)
+    {
+        for(j = 0; j < rows; j++)
+        {
+            matrix1.at(j,i) = g;
+        }
+    }
+    ASSERT_TRUE(matr == matrix1);
+}
+
+TEST(PIMathMatrixT_Test, isSquare)
+{
+    PIMathMatrixT<rows, cols, double> matrix1;
+    const uint new_Cols = 4;
+    PIMathMatrixT<rows, new_Cols, double> matrix2;
+    bool b;
+    if((matrix1.isSquare() == true) && (matrix2.isSquare() == false))
+    {
+        b = true;
+    }
+    else
+    {
+        b = false;
+    }
+    ASSERT_TRUE(b);
+}
+
+TEST(PIMathMatrixT_Test, isIdentity)
+{
+    PIMathMatrixT<rows, cols, double> matrix1;
+    PIMathMatrixT<rows, cols, double> matrix2;
+    bool b;
+    matrix1 = matr.identity();
+    matrix2 = matr.filled(3.67);
+    if((matrix1.isIdentity() == true) && (matrix2.isIdentity() == false))
+    {
+        b = true;
+    }
+    else
+    {
+        b = false;
+    }
+    ASSERT_TRUE(b);
+}
+
+TEST(PIMathMatrixT_Test, isNull)
+{
+    PIMathMatrixT<rows, cols, double> matrix1;
+    PIMathMatrixT<rows, cols, double> matrix2;
+    bool b;
+    matrix2 = matr.filled(3.67);
+    if((matrix1.isNull() == true) && (matrix2.isNull() == false))
+    {
+        b = true;
+    }
+    else
+    {
+        b = false;
+    }
+    ASSERT_TRUE(b);
+}
+
+TEST(PIMathMatrixT_Test, operator_Assignment)
+{
+    PIMathMatrixT<rows, cols, double> matrix1;
+    PIMathMatrixT<rows, cols, double> matrix2;
+    int i = 0;
+    int j = 0;
+    int k = 0;
+    bool b;
+    matrix2.fill(6.72);
+    matrix1 = matrix2;
+    while(i < 9)
+    {
+        if(k < 3)
+        {
+            if(matrix1.at(j,k) == 6.72)
+            {
+                b = true;
+            }
+            else
+            {
+                b = false;
+                break;
+            }
+            k++;
+            if(k == 3)
+            {
+                j++;
+                k = 0;
+            }
+        }
+        i++;
+    }
+    ASSERT_TRUE(b);
+}
+
+TEST(PIMathMatrixT_Test, operator_Equal)
+{
+    PIMathMatrixT<rows, cols, double> matrix1;
+    PIMathMatrixT<rows, cols, double> matrix2;
+    bool b;
+    matr.at(0,0) = 3;
+    matr.at(0,1) = 6;
+    matr.at(0,2) = 8;
+    matr.at(1,0) = 2;
+    matr.at(1,1) = 1;
+    matr.at(1,2) = 4;
+    matr.at(2,0) = 6;
+    matr.at(2,1) = 2;
+    matr.at(2,2) = 5;
+    matrix1 = matr;
+    matrix2 = matr;
+    matrix2.at(2, 2) = 232;
+    if(((matr == matrix1) == true) && ((matr == matrix2) == false))
+    {
+        b = true;
+    }
+    else
+    {
+        b = false;
+    }
+    ASSERT_TRUE(b);
+}
+
+TEST(PIMathMatrixT_Test, operator_Not_Equal)
+{
+    PIMathMatrixT<rows, cols, double> matrix1;
+    PIMathMatrixT<rows, cols, double> matrix2;
+    bool b;
+    matr.at(0,0) = 3;
+    matr.at(0,1) = 6;
+    matr.at(0,2) = 8;
+    matr.at(1,0) = 2;
+    matr.at(1,1) = 1;
+    matr.at(1,2) = 4;
+    matr.at(2,0) = 6;
+    matr.at(2,1) = 2;
+    matr.at(2,2) = 5;
+    matrix1 = matr;
+    matrix2 = matr;
+    matrix2.at(2, 2) = 232;
+    if(((matr != matrix1) == false) && ((matr != matrix2) == true))
+    {
+        b = true;
+    }
+    else
+    {
+        b = false;
+    }
+    ASSERT_TRUE(b);
+}
+
+TEST(PIMathMatrixT_Test, operator_Addition_Aassignment)
+{
+    PIMathMatrixT<rows, cols, double> matrix1;
+    PIMathMatrixT<rows, cols, double> matrix2;
+    bool b;
+    int i = 0;
+    int j = 0;
+    int k = 0;
+    matrix2.fill(6.72);
+    matrix1.fill(1.0);
+    matrix1 += matrix2;
+    while(i < 9)
+    {
+        if(k < 3)
+        {
+            if(matrix1.at(j,k) == 7.72)
+            {
+                b = true;
+            }
+            else
+            {
+                b = false;
+                break;
+            }
+            k++;
+            if(k == 3)
+            {
+                j++;
+                k = 0;
+            }
+        }
+        i++;
+    }
+    ASSERT_TRUE(b);
+}
+
+TEST(PIMathMatrixT_Test, operator_Subtraction_Assignment)
+{
+    PIMathMatrixT<rows, cols, double> matrix1;
+    PIMathMatrixT<rows, cols, double> matrix2;
+    bool b;
+    int i = 0;
+    int j = 0;
+    int k = 0;
+    matrix2.fill(6.72);
+    matrix1.fill(1.0);
+    matrix1 -= matrix2;
+    while(i < 9)
+    {
+        if(k < 3)
+        {
+            if(matrix1.at(j,k) == -5.72)
+            {
+                b = true;
+            }
+            else
+            {
+                b = false;
+                break;
+            }
+            k++;
+            if(k == 3)
+            {
+                j++;
+                k = 0;
+            }
+        }
+        i++;
+    }
+    ASSERT_TRUE(b);
+}
+
+TEST(PIMathMatrixT_Test, operator_Multiplication_Assignment)
+{
+    PIMathMatrixT<rows, cols, double> matrix1;
+    bool b;
+    int i = 0;
+    int j = 0;
+    int k = 0;
+    matrix1.fill(6.72);
+    matrix1 *= 2.0;
+    while(i < 9)
+    {
+        if(k < 3)
+        {
+            if(matrix1.at(j,k) == 13.44)
+            {
+                b = true;
+            }
+            else
+            {
+                b = false;
+                break;
+            }
+            k++;
+            if(k == 3)
+            {
+                j++;
+                k = 0;
+            }
+        }
+        i++;
+    }
+    ASSERT_TRUE(b);
+}
+
+TEST(PIMathMatrixT_Test, operator_Division_Assignment)
+{
+    PIMathMatrixT<rows, cols, double> matrix1;
+    bool b;
+    int i = 0;
+    int j = 0;
+    int k = 0;
+    matrix1.fill(6.72);
+    matrix1 /= 2.0;
+    while(i < 9)
+    {
+        if(k < 3)
+        {
+            if(matrix1.at(j,k) == 3.36)
+            {
+                b = true;
+            }
+            else
+            {
+                b = false;
+                break;
+            }
+            k++;
+            if(k == 3)
+            {
+                j++;
+                k = 0;
+            }
+        }
+        i++;
+    }
+    ASSERT_TRUE(b);
+}
+
+TEST(PIMathMatrixT_Test, operator_Addition)
+{
+    PIMathMatrixT<rows, cols, double> matrix1;
+    PIMathMatrixT<rows, cols, double> matrix2;
+    bool b;
+    int i = 0;
+    int j = 0;
+    int k = 0;
+    matrix1.fill(6.72);
+    matrix2.fill(8.28);
+    while(i < 9)
+    {
+        if(k < 3)
+        {
+            if((matrix1 + matrix2).at(j,k) == 15.0)
+            {
+                b = true;
+            }
+            else
+            {
+                b = false;
+                break;
+            }
+            k++;
+            if(k == 3)
+            {
+                j++;
+                k = 0;
+            }
+        }
+        i++;
+    }
+    ASSERT_TRUE(b);
+}
+
+TEST(PIMathMatrixT_Test, operator_Subtraction)
+{
+    PIMathMatrixT<rows, cols, double> matrix1;
+    PIMathMatrixT<rows, cols, double> matrix2;
+    bool b;
+    int i = 0;
+    int j = 0;
+    int k = 0;
+    matrix1.fill(6.72);
+    matrix2.fill(8.28);
+    while(i < 9)
+    {
+        if(k < 3)
+        {
+            if(round((matrix1 - matrix2).at(j,k) * 10000) / 10000 == -1.56)
+            {
+                b = true;
+            }
+            else
+            {
+                b = false;
+                break;
+            }
+            k++;
+            if(k == 3)
+            {
+                j++;
+                k = 0;
+            }
+        }
+        i++;
+    }
+    ASSERT_TRUE(b);
+}
+
+TEST(PIMathMatrixT_Test, operator_Multiplication)
+{
+    PIMathMatrixT<rows, cols, double> matrix1;
+    PIMathMatrixT<rows, cols, double> matrix2;
+    bool b;
+    int i = 0;
+    int j = 0;
+    int k = 0;
+    matrix1.fill(6.72);
+    matrix2 = matrix1*4.0;
+    while(i < 9)
+    {
+        if(k < 3)
+        {
+            if(matrix2.at(j,k) == 26.88)
+            {
+                b = true;
+            }
+            else
+            {
+                b = false;
+                break;
+            }
+            k++;
+            if(k == 3)
+            {
+                j++;
+                k = 0;
+            }
+        }
+        i++;
+    }
+    ASSERT_TRUE(b);
+}
+TEST(PIMathMatrixT_Test, operator_Division)
+{
+    PIMathMatrixT<rows, cols, double> matrix1;
+    PIMathMatrixT<rows, cols, double> matrix2;
+    bool b;
+    int i = 0;
+    int j = 0;
+    int k = 0;
+    matrix1.fill(6.72);
+    matrix2 = matrix1/4.0;
+    while(i < 9)
+    {
+        if(k < 3)
+        {
+            if(matrix2.at(j,k) == 1.68)
+            {
+                b = true;
+            }
+            else
+            {
+                b = false;
+                break;
+            }
+            k++;
+            if(k == 3)
+            {
+                j++;
+                k = 0;
+            }
+        }
+        i++;
+    }
+    ASSERT_TRUE(b);
+}
+
+
+TEST(PIMathMatrixT_Test, determinant)
+{
+    double d;
+    double i = 59.0;
+    matr.at(0,0) = 3;
+    matr.at(0,1) = 6;
+    matr.at(0,2) = 8;
+    matr.at(1,0) = 2;
+    matr.at(1,1) = 1;
+    matr.at(1,2) = 4;
+    matr.at(2,0) = 6;
+    matr.at(2,1) = 2;
+    matr.at(2,2) = 5;
+    d = matr.determinant();
+    ASSERT_DOUBLE_EQ(i, d);
+}
+
+TEST(PIMathMatrixT_Test, invert)
+{
+    PIMathMatrixT<rows, cols, double> matrix1;
+    PIMathMatrixT<rows, cols, double> matrix2;
+    PIMathMatrixT<rows, cols, double> matrix3;
+    double d1, d2;
+    bool b;
+    matrix1 = matr.identity();
+    matr.at(0,0) = 3;
+    matr.at(0,1) = 6;
+    matr.at(0,2) = 8;
+    matr.at(1,0) = 2;
+    matr.at(1,1) = 1;
+    matr.at(1,2) = 4;
+    matr.at(2,0) = 6;
+    matr.at(2,1) = 2;
+    matr.at(2,2) = 5;
+    matrix2 = matr;
+    matr.invert();
+    d1 = matr.determinant();
+    d2 = matrix2.determinant();
+    matrix3 = matrix1;
+    matrix1.invert();
+    if((matrix1 == matrix3) && (d1 == 1/d2))
+    {
+        b = true;
+    }
+    else
+    {
+        b = false;
+    }
+    ASSERT_TRUE(b);
+}
+
+TEST(PIMathMatrixT_Test, inverted)
+{
+    PIMathMatrixT<rows, cols, double> matrix1;
+    PIMathMatrixT<rows, cols, double> matrix2;
+    PIMathMatrixT<rows, cols, double> matrix3;
+    double d1, d2;
+    bool b;
+    matrix1 = matr.identity();
+    matr.at(0,0) = 3;
+    matr.at(0,1) = 6;
+    matr.at(0,2) = 8;
+    matr.at(1,0) = 2;
+    matr.at(1,1) = 1;
+    matr.at(1,2) = 4;
+    matr.at(2,0) = 6;
+    matr.at(2,1) = 2;
+    matr.at(2,2) = 5;
+    matrix2 = matr.inverted();
+    d1 = matr.determinant();
+    d2 = matrix2.determinant();
+    matrix3 = matrix1.inverted();
+    if((matrix1 == matrix3) && (round((1/d1)*10000)/10000 == round(d2*10000)/10000))
+    {
+        b = true;
+    }
+    else
+    {
+        b = false;
+    }
+    ASSERT_TRUE(b);
+}
+
+TEST(PIMathMatrixT_Test, toUpperTriangular)
+{
+    PIMathMatrixT<rows, cols, double> matrix;
+    double d1, d2 = 1;
+    uint i;
+    matr.at(0,0) = 3;
+    matr.at(0,1) = 6;
+    matr.at(0,2) = 8;
+    matr.at(1,0) = 2;
+    matr.at(1,1) = 1;
+    matr.at(1,2) = 4;
+    matr.at(2,0) = 6;
+    matr.at(2,1) = 2;
+    matr.at(2,2) = 5;
+    matrix = matr.toUpperTriangular();
+    d1 = matrix.determinant();
+    for(i = 0; i < cols; i++)
+    {
+        d2 = d2*matrix.at(i,i);
+    }
+    ASSERT_DOUBLE_EQ(d1, d2);
+}
+
+TEST(PIMathMatrixT_Test, transposed)
+{
+    PIMathMatrixT<rows, cols, double> matrix1;
+    PIMathMatrixT<rows, cols, double> matrix2;
+    double d1, d2;
+    bool b;
+    matr.at(0,0) = 3;
+    matr.at(0,1) = 6;
+    matr.at(0,2) = 8;
+    matr.at(1,0) = 2;
+    matr.at(1,1) = 1;
+    matr.at(1,2) = 4;
+    matr.at(2,0) = 6;
+    matr.at(2,1) = 2;
+    matr.at(2,2) = 5;
+    d1 = matr.determinant();
+    matrix1 = matr.transposed();
+    d2 = matrix1.determinant();
+    matrix2 = matrix1.transposed();
+    if((d1 == d2) && (matr == matrix2))
+    {
+        b = true;
+    }
+    else
+    {
+        b = false;
+    }
+    ASSERT_TRUE(b);
+}
+
+TEST(PIMathMatrixT_Test, rotation)
+{
+    double angle = 1.0;
+    bool b;
+    PIMathMatrixT<2u, 2u, double> matrix = PIMathMatrixT<2u, 2u, double>::rotation(angle);
+    double c = cos(angle);
+    double s = sin(angle);
+    if((c == matrix.at(1u,1u)) && (c == matrix.at(0u,0u)) && (-s == matrix.at(0u,1u)) && (s == matrix.at(1u,0u)))
+    {
+        b = true;
+    }
+    else
+    {
+        b = false;
+    }
+    ASSERT_TRUE(b);
+}
+
+TEST(PIMathMatrixT_Test, scaleX_two)
+{
+    double factor = 5.64;
+    bool b;
+    PIMathMatrixT<2u, 2u, double> matrix = PIMathMatrixT<2u, 2u, double>::scaleX(factor);
+
+    if((1.0 == matrix.at(1u,1u)) && (factor == matrix.at(0u,0u)))
+    {
+        b = true;
+    }
+    else
+    {
+        b = false;
+    }
+    ASSERT_TRUE(b);
+}
+
+TEST(PIMathMatrixT_Test, scaleY_two)
+{
+    double factor = 5.64;
+    bool b;
+    PIMathMatrixT<2u, 2u, double> matrix = PIMathMatrixT<2u, 2u, double>::scaleY(factor);
+
+    if((factor == matrix.at(1u,1u)) && (1.0 == matrix.at(0u,0u)))
+    {
+        b = true;
+    }
+    else
+    {
+        b = false;
+    }
+    ASSERT_TRUE(b);
+}
+
+TEST(PIMathMatrixT_Test, rotationX)
+{
+    double angle = 1.0;
+    bool b;
+    double c = cos(angle);
+    double s = sin(angle);
+    PIMathMatrixT<3u, 3u, double> matrix = PIMathMatrixT<3u, 3u, double>::rotationX(angle);
+
+    if((1.0 == matrix.at(0u,0u)) && (c == matrix.at(1u,1u)) && (c == matrix.at(2u,2u)) && (s == matrix.at(2u,1u)) && (-s == matrix.at(1u,2u)))
+    {
+        b = true;
+    }
+    else
+    {
+        b = false;
+    }
+    ASSERT_TRUE(b);
+}
+
+TEST(PIMathMatrixT_Test, rotationY)
+{
+    double angle = 1.0;
+    bool b;
+    double c = cos(angle);
+    double s = sin(angle);
+    PIMathMatrixT<3u, 3u, double> matrix = PIMathMatrixT<3u, 3u, double>::rotationY(angle);
+
+    if((1.0 == matrix.at(1u,1u)) && (c == matrix.at(0u,0u)) && (c == matrix.at(2u,2u)) && (s == matrix.at(0u,2u)) && (-s == matrix.at(2u,0u)))
+    {
+        b = true;
+    }
+    else
+    {
+        b = false;
+    }
+    ASSERT_TRUE(b);
+}
+
+TEST(PIMathMatrixT_Test, rotationZ)
+{
+    double angle = 1.0;
+    bool b;
+    double c = cos(angle);
+    double s = sin(angle);
+    PIMathMatrixT<3u, 3u, double> matrix = PIMathMatrixT<3u, 3u, double>::rotationZ(angle);
+
+    if((1.0 == matrix.at(2u,2u)) && (c == matrix.at(0u,0u)) && (c == matrix.at(1u,1u)) && (s == matrix.at(1u,0u)) && (-s == matrix.at(0u,1u)))
+    {
+        b = true;
+    }
+    else
+    {
+        b = false;
+    }
+    ASSERT_TRUE(b);
+}
+
+TEST(PIMathMatrixT_Test, scaleX_three)
+{
+    double factor = 23.65;
+    bool b;
+    PIMathMatrixT<3u, 3u, double> matrix = PIMathMatrixT<3u, 3u, double>::scaleX(factor);
+    if((1.0 == matrix.at(2u,2u)) && (factor == matrix.at(0u,0u)) && (1.0 == matrix.at(1u,1u)))
+    {
+        b = true;
+    }
+    else
+    {
+        b = false;
+    }
+    ASSERT_TRUE(b);
+}
+
+TEST(PIMathMatrixT_Test, scaleY_three)
+{
+    double factor = 23.65;
+    bool b;
+    PIMathMatrixT<3u, 3u, double> matrix = PIMathMatrixT<3u, 3u, double>::scaleY(factor);
+    if((1.0 == matrix.at(2u,2u)) && (1.0 == matrix.at(0u,0u)) && (factor == matrix.at(1u,1u)))
+    {
+        b = true;
+    }
+    else
+    {
+        b = false;
+    }
+    ASSERT_TRUE(b);
+}
+
+TEST(PIMathMatrixT_Test, scaleZ_three)
+{
+    double factor = 23.65;
+    bool b;
+    PIMathMatrixT<3u, 3u, double> matrix = PIMathMatrixT<3u, 3u, double>::scaleZ(factor);
+    if((factor == matrix.at(2u,2u)) && (1.0 == matrix.at(0u,0u)) && (1.0 == matrix.at(1u,1u)))
+    {
+        b = true;
+    }
+    else
+    {
+        b = false;
+    }
+    ASSERT_TRUE(b);
+}
+