v0.7.0 - reworked conversion operators for 1D basic_vector and indexed_vector so they convert more easily to scalar type

Author: davidbrowne

README.md

@@ -130,11 +130,11 @@ This may be a single header library, but if Visual Studio is being used, we reco
 
 ## Status
 
-Current version: `v0.6.6`
+Current version: `v0.7.0`
 
 * **All the vector and matrix functionality is implemented.**
 * First pass at test coverage. Everything major has some tests, but code coverage is not 100%. 
-* [Released v0.6.5](https://github.com/davidbrowne/dsga/releases/tag/v0.6.5)
+* [Released v0.7.0](https://github.com/davidbrowne/dsga/releases/tag/v0.7.0)
 
 ### The next steps
 * Example projects: need small, medium, and large examples. The quick peek at the top of this page is a start, as is a [more detailed generic version of the example](docs/DETAILS.md#detailed-generic-example).
@@ -151,7 +151,7 @@ More in depth explanation can be found in the [details](docs/DETAILS.md).
 
 This project uses [doctest](https://github.com/onqtam/doctest) for testing. We occasionally use [nanobench](https://github.com/martinus/nanobench) for understanding implementation tradeoffs.
 
-Both MSVC and gcc (for Windows and on Ubuntu on WSL2) pass all the tests. clang for Windows passes, but there is 1 test out of 1806 that fails for clang-14 on Ubuntu.
+Both MSVC and gcc (for Windows and on Ubuntu on WSL2) pass all the tests. clang for Windows passes, but there is 1 test out of 1808 that fails for clang-14 on Ubuntu.
 
 The tests have been most recently run on:
 
@@ -164,7 +164,7 @@ The tests have been most recently run on:
 [doctest] run with "--help" for options
 ===============================================================================
 [doctest] test cases:   81 |   81 passed | 0 failed | 0 skipped
-[doctest] assertions: 1822 | 1822 passed | 0 failed |
+[doctest] assertions: 1824 | 1824 passed | 0 failed |
 [doctest] Status: SUCCESS!
 ```
 
@@ -175,7 +175,7 @@ The tests have been most recently run on:
 [doctest] run with "--help" for options
 ===============================================================================
 [doctest] test cases:   81 |   81 passed | 0 failed | 0 skipped
-[doctest] assertions: 1822 | 1822 passed | 0 failed |
+[doctest] assertions: 1824 | 1824 passed | 0 failed |
 [doctest] Status: SUCCESS!
 ```
 
@@ -188,7 +188,7 @@ Performs all the unit tests except where there is lack of support for ```std::is
 [doctest] run with "--help" for options
 ===============================================================================
 [doctest] test cases:   81 |   81 passed | 0 failed | 0 skipped
-[doctest] assertions: 1806 | 1806 passed | 0 failed |
+[doctest] assertions: 1808 | 1808 passed | 0 failed |
 [doctest] Status: SUCCESS!
 ```
 
@@ -201,7 +201,7 @@ Performs all the unit tests except where there is lack of support for ```std::is
 [doctest] run with "--help" for options
 ===============================================================================
 [doctest] test cases:   81 |   81 passed | 0 failed | 0 skipped
-[doctest] assertions: 1822 | 1822 passed | 0 failed |
+[doctest] assertions: 1824 | 1824 passed | 0 failed |
 [doctest] Status: SUCCESS!
 ```
 
@@ -223,7 +223,7 @@ swizzle_test.cxx:1841: ERROR: CHECK_UNARY( std::is_trivial_v<dmat4> ) is NOT cor
 
 ===============================================================================
 [doctest] test cases:   81 |   80 passed | 1 failed | 0 skipped
-[doctest] assertions: 1806 | 1805 passed | 1 failed |
+[doctest] assertions: 1808 | 1807 passed | 1 failed |
 [doctest] Status: FAILURE!
 ```
 

include/dsga.hxx

@@ -28,8 +28,8 @@
 // version info
 
 constexpr inline int DSGA_MAJOR_VERSION = 0;
-constexpr inline int DSGA_MINOR_VERSION = 6;
-constexpr inline int DSGA_PATCH_VERSION = 6;
+constexpr inline int DSGA_MINOR_VERSION = 7;
+constexpr inline int DSGA_PATCH_VERSION = 0;
 
 namespace dsga
 {
@@ -1553,19 +1553,18 @@ namespace dsga
 			return *this;
 		}
 
-		// scalar conversion operator
+		//
+		// scalar conversion operators
+		//
+
 		// this is extremely important and is only for indexed_vector of [Count == 1]
-		template <typename U>
-		requires implicitly_convertible_to<T, U>
-		constexpr operator U() const noexcept
+		constexpr operator T() const noexcept
 		{
-			return static_cast<U>(value[I]);
+			return value[I];
 		}
 
-		// scalar conversion operator
-		// this is extremely important and is only for indexed_vector of [Count == 1]
 		template <typename U>
-		requires (!implicitly_convertible_to<T, U>) && std::convertible_to<T, U>
+		requires std::convertible_to<T, U>
 		explicit constexpr operator U() const noexcept
 		{
 			return static_cast<U>(value[I]);
@@ -1727,20 +1726,17 @@ namespace dsga
 		}
 
 		//
-		// conversion operators
+		// scalar conversion operators
 		//
 
 		// this is extremely important and is only for basic_vector of [Size == 1]
-
-		template <typename U>
-		requires implicitly_convertible_to<T, U>
-		constexpr operator U() const noexcept
+		constexpr operator T() const noexcept
 		{
-			return static_cast<U>(store.value[0u]);
+			return store.value[0u];
 		}
 
 		template <typename U>
-		requires (!implicitly_convertible_to<T, U>) && std::convertible_to<T, U>
+		requires std::convertible_to<T, U>
 		explicit constexpr operator U() const noexcept
 		{
 			return static_cast<U>(store.value[0u]);

tests/conversion_test.cxx

@@ -524,25 +524,28 @@ TEST_SUITE("test conversions")
 		{
 			// the three conversion operators
 
-			int val1 = cx_three.y;					// #1 to scalar type
-			iscal val2 = cx_three.x;				// #2 implicit conversion operator
-			auto val3 = fscal(cx_three.z);			// #3 explicit cast needed to invoke conversion operator
+			int val1 = cx_three.y;							// implicit conversion
+			dscal val2{1};
+			float val3 = static_cast<float>(cx_three.z);	// explicit conversion
+			auto val4 = std::asin(val2.x);			// implicit conversion
 
 			CHECK_EQ(val1, 5);
 			CHECK_NE(val1, 4);
 
-			CHECK_EQ(val2, iscal(4));
+			CHECK_EQ(val2, 1.0);
 			CHECK_NE(val2, iscal(0));
 
 			CHECK_EQ(val3, fscal(6.0f));
 			CHECK_NE(val3, fscal(4.0f));
+
+			CHECK_EQ(val4, std::asin(1.0));
 		}
 
 		SUBCASE("2D indexed_vector conversions")
 		{
 			// the two conversion operators
 
-			ivec2 val1 = cx_three.yz;				// #1 implicit conversion
+			ivec2 val1 = cx_three.yz;						// #1 implicit conversion
 			auto val2 = fvec2(cx_three.xy);		// #2 explicit cast needed to invoke conversion operator
 
 			CHECK_EQ(val1, ivec2(5, 6));
@@ -556,7 +559,7 @@ TEST_SUITE("test conversions")
 		{
 			// the two conversion operators
 
-			ivec3 val1 = cx_three.yzy;				// #1 implicit conversion
+			ivec3 val1 = cx_three.yzy;						// #1 implicit conversion
 			auto val2 = fvec3(cx_three.zzx);		// #2 explicit cast needed to invoke conversion operator
 
 			CHECK_EQ(val1, ivec3(5, 6, 5));
@@ -570,7 +573,7 @@ TEST_SUITE("test conversions")
 		{
 			// the two conversion operators
 
-			ivec4 val1 = cx_three.yzyx;				// #1 implicit conversion
+			ivec4 val1 = cx_three.yzyx;						// #1 implicit conversion
 			auto val2 = fvec4(cx_three.zxyy);		// #2 explicit cast needed to invoke conversion operator
 
 			CHECK_EQ(val1, ivec4(5, 6, 5, 4));
@@ -586,17 +589,22 @@ TEST_SUITE("test conversions")
 		// the only basic_vector with conversion operators is
 		// for 1D, as we want them to mimic the scalar type.
 
-		const int val1 = cx_one;							// #1 implicit conversion
-		[[maybe_unused]] float f2 = cx_one;							// #1 implicit conversion
+		const int val1 = cx_one;										// implicit conversion
+		[[maybe_unused]] float f2 = static_cast<float>(cx_one);			// explicit conversion
 
 		const fscal fone = 9.9f;
-		const int val2 = static_cast<int>(fone);			// #2 explicit conversion
+		const int val2 = static_cast<int>(fone);						// explicit conversion
+
+		dscal dval = 1.0;
+		auto val3 = std::asin(dval);							// implicit conversion
 
 		CHECK_EQ(val1, 9);
 		CHECK_NE(val1, 0);
 
 		CHECK_EQ(val2, 9);
 		CHECK_NE(val2, 0);
+
+		CHECK_EQ(val3, std::asin(1.0));
 	}
 
 	TEST_CASE("basic_vector conversion constructors")