v1.5.0 - added initializer list constructors for basic_vector and basic_matrix

Author: davidbrowne

README.md

@@ -6,7 +6,7 @@
 [https://github.com/davidbrowne/dsga](https://github.com/davidbrowne/dsga)
 
 ## Current Version
-v1.4.1
+v1.5.0
 
 ## Minimum Version of Tested Compilers
 * Microsoft Visual Studio 2022 v17.x
@@ -172,7 +172,7 @@ constexpr dsga::vec3 right_handed_normal(const dsga::vec3 &v1, const dsga::vec3
 // cross product
 //
 
-// arguments are of the vector base class type, and this function will be used if any passed argument is of type ```indexed_vector```
+// arguments are of the vector base class type, and this function will be used if any passed argument is of type indexed_vector
 template <bool W1, dsga::floating_point_scalar T1, typename D1, bool W2, dsga::floating_point_scalar T2, typename D2>
 [[nodiscard]] constexpr auto cross(const dsga::vector_base<W1, T1, 3, D1> &a,
                                    const dsga::vector_base<W2, T2, 3, D2> &b) noexcept
@@ -183,7 +183,7 @@ template <bool W1, dsga::floating_point_scalar T1, typename D1, bool W2, dsga::f
                               (a[0] * b[1]) - (b[0] * a[1]));
 }
 
-// arguments are of type ```basic_vector```, and there is a compact swizzled implementation
+// arguments are of type basic_vector, and there is a compact swizzled implementation
 template <dsga::floating_point_scalar T1, dsga::floating_point_scalar T2>
 [[nodiscard]] constexpr auto cross(const dsga::basic_vector<T1, 3> &a,
                                    const dsga::basic_vector<T2, 3> &b) noexcept
@@ -278,7 +278,7 @@ To make the vectors and matrices as useful as possible in a C++ context, various
         * vector - pointer to scalars of concept type ```dsga::dimensional_scalar```
         * matrix - pointer to column vectors whose scalars are of concept type ```dsga::floating_point_scalar```
     * ```size```
-    * vector only - these allow logical use of ```data```
+    * vector only - these ordering facilities allow logical use of ```data```
         * ```offsets```
         * ```sequence```
 * Type Conversions
@@ -311,10 +311,10 @@ This is a c++20 library, so that needs to be the minimum standard that you tell
 
 ## Status
 
-Current version: `v1.4.1`
+Current version: `v1.5.0`
 
 * Everything major has some tests, but code coverage is not 100%.
-* [Last Released: v1.4.0](https://github.com/davidbrowne/dsga/releases/tag/v1.4.0)
+* [Last Released: v1.5.0](https://github.com/davidbrowne/dsga/releases/tag/v1.5.0)
 
 ### The next steps
 * Refining API documentation.
@@ -345,8 +345,8 @@ The tests have been most recently run on:
 [doctest] doctest version is "2.4.11"
 [doctest] run with "--help" for options
 ===============================================================================
-[doctest] test cases:  109 |  109 passed | 0 failed | 0 skipped
-[doctest] assertions: 2159 | 2159 passed | 0 failed |
+[doctest] test cases:  111 |  111 passed | 0 failed | 0 skipped
+[doctest] assertions: 2167 | 2167 passed | 0 failed |
 [doctest] Status: SUCCESS!
 ```
 
@@ -356,8 +356,8 @@ The tests have been most recently run on:
 [doctest] doctest version is "2.4.11"
 [doctest] run with "--help" for options
 ===============================================================================
-[doctest] test cases:  109 |  109 passed | 0 failed | 0 skipped
-[doctest] assertions: 2159 | 2159 passed | 0 failed |
+[doctest] test cases:  111 |  111 passed | 0 failed | 0 skipped
+[doctest] assertions: 2167 | 2167 passed | 0 failed |
 [doctest] Status: SUCCESS!
 ```
 
@@ -369,8 +369,8 @@ Performs all the unit tests except where there is lack of support for ```std::is
 [doctest] doctest version is "2.4.11"
 [doctest] run with "--help" for options
 ===============================================================================
-[doctest] test cases:  109 |  109 passed | 0 failed | 0 skipped
-[doctest] assertions: 2143 | 2143 passed | 0 failed |
+[doctest] test cases:  111 |  111 passed | 0 failed | 0 skipped
+[doctest] assertions: 2151 | 2151 passed | 0 failed |
 [doctest] Status: SUCCESS!
 ```
 
@@ -382,8 +382,8 @@ Performs all the unit tests except where there is lack of support for ```std::is
 [doctest] doctest version is "2.4.11"
 [doctest] run with "--help" for options
 ===============================================================================
-[doctest] test cases:  109 |  109 passed | 0 failed | 0 skipped
-[doctest] assertions: 2159 | 2159 passed | 0 failed |
+[doctest] test cases:  111 |  111 passed | 0 failed | 0 skipped
+[doctest] assertions: 2167 | 2167 passed | 0 failed |
 [doctest] Status: SUCCESS!
 ```
 
@@ -395,8 +395,8 @@ Performs all the unit tests except where there is lack of support for ```std::is
 [doctest] doctest version is "2.4.11"
 [doctest] run with "--help" for options
 ===============================================================================
-[doctest] test cases:  109 |  109 passed | 0 failed | 0 skipped
-[doctest] assertions: 2143 | 2143 passed | 0 failed |
+[doctest] test cases:  111 |  111 passed | 0 failed | 0 skipped
+[doctest] assertions: 2151 | 2151 passed | 0 failed |
 [doctest] Status: SUCCESS!
 ```
 
@@ -408,8 +408,8 @@ Performs all the unit tests except where there is lack of support for ```std::is
 [doctest] doctest version is "2.4.11"
 [doctest] run with "--help" for options
 ===============================================================================
-[doctest] test cases:  109 |  109 passed | 0 failed | 0 skipped
-[doctest] assertions: 2159 | 2159 passed | 0 failed |
+[doctest] test cases:  111 |  111 passed | 0 failed | 0 skipped
+[doctest] assertions: 2167 | 2167 passed | 0 failed |
 [doctest] Status: SUCCESS!
 ```
 
@@ -421,8 +421,8 @@ Performs all the unit tests except where there is lack of support for ```std::is
 [doctest] doctest version is "2.4.11"
 [doctest] run with "--help" for options
 ===============================================================================
-[doctest] test cases:  109 |  109 passed | 0 failed | 0 skipped
-[doctest] assertions: 2143 | 2143 passed | 0 failed |
+[doctest] test cases:  111 |  111 passed | 0 failed | 0 skipped
+[doctest] assertions: 2151 | 2151 passed | 0 failed |
 [doctest] Status: SUCCESS!
 ```
 

docs/API.md

@@ -841,6 +841,11 @@ explicit constexpr basic_vector(const U &u, const Args & ...args) noexcept;
 ```
 Variadic constructor. Can take a combination of vectors, scalars, and matrixes as arguments to initialize the ```basic_vector```.
 
+```c++
+constexpr basic_vector(const std::initializer_list<T> &init_list) noexcept;
+```
+An intializer list of values. If too few values for the vector, the rest of the elements will be set to 0. If too many values for the vector, the rest of the initialization list will be ignored.
+
 ##### ```basic_vector::base```
 ```c++
 storage_wrapper<T, Size> base;
@@ -1072,6 +1077,11 @@ explicit constexpr basic_matrix(const basic_matrix<U, Cols, Rows> &arg) noexcept
 ```
 Constructors that take a matrix as an argument, but not a normal copy constructor (see default constructors).
 
+```c++
+constexpr basic_matrix(const std::initializer_list<T> &init_list) noexcept;
+```
+An intializer list of values. If too few values for the matrix, the rest of the elements will be set to 0. If too many values for the matrix, the rest of the initialization list will be ignored.
+
 ##### ```basic_matrix::columns```
 ```c++
 std::array<basic_vector<T, R>, C> columns;

docs/DOCUMENTATION.md

@@ -317,7 +317,11 @@ template <typename ... Args>
 constexpr basic_vector(const Args & ...args) noexcept;
 ```
 
-This approach is exactly what ```basic_matrix``` does.
+* An intializer list of values. If too few values for the vector, the rest of the elements will be set to 0. If too many values for the vector, the rest of the initialization list will be ignored.
+
+```c++
+constexpr basic_vector(const std::initializer_list<T> &init_list) noexcept;
+```
 
 ### Vector Member Functions
 
@@ -529,6 +533,12 @@ template <typename ... Args>
 constexpr basic_matrix(const Args & ...args) noexcept;
 ``` 
 
+* An intializer list of values. If too few values for the matrix, the rest of the elements will be set to 0. If too many values for the matrix, the rest of the initialization list will be ignored.
+
+```c++
+constexpr basic_matrix(const std::initializer_list<T> &init_list) noexcept;
+```
+
 ### Matrix Member Functions
 
 These are the members that are not part of the [iterator interface](#iterators), the [tuple protocol](#tuple-protocol), or the [low-level interface](#low-level-pointer-access).

include/dsga.hxx

@@ -95,8 +95,8 @@ inline void cxcm_constexpr_assert_failed(Assert &&a) noexcept
 // version info
 
 constexpr inline int DSGA_MAJOR_VERSION = 1;
-constexpr inline int DSGA_MINOR_VERSION = 4;
-constexpr inline int DSGA_PATCH_VERSION = 1;
+constexpr inline int DSGA_MINOR_VERSION = 5;
+constexpr inline int DSGA_PATCH_VERSION = 0;
 
 namespace dsga
 {
@@ -2014,16 +2014,16 @@ namespace dsga
 		using reference = const T &;
 
 		// range of valid values for mapper_index
-		constexpr static std::size_t begin_index = 0;
-		constexpr static std::size_t end_index = Count;
+		constexpr static int begin_index = 0;
+		constexpr static int end_index = Count;
 
 		// the data
 		const indexed_vector<T, Size, Count, Is ...> *mapper_ptr;
-		std::size_t mapper_index;
+		int mapper_index;
 
 		// index == 0 is begin iterator
 		// index == Count is end iterator -- clamp index in [0, Count] range
-		constexpr indexed_vector_const_iterator(const indexed_vector<T, Size, Count, Is ...> &mapper, std::size_t index) noexcept
+		constexpr indexed_vector_const_iterator(const indexed_vector<T, Size, Count, Is ...> &mapper, int index) noexcept
 			: mapper_ptr(std::addressof(mapper)), mapper_index(index)
 		{
 			dsga_constexpr_assert((mapper_index >= begin_index) && (mapper_index <= end_index), "index not in range");
@@ -2170,7 +2170,7 @@ namespace dsga
 
 		// index == 0 is begin iterator
 		// index == Count is end iterator -- clamp index in [0, Count] range
-		constexpr indexed_vector_iterator(indexed_vector<T, Size, Count, Is ...> &mapper, std::size_t index) noexcept
+		constexpr indexed_vector_iterator(indexed_vector<T, Size, Count, Is ...> &mapper, int index) noexcept
 			: base_iter(mapper, index)
 		{
 		}
@@ -2718,6 +2718,16 @@ namespace dsga
 			}(std::make_index_sequence<Count>{});
 		}
 
+		// initializer list constructor -- it will use the first Count number of elements of the list,
+		// and if list size is less than Count, it will initialize the rest of the vector elements with 0
+		constexpr basic_vector(const std::initializer_list<T> &init_list) noexcept
+		{
+			auto copy_size = (Count > init_list.size()) ? init_list.size() : Count;
+			auto fill_size = Count - copy_size;
+			auto fill_iter = std::copy_n(init_list.begin(), copy_size, this->begin());
+			std::fill_n(fill_iter, fill_size, T(0));
+		}
+
 		//
 		// implicit assignment operators
 		//
@@ -2924,6 +2934,16 @@ namespace dsga
 			}(std::make_index_sequence<Count>{});
 		}
 
+		// initializer list constructor -- it will use the first Count number of elements of the list,
+		// and if list size is less than Count, it will initialize the rest of the vector elements with 0
+		constexpr basic_vector(const std::initializer_list<T> &init_list) noexcept
+		{
+			auto copy_size = (Count > init_list.size()) ? init_list.size() : Count;
+			auto fill_size = Count - copy_size;
+			auto fill_iter = std::copy_n(init_list.begin(), copy_size, this->begin());
+			std::fill_n(fill_iter, fill_size, T(0));
+		}
+
 		//
 		// assignment operator
 		//
@@ -3200,6 +3220,16 @@ namespace dsga
 			}(std::make_index_sequence<Count>{});
 		}
 
+		// initializer list constructor -- it will use the first Count number of elements of the list,
+		// and if list size is less than Count, it will initialize the rest of the vector elements with 0
+		constexpr basic_vector(const std::initializer_list<T> &init_list) noexcept
+		{
+			auto copy_size = (Count > init_list.size()) ? init_list.size() : Count;
+			auto fill_size = Count - copy_size;
+			auto fill_iter = std::copy_n(init_list.begin(), copy_size, this->begin());
+			std::fill_n(fill_iter, fill_size, T(0));
+		}
+
 		//
 		// assignment operators
 		//
@@ -3699,6 +3729,16 @@ namespace dsga
 			}(std::make_index_sequence<Count>{});
 		}
 
+		// initializer list constructor -- it will use the first Count number of elements of the list,
+		// and if list size is less than Count, it will initialize the rest of the vector elements with 0
+		constexpr basic_vector(const std::initializer_list<T> &init_list) noexcept
+		{
+			auto copy_size = (Count > init_list.size()) ? init_list.size() : Count;
+			auto fill_size = Count - copy_size;
+			auto fill_iter = std::copy_n(init_list.begin(), copy_size, this->begin());
+			std::fill_n(fill_iter, fill_size, T(0));
+		}
+
 		//
 		// assignment operators
 		//
@@ -6210,6 +6250,24 @@ namespace dsga
 			}
 		}
 
+		// initializer list constructor -- it will use the first ComponentCount number of elements of the list,
+		// and if list size is less than ComponentCount, it will initialize the rest of the matrix elements with 0
+		constexpr basic_matrix(const std::initializer_list<T> &init_list) noexcept
+		{
+			auto element_values = std::array<T, ComponentCount>{};
+			auto copy_size = (ComponentCount > init_list.size()) ? init_list.size() : ComponentCount;
+			std::copy_n(init_list.begin(), copy_size, element_values.begin());
+
+			[&]<std::size_t ...Is>(std::index_sequence <Is...>) noexcept
+			{
+				(([&]<std::size_t ...Js>(std::index_sequence <Js...>) noexcept
+				{
+					constexpr std::size_t Col = Is;
+					columns[Col].set(element_values[Col * R + Js] ...);
+				}(std::make_index_sequence<R>{})), ...);
+			}(std::make_index_sequence<C>{});
+		}
+
 		//
 		// assignment operators
 		//

tests/constructor_test.cxx

@@ -261,6 +261,19 @@ TEST_SUITE("test vector constructors")
 		auto s1 = dsga::storage_wrapper{1.1, 2.2, 3, true};
 		CHECK_EQ(s1, dsga::storage_wrapper<double, 4>{1.1, 2.2, 3.0, 1.0});
 	}
+
+	TEST_CASE("initializer list vector constructor")
+	{
+		dsga::vec4 initlist_vec1 = {1, 2};
+		dsga::vec4 initlist_vec2 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20};
+		dsga::vec4 initlist_vec3{1, 2};
+		dsga::vec4 initlist_vec4{};
+
+		CHECK_EQ(initlist_vec1, vec4(1, 2, 0, 0));
+		CHECK_EQ(initlist_vec2, vec4(1, 2, 3, 4));
+		CHECK_EQ(initlist_vec3, vec4(1, 2, 0, 0));
+		CHECK_EQ(initlist_vec4, vec4(0, 0, 0, 0));
+	}
 }
 
 TEST_SUITE("test matrix constructors")
@@ -553,4 +566,17 @@ TEST_SUITE("test matrix constructors")
 		CHECK_EQ(tm10, mat4x4(9, 0, 0, 0, 0, 9, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1));
 		CHECK_EQ(tm11, dmat4x4(1, 2, 0, 0, 3, 4, 0, 0, 5, 6, 1, 0, 7, 8, 0, 1));
 	}
+
+	TEST_CASE("initializer list matrix constructor")
+	{
+		dsga::mat4 initlist_mat1 = {1, 2, 3, 4, 5, 6};
+		dsga::mat4 initlist_mat2 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20};
+		dsga::mat4 initlist_mat3{1, 2, 3, 4, 5, 6};
+		dsga::mat4 initlist_mat4{};
+
+		CHECK_EQ(initlist_mat1, mat4(1, 2, 3, 4, 5, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0));
+		CHECK_EQ(initlist_mat2, mat4(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16));
+		CHECK_EQ(initlist_mat3, mat4(1, 2, 3, 4, 5, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0));
+		CHECK_EQ(initlist_mat4, mat4(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0));
+	}
 }