├── cmake └── math3dConfig.cmake.in ├── include └── math3d │ ├── core.h │ ├── opflags.h │ ├── math3d.hpp │ ├── utils.h │ ├── lu.hpp │ ├── vecn.hpp │ ├── quaternion.hpp │ ├── matn.hpp │ └── core.cuh ├── examples ├── CMakeLists.txt ├── vector.cpp └── matrix.cpp ├── tests ├── CMakeLists.txt ├── test_math3d.cpp ├── test_lu.cpp ├── test_vecn.cpp ├── test_matn.cpp └── test_quaternion.cpp ├── .gitignore ├── LICENSE ├── src └── utils.cpp ├── CMakeLists.txt └── README.md /cmake/math3dConfig.cmake.in: -------------------------------------------------------------------------------- 1 | @PACKAGE_INIT@ 2 | 3 | include("${CMAKE_CURRENT_LIST_DIR}/@PROJECT_NAME@Targets.cmake") 4 | check_required_components("@PROJECT_NAME@") 5 | -------------------------------------------------------------------------------- /include/math3d/core.h: -------------------------------------------------------------------------------- 1 | #ifndef CORE_H 2 | #define CORE_H 3 | 4 | #include "lu.hpp" 5 | #include "matn.hpp" 6 | #include "opflags.h" 7 | #include "quaternion.hpp" 8 | #include "vecn.hpp" 9 | 10 | #endif 11 | -------------------------------------------------------------------------------- /examples/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | 2 | add_executable(vectorExample "vector.cpp") 3 | target_link_libraries(vectorExample PRIVATE ${PROJECT_NAME}) 4 | 5 | 6 | add_executable(matrixExample "matrix.cpp") 7 | target_link_libraries(matrixExample PRIVATE ${PROJECT_NAME}) 8 | -------------------------------------------------------------------------------- /tests/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # declare test executable 2 | 3 | 4 | include(FetchContent) 5 | 6 | FetchContent_Declare( 7 | googletest 8 | GIT_REPOSITORY https://github.com/google/googletest.git 9 | GIT_TAG v1.14.0 10 | ) 11 | FetchContent_MakeAvailable(googletest) 12 | add_library(GTest::GTest INTERFACE IMPORTED) 13 | target_link_libraries(GTest::GTest INTERFACE gtest_main) 14 | 15 | add_executable( 16 | ${PROJECT_NAME}_Test 17 | "test_matn.cpp" 18 | "test_vecn.cpp" 19 | "test_quaternion.cpp" 20 | "test_lu.cpp" 21 | "test_math3d.cpp" 22 | ) 23 | 24 | target_link_libraries(${PROJECT_NAME}_Test PRIVATE GTest::GTest ${PROJECT_NAME}) 25 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | # Prerequisites 2 | *.d 3 | 4 | # Compiled Object files 5 | *.slo 6 | *.lo 7 | *.o 8 | *.obj 9 | 10 | # Precompiled Headers 11 | *.gch 12 | *.pch 13 | 14 | # Compiled Dynamic libraries 15 | *.so 16 | *.dylib 17 | *.dll 18 | 19 | # Fortran module files 20 | *.mod 21 | *.smod 22 | 23 | # Compiled Static libraries 24 | *.lai 25 | *.la 26 | *.a 27 | *.lib 28 | 29 | # Executables 30 | *.exe 31 | *.out 32 | *.app 33 | 34 | # cmake 35 | CMakeLists.txt.user 36 | CMakeCache.txt 37 | CMakeFiles 38 | CMakeScripts 39 | Testing 40 | Makefile 41 | cmake_install.cmake 42 | install_manifest.txt 43 | compile_commands.json 44 | CTestTestfile.cmake 45 | _deps 46 | 47 | # build 48 | build/ 49 | test/ 50 | -------------------------------------------------------------------------------- /include/math3d/opflags.h: -------------------------------------------------------------------------------- 1 | #ifndef OPFLAGS_H 2 | #define OPFLAGS_H 3 | 4 | #include 5 | 6 | namespace math3d { 7 | 8 | enum opstatus_t : uint8_t { 9 | SUCCESS = 1, 10 | INDEX_ERROR = 2, 11 | SIZE_ERROR = 3, 12 | ARG_ERROR = 4, 13 | LU_ERROR = 5, 14 | NOT_IMPLEMENTED = 6 15 | }; 16 | 17 | struct OpResult { 18 | // 19 | size_t line_info = 0; 20 | const char *file_name{nullptr}; 21 | const char *fn_name{nullptr}; 22 | const char *call_name{nullptr}; 23 | const char *duration_info{nullptr}; 24 | 25 | opstatus_t status = NOT_IMPLEMENTED; 26 | bool success = false; 27 | 28 | OpResult() = default; 29 | ~OpResult() = default; 30 | 31 | OpResult(size_t line, const char *fname, 32 | const char *funcname, const char *cname, 33 | opstatus_t op) 34 | : line_info(line), file_name(fname), 35 | fn_name(funcname), call_name(cname), status(op), 36 | success(op == SUCCESS) {} 37 | }; 38 | 39 | } // namespace math3d 40 | 41 | #endif 42 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2023 DKE 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /src/utils.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | namespace math3d { 6 | 7 | bool CHECK(OpResult r) { return r.status == SUCCESS; } 8 | 9 | std::stringstream to_xml(const OpResult &res) { 10 | std::stringstream s; 11 | s << ""; 17 | return s; 18 | } 19 | OpResult INFO(const OpResult &res) { 20 | std::stringstream s = to_xml(res); 21 | std::cerr << s.str() << std::endl; 22 | return res; 23 | } 24 | OpResult INFO_VERBOSE(const OpResult &res) { 25 | return INFO(res); 26 | } 27 | 28 | } // namespace math3d 29 | 30 | // 31 | std::ostream &operator<<(std::ostream &out, 32 | math3d::opstatus_t flag) { 33 | switch (flag) { 34 | case math3d::SUCCESS: { 35 | out << "SUCCESS"; 36 | break; 37 | } 38 | case math3d::SIZE_ERROR: { 39 | out << "SIZE_ERROR"; 40 | break; 41 | } 42 | case math3d::INDEX_ERROR: { 43 | out << "INDEX_ERROR"; 44 | break; 45 | } 46 | case math3d::ARG_ERROR: { 47 | out << "ARG_ERROR"; 48 | break; 49 | } 50 | case math3d::NOT_IMPLEMENTED: { 51 | out << "NOT_IMPLEMENTED"; 52 | break; 53 | } 54 | case math3d::LU_ERROR: { 55 | out << "LU_DECOMPOSITION_ERROR"; 56 | break; 57 | } 58 | } 59 | return out; 60 | } 61 | -------------------------------------------------------------------------------- /CMakeLists.txt: -------------------------------------------------------------------------------- 1 | cmake_minimum_required(VERSION 3.12) 2 | 3 | project("math3d" 4 | VERSION 0.1.0 5 | DESCRIPTION "A C-ish C++ library with mostly n dimensional objects tailored for 3d math" 6 | HOMEPAGE_URL "https://github.com/D-K-E/math3d") 7 | 8 | 9 | include(GNUInstallDirs) 10 | 11 | add_library(${PROJECT_NAME} "src/utils.cpp") 12 | add_library(${PROJECT_NAME}::${PROJECT_NAME} ALIAS ${PROJECT_NAME}) 13 | 14 | 15 | target_include_directories( 16 | ${PROJECT_NAME} PUBLIC 17 | $ 18 | $) 19 | 20 | # provide install targets 21 | install(TARGETS ${PROJECT_NAME} 22 | EXPORT ${PROJECT_NAME}_Targets 23 | ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR} 24 | LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} 25 | RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}) 26 | 27 | 28 | include(CMakePackageConfigHelpers) 29 | write_basic_package_version_file("${PROJECT_NAME}ConfigVersion.cmake" 30 | VERSION ${PROJECT_VERSION} 31 | COMPATIBILITY SameMajorVersion) 32 | 33 | configure_package_config_file( 34 | "${PROJECT_SOURCE_DIR}/cmake/${PROJECT_NAME}Config.cmake.in" 35 | "${PROJECT_BINARY_DIR}/${PROJECT_NAME}Config.cmake" 36 | INSTALL_DESTINATION 37 | ${CMAKE_INSTALL_DATAROOTDIR}/${PROJECT_NAME}/cmake 38 | ) 39 | 40 | # create name space for selecting 41 | install(EXPORT ${PROJECT_NAME}_Targets 42 | FILE ${PROJECT_NAME}Targets.cmake 43 | NAMESPACE ${PROJECT_NAME}:: 44 | DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/${PROJECT_NAME}/cmake) 45 | 46 | 47 | install(FILES "${PROJECT_BINARY_DIR}/${PROJECT_NAME}Config.cmake" 48 | "${PROJECT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.cmake" 49 | DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/${PROJECT_NAME}/cmake) 50 | 51 | install(DIRECTORY ${PROJECT_SOURCE_DIR}/include/math3d DESTINATION include) 52 | 53 | option(MATH3D_BUILD_TESTS "Build test programs" OFF) 54 | if(MATH3D_BUILD_TESTS) 55 | add_subdirectory("tests") 56 | endif(MATH3D_BUILD_TESTS) 57 | 58 | option(MATH3D_BUILD_EXAMPLES "Build example programs" OFF) 59 | if (MATH3D_BUILD_EXAMPLES) 60 | add_subdirectory("examples") 61 | endif(MATH3D_BUILD_EXAMPLES) 62 | -------------------------------------------------------------------------------- /include/math3d/math3d.hpp: -------------------------------------------------------------------------------- 1 | #ifndef MATH3D_HPP 2 | #define MATH3D_HPP 3 | 4 | #include "core.h" 5 | #include "utils.h" 6 | 7 | namespace math3d { 8 | 9 | template 10 | OpResult to_skew_mat(const vecn::VecN &vec, 11 | matn::MatN &out) { 12 | // 13 | T a3; 14 | vec(2, a3); 15 | T a2; 16 | vec(1, a2); 17 | T a1; 18 | vec(0, a1); 19 | 20 | matn::MatN m; 21 | 22 | T c1[] = {0, a3, -a2}; 23 | T c2[] = {-a3, 0, a1}; 24 | T c3[] = {a2, -a1, 0}; 25 | m.set_column(0, c1); 26 | m.set_column(1, c2); 27 | m.set_column(2, c3); 28 | out = m; 29 | return OpResult(__LINE__, __FILE__, __FUNCTION__, 30 | "to_skew_mat", SUCCESS); 31 | } 32 | 33 | /**convert quaternion to rotation matrix 34 | from Vince, 2011, Quaternion ..., p. 123 35 | */ 36 | template 37 | OpResult toRotMat3x3(const quaternion::Quaternion &q_in, 38 | matn::MatN &out) { 39 | quaternion::Quaternion q; 40 | q_in.normalized(q); 41 | // 42 | T s; 43 | q.scalar(s); 44 | 45 | // 46 | vecn::VecN xyz; 47 | q.vector(xyz); 48 | T x; 49 | xyz(0, x); 50 | T y; 51 | xyz(1, y); 52 | T z; 53 | xyz(2, z); 54 | 55 | // to rotation matrix 56 | T c1_1 = 1 - (2 * ((y * y) + (z * z))); 57 | T c1_2 = 2 * (x * y + s * z); 58 | T c1_3 = 2 * (x * z - s * y); 59 | // 60 | T c2_1 = 2 * (x * y - s * z); 61 | T c2_2 = 1 - 2 * ((x * x) + (z * z)); 62 | T c2_3 = 2 * (y * z + s * x); 63 | // 64 | T c3_1 = 2 * (x * z + s * y); 65 | T c3_2 = 2 * (y * z - s * x); 66 | T c3_3 = 1 - 2 * ((x * x) + (y * y)); 67 | 68 | T c1[] = {c1_1, c1_2, c1_3}; 69 | T c2[] = {c2_1, c2_2, c2_3}; 70 | T c3[] = {c3_1, c3_2, c3_3}; 71 | matn::MatN m; 72 | m.set_column(0, c1); 73 | m.set_column(1, c2); 74 | m.set_column(2, c3); 75 | out = m; 76 | return OpResult(__LINE__, __FILE__, __FUNCTION__, 77 | "toRotMat3x3", SUCCESS); 78 | } 79 | 80 | template 81 | OpResult invert_mat(const matn::MatN &m, 82 | matn::MatN &out) { 83 | // 84 | lu::LUdecomp lu_d(m); 85 | matn::MatN B; 86 | matn::identity(B); 87 | matn::MatN inv_m; 88 | lu_d.solve_mat(B, inv_m); 89 | out = inv_m; 90 | return OpResult(__LINE__, __FILE__, __FUNCTION__, 91 | "invert_mat", SUCCESS); 92 | } 93 | 94 | } // namespace math3d 95 | 96 | #endif 97 | -------------------------------------------------------------------------------- /examples/vector.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | typedef float real; 4 | 5 | int main(void) { 6 | // 7 | math3d::vecn::VecN v1({-21, 1, 2, 1.53, 3}); 8 | math3d::vecn::VecN v2(3); 9 | 10 | // access to different properties of vector 11 | 12 | // size 13 | std::size_t size; 14 | v1(size); 15 | std::cout << (size == 5) << std::endl; 16 | // prints out: 1 17 | 18 | // all content 19 | real a[5]; 20 | v1(a); 21 | for (std::size_t i = 0; i < size; ++i) { 22 | std::cout << a[i] << " "; 23 | } 24 | std::cout << std::endl; 25 | // prints out: -21 1 2 1.53 3 26 | 27 | // single member 28 | real b; 29 | v1(3, b); 30 | std::cout << (b == 1.53f) << std::endl; 31 | // prints out: 1 32 | 33 | // set a new value 34 | v1(math3d::vecn::make_vecn_cell(0.1f, 1)); 35 | // or 36 | v1({.content = 0.1f, .index = 1}); 37 | 38 | // some basic math 39 | math3d::vecn::VecN out; 40 | v1.add(v2, out); 41 | std::cout << out << std::endl; 42 | // prints out: { -18, 3.1, 5, 4.53, 6 } 43 | 44 | // 45 | v1.subtract(v2, out); 46 | std::cout << out << std::endl; 47 | // prints out: { -24, -2.9, -1, -1.47, 0 } 48 | 49 | // elementwise multiplication 50 | v1.multiply(v2, out); 51 | std::cout << out << std::endl; 52 | // prints out: { -63, 0.3, 6, 4.59, 9 } 53 | 54 | v1.divide(v2, out); 55 | std::cout << out << std::endl; 56 | // prints out: { -7, 0.0333333, 0.666667, 0.51, 1 } 57 | 58 | // what if there is a 0 division? 59 | math3d::OpResult result = v1.divide(0, out); 60 | std::cout << (result.status == math3d::ARG_ERROR) 61 | << std::endl; 62 | // prints out: 1 63 | 64 | // notice the `out` doesn't get modified 65 | std::cout << out << std::endl; 66 | // prints out: { -7, 0.0333333, 0.666667, 0.51, 1 } 67 | 68 | // dot product 69 | real out2; 70 | v1.dot(v2, out2); 71 | std::cout << out2 << std::endl; 72 | // prints out: -43.11 73 | 74 | // some information about the call 75 | math3d::OpResult res; 76 | INFO_VERBOSE_MATH3D(v1.dot(v2, out2), res); 77 | // prints to std::cerr some useful information in xml 78 | // format 79 | /* 83 | */ 84 | 85 | // create a base vector 86 | math3d::vecn::base(out); 87 | std::cout << out << std::endl; 88 | // prints out: { 0, 1, 0, 0, 0 } 89 | 90 | math3d::vecn::base(out); 91 | std::cout << out << std::endl; 92 | // prints out: { 0, 0, 0, 1, 0 } 93 | 94 | return 0; 95 | } 96 | -------------------------------------------------------------------------------- /tests/test_math3d.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | typedef float real; 5 | using namespace math3d::lu; 6 | using namespace math3d::matn; 7 | using namespace math3d::vecn; 8 | using namespace math3d::quaternion; 9 | using namespace math3d; 10 | 11 | TEST(Math3DTest, test_invert_mat) { 12 | 13 | MatN m; 14 | m.set_column(0, {25, 64, 144}); 15 | m.set_column(1, {5, 8, 12}); 16 | m.set_column(2, {1, 1, 1}); 17 | MatN X; 18 | invert_mat(m, X); 19 | real c1[3], c2[3], c3[3]; 20 | X.get_column(0, c1); 21 | X.get_column(1, c2); 22 | X.get_column(2, c3); 23 | // 24 | EXPECT_EQ(std::round(c1[0] * 100.0f) / 100.0f, 0.05f); 25 | EXPECT_EQ(std::round(c1[1] * 100.0f) / 100.0f, -0.95f); 26 | EXPECT_EQ(std::round(c1[2] * 100.0f) / 100.0f, 4.57f); 27 | // 28 | EXPECT_EQ(std::round(c2[0] * 100.0f) / 100.0f, -0.08f); 29 | EXPECT_EQ(std::round(c2[1] * 100.0f) / 100.0f, 1.42f); 30 | EXPECT_EQ(std::round(c2[2] * 100.0f) / 100.0f, -5.0f); 31 | // 32 | EXPECT_EQ(std::round(c3[0] * 100.0f) / 100.0f, 0.04f); 33 | EXPECT_EQ(std::round(c3[1] * 100.0f) / 100.0f, -0.46f); 34 | EXPECT_EQ(std::round(c3[2] * 100.0f) / 100.0f, 1.43f); 35 | } 36 | 37 | TEST(Math3DTest, test_toRotMat3x3) { 38 | /* 39 | 0.35 + 0.2i + 0.3j + 0.1k 40 | 41 | 0.238095 0.190476 0.952381 42 | 0.72381 0.619048 -0.304762 43 | -0.647619 0.761905 0.0095236 44 | */ 45 | 46 | MatN m; 47 | Quaternion q(0.35f, 48 | VecN({0.2f, 0.3f, 0.1f})); 49 | toRotMat3x3(q, m); 50 | real c1[3], c2[3], c3[3]; 51 | m.get_column(0, c1); 52 | m.get_column(1, c2); 53 | m.get_column(2, c3); 54 | // 55 | EXPECT_EQ(std::round(c1[0] * 100.0f) / 100.0f, 0.24f); 56 | EXPECT_EQ(std::round(c1[1] * 100.0f) / 100.0f, 0.72f); 57 | EXPECT_EQ(std::round(c1[2] * 100.0f) / 100.0f, -0.65f); 58 | // 59 | EXPECT_EQ(std::round(c2[0] * 100.0f) / 100.0f, 0.19f); 60 | EXPECT_EQ(std::round(c2[1] * 100.0f) / 100.0f, 0.62f); 61 | EXPECT_EQ(std::round(c2[2] * 100.0f) / 100.0f, 0.76f); 62 | // 63 | EXPECT_EQ(std::round(c3[0] * 100.0f) / 100.0f, 0.95f); 64 | EXPECT_EQ(std::round(c3[1] * 100.0f) / 100.0f, -0.3f); 65 | EXPECT_EQ(std::round(c3[2] * 100.0f) / 100.0f, 0.01f); 66 | } 67 | 68 | TEST(Math3DTest, test_debug_check_m_true) { 69 | VecN v; 70 | std::size_t vsize = 5; 71 | OpResult res; 72 | CHECK_MATH3D(v(vsize), res); 73 | EXPECT_EQ(res.success, true); 74 | std::string cname = "v(vsize)"; 75 | std::string rcname = res.call_name; 76 | EXPECT_EQ(rcname, cname); 77 | } 78 | 79 | TEST(MatnTest, test_divide_scalar_value_false_check_macro) { 80 | 81 | real mv[] = {0, 1, 2, 0, 2, 4}; 82 | 83 | MatN m(mv); 84 | MatN out; 85 | auto r = CHECK(m.divide(0, out)); 86 | EXPECT_EQ(r, false); 87 | // 88 | } 89 | 90 | TEST(Math3DTest, test_debug_check_true) { 91 | VecN v; 92 | std::size_t vsize = 5; 93 | bool vflag = CHECK(v(vsize)); 94 | EXPECT_EQ(vflag, true); 95 | } 96 | -------------------------------------------------------------------------------- /examples/matrix.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | typedef float real; 4 | 5 | int main(void) { 6 | // empty constructor 7 | math3d::matn::MatN m1; 8 | 9 | // single array constructor 10 | math3d::matn::MatN m2({0, 1, 2, 0, 2, 4}); 11 | std::cout << m2 << std::endl; 12 | /** prints: 13 | 0 1 2 14 | 0 2 4 15 | */ 16 | 17 | // single value constructor 18 | math3d::matn::MatN m3(2.0f); 19 | std::cout << m3 << std::endl; 20 | /** 21 | 2 2 2 22 | 2 2 2 23 | */ 24 | 25 | // access to certain properties 26 | std::size_t snb; 27 | m2(snb); // get size 28 | std::cout << snb << std::endl; 29 | // 6 30 | 31 | std::size_t rnb, cols; 32 | auto r = m2(rnb, cols); // get row and col number 33 | std::cout << rnb << "x" << cols << std::endl; 34 | // 2x3 35 | 36 | // get column 37 | real c1[2]; 38 | m2.get_column(1, c1); 39 | for (std::size_t i = 0; i < 2; ++i) { 40 | std::cout << c1[i] << " "; 41 | } 42 | std::cout << std::endl; 43 | // prints: 1 2 44 | 45 | // get row 46 | real r1[3]; 47 | m2.get_row(1, r1); 48 | for (std::size_t i = 0; i < 3; ++i) { 49 | std::cout << r1[i] << " "; 50 | } 51 | std::cout << std::endl; 52 | // prints: 0 2 4 53 | 54 | // set value 55 | m2({.content = 1.1, .row = 0, .column = 1}); 56 | std::cout << m2 << std::endl; 57 | /* 58 | 0 1.1 2 59 | 0 2 4 60 | */ 61 | 62 | // set column 63 | c1[0] = 4.1f; 64 | c1[1] = 0.2f; 65 | m2.set_column(1, c1); 66 | std::cout << m2 << std::endl; 67 | /* 68 | 0 4.1 2 69 | 0 0.2 4 70 | */ 71 | 72 | // set row 73 | r1[0] = -1.1; 74 | r1[1] = 2.01; 75 | r1[2] = 3.1f; 76 | m2.set_row(1, r1); 77 | std::cout << m2 << std::endl; 78 | /* 79 | 0 4.1 2 80 | -1.1 2.01 3.1 81 | */ 82 | 83 | // set 2 rows 84 | real r2[3 * 2] = {1, 9, 6, 3, 0, 4}; 85 | math3d::matn::MatN padded; 86 | m1.add_rows<6>(r2, padded); 87 | std::cout << padded << std::endl; 88 | /* 89 | 0 0 90 | 0 0 91 | 0 0 92 | 1 9 93 | 6 3 94 | 0 4 95 | */ 96 | 97 | // transpose 98 | math3d::matn::MatN m2_T; 99 | m2.transpose(m2_T); 100 | std::cout << m2_T << std::endl; 101 | /** 102 | 0 4.1 103 | -1.1 2.01 104 | 3.1 0 105 | */ 106 | 107 | // some basic arithmetic 108 | math3d::matn::MatN mout; 109 | m2.add(m3, mout); 110 | std::cout << mout << std::endl; 111 | /* 112 | 2 6.1 4 113 | 0.9 4.01 5.1 114 | */ 115 | 116 | m2.subtract(m3, mout); 117 | std::cout << mout << std::endl; 118 | /* 119 | -2 2.1 0 120 | -3.1 0.009 1.1 121 | */ 122 | 123 | m2.hadamard_product(m3, mout); 124 | std::cout << mout << std::endl; 125 | /* 126 | 0 8.2 4 127 | -2.2 4.02 6.2 128 | */ 129 | 130 | m2.divide(m3, mout); 131 | std::cout << mout << std::endl; 132 | /* 133 | 0 2.05 1 134 | -0.55 1.005 1.55 135 | */ 136 | 137 | math3d::matn::MatN mout2; 138 | m2.multiply(m2_T, mout2); 139 | std::cout << mout2 << std::endl; 140 | /* 141 | 1.69 8.241 142 | 7.399 -0.4699 143 | */ 144 | 145 | // make the identity matrix 146 | math3d::matn::identity(mout2); 147 | std::cout << mout2 << std::endl; 148 | /* 149 | 1 0 150 | 0 1 151 | */ 152 | return 0; 153 | } 154 | -------------------------------------------------------------------------------- /tests/test_lu.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | typedef float real; 5 | using namespace math3d::lu; 6 | using namespace math3d::matn; 7 | using namespace math3d::vecn; 8 | using namespace math3d; 9 | 10 | /** 11 | all test values are 12 | from:https://math.libretexts.org/Bookshelves/Linear_Algebra/Introduction_to_Matrix_Algebra_(Kaw)/01%3A_Chapters/1.07%3A_LU_Decomposition_Method_for_Solving_Simultaneous_Linear_Equations 13 | */ 14 | 15 | TEST(LUTest, test_L) { 16 | // 17 | 18 | MatN m; 19 | m.set_column(0, {25, 64, 144}); 20 | m.set_column(1, {5, 8, 12}); 21 | m.set_column(2, {1, 1, 1}); 22 | LUdecomp lu_d(m); 23 | MatN L; 24 | lu_d.lower(L); 25 | real row1[3], row2[3], row3[3]; 26 | L.get_row(0, row1); 27 | L.get_row(1, row2); 28 | L.get_row(2, row3); 29 | // 30 | EXPECT_EQ(row1[0], 1); 31 | EXPECT_EQ(row1[1], 0); 32 | EXPECT_EQ(row1[2], 0); 33 | // 34 | EXPECT_EQ(std::round(row2[0] * 100.0f) / 100.0f, 2.56f); 35 | EXPECT_EQ(std::round(row2[1] * 100.0f) / 100.0f, 1.0f); 36 | EXPECT_EQ(std::round(row2[2] * 100.0f) / 100.0f, 0); 37 | // 38 | EXPECT_EQ(std::round(row3[0] * 100.0f) / 100.0f, 5.76f); 39 | EXPECT_EQ(std::round(row3[1] * 100.0f) / 100.0f, 3.5f); 40 | EXPECT_EQ(std::round(row3[2] * 100.0f) / 100.0f, 1.0); 41 | } 42 | TEST(LUTest, test_U) { 43 | 44 | MatN m; 45 | m.set_column(0, {25, 64, 144}); 46 | m.set_column(1, {5, 8, 12}); 47 | m.set_column(2, {1, 1, 1}); 48 | LUdecomp lu_d(m); 49 | MatN U; 50 | lu_d.upper(U); 51 | real row1[3], row2[3], row3[3]; 52 | U.get_row(0, row1); 53 | U.get_row(1, row2); 54 | U.get_row(2, row3); 55 | // 56 | EXPECT_EQ(row1[0], 25); 57 | EXPECT_EQ(row1[1], 5); 58 | EXPECT_EQ(row1[2], 1); 59 | // 60 | EXPECT_EQ(std::round(row2[0] * 100.0f) / 100.0f, 0); 61 | EXPECT_EQ(std::round(row2[1] * 100.0f) / 100.0f, -4.8f); 62 | EXPECT_EQ(std::round(row2[2] * 100.0f) / 100.0f, -1.56f); 63 | // 64 | EXPECT_EQ(std::round(row3[0] * 100.0f) / 100.0f, 0); 65 | EXPECT_EQ(std::round(row3[1] * 100.0f) / 100.0f, 0); 66 | EXPECT_EQ(std::round(row3[2] * 100.0f) / 100.0f, 0.7f); 67 | } 68 | TEST(LUTest, test_solve_forward) { 69 | 70 | MatN m; 71 | m.set_column(0, {25, 64, 144}); 72 | m.set_column(1, {5, 8, 12}); 73 | m.set_column(2, {1, 1, 1}); 74 | VecN b({106.8f, 177.2f, 279.2f}); 75 | LUdecomp lu_d(m); 76 | VecN x; 77 | lu_d.solve_forward(b, x); 78 | real row[3]; 79 | x(row); 80 | // 81 | EXPECT_EQ(std::round(row[0] * 100.0f) / 100.0f, 106.8f); 82 | EXPECT_EQ(std::round(row[1] * 100.0f) / 100.0f, -96.21f); 83 | EXPECT_EQ(std::round(row[2] * 100.0f) / 100.0f, 0.76f); 84 | // 85 | } 86 | TEST(LUTest, test_solve_backward) { 87 | 88 | MatN m; 89 | m.set_column(0, {25, 64, 144}); 90 | m.set_column(1, {5, 8, 12}); 91 | m.set_column(2, {1, 1, 1}); 92 | 93 | VecN b({106.8f, -96.21f, 0.76f}); 94 | LUdecomp lu_d(m); 95 | VecN x; 96 | lu_d.solve_backward(b, x); 97 | real row[3]; 98 | x(row); 99 | // 100 | EXPECT_EQ(std::round(row[0] * 100.0f) / 100.0f, 0.29f); 101 | EXPECT_EQ(std::round(row[1] * 100.0f) / 100.0f, 19.69f); 102 | EXPECT_EQ(std::round(row[2] * 100.0f) / 100.0f, 1.09f); 103 | // 104 | } 105 | 106 | TEST(LUTest, test_solve) { 107 | 108 | MatN m; 109 | m.set_column(0, {25, 64, 144}); 110 | m.set_column(1, {5, 8, 12}); 111 | m.set_column(2, {1, 1, 1}); 112 | VecN b({106.8f, 177.2f, 279.2f}); 113 | LUdecomp lu_d(m); 114 | VecN x; 115 | lu_d.solve(b, x); 116 | real row[3]; 117 | x(row); 118 | // 119 | EXPECT_EQ(std::round(row[0] * 100.0f) / 100.0f, 0.29f); 120 | EXPECT_EQ(std::round(row[1] * 100.0f) / 100.0f, 19.69f); 121 | EXPECT_EQ(std::round(row[2] * 100.0f) / 100.0f, 1.09f); 122 | // 123 | } 124 | 125 | TEST(LUTest, test_solve_mat) { 126 | 127 | MatN m; 128 | m.set_column(0, {25, 64, 144}); 129 | m.set_column(1, {5, 8, 12}); 130 | m.set_column(2, {1, 1, 1}); 131 | MatN B; 132 | identity(B); 133 | LUdecomp lu_d(m); 134 | MatN X; 135 | lu_d.solve_mat<3>(B, X); 136 | real c1[3], c2[3], c3[3]; 137 | X.get_column(0, c1); 138 | X.get_column(1, c2); 139 | X.get_column(2, c3); 140 | // 141 | EXPECT_EQ(std::round(c1[0] * 100.0f) / 100.0f, 0.05f); 142 | EXPECT_EQ(std::round(c1[1] * 100.0f) / 100.0f, -0.95f); 143 | EXPECT_EQ(std::round(c1[2] * 100.0f) / 100.0f, 4.57f); 144 | // 145 | EXPECT_EQ(std::round(c2[0] * 100.0f) / 100.0f, -0.08f); 146 | EXPECT_EQ(std::round(c2[1] * 100.0f) / 100.0f, 1.42f); 147 | EXPECT_EQ(std::round(c2[2] * 100.0f) / 100.0f, -5.0f); 148 | // 149 | EXPECT_EQ(std::round(c3[0] * 100.0f) / 100.0f, 0.04f); 150 | EXPECT_EQ(std::round(c3[1] * 100.0f) / 100.0f, -0.46f); 151 | EXPECT_EQ(std::round(c3[2] * 100.0f) / 100.0f, 1.43f); 152 | } 153 | -------------------------------------------------------------------------------- /include/math3d/utils.h: -------------------------------------------------------------------------------- 1 | #include "core.h" 2 | #include 3 | #include 4 | #include 5 | 6 | std::ostream &operator<<(std::ostream &out, 7 | math3d::opstatus_t flag); 8 | 9 | template 10 | std::ostream & 11 | operator<<(std::ostream &out, 12 | const math3d::matn::MatN &m) { 13 | T arr[R * C]; 14 | m(arr); 15 | for (std::size_t i = 0; i < (R * C); i++) { 16 | if (i % C == 0) { 17 | out << std::endl; 18 | } 19 | out << " " << arr[i] << " "; 20 | } 21 | out << std::endl; 22 | return out; 23 | } 24 | 25 | template 26 | std::ostream & 27 | operator<<(std::ostream &out, 28 | const math3d::vecn::VecN &m) { 29 | T arr[R]; 30 | m(arr); 31 | out << "{ " << arr[0]; 32 | for (std::size_t i = 1; i < R; i++) { 33 | out << ", " << arr[i]; 34 | } 35 | out << " }"; 36 | return out; 37 | } 38 | 39 | template 40 | std::ostream & 41 | operator<<(std::ostream &out, 42 | const math3d::quaternion::QuaternionBase &b) { 43 | switch (b) { 44 | case math3d::quaternion::kSCALAR: { 45 | out << "scalar_base" << std::endl; 46 | break; 47 | } 48 | case math3d::quaternion::kI: { 49 | out << "i_base" << std::endl; 50 | break; 51 | } 52 | case math3d::quaternion::kJ: { 53 | out << "j_base::" << std::endl; 54 | break; 55 | } 56 | case math3d::quaternion::kK: { 57 | out << "k_base::" << std::endl; 58 | break; 59 | } 60 | } 61 | return out; 62 | } 63 | template 64 | std::ostream &operator<<( 65 | std::ostream &out, 66 | const math3d::quaternion::QuaternionComponent &c) { 67 | switch (c.base) { 68 | case math3d::quaternion::kSCALAR: { 69 | out << c.r << std::endl; 70 | break; 71 | } 72 | case math3d::quaternion::kI: { 73 | out << c.r << "i"; 74 | break; 75 | } 76 | case math3d::quaternion::kJ: { 77 | out << c.r << "j"; 78 | break; 79 | } 80 | case math3d::quaternion::kK: { 81 | out << c.r << "k"; 82 | break; 83 | } 84 | } 85 | return out; 86 | } 87 | 88 | template 89 | std::ostream & 90 | operator<<(std::ostream &out, 91 | const math3d::quaternion::Quaternion &q) { 92 | math3d::quaternion::QuaternionComponent c; 93 | q(math3d::quaternion::kSCALAR, c); 94 | out << c << " + "; 95 | q(math3d::quaternion::kI, c); 96 | out << c << " + "; 97 | q(math3d::quaternion::kJ, c); 98 | out << c << " + "; 99 | q(math3d::quaternion::kK, c); 100 | out << c << std::endl; 101 | return out; 102 | } 103 | 104 | namespace math3d { 105 | bool CHECK(OpResult r); 106 | OpResult INFO(const OpResult &res); 107 | OpResult INFO_VERBOSE(const OpResult &res); 108 | } // namespace math3d 109 | 110 | /**Checks if operation was successful*/ 111 | #define CHECK_MATH3D(call, res) \ 112 | do { \ 113 | res = call; \ 114 | res.call_name = #call; \ 115 | res.line_info = __LINE__; \ 116 | res.file_name = __FILE__; \ 117 | } while (0) 118 | 119 | /**Prints information about the operation*/ 120 | #define INFO_MATH3D(call, res) \ 121 | do { \ 122 | res = call; \ 123 | res.call_name = #call; \ 124 | res.line_info = __LINE__; \ 125 | res.file_name = __FILE__; \ 126 | if (res.status != SUCCESS) { \ 127 | res = math3d::INFO(res); \ 128 | } \ 129 | } while (0) 130 | 131 | /**Prints everything about operation result*/ 132 | #define INFO_VERBOSE_MATH3D(call, res) \ 133 | do { \ 134 | auto start = std::chrono::steady_clock::now(); \ 135 | res = call; \ 136 | auto stop = std::chrono::steady_clock::now(); \ 137 | auto duration = std::chrono::duration_cast< \ 138 | std::chrono::microseconds>(stop - start); \ 139 | auto str_inf = std::to_string( \ 140 | static_cast(duration.count())); \ 141 | res.duration_info = str_inf.c_str(); \ 142 | res.call_name = #call; \ 143 | res.line_info = __LINE__; \ 144 | res.file_name = __FILE__; \ 145 | INFO_VERBOSE(res); \ 146 | } while (0) 147 | -------------------------------------------------------------------------------- /include/math3d/lu.hpp: -------------------------------------------------------------------------------- 1 | #ifndef LU_HPP 2 | #define LU_HPP 3 | #include "matn.hpp" 4 | #include "vecn.hpp" 5 | namespace math3d { 6 | namespace lu { 7 | 8 | template struct LUdecomp { 9 | matn::MatN LU; 10 | /** 11 | decompose the given matrix into two matrices, L, U, so 12 | that A=LU 13 | implemented from Golub and Van Loan 2013, Matrix 14 | computations, p. 116, algorithm 3.2.1 15 | */ 16 | LUdecomp(const matn::MatN &in_m) { 17 | T mdata[N * N]; 18 | in_m(mdata); 19 | 20 | T ludata[N * N]; 21 | memcpy(ludata, mdata, (N * N) * sizeof(T)); 22 | 23 | // 24 | LU = matn::MatN(ludata); 25 | for (std::size_t k = 0; k < (N - 1); ++k) { 26 | // 27 | 28 | for (std::size_t r = k + 1; r < N; ++r) { 29 | // 30 | T r_k; 31 | LU(r, k, r_k); 32 | T k_k; 33 | LU(k, k, k_k); 34 | 35 | // set L 36 | LU(matn::make_matn_cell(r_k / k_k, r, k)); 37 | } 38 | for (std::size_t i = k + 1; i < N; ++i) { 39 | for (std::size_t j = k + 1; j < N; ++j) { 40 | // 41 | T i_k; 42 | LU(i, k, i_k); 43 | T k_j; 44 | LU(k, j, k_j); 45 | 46 | // 47 | T i_j; 48 | LU(i, j, i_j); 49 | LU(matn::make_matn_cell(i_j - i_k * k_j, i, j)); 50 | } 51 | } 52 | } 53 | } 54 | 55 | // tested 56 | OpResult upper(matn::MatN &U) const { 57 | for (std::size_t i = 0; i < N; ++i) { 58 | for (std::size_t j = i; j < N; ++j) { 59 | T udata; 60 | LU(i, j, udata); 61 | U({.content = udata, .row = i, .column = j}); 62 | } 63 | } 64 | return OpResult(__LINE__, __FILE__, __FUNCTION__, 65 | "upper", SUCCESS); 66 | } 67 | // tested 68 | OpResult lower(matn::MatN &L) const { 69 | matn::identity(L); 70 | for (std::size_t i = 0; i < (N - 1); ++i) { 71 | for (std::size_t j = i + 1; j < N; ++j) { 72 | T udata; 73 | LU(j, i, udata); 74 | L({.content = udata, .row = j, .column = i}); 75 | } 76 | } 77 | return OpResult(__LINE__, __FILE__, __FUNCTION__, 78 | "lower", SUCCESS); 79 | } 80 | 81 | // from Golub and Van Loan 2013, Matrix computations, p. 82 | // 108 83 | // tested 84 | OpResult solve_forward(const vecn::VecN &b, 85 | vecn::VecN &x) const { 86 | matn::MatN L; 87 | OpResult res = lower(L); 88 | T b_0; 89 | b(0, b_0); 90 | T L_0; 91 | L(0, 0, L_0); 92 | if (L_0 == 0) { 93 | return OpResult(__LINE__, __FILE__, __FUNCTION__, 94 | "solve_forward", ARG_ERROR); 95 | } 96 | x({.content = b_0 / L_0, .index = 0}); 97 | for (std::size_t i = 1; i < N; ++i) { 98 | T x_i; 99 | b(i, x_i); 100 | x({.content = x_i, .index = i}); 101 | 102 | // compute vdot 103 | T out = 0; 104 | for (std::size_t j = 0; j <= (i - 1); ++j) { 105 | T ij; 106 | L(i, j, ij); 107 | T x_j; 108 | x(j, x_j); 109 | out += ij * x_j; 110 | } 111 | 112 | x(i, x_i); 113 | T diff = x_i - out; 114 | 115 | T i_i; 116 | L(i, i, i_i); 117 | 118 | if (i_i == 0) { 119 | return OpResult(__LINE__, __FILE__, __FUNCTION__, 120 | "solve_forward", ARG_ERROR); 121 | } 122 | x({.content = diff / i_i, .index = i}); 123 | } 124 | return OpResult(__LINE__, __FILE__, __FUNCTION__, 125 | "solve_forward", SUCCESS); 126 | } 127 | 128 | // from Golub and Van Loan 2013, Matrix computations, p. 129 | // 108 130 | // tested 131 | OpResult solve_backward(const vecn::VecN &b, 132 | vecn::VecN &x) const { 133 | matn::MatN U; 134 | OpResult res = upper(U); 135 | T u_n; 136 | U(N - 1, N - 1, u_n); 137 | if (u_n == 0) { 138 | return OpResult(__LINE__, __FILE__, __FUNCTION__, 139 | "solve_backward", ARG_ERROR); 140 | } 141 | T b_n; 142 | b(N - 1, b_n); 143 | x({.content = b_n / u_n, .index = N - 1}); 144 | 145 | std::size_t i = N - 2; 146 | 147 | while (i >= 0) { 148 | T b_i; 149 | b(i, b_i); 150 | x({.content = b_i, .index = i}); 151 | 152 | // compute vdot 153 | T out = 0; 154 | for (std::size_t j = i + 1; j < N; ++j) { 155 | T ij; 156 | U(i, j, ij); 157 | T x_j; 158 | x(j, x_j); 159 | out += ij * x_j; 160 | } 161 | // 162 | T x_i; 163 | x(i, x_i); 164 | T i_i; 165 | U(i, i, i_i); 166 | 167 | if (i_i == 0) { 168 | return OpResult(__LINE__, __FILE__, __FUNCTION__, 169 | "solve_backward", ARG_ERROR); 170 | } 171 | 172 | x({.content = (x_i - out) / i_i, .index = i}); 173 | 174 | // size_t acts weird if we don't decrement it this way 175 | if (i == 0) { 176 | break; 177 | } else { 178 | --i; 179 | } 180 | } 181 | 182 | return OpResult(__LINE__, __FILE__, __FUNCTION__, 183 | "solve_backward", SUCCESS); 184 | } 185 | OpResult solve(const vecn::VecN &b, 186 | vecn::VecN &x) { 187 | vecn::VecN in_x; 188 | OpResult res = solve_forward(b, in_x); 189 | if (res.status != SUCCESS) { 190 | return res; 191 | } 192 | res = solve_backward(in_x, x); 193 | if (res.status != SUCCESS) { 194 | return res; 195 | } 196 | 197 | return OpResult(__LINE__, __FILE__, __FUNCTION__, 198 | "solve", SUCCESS); 199 | } 200 | 201 | // from Golub and Van Loan 2013, Matrix computations, p. 202 | // 108 203 | template 204 | OpResult solve_mat(const matn::MatN &B, 205 | matn::MatN &X) { 206 | for (std::size_t j = 0; j < Q; ++j) { 207 | // 208 | T b_j[N]; 209 | B.get_column(j, b_j); 210 | vecn::VecN b(b_j); 211 | 212 | T x_j[N]; 213 | X.get_column(j, x_j); 214 | // 215 | vecn::VecN x(x_j); 216 | OpResult res = solve(b, x); 217 | if (res.status != SUCCESS) { 218 | return res; 219 | } 220 | // pass data to x_j 221 | x(x_j); 222 | X.set_column(j, x_j); 223 | } 224 | return OpResult(__LINE__, __FILE__, __FUNCTION__, 225 | "solve_mat", SUCCESS); 226 | } 227 | }; 228 | 229 | } // namespace lu 230 | } // namespace math3d 231 | #endif 232 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # math3d 2 | yet another 3d math library 3 | 4 | This one doesn't throw any exceptions. It doesn't allocate memory on the heap. 5 | It doesn't contain any virtual function, nor a recursive function. It also 6 | doesn't use any function pointers. No concurrency and threading libraries are 7 | used either. All methods are `const` qualified except for setters. 8 | 9 | Hence it is highly compatible with OpenCL-C++ and CUDA at the same time. 10 | For CUDA, one would need to add `__host__`, `__device__` attributes in front 11 | of the methods. 12 | For OpenCL-C++ you probably don't need anything, just copy-paste the stuff 13 | into your kernel and it should be good to go. 14 | 15 | We also provide 2 optional headers for facilitating integration of this 16 | library to cuda/opencl projects: 17 | 18 | - `include/math3d/core.cuh`: contains all 4 objects (`VecN`, `MatN`, `Quaternion`, 19 | `LUdecomp`) in a single header. It is destined to be used in CUDA projects. 20 | 21 | - `include/math3d/core_cl.h`: contains all 4 objects (`VecN`, `MatN`, `Quaternion`, 22 | `LUdecomp`) in a single header. It is destined to be used in OpenCL-C++ 23 | projects. 24 | 25 | # Usage 26 | 27 | Here are some usage examples. 28 | 29 | The following snippet outlines several operations that can be done with 30 | vectors. 31 | 32 | ```c++ 33 | // vector example 34 | #include 35 | 36 | typedef float real; 37 | 38 | int main(void) { 39 | // 40 | math3d::vecn::VecN v1({-21, 1, 2, 1.53, 3}); 41 | math3d::vecn::VecN v2(3); 42 | 43 | // access to different properties of vector 44 | 45 | // size 46 | std::size_t size; 47 | v1(size); 48 | std::cout << (size == 5) << std::endl; 49 | // prints out: 1 50 | 51 | // all content 52 | real a[5]; 53 | v1(a); 54 | for (std::size_t i = 0; i < size; ++i) { 55 | std::cout << a[i] << " "; 56 | } 57 | std::cout << std::endl; 58 | // prints out: -21 1 2 1.53 3 59 | 60 | // single member 61 | real b; 62 | v1(3, b); 63 | std::cout << (b == 1.53f) << std::endl; 64 | // prints out: 1 65 | 66 | // set a new value 67 | v1(math3d::vecn::make_vecn_cell(0.1f, 1)); 68 | // or 69 | v1({.content = 0.1f, .index = 1}); 70 | 71 | // some basic math 72 | math3d::vecn::VecN out; 73 | v1.add(v2, out); 74 | std::cout << out << std::endl; 75 | // prints out: { -18, 3.1, 5, 4.53, 6 } 76 | 77 | // 78 | v1.subtract(v2, out); 79 | std::cout << out << std::endl; 80 | // prints out: { -24, -2.9, -1, -1.47, 0 } 81 | 82 | // elementwise multiplication 83 | v1.multiply(v2, out); 84 | std::cout << out << std::endl; 85 | // prints out: { -63, 0.3, 6, 4.59, 9 } 86 | 87 | v1.divide(v2, out); 88 | std::cout << out << std::endl; 89 | // prints out: { -7, 0.0333333, 0.666667, 0.51, 1 } 90 | 91 | // what if there is a 0 division? 92 | math3d::OpResult result = v1.divide(0, out); 93 | std::cout << (result.status == math3d::ARG_ERROR) 94 | << std::endl; 95 | // prints out: 1 96 | 97 | // notice the `out` doesn't get modified 98 | std::cout << out << std::endl; 99 | // prints out: { -7, 0.0333333, 0.666667, 0.51, 1 } 100 | 101 | // dot product 102 | real out2; 103 | v1.dot(v2, out2); 104 | std::cout << out2 << std::endl; 105 | // prints out: -43.11 106 | 107 | // some information about the call 108 | math3d::OpResult res; 109 | INFO_VERBOSE_MATH3D(v1.dot(v2, out2), res); 110 | // prints to std::cerr some useful information in xml 111 | // format 112 | /* 116 | */ 117 | 118 | // create a base vector 119 | math3d::vecn::base(out); 120 | std::cout << out << std::endl; 121 | // prints out: { 0, 1, 0, 0, 0 } 122 | 123 | math3d::vecn::base(out); 124 | std::cout << out << std::endl; 125 | // prints out: { 0, 0, 0, 1, 0 } 126 | 127 | return 0; 128 | } 129 | ``` 130 | 131 | The following snippet outlines several operations that can be done with 132 | matrices: 133 | ```c++ 134 | // matrix example 135 | #include 136 | 137 | typedef float real; 138 | 139 | int main(void) { 140 | // empty constructor 141 | math3d::matn::MatN m1; 142 | 143 | // single array constructor 144 | math3d::matn::MatN m2({0, 1, 2, 0, 2, 4}); 145 | std::cout << m2 << std::endl; 146 | /** prints: 147 | 0 1 2 148 | 0 2 4 149 | */ 150 | 151 | // single value constructor 152 | math3d::matn::MatN m3(2.0f); 153 | std::cout << m3 << std::endl; 154 | /** 155 | 2 2 2 156 | 2 2 2 157 | */ 158 | 159 | // access to certain properties 160 | std::size_t snb; 161 | m2(snb); // get size 162 | std::cout << snb << std::endl; 163 | // 6 164 | 165 | std::size_t rnb, cols; 166 | auto r = m2(rnb, cols); // get row and col number 167 | std::cout << rnb << "x" << cols << std::endl; 168 | // 2x3 169 | 170 | // get column 171 | real c1[2]; 172 | m2.get_column(1, c1); 173 | for (std::size_t i = 0; i < 2; ++i) { 174 | std::cout << c1[i] << " "; 175 | } 176 | std::cout << std::endl; 177 | // prints: 1 2 178 | 179 | // get row 180 | real r1[3]; 181 | m2.get_row(1, r1); 182 | for (std::size_t i = 0; i < 3; ++i) { 183 | std::cout << r1[i] << " "; 184 | } 185 | std::cout << std::endl; 186 | // prints: 0 2 4 187 | 188 | // set value 189 | m2({.content = 1.1, .row = 0, .column = 1}); 190 | std::cout << m2 << std::endl; 191 | /* 192 | 0 1.1 2 193 | 0 2 4 194 | */ 195 | 196 | // set column 197 | c1[0] = 4.1f; 198 | c1[1] = 0.2f; 199 | m2.set_column(1, c1); 200 | std::cout << m2 << std::endl; 201 | /* 202 | 0 4.1 2 203 | 0 0.2 4 204 | */ 205 | 206 | // set row 207 | r1[0] = -1.1; 208 | r1[1] = 2.01; 209 | r1[2] = 3.1f; 210 | m2.set_row(1, r1); 211 | std::cout << m2 << std::endl; 212 | /* 213 | 0 4.1 2 214 | -1.1 2.01 3.1 215 | */ 216 | 217 | // set 2 rows 218 | real r2[3 * 2] = {1, 9, 6, 3, 0, 4}; 219 | math3d::matn::MatN padded; 220 | m1.add_rows<6>(r2, padded); 221 | std::cout << padded << std::endl; 222 | /* 223 | 0 0 224 | 0 0 225 | 0 0 226 | 1 9 227 | 6 3 228 | 0 4 229 | */ 230 | 231 | // transpose 232 | math3d::matn::MatN m2_T; 233 | m2.transpose(m2_T); 234 | std::cout << m2_T << std::endl; 235 | /** 236 | 0 4.1 237 | -1.1 2.01 238 | 3.1 0 239 | */ 240 | 241 | // some basic arithmetic 242 | math3d::matn::MatN mout; 243 | m2.add(m3, mout); 244 | std::cout << mout << std::endl; 245 | /* 246 | 2 6.1 4 247 | 0.9 4.01 5.1 248 | */ 249 | 250 | m2.subtract(m3, mout); 251 | std::cout << mout << std::endl; 252 | /* 253 | -2 2.1 0 254 | -3.1 0.009 1.1 255 | */ 256 | 257 | m2.hadamard_product(m3, mout); 258 | std::cout << mout << std::endl; 259 | /* 260 | 0 8.2 4 261 | -2.2 4.02 6.2 262 | */ 263 | 264 | m2.divide(m3, mout); 265 | std::cout << mout << std::endl; 266 | /* 267 | 0 2.05 1 268 | -0.55 1.005 1.55 269 | */ 270 | 271 | math3d::matn::MatN mout2; 272 | m2.multiply(m2_T, mout2); 273 | std::cout << mout2 << std::endl; 274 | /* 275 | 1.69 8.241 276 | 7.399 -0.4699 277 | */ 278 | 279 | // make the identity matrix 280 | math3d::matn::identity(mout2); 281 | std::cout << mout2 << std::endl; 282 | /* 283 | 1 0 284 | 0 1 285 | */ 286 | return 0; 287 | } 288 | ``` 289 | -------------------------------------------------------------------------------- /include/math3d/vecn.hpp: -------------------------------------------------------------------------------- 1 | #ifndef VECN_HPP 2 | #define VECN_HPP 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | 9 | #include "opflags.h" 10 | 11 | namespace math3d { 12 | namespace vecn { 13 | 14 | template struct VecNCell { 15 | T content; 16 | std::size_t index = 0; 17 | }; 18 | 19 | template 20 | VecNCell make_vecn_cell(const T &c, std::size_t i) { 21 | VecNCell cell{.content = c, .index = i}; 22 | return cell; 23 | } 24 | 25 | template class VecN { 26 | 27 | public: 28 | /*! Tested */ 29 | VecN() { 30 | for (std::size_t i = 0; i < N; ++i) { 31 | data[i] = 0; 32 | } 33 | } 34 | /*! Tested */ 35 | VecN(const T (&arr)[N]) { 36 | memcpy(data, arr, N * sizeof(T)); 37 | } 38 | VecN(T s) { 39 | for (std::size_t i = 0; i < N; ++i) { 40 | data[i] = s; 41 | } 42 | } 43 | /*! Tested */ 44 | OpResult operator()(std::size_t index, T &out) const { 45 | if (index >= N) { 46 | OpResult vflag(__LINE__, __FILE__, __FUNCTION__, 47 | "(size_t, T&)", INDEX_ERROR); 48 | return vflag; 49 | } 50 | out = data[index]; 51 | OpResult vflag(__LINE__, __FILE__, __FUNCTION__, 52 | "(size_t, T&)", SUCCESS); 53 | return vflag; 54 | } 55 | OpResult operator()(T (&out)[N]) const { 56 | memcpy(out, data, N * sizeof(T)); 57 | OpResult vflag(__LINE__, __FILE__, __FUNCTION__, 58 | "(T (&)[N])", SUCCESS); 59 | return vflag; 60 | } 61 | constexpr OpResult operator()(std::size_t &out) const { 62 | out = N; 63 | OpResult vflag(__LINE__, __FILE__, __FUNCTION__, 64 | "(size_t)", SUCCESS); 65 | return vflag; 66 | } 67 | 68 | /*! Tested */ 69 | OpResult operator()(const VecNCell &cell) { 70 | if (cell.index >= N) { 71 | return OpResult(__LINE__, __FILE__, __FUNCTION__, 72 | "(const VecNCell&)", INDEX_ERROR); 73 | } 74 | data[cell.index] = cell.content; 75 | 76 | return OpResult(__LINE__, __FILE__, __FUNCTION__, 77 | "(const VecNCell&)", SUCCESS); 78 | } 79 | 80 | /*! Tested */ 81 | OpResult add(T v, T (&out)[N]) const { 82 | VecN v_1(v); 83 | T v_in[N]; 84 | v_1(v_in); 85 | // 86 | auto res = add(v_in, out); 87 | OpResult vflag(__LINE__, __FILE__, __FUNCTION__, 88 | "add(T, T (&)[N])", res.status); 89 | return vflag; 90 | } 91 | 92 | /*! Tested */ 93 | OpResult add(T v, VecN &vout) const { 94 | T out[N]; 95 | auto res = add(v, out); 96 | vout = VecN(out); 97 | 98 | OpResult vflag(__LINE__, __FILE__, __FUNCTION__, 99 | "add(T, VecN&", res.status); 100 | return vflag; 101 | } 102 | /*! Tested */ 103 | OpResult add(const T (&v)[N], T (&out)[N]) const { 104 | auto fn = [](T thisel, T argel) { 105 | return thisel + argel; 106 | }; 107 | auto res = apply_el(v, fn, out); 108 | 109 | OpResult vflag(__LINE__, __FILE__, __FUNCTION__, 110 | "add(const T(&)[N], T (&)[N])", 111 | res.status); 112 | return vflag; 113 | } 114 | /*! Tested */ 115 | OpResult add(const VecN &v, VecN &out) const { 116 | T v_in[N]; 117 | v(v_in); 118 | T vout[N]; 119 | auto res = add(v_in, vout); 120 | out = VecN(vout); 121 | OpResult vflag(__LINE__, __FILE__, __FUNCTION__, 122 | "add(const VecN&, VecN&)", 123 | res.status); 124 | return vflag; 125 | } 126 | // 127 | OpResult subtract(T v, T (&out)[N]) const { 128 | VecN v_1(v); 129 | T v_in[N]; 130 | v_1(v_in); 131 | auto res = subtract(v_in, out); 132 | 133 | OpResult vflag(__LINE__, __FILE__, __FUNCTION__, 134 | "subtract(T, T (&)[N])", res.status); 135 | return vflag; 136 | } 137 | /*! Tested */ 138 | OpResult subtract(T v, VecN &vout) const { 139 | VecN v_1(v); 140 | T v_in[N]; 141 | v_1(v_in); 142 | T out[N]; 143 | auto res = subtract(v_in, out); 144 | vout = VecN(out); 145 | 146 | OpResult vflag(__LINE__, __FILE__, __FUNCTION__, 147 | "subtract(T, VecN&", res.status); 148 | return vflag; 149 | } 150 | /*! Tested */ 151 | OpResult subtract(const T (&v)[N], T (&out)[N]) const { 152 | auto fn = [](T thisel, T argel) { 153 | return thisel - argel; 154 | }; 155 | auto res = apply_el(v, fn, out); 156 | 157 | OpResult vflag(__LINE__, __FILE__, __FUNCTION__, 158 | "subtract(const T(&)[N], T (&)[N])", 159 | res.status); 160 | return vflag; 161 | } 162 | /*! Tested */ 163 | OpResult subtract(const VecN &v, 164 | VecN &out) const { 165 | T v_in[N]; 166 | v(v_in); 167 | T vout[N]; 168 | auto res = subtract(v_in, vout); 169 | out = VecN(vout); 170 | 171 | OpResult vflag( 172 | __LINE__, __FILE__, __FUNCTION__, 173 | "subtract(const VecN&, VecN&)", 174 | res.status); 175 | return vflag; 176 | } 177 | // 178 | OpResult multiply(T v, T (&out)[N]) const { 179 | T v_in[N]; 180 | VecN vv(v); 181 | vv(v_in); 182 | 183 | auto res = multiply(v_in, out); 184 | 185 | OpResult vflag(__LINE__, __FILE__, __FUNCTION__, 186 | "multiply(T, T (&)[N])", res.status); 187 | return vflag; 188 | } 189 | /*! Tested */ 190 | OpResult multiply(T v, VecN &vout) const { 191 | T v_in[N]; 192 | VecN vv(v); 193 | vv(v_in); 194 | 195 | T out[N]; 196 | auto res = multiply(v_in, out); 197 | vout = VecN(out); 198 | 199 | OpResult vflag(__LINE__, __FILE__, __FUNCTION__, 200 | "multiply(T, VecN&", res.status); 201 | return vflag; 202 | } 203 | /*! Tested */ 204 | OpResult multiply(const T (&v)[N], T (&out)[N]) const { 205 | auto fn = [](T thisel, T argel) { 206 | return thisel * argel; 207 | }; 208 | auto res = apply_el(v, fn, out); 209 | 210 | OpResult vflag(__LINE__, __FILE__, __FUNCTION__, 211 | "multiply(const T(&)[N], T (&)[N])", 212 | res.status); 213 | return vflag; 214 | } 215 | /*! Tested */ 216 | OpResult multiply(const VecN &v, 217 | VecN &out) const { 218 | T v_in[N]; 219 | v(v_in); 220 | T vout[N]; 221 | auto res = multiply(v_in, vout); 222 | out = VecN(vout); 223 | 224 | OpResult vflag( 225 | __LINE__, __FILE__, __FUNCTION__, 226 | "multiply(const VecN&, VecN&)", 227 | res.status); 228 | return vflag; 229 | } 230 | 231 | // 232 | OpResult divide(T v, T (&out)[N]) const { 233 | if (v == static_cast(0)) { 234 | OpResult vflag(__LINE__, __FILE__, __FUNCTION__, 235 | "divide(T, T (&)[N])", ARG_ERROR); 236 | return vflag; 237 | } 238 | 239 | T v_in[N]; 240 | VecN v_(v); 241 | v_(v_in); 242 | 243 | auto res = divide(v_in, out); 244 | 245 | OpResult vflag(__LINE__, __FILE__, __FUNCTION__, 246 | "divide(T, T (&)[N])", res.status); 247 | return vflag; 248 | } 249 | /*! Tested */ 250 | OpResult divide(T v, VecN &vout) const { 251 | // check for zero division 252 | if (v == static_cast(0)) { 253 | OpResult vflag(__LINE__, __FILE__, __FUNCTION__, 254 | "divide(T, VecN&", ARG_ERROR); 255 | return vflag; 256 | } 257 | T v_in[N]; 258 | VecN v_(v); 259 | v_(v_in); 260 | T out[N]; 261 | 262 | auto res = divide(v_in, out); 263 | vout = VecN(out); 264 | 265 | OpResult vflag(__LINE__, __FILE__, __FUNCTION__, 266 | "divide(T, VecN&", res.status); 267 | return vflag; 268 | } 269 | /*! Tested */ 270 | OpResult divide(const T (&v)[N], T (&out)[N]) const { 271 | for (std::size_t j = 0; j < N; j++) { 272 | if (v[j] == static_cast(0)) { 273 | OpResult vflag(__LINE__, __FILE__, __FUNCTION__, 274 | "divide(const T(&)[N], T (&)[N])", 275 | ARG_ERROR); 276 | return vflag; 277 | } 278 | } 279 | auto fn = [](T thisel, T argel) { 280 | return thisel / argel; 281 | }; 282 | auto res = apply_el(v, fn, out); 283 | 284 | OpResult vflag(__LINE__, __FILE__, __FUNCTION__, 285 | "divide(const T(&)[N], T (&)[N])", 286 | res.status); 287 | return vflag; 288 | } 289 | /*! Tested */ 290 | OpResult divide(const VecN &v, 291 | VecN &out) const { 292 | // check zero division 293 | T v_in[N]; 294 | v(v_in); 295 | T vout[N]; 296 | auto res = divide(v_in, vout); 297 | out = VecN(vout); 298 | 299 | OpResult vflag(__LINE__, __FILE__, __FUNCTION__, 300 | "divide(const VecN&, VecN&)", 301 | res.status); 302 | return vflag; 303 | } 304 | OpResult dot(const T &v, T &out) const { 305 | T v_in[N]; 306 | VecN v_(v); 307 | v_(v_in); 308 | dot(v_in, out); 309 | OpResult vflag(__LINE__, __FILE__, __FUNCTION__, 310 | "dot(const T&, T &)", SUCCESS); 311 | return vflag; 312 | } 313 | OpResult dot(const T (&v)[N], T &out) const { 314 | out = static_cast(0); 315 | for (std::size_t i = 0; i < N; i++) { 316 | out += data[i] * v[i]; 317 | } 318 | 319 | OpResult vflag(__LINE__, __FILE__, __FUNCTION__, 320 | "dot(const T(&)[N], T &)", SUCCESS); 321 | return vflag; 322 | } 323 | OpResult dot(const VecN &v, T &out) const { 324 | T v_in[N]; 325 | v(v_in); 326 | dot(v_in, out); 327 | 328 | OpResult vflag(__LINE__, __FILE__, __FUNCTION__, 329 | "dot(const VecN&, T &)", SUCCESS); 330 | return vflag; 331 | } 332 | 333 | OpResult cross(const VecN &v, 334 | VecN &out) const { 335 | OpResult vflag(__LINE__, __FILE__, __FUNCTION__, 336 | "cross(const VecN&, VecN &)", 337 | NOT_IMPLEMENTED); 338 | return vflag; 339 | } 340 | 341 | private: 342 | /** holds the vector data*/ 343 | T data[N]; 344 | 345 | template 346 | OpResult apply_el(const T (&v)[N], const Func &fn, 347 | T (&out)[N]) const { 348 | 349 | for (std::size_t i = 0; i < N; i++) { 350 | out[i] = fn(data[i], v[i]); 351 | } 352 | OpResult vflag( 353 | __LINE__, __FILE__, __FUNCTION__, 354 | "apply_el(const T(&)[N], const Func&, T(&)[N])", 355 | SUCCESS); 356 | return vflag; 357 | } 358 | }; 359 | 360 | template 361 | OpResult base(VecN &vout) { 362 | if (BaseOrder >= N) { 363 | OpResult vflag(__LINE__, __FILE__, __FUNCTION__, 364 | "base(VecN&)", ARG_ERROR); 365 | return vflag; 366 | } 367 | VecN out; 368 | out(make_vecn_cell(1, BaseOrder)); 369 | vout = out; 370 | OpResult vflag(__LINE__, __FILE__, __FUNCTION__, 371 | "base(VecN&)", SUCCESS); 372 | return vflag; 373 | } 374 | 375 | template 376 | OpResult cross(const VecN &v1, const VecN &v2, 377 | T &out) { 378 | T t1; 379 | v1(0, t1); 380 | T t2; 381 | v1(1, t2); 382 | T v_1; 383 | v2(0, v_1); 384 | T v_2; 385 | v2(1, v_2); 386 | T t1v2 = t1 * v_2; 387 | T t2v1 = t2 * v_1; 388 | out = t1v2 - t2v1; 389 | OpResult vflag(__LINE__, __FILE__, __FUNCTION__, 390 | "cross(const VecN&, T&)", SUCCESS); 391 | return vflag; 392 | } 393 | 394 | template 395 | OpResult cross(const VecN &a, const VecN &b, 396 | VecN &out) { 397 | T tx; 398 | a(0, tx); 399 | T ty; 400 | a(1, ty); 401 | T tz; 402 | a(2, tz); 403 | // 404 | T vx; 405 | b(0, vx); 406 | T vy; 407 | b(1, vy); 408 | T vz; 409 | b(2, vz); 410 | // 411 | T x = ty * vz - tz * vy; 412 | T y = tz * vx - tx * vz; 413 | T z = tx * vy - ty * vx; 414 | out(make_vecn_cell(x, 0)); 415 | out(make_vecn_cell(y, 1)); 416 | out(make_vecn_cell(z, 2)); 417 | OpResult vflag(__LINE__, __FILE__, __FUNCTION__, 418 | "cross(const VecN&, VecN&)", 419 | SUCCESS); 420 | return vflag; 421 | } 422 | 423 | } // namespace vecn 424 | } // namespace math3d 425 | 426 | #endif 427 | -------------------------------------------------------------------------------- /include/math3d/quaternion.hpp: -------------------------------------------------------------------------------- 1 | #ifndef QUATERNION_HPP 2 | #define QUATERNION_HPP 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | 9 | #include "opflags.h" 10 | #include "vecn.hpp" 11 | 12 | namespace math3d { 13 | namespace quaternion { 14 | // holds quaternion related operations 15 | 16 | /**Quaternion bases*/ 17 | enum QuaternionBase : std::uint8_t { 18 | kSCALAR = 1, // null value for quaternion base it has 19 | // no effect on computation 20 | kI = 2, // i base for the second quaternion component 21 | kJ = 3, // j base for the third quaternion component 22 | kK = 4 // k base for the fourth quaternion component 23 | }; 24 | 25 | /** 26 | \brief Quaternion component 27 | */ 28 | template struct QuaternionComponent { 29 | QuaternionBase base; 30 | T r; 31 | 32 | QuaternionComponent() : r(0), base(kSCALAR) {} 33 | QuaternionComponent(QuaternionBase b, T a) 34 | : base(b), r(a) {} 35 | }; 36 | 37 | template class Quaternion { 38 | public: 39 | Quaternion() 40 | : coeffs{static_cast(0), static_cast(1), 41 | static_cast(1), static_cast(1)} {} 42 | // 43 | Quaternion(T c1, const QuaternionComponent qs[3]) { 44 | coeffs[0] = c1; 45 | coeffs[static_cast(qs[0].base) - 1] = 46 | qs[0].r; 47 | coeffs[static_cast(qs[1].base) - 1] = 48 | qs[1].r; 49 | coeffs[static_cast(qs[2].base) - 1] = 50 | qs[2].r; 51 | } 52 | Quaternion(T c1, const vecn::VecN &vs) { 53 | coeffs[0] = c1; 54 | T v_0; 55 | vs(0, v_0); 56 | T v_1; 57 | vs(1, v_1); 58 | T v_2; 59 | vs(2, v_2); 60 | coeffs[1] = v_0; 61 | coeffs[2] = v_1; 62 | coeffs[3] = v_2; 63 | } 64 | 65 | Quaternion(const QuaternionComponent qs[4]) { 66 | coeffs[static_cast(qs[0].base) - 1] = 67 | qs[0].r; 68 | coeffs[static_cast(qs[1].base) - 1] = 69 | qs[1].r; 70 | coeffs[static_cast(qs[2].base) - 1] = 71 | qs[2].r; 72 | coeffs[static_cast(qs[3].base) - 1] = 73 | qs[3].r; 74 | } 75 | 76 | OpResult operator()(T &out) const { return scalar(out); } 77 | OpResult scalar(T &out) const { 78 | 79 | out = coeffs[0]; 80 | return OpResult(__LINE__, __FILE__, __FUNCTION__, 81 | "scalar", SUCCESS); 82 | } 83 | OpResult vector(vecn::VecN &out) const { 84 | T v[3]; 85 | v[0] = coeffs[1]; 86 | v[1] = coeffs[2]; 87 | v[2] = coeffs[3]; 88 | out = vecn::VecN(v); 89 | 90 | return OpResult(__LINE__, __FILE__, __FUNCTION__, 91 | "vector", SUCCESS); 92 | } 93 | OpResult operator()(vecn::VecN &out) const { 94 | return vector(out); 95 | } 96 | OpResult operator()(const QuaternionBase &b, 97 | QuaternionComponent &c) const { 98 | switch (b) { 99 | case kSCALAR: { 100 | c = QuaternionComponent(kSCALAR, coeffs[0]); 101 | break; 102 | } 103 | case kI: { 104 | c = QuaternionComponent(kI, coeffs[1]); 105 | break; 106 | } 107 | case kJ: { 108 | c = QuaternionComponent(kJ, coeffs[2]); 109 | break; 110 | } 111 | case kK: { 112 | c = QuaternionComponent(kK, coeffs[3]); 113 | break; 114 | } 115 | } 116 | 117 | return OpResult( 118 | __LINE__, __FILE__, __FUNCTION__, 119 | "(const QuaternionBase&, QuaternionComponent&)", 120 | SUCCESS); 121 | } 122 | 123 | OpResult 124 | operator()(const QuaternionComponent &c) const { 125 | QuaternionBase b = c.base; 126 | coeffs[static_cast(c.base) - 1] = c.r; 127 | return OpResult(__LINE__, __FILE__, __FUNCTION__, 128 | "(const QuaternionComponent&)", 129 | SUCCESS); 130 | } 131 | OpResult multiply(T t, vecn::VecN &out) const { 132 | vecn::VecN vec; 133 | vector(vec); 134 | return vec.multiply(t, out); 135 | } 136 | OpResult add(T t, vecn::VecN &out) const { 137 | vecn::VecN vec; 138 | vector(vec); 139 | return vec.add(t, out); 140 | } 141 | OpResult subtract(T t, vecn::VecN &out) const { 142 | vecn::VecN vec; 143 | vector(vec); 144 | return vec.subtract(t, out); 145 | } 146 | OpResult divide(T t, vecn::VecN &out) const { 147 | if (t == 0) { 148 | return OpResult(__LINE__, __FILE__, __FUNCTION__, 149 | "divide", ARG_ERROR); 150 | } 151 | vecn::VecN vec; 152 | vector(vec); 153 | return vec.divide(t, out); 154 | } 155 | /** arithmetic operations with a vector on vector part*/ 156 | OpResult multiply(vecn::VecN t, 157 | vecn::VecN &out) const { 158 | vecn::VecN vec; 159 | vector(vec); 160 | return vec.multiply(t, out); 161 | } 162 | OpResult add(vecn::VecN t, 163 | vecn::VecN &out) const { 164 | 165 | vecn::VecN vec; 166 | vector(vec); 167 | return vec.add(t, out); 168 | } 169 | OpResult subtract(vecn::VecN t, 170 | vecn::VecN &out) const { 171 | 172 | vecn::VecN vec; 173 | vector(vec); 174 | return vec.subtract(t, out); 175 | } 176 | OpResult divide(vecn::VecN t, 177 | vecn::VecN &out) const { 178 | for (std::size_t i = 0; i < 3; i++) { 179 | T v; 180 | t(i, v); 181 | if (v == 0) { 182 | return OpResult(__LINE__, __FILE__, __FUNCTION__, 183 | "divide", ARG_ERROR); 184 | } 185 | } 186 | vecn::VecN vec; 187 | vector(vec); 188 | return vec.divide(t, out); 189 | } 190 | /** dot product and cross product for two vec3*/ 191 | OpResult dot(const vecn::VecN &t, T &out) const { 192 | 193 | vecn::VecN vec; 194 | vector(vec); 195 | return vec.dot(t, out); 196 | } 197 | OpResult cross(const vecn::VecN &t, 198 | vecn::VecN &out) const { 199 | vecn::VecN vec; 200 | vector(vec); 201 | return vecn::cross(vec, t, out); 202 | } 203 | 204 | /** Quaternion product as it is shown by Vince 2011 p. 205 | * 63 206 | Given a quaternion \f[q_a = [s_a, a]\f] and 207 | another quaternion \f[q_b = [s_b, b]\f] 208 | Their product is equal to: 209 | \f[s_a s_b - a \cdot b, s_a b + s_b a + a \times b \f] 210 | */ 211 | OpResult hamilton_product(const Quaternion &q_b, 212 | Quaternion &out) const { 213 | // s_a, s_b, a, b 214 | T s_a = static_cast(0); 215 | auto res = scalar(s_a); 216 | if (res.status != SUCCESS) { 217 | return res; 218 | } 219 | 220 | T s_b = static_cast(0); 221 | res = q_b.scalar(s_b); 222 | if (res.status != SUCCESS) { 223 | return res; 224 | } 225 | 226 | vecn::VecN a; 227 | res = vector(a); 228 | if (res.status != SUCCESS) { 229 | return res; 230 | } 231 | 232 | vecn::VecN b; 233 | res = q_b.vector(b); 234 | if (res.status != SUCCESS) 235 | return res; 236 | 237 | // s_a * s_b 238 | T s_ab = s_a * s_b; 239 | 240 | // a \cdot b 241 | T a_dot_b = static_cast(0); 242 | res = a.dot(b, a_dot_b); 243 | if (res.status != SUCCESS) 244 | return res; 245 | 246 | // a \times b 247 | vecn::VecN cross_ab; 248 | res = vecn::cross(a, b, cross_ab); 249 | if (res.status != SUCCESS) { 250 | return res; 251 | } 252 | 253 | // s_a * b + s_b * a + a \times b 254 | T out_v[3]; 255 | T b_s[3]; 256 | T a_s[3]; 257 | T ab_s[3]; 258 | b(b_s); 259 | a(a_s); 260 | cross_ab(ab_s); 261 | for (std::size_t i = 0; i < 3; i++) { 262 | out_v[i] = s_a * b_s[i] + s_b * a_s[i] + ab_s[i]; 263 | } 264 | vecn::VecN tout(out_v); 265 | out = Quaternion(s_ab - a_dot_b, tout); 266 | return OpResult(__LINE__, __FILE__, __FUNCTION__, 267 | "hamilton_product", SUCCESS); 268 | } 269 | OpResult conjugate(Quaternion &out) const { 270 | T s = static_cast(0); 271 | auto res = scalar(s); 272 | if (res.status != SUCCESS) 273 | return res; 274 | 275 | vecn::VecN vec; 276 | res = vector(vec); 277 | 278 | if (res.status != SUCCESS) 279 | return res; 280 | 281 | res = multiply(static_cast(-1), vec); 282 | if (res.status != SUCCESS) 283 | return res; 284 | 285 | out = Quaternion(s, vec); 286 | return OpResult(__LINE__, __FILE__, __FUNCTION__, 287 | "conjugate", SUCCESS); 288 | } 289 | /** 290 | \brief from Vince 2011 - Quaternions for Computer 291 | Graphics p. 69 292 | */ 293 | OpResult normalized(Quaternion &out) const { 294 | T nval = static_cast(0); 295 | auto res = norm(nval); 296 | if (res.status != SUCCESS) 297 | return res; 298 | T inv_mag = static_cast(1.0) / nval; 299 | 300 | res = scalar(nval); 301 | 302 | if (res.status != SUCCESS) 303 | return res; 304 | 305 | T scalar_part = nval * inv_mag; 306 | vecn::VecN vs; 307 | res = vector(vs); 308 | if (res.status != SUCCESS) 309 | return res; 310 | res = multiply(inv_mag, vs); 311 | 312 | if (res.status != SUCCESS) 313 | return res; 314 | out = Quaternion(scalar_part, vs); 315 | 316 | return OpResult(__LINE__, __FILE__, __FUNCTION__, 317 | "normalized", SUCCESS); 318 | } 319 | /** 320 | \brief from Vince 2011 - Quaternions for Computer 321 | Graphics p. 69 322 | */ 323 | OpResult inversed(Quaternion &out) const { 324 | // 325 | T q_norm = static_cast(0); 326 | auto res = norm_squared(q_norm); 327 | if (res.status != SUCCESS) { 328 | return res; 329 | } 330 | 331 | Quaternion conj; 332 | res = conjugate(conj); 333 | if (res.status != SUCCESS) { 334 | return res; 335 | } 336 | T c_s; vecn::VecN c_v; conj(c_s); conj(c_v); vecn::VecN v; 337 | c_v.divide(q_norm, v); 338 | out = Quaternion(c_s/ q_norm, v); 339 | return OpResult(__LINE__, __FILE__, __FUNCTION__, 340 | "inversed", SUCCESS); 341 | } 342 | /** 343 | \brief from Vince 2011 - Quaternions for Computer 344 | Graphics p. 69 345 | */ 346 | OpResult add(const Quaternion &q, 347 | Quaternion &out) const { 348 | auto fn = [](T thisval, T tval) { 349 | return thisval + tval; 350 | }; 351 | return OpResult(__LINE__, __FILE__, __FUNCTION__, "add", 352 | apply_el(q, fn, out)); 353 | } 354 | /** 355 | \brief from Vince 2011 - Quaternions for Computer 356 | Graphics p. 69 357 | */ 358 | OpResult subtract(const Quaternion &q, 359 | Quaternion &out) const { 360 | auto fn = [](T thisval, T tval) { 361 | return thisval - tval; 362 | }; 363 | return OpResult(__LINE__, __FILE__, __FUNCTION__, 364 | "subtract", apply_el(q, fn, out)); 365 | } 366 | /** 367 | \brief from Vince 2011 - Quaternions for Computer 368 | Graphics p. 69 369 | */ 370 | OpResult product(const Quaternion &q, 371 | Quaternion &out) const { 372 | return hamilton_product(q, out); 373 | } 374 | /** 375 | \brief from Vince 2011 - Quaternions for Computer 376 | Graphics p. 69 377 | */ 378 | OpResult product(T r, Quaternion &out) const { 379 | auto fn = [](T thisval, T tval) { 380 | return thisval * tval; 381 | }; 382 | Quaternion q(r, vecn::VecN(r)); 383 | return OpResult(__LINE__, __FILE__, __FUNCTION__, 384 | "product", apply_el(q, fn, out)); 385 | } 386 | OpResult power(std::size_t i, Quaternion &out) const { 387 | Quaternion accumulant = *this; 388 | Quaternion result2 = *this; 389 | for (std::size_t j = 1; j < i; j++) { 390 | accumulant.hamilton_product(result2, accumulant); 391 | } 392 | out = accumulant; 393 | return OpResult(__LINE__, __FILE__, __FUNCTION__, 394 | "power", SUCCESS); 395 | } 396 | OpResult squared(Quaternion &out) const { 397 | Quaternion r1 = *this; 398 | Quaternion r2 = *this; 399 | auto res = product(r1, out); 400 | if (res.status != SUCCESS) 401 | return res; 402 | 403 | res = product(r2, out); 404 | if (res.status != SUCCESS) 405 | return res; 406 | 407 | return OpResult(__LINE__, __FILE__, __FUNCTION__, 408 | "squared", SUCCESS); 409 | } 410 | /** 411 | \brief from Vince 2011 - Quaternions for Computer 412 | Graphics p. 69 413 | */ 414 | OpResult norm(T &out) const { 415 | auto res = norm_squared(out); 416 | 417 | if (res.status != SUCCESS) 418 | return res; 419 | // 420 | out = sqrt(out); 421 | 422 | return OpResult(__LINE__, __FILE__, __FUNCTION__, 423 | "norm", SUCCESS); 424 | } 425 | 426 | /** 427 | \brief from Vince 2011 - Quaternions for Computer 428 | Graphics p. 25 429 | */ 430 | OpResult norm_squared(T &out) const { 431 | T s = static_cast(0); 432 | auto res = scalar(s); 433 | if (res.status != SUCCESS) 434 | return res; 435 | vecn::VecN vec; 436 | res = vector(vec); 437 | if (res.status != SUCCESS) 438 | return res; 439 | 440 | T a = s * s; 441 | T b; 442 | T v[3]; 443 | vec(v); 444 | res = vec.dot(v, b); 445 | if (res.status != SUCCESS) 446 | return res; 447 | out = a + b; 448 | return OpResult(__LINE__, __FILE__, __FUNCTION__, 449 | "norm_squared", SUCCESS); 450 | } 451 | OpResult magnitude(T &out) const { return norm(out); } 452 | 453 | private: 454 | template 455 | opstatus_t apply_el(const Quaternion &q, const Func &fn, 456 | Quaternion &out) const { 457 | T s; 458 | scalar(s); 459 | vecn::VecN v; 460 | vector(v); 461 | T vs[3]; 462 | v(vs); 463 | 464 | // 465 | T q_s; 466 | q.scalar(q_s); 467 | vecn::VecN q_v; 468 | q.vector(q_v); 469 | T qs[3]; 470 | q_v(qs); 471 | // 472 | T rs[3]; 473 | for (std::size_t i = 0; i < 3; ++i) { 474 | rs[i] = fn(vs[i], qs[i]); 475 | } 476 | T r = fn(s, q_s); 477 | out = Quaternion(r, vecn::VecN(rs)); 478 | return SUCCESS; 479 | } 480 | 481 | // 482 | T coeffs[4]; 483 | }; 484 | 485 | } // namespace quaternion 486 | 487 | }; // namespace math3d 488 | 489 | #endif 490 | -------------------------------------------------------------------------------- /tests/test_vecn.cpp: -------------------------------------------------------------------------------- 1 | // test file for quaternion 2 | #include 3 | #include 4 | 5 | /*! @{ 6 | */ 7 | 8 | typedef float real; 9 | using namespace math3d::vecn; 10 | using namespace math3d; 11 | 12 | /*! @{ testing constructors for the vector 13 | */ 14 | 15 | TEST(VecNTest, test_empty_constructor) { 16 | VecN vec; 17 | std::size_t vsize; 18 | vec(vsize); 19 | EXPECT_EQ(vsize, static_cast(2)); 20 | } 21 | 22 | TEST(VecNTest, test_vector_constructor) { 23 | real v1 = static_cast(-21); 24 | real v2 = static_cast(1); 25 | real v3 = static_cast(2); 26 | real v4 = static_cast(1.53); 27 | real v5 = static_cast(3); 28 | VecN v({v1, v2, v3, v4, v5}); 29 | real t1 = 0, t2 = 0, t3 = 0, t4 = 0, t5 = 0, t6 = 0; 30 | // test size 31 | std::size_t vsize = 6156; 32 | v(vsize); 33 | EXPECT_EQ(vsize, 5); 34 | 35 | // test values 36 | // first value 37 | EXPECT_EQ(v(0, t1).status, SUCCESS); 38 | EXPECT_EQ(t1, v1); 39 | 40 | // second value 41 | EXPECT_EQ(v(1, t2).status, SUCCESS); 42 | EXPECT_EQ(t2, v2); 43 | // third value 44 | 45 | EXPECT_EQ(v(2, t3).status, SUCCESS); 46 | EXPECT_EQ(t3, v3); 47 | 48 | // fourth value 49 | EXPECT_EQ(v(3, t4).status, SUCCESS); 50 | EXPECT_EQ(t4, v4); 51 | 52 | // fifth value 53 | EXPECT_EQ(v(4, t5).status, SUCCESS); 54 | EXPECT_EQ(t5, v5); 55 | 56 | // sixth value 57 | EXPECT_EQ(v(5, t6).status, INDEX_ERROR); 58 | } 59 | 60 | TEST(VecNTest, test_dimension_constructor) { 61 | VecN v(5); 62 | real r1 = static_cast(5); 63 | // test values 64 | real t1 = 0; 65 | // first value 66 | EXPECT_EQ(v(0, t1).status, SUCCESS); 67 | EXPECT_EQ(t1, r1); 68 | 69 | // second value 70 | EXPECT_EQ(v(1, t1).status, SUCCESS); 71 | EXPECT_EQ(t1, r1); 72 | // third value 73 | 74 | EXPECT_EQ(v(2, t1).status, SUCCESS); 75 | EXPECT_EQ(t1, r1); 76 | 77 | // fourth value 78 | EXPECT_EQ(v(3, t1).status, SUCCESS); 79 | EXPECT_EQ(t1, r1); 80 | 81 | // fifth value 82 | 83 | EXPECT_EQ(v(make_vecn_cell(t1, 4)).status, SUCCESS); 84 | EXPECT_EQ(t1, r1); 85 | 86 | // sixth value 87 | EXPECT_EQ(v(5, t1).status, INDEX_ERROR); 88 | EXPECT_EQ(v(make_vecn_cell(t1, 5)).status, INDEX_ERROR); 89 | } 90 | 91 | TEST(VecNTest, test_vecn_flag_fn_name) { 92 | VecN v; 93 | std::size_t vsize = 5; 94 | auto vflag = v(vsize); 95 | const std::string fname = vflag.fn_name; 96 | const std::string compval = "operator()"; 97 | EXPECT_EQ(fname, compval); 98 | } 99 | 100 | /*! @} */ 101 | 102 | /*! @{ testing base dimensions for the vector 103 | */ 104 | TEST(VecNTest, test_to_base_dimensions_vector) { 105 | // 106 | VecN vout{}; 107 | base(vout); 108 | real out[6]; 109 | vout(out); 110 | EXPECT_EQ(out[1], static_cast(1)); 111 | } 112 | TEST(VecNTest, test_to_base_dimensions_vecn) { 113 | // 114 | VecN vout; 115 | base(vout); 116 | real tout = 0; 117 | EXPECT_EQ(vout(1, tout).status, SUCCESS); 118 | EXPECT_EQ(tout, static_cast(1)); 119 | } 120 | 121 | /*! @} */ 122 | 123 | /*! @{ testing summation for the vector 124 | */ 125 | TEST(VecNTest, test_add_scalar_vector) { 126 | real inv[5]; 127 | inv[0] = 1; 128 | inv[1] = 2; 129 | inv[2] = 3; 130 | inv[3] = 2; 131 | inv[4] = 1; 132 | VecN v(inv); 133 | real out[5]; 134 | auto result = v.add(1, out).status; 135 | EXPECT_EQ(result, SUCCESS); 136 | EXPECT_EQ(out[0], 2); 137 | EXPECT_EQ(out[1], 3); 138 | EXPECT_EQ(out[2], 4); 139 | EXPECT_EQ(out[3], 3); 140 | EXPECT_EQ(out[4], 2); 141 | } 142 | TEST(VecNTest, test_add_scalar_vecn) { 143 | real inv[5]; 144 | inv[0] = 1; 145 | inv[1] = 2; 146 | inv[2] = 3; 147 | inv[3] = 2; 148 | inv[4] = 1; 149 | VecN v(inv); 150 | VecN out; 151 | auto result = v.add(1, out).status; 152 | EXPECT_EQ(result, SUCCESS); 153 | real t = static_cast(0); 154 | out(0, t); 155 | EXPECT_EQ(t, 2); 156 | out(1, t); 157 | EXPECT_EQ(t, 3); 158 | out(2, t); 159 | EXPECT_EQ(t, 4); 160 | out(3, t); 161 | EXPECT_EQ(t, 3); 162 | out(4, t); 163 | EXPECT_EQ(t, 2); 164 | } 165 | 166 | TEST(VecNTest, test_add_vector_to_vector_t) { 167 | real inv[5]; 168 | inv[0] = 1; 169 | inv[1] = 2; 170 | inv[2] = 3; 171 | inv[3] = 2; 172 | inv[4] = 1; 173 | VecN v(inv); 174 | real out[5]; 175 | real avec[5]; 176 | avec[0] = 1; 177 | avec[1] = 2; 178 | avec[2] = 2; 179 | avec[3] = 2; 180 | avec[4] = 1; 181 | auto result = v.add(avec, out).status; 182 | EXPECT_EQ(result, SUCCESS); 183 | EXPECT_EQ(out[0], static_cast(2)); 184 | EXPECT_EQ(out[1], static_cast(4)); 185 | EXPECT_EQ(out[2], static_cast(5)); 186 | EXPECT_EQ(out[3], static_cast(4)); 187 | EXPECT_EQ(out[4], static_cast(2)); 188 | } 189 | TEST(VecNTest, test_add_vecn_to_vecn_t) { 190 | real inv[5]; 191 | inv[0] = 1; 192 | inv[1] = 2; 193 | inv[2] = 3; 194 | inv[3] = 2; 195 | inv[4] = 1; 196 | VecN v(inv); 197 | 198 | // output vector 199 | VecN out; 200 | 201 | real avec[5]; 202 | // prepare vector to add 203 | avec[0] = 1; 204 | avec[1] = 2; 205 | avec[2] = 2; 206 | avec[3] = 2; 207 | avec[4] = 1; 208 | 209 | VecN avecn(avec); 210 | auto result = v.add(avecn, out).status; 211 | 212 | real t = static_cast(0); 213 | out(0, t); 214 | // 215 | EXPECT_EQ(result, SUCCESS); 216 | EXPECT_EQ(t, static_cast(2)); 217 | 218 | out(1, t); 219 | EXPECT_EQ(t, static_cast(4)); 220 | 221 | out(2, t); 222 | EXPECT_EQ(t, static_cast(5)); 223 | 224 | out(3, t); 225 | EXPECT_EQ(t, static_cast(4)); 226 | 227 | out(4, t); 228 | EXPECT_EQ(t, static_cast(2)); 229 | } 230 | /*! @} */ 231 | 232 | /*! @{ testing subtraction for the vector 233 | */ 234 | TEST(VecNTest, test_subtract_scalar_vector) { 235 | real inv[5]; 236 | inv[0] = 1; 237 | inv[1] = 2; 238 | inv[2] = 3; 239 | inv[3] = 2; 240 | inv[4] = 1; 241 | VecN v(inv); 242 | real out[5]; 243 | auto result = v.subtract(1, out).status; 244 | EXPECT_EQ(result, SUCCESS); 245 | EXPECT_EQ(out[0], 0); 246 | EXPECT_EQ(out[1], 1); 247 | EXPECT_EQ(out[2], 2); 248 | EXPECT_EQ(out[3], 1); 249 | EXPECT_EQ(out[4], 0); 250 | } 251 | TEST(VecNTest, test_subtract_scalar_vecn) { 252 | real inv[5]; 253 | inv[0] = 1; 254 | inv[1] = 2; 255 | inv[2] = 3; 256 | inv[3] = 2; 257 | inv[4] = 1; 258 | VecN v(inv); 259 | VecN out; 260 | auto result = v.subtract(1, out).status; 261 | EXPECT_EQ(result, SUCCESS); 262 | real t = static_cast(0); 263 | out(0, t); 264 | EXPECT_EQ(t, 0); 265 | out(1, t); 266 | EXPECT_EQ(t, 1); 267 | out(2, t); 268 | EXPECT_EQ(t, 2); 269 | out(3, t); 270 | EXPECT_EQ(t, 1); 271 | out(4, t); 272 | EXPECT_EQ(t, 0); 273 | } 274 | TEST(VecNTest, test_subtract_vector_to_vector_t) { 275 | real inv[5]; 276 | inv[0] = 1; 277 | inv[1] = 2; 278 | inv[2] = 3; 279 | inv[3] = 2; 280 | inv[4] = 1; 281 | VecN v(inv); 282 | real out[5]; 283 | real avec[5]; 284 | avec[0] = 1; 285 | avec[1] = 2; 286 | avec[2] = 2; 287 | avec[3] = 2; 288 | avec[4] = 1; 289 | auto result = v.subtract(avec, out).status; 290 | EXPECT_EQ(result, SUCCESS); 291 | EXPECT_EQ(out[0], static_cast(0)); 292 | EXPECT_EQ(out[1], static_cast(0)); 293 | EXPECT_EQ(out[2], static_cast(1)); 294 | EXPECT_EQ(out[3], static_cast(0)); 295 | EXPECT_EQ(out[4], static_cast(0)); 296 | } 297 | TEST(VecNTest, test_subtract_vecn_to_vecn_t) { 298 | real inv[5]; 299 | inv[0] = 1; 300 | inv[1] = 2; 301 | inv[2] = 3; 302 | inv[3] = 2; 303 | inv[4] = 1; 304 | VecN v(inv); 305 | 306 | // output vector 307 | VecN out; 308 | 309 | real avec[5]; 310 | // prepare vector to subtract 311 | avec[0] = 1; 312 | avec[1] = 2; 313 | avec[2] = 2; 314 | avec[3] = 2; 315 | avec[4] = 1; 316 | 317 | VecN avecn(avec); 318 | auto result = v.subtract(avecn, out).status; 319 | 320 | real t = static_cast(0); 321 | out(0, t); 322 | // 323 | EXPECT_EQ(result, SUCCESS); 324 | EXPECT_EQ(t, static_cast(0)); 325 | 326 | out(1, t); 327 | EXPECT_EQ(t, static_cast(0)); 328 | 329 | out(2, t); 330 | EXPECT_EQ(t, static_cast(1)); 331 | 332 | out(3, t); 333 | EXPECT_EQ(t, static_cast(0)); 334 | 335 | out(4, t); 336 | EXPECT_EQ(t, static_cast(0)); 337 | } 338 | 339 | /*! @} */ 340 | 341 | /*! @{ testing element-wise multiplication for the vector 342 | */ 343 | TEST(VecNTest, test_multiply_scalar_vector) { 344 | real inv[5]; 345 | inv[0] = 1; 346 | inv[1] = 2; 347 | inv[2] = 3; 348 | inv[3] = 2; 349 | inv[4] = 1; 350 | VecN v(inv); 351 | real out[5]; 352 | auto result = v.multiply(2, out).status; 353 | EXPECT_EQ(result, SUCCESS); 354 | EXPECT_EQ(out[0], 2); 355 | EXPECT_EQ(out[1], 4); 356 | EXPECT_EQ(out[2], 6); 357 | EXPECT_EQ(out[3], 4); 358 | EXPECT_EQ(out[4], 2); 359 | } 360 | TEST(VecNTest, test_multiply_scalar_vecn) { 361 | real inv[5]; 362 | inv[0] = 1; 363 | inv[1] = 2; 364 | inv[2] = 3; 365 | inv[3] = 2; 366 | inv[4] = 1; 367 | VecN v(inv); 368 | VecN out; 369 | auto result = v.multiply(2, out).status; 370 | EXPECT_EQ(result, SUCCESS); 371 | real t = static_cast(0); 372 | out(0, t); 373 | EXPECT_EQ(t, 2); 374 | out(1, t); 375 | EXPECT_EQ(t, 4); 376 | out(2, t); 377 | EXPECT_EQ(t, 6); 378 | out(3, t); 379 | EXPECT_EQ(t, 4); 380 | out(4, t); 381 | EXPECT_EQ(t, 2); 382 | } 383 | TEST(VecNTest, test_multiply_vector_to_vector_t) { 384 | real inv[5]; 385 | inv[0] = 1; 386 | inv[1] = 2; 387 | inv[2] = 3; 388 | inv[3] = 2; 389 | inv[4] = 1; 390 | VecN v(inv); 391 | real out[5]; 392 | real avec[5]; 393 | avec[0] = 1; 394 | avec[1] = 2; 395 | avec[2] = 2; 396 | avec[3] = 2; 397 | avec[4] = 1; 398 | auto result = v.multiply(avec, out).status; 399 | EXPECT_EQ(result, SUCCESS); 400 | EXPECT_EQ(out[0], static_cast(1)); 401 | EXPECT_EQ(out[1], static_cast(4)); 402 | EXPECT_EQ(out[2], static_cast(6)); 403 | EXPECT_EQ(out[3], static_cast(4)); 404 | EXPECT_EQ(out[4], static_cast(1)); 405 | } 406 | TEST(VecNTest, test_multiply_vecn_to_vecn_t) { 407 | real inv[5]; 408 | inv[0] = 1; 409 | inv[1] = 2; 410 | inv[2] = 3; 411 | inv[3] = 2; 412 | inv[4] = 1; 413 | VecN v(inv); 414 | 415 | // output vector 416 | VecN out; 417 | 418 | real avec[5]; 419 | // prepare vector to multiply 420 | avec[0] = 1; 421 | avec[1] = 2; 422 | avec[2] = 2; 423 | avec[3] = 2; 424 | avec[4] = 1; 425 | 426 | VecN avecn(avec); 427 | auto result = v.multiply(avecn, out).status; 428 | 429 | real t = static_cast(0); 430 | out(0, t); 431 | // 432 | EXPECT_EQ(result, SUCCESS); 433 | EXPECT_EQ(t, static_cast(1)); 434 | 435 | out(1, t); 436 | EXPECT_EQ(t, static_cast(4)); 437 | 438 | out(2, t); 439 | EXPECT_EQ(t, static_cast(6)); 440 | 441 | out(3, t); 442 | EXPECT_EQ(t, static_cast(4)); 443 | 444 | out(4, t); 445 | EXPECT_EQ(t, static_cast(1)); 446 | } 447 | 448 | /*! @} */ 449 | /*! @{ testing element-wise division for the vector 450 | */ 451 | TEST(VecNTest, test_divide_scalar_vector) { 452 | real inv[5]; 453 | inv[0] = 2; 454 | inv[1] = 4; 455 | inv[2] = 6; 456 | inv[3] = 2; 457 | inv[4] = 0; 458 | VecN v(inv); 459 | real out[5]; 460 | auto result = v.divide(2, out).status; 461 | EXPECT_EQ(result, SUCCESS); 462 | EXPECT_EQ(out[0], 1); 463 | EXPECT_EQ(out[1], 2); 464 | EXPECT_EQ(out[2], 3); 465 | EXPECT_EQ(out[3], 1); 466 | EXPECT_EQ(out[4], 0); 467 | } 468 | TEST(VecNTest, test_divide_scalar_vector_zero) { 469 | real inv[5]; 470 | inv[0] = 2; 471 | inv[1] = 4; 472 | inv[2] = 6; 473 | inv[3] = 2; 474 | inv[4] = 0; 475 | VecN v(inv); 476 | real out[5]; 477 | auto result = v.divide(0, out).status; 478 | EXPECT_EQ(result, ARG_ERROR); 479 | } 480 | TEST(VecNTest, test_divide_scalar_vecn) { 481 | real inv[5]; 482 | inv[0] = 2; 483 | inv[1] = 4; 484 | inv[2] = 6; 485 | inv[3] = 2; 486 | inv[4] = 0; 487 | VecN v(inv); 488 | VecN out; 489 | auto result = v.divide(2, out).status; 490 | EXPECT_EQ(result, SUCCESS); 491 | real t = static_cast(0); 492 | out(0, t); 493 | EXPECT_EQ(t, 1); 494 | out(1, t); 495 | EXPECT_EQ(t, 2); 496 | out(2, t); 497 | EXPECT_EQ(t, 3); 498 | out(3, t); 499 | EXPECT_EQ(t, 1); 500 | out(4, t); 501 | EXPECT_EQ(t, 0); 502 | } 503 | TEST(VecNTest, test_divide_scalar_vecn_zero) { 504 | real inv[5]; 505 | inv[0] = 2; 506 | inv[1] = 4; 507 | inv[2] = 6; 508 | inv[3] = 2; 509 | inv[4] = 0; 510 | VecN v(inv); 511 | VecN out; 512 | auto result = v.divide(0, out).status; 513 | EXPECT_EQ(result, ARG_ERROR); 514 | } 515 | TEST(VecNTest, test_divide_vector_to_vector_t) { 516 | real inv[5]; 517 | inv[0] = 1; 518 | inv[1] = 2; 519 | inv[2] = 4; 520 | inv[3] = 2; 521 | inv[4] = 1; 522 | VecN v(inv); 523 | real out[5]; 524 | real avec[5]; 525 | avec[0] = 1; 526 | avec[1] = 2; 527 | avec[2] = 2; 528 | avec[3] = 2; 529 | avec[4] = 1; 530 | auto result = v.divide(avec, out).status; 531 | EXPECT_EQ(result, SUCCESS); 532 | EXPECT_EQ(out[0], static_cast(1)); 533 | EXPECT_EQ(out[1], static_cast(1)); 534 | EXPECT_EQ(out[2], static_cast(2)); 535 | EXPECT_EQ(out[3], static_cast(1)); 536 | EXPECT_EQ(out[4], static_cast(1)); 537 | } 538 | TEST(VecNTest, test_divide_vector_to_vector_zero) { 539 | real inv[5]; 540 | inv[0] = 1; 541 | inv[1] = 2; 542 | inv[2] = 4; 543 | inv[3] = 2; 544 | inv[4] = 1; 545 | VecN v(inv); 546 | real out[5]; 547 | real avec[5]; 548 | avec[0] = 1; 549 | avec[1] = 2; 550 | avec[2] = 0; 551 | avec[3] = 2; 552 | avec[4] = 1; 553 | auto result = v.divide(avec, out).status; 554 | EXPECT_EQ(result, ARG_ERROR); 555 | } 556 | TEST(VecNTest, test_divide_vecn_to_vecn_t) { 557 | real inv[5]; 558 | inv[0] = 1; 559 | inv[1] = 2; 560 | inv[2] = 4; 561 | inv[3] = 2; 562 | inv[4] = 1; 563 | VecN v(inv); 564 | 565 | // output vector 566 | VecN out; 567 | 568 | real avec[5]; 569 | // prepare vector to divide 570 | avec[0] = 1; 571 | avec[1] = 2; 572 | avec[2] = 2; 573 | avec[3] = 2; 574 | avec[4] = 1; 575 | 576 | VecN avecn(avec); 577 | auto result = v.divide(avecn, out).status; 578 | 579 | real t = static_cast(0); 580 | out(0, t); 581 | // 582 | EXPECT_EQ(result, SUCCESS); 583 | EXPECT_EQ(t, static_cast(1)); 584 | 585 | out(1, t); 586 | EXPECT_EQ(t, static_cast(1)); 587 | 588 | out(2, t); 589 | EXPECT_EQ(t, static_cast(2)); 590 | 591 | out(3, t); 592 | EXPECT_EQ(t, static_cast(1)); 593 | 594 | out(4, t); 595 | EXPECT_EQ(t, static_cast(1)); 596 | } 597 | TEST(VecNTest, test_divide_vecn_to_vecn_zero) { 598 | real inv[5]; 599 | inv[0] = 1; 600 | inv[1] = 2; 601 | inv[2] = 4; 602 | inv[3] = 2; 603 | inv[4] = 1; 604 | VecN v(inv); 605 | 606 | // output vector 607 | VecN out; 608 | 609 | real avec[5]; 610 | // prepare vector to divide 611 | avec[0] = 1; 612 | avec[1] = 2; 613 | avec[2] = -10; 614 | avec[3] = 2; 615 | avec[4] = 0; 616 | 617 | VecN avecn(avec); 618 | auto result = v.divide(avecn, out).status; 619 | 620 | real t = static_cast(0); 621 | out(0, t); 622 | // 623 | EXPECT_EQ(result, ARG_ERROR); 624 | } 625 | 626 | /*! @} */ 627 | 628 | /*! @{ testing element-wise division for the vector 629 | */ 630 | 631 | TEST(VecNTest, test_dot_scalar_t) { 632 | real inv[5]; 633 | inv[0] = 1; // 2 634 | inv[1] = 2; // 4 635 | inv[2] = 3; // 6 636 | inv[3] = 2; // 4 637 | inv[4] = 1; // 2 638 | // sum == 18 639 | VecN v(inv); 640 | real out; 641 | auto result = v.dot(static_cast(2), out).status; 642 | EXPECT_EQ(result, SUCCESS); 643 | EXPECT_EQ(out, static_cast(18)); 644 | } 645 | TEST(VecNTest, test_dot_scalar_zero) { 646 | real inv[5]; 647 | inv[0] = 1; // 2 648 | inv[1] = 2; // 4 649 | inv[2] = 3; // 6 650 | inv[3] = 2; // 4 651 | inv[4] = 1; // 2 652 | // sum == 18 653 | VecN v(inv); 654 | real out; 655 | auto result = v.dot(static_cast(0), out).status; 656 | EXPECT_EQ(result, SUCCESS); 657 | EXPECT_EQ(out, static_cast(0)); 658 | } 659 | TEST(VecNTest, test_dot_vector_t) { 660 | real inv[5]; 661 | inv[0] = 1; // 1 662 | inv[1] = 2; // 4 663 | inv[2] = 3; // 3 664 | inv[3] = 2; // 0 665 | inv[4] = 1; // 0 666 | // sum == 8 667 | real avec[5]; 668 | VecN