v1.0.0 released

Author: davidbrowne

README.md

@@ -2,9 +2,13 @@
 
 **dsga** is a single header-only **c++20 library** that implements the **vectors** and **matrices** from the OpenGL Shading Language 4.6 specification ([pdf](https://www.khronos.org/registry/OpenGL/specs/gl/GLSLangSpec.4.60.pdf) | [html](https://registry.khronos.org/OpenGL/specs/gl/GLSLangSpec.4.60.html)). It is inspired by the spec, but does deviate in some small ways, mostly to make it work well in c++20. It is not intended to be used for rendering, just for sharing the fundamental data structures and associated functions. Our requirements in general are for things like 3D CAD/CAM applications and other geometric and algebraic things. See [motivation](docs/MOTIVATION.md) for more details. This library does not use SIMD instructions or types under the hood, beyond whatever the compiler provides through optimization.
 
+## Current Version
+v1.0.0
+
 ## Contents
 * [Some Quick Examples](#some-quick-examples)
 * [Relevant GLSL Overview](#relevant-glsl-overview)
+* [Implemented Interfaces](#implemented-interfaces)
 * [Installation](#installation)
 * [Status](#status)
 * [Usage](#usage)
@@ -222,6 +226,43 @@ The following links to the shading specification should help with understanding
 
       In addtion, we have added the non-GLSL convenience function ```none()```, which returns ```!any()```.
 
+## Implemented Interfaces
+
+To make the vectors and matrices as useful as possible in a c++ context, various c++ customization points were implemented or interfaces partially emulated, e.g., ```std::valarray<>```. For ```dsga``` vectors and matrices, we have:
+
+* swizzling from GLSL (just vector)
+    * just from the set of {x, y, z, w}, e.g., ```foo.wyxz```
+* ```std::valarray<>``` (just vector)
+    * ```apply()```
+    * ```shift()```
+    * ```cshift()```
+    * ```min()```
+    * ```max()```
+    * ```sum()```
+* ```std::tuple```, structured bindings
+    * ```tuple_size<>```
+    * ```tuple_element<>```
+    * ```get<>()```
+* iterators, ranges, range-for loop
+    * ```begin()```
+    * ```cbegin()```
+    * ```rbegin()```
+    * ```crbegin()```
+    * ```end()```
+    * ```cend()```
+    * ```rend()```
+    * ```crend()```
+* indexing
+    * ```operator []```
+* pointer (just vector)
+    * ```data()```
+    * ```offsets```
+    * ```sequence()```
+ * output
+    * [```std::ostream<>``` example](examples/ostream_output.hxx)
+    * [```std::formatter<>``` example](examples/format_output.hxx)
+
+
 ## Installation
 
 This is a **single header library**, where you just need the file [dsga.hxx](include/dsga.hxx). Things are defined in the ```dsga``` namespace. The types provided by this library can be seen summarized in the [documentation](docs/DOCUMENTATION.md), [using directives](docs/DOCUMENTATION.md#types-and-functions).
@@ -238,18 +279,15 @@ Remember, this is a c++20 library, so that needs to be the minimum standard that
 
 ## Status
 
-Current version: `v0.11.0`
+Current version: `v1.0.0`
 
-* **All the intended vector and matrix functionality from the GLSL specification is implemented.** We keep refining the implementation, and we keep expanding the API to better support ```c++20``` idioms and usage as we go.
-* First pass at test coverage. Everything major has some tests, but code coverage is not 100%.
-* [Released v0.11.0](https://github.com/davidbrowne/dsga/releases/tag/v0.11.0)
+* Everything major has some tests, but code coverage is not 100%.
+* [Released v1.0.0](https://github.com/davidbrowne/dsga/releases/tag/v1.0.0)
 
 ### The next steps
 * Working on much better API documentation.
 * Working on better ```cmake``` support.
 
-Once we have detailed API documentation and better ```cmake``` support, we can think about releasing a v1.0 version.
-
 ## Usage
 
 Use it more or less like you would use vectors and matrices in a shader program, but not necessarily for shading. We hope to be able to use it for rapid development of geometric algorithms. See the [examples](examples) directory.

include/dsga.hxx

@@ -58,8 +58,8 @@ inline void dsga_constexpr_assert_failed(Assert &&a) noexcept
 
 // version info
 
-constexpr inline int DSGA_MAJOR_VERSION = 0;
-constexpr inline int DSGA_MINOR_VERSION = 11;
+constexpr inline int DSGA_MAJOR_VERSION = 1;
+constexpr inline int DSGA_MINOR_VERSION = 0;
 constexpr inline int DSGA_PATCH_VERSION = 0;
 
 namespace dsga
@@ -1240,13 +1240,13 @@ namespace dsga
 			{
 				int count = by > max_val ? max_val : by;
 				auto shifted_end = std::shift_left(copy.begin(), copy.end(), count);
-				std::fill_n(shifted_end, count, T(0));
+				std::ranges::fill_n(shifted_end, count, T(0));
 			}
 			else if (by < 0)
 			{
 				int count = -by > max_val ? max_val : -by;
 				std::shift_right(copy.begin(), copy.end(), count);
-				std::fill_n(copy.begin(), count, T(0));
+				std::ranges::fill_n(copy.begin(), count, T(0));
 			}
 
 			return copy;
@@ -1261,22 +1261,22 @@ namespace dsga
 			if (by > 0)
 			{
 				int count = by > max_val ? max_val : by;
-				std::rotate(copy.begin(), copy.begin() + count, copy.end());
+				std::ranges::rotate(copy, copy.begin() + count);
 			}
 			else if (by < 0)
 			{
 				int count = -by > max_val ? max_val : -by;
-				std::rotate(copy.begin(), copy.begin() + max_val - count, copy.end());
+				std::ranges::rotate(copy, copy.begin() + max_val - count);
 			}
 
 			return copy;
 		}
 
 		// min value in vector
-		[[nodiscard]] constexpr T min() const noexcept requires non_bool_scalar<T>		{ return *std::min_element(begin(), end()); }
+		[[nodiscard]] constexpr T min() const noexcept requires non_bool_scalar<T>		{ return *std::ranges::min_element(*this); }
 
 		// max value in vector
-		[[nodiscard]] constexpr T max() const noexcept requires non_bool_scalar<T>		{ return *std::max_element(begin(), end()); }
+		[[nodiscard]] constexpr T max() const noexcept requires non_bool_scalar<T>		{ return *std::ranges::max_element(*this); }
 
 		// sum of values in vector
 		[[nodiscard]] constexpr T sum() const noexcept requires non_bool_scalar<T>		{ return std::accumulate(begin(), end(), T(0)); }

src/main.cxx

@@ -6,7 +6,6 @@
 
 //#include "nanobench.h"
 #include "dsga.hxx"
-#include "../examples/format_output.hxx"
 
 //
 //
@@ -22,21 +21,6 @@ void sandbox_function()
 {
 	// put fun code here
 
-#if defined(__cpp_lib_format)
-	auto fmt_arr = std::array<double, 4>{1, 2, 3, 4};
-	auto empty_arr = std::array<double, 0>{};
-	auto one_arr = std::array<double, 1>{99};
-	auto fmt_vec = dsga::dvec4(10, 20, 30, 40);
-	auto fmt_mat = dsga::dmat3x2(1, 2, 3, 4, 5, 6);
-	test_format_array(empty_arr);
-	test_format_array(one_arr);
-	test_format_array(fmt_arr);
-	test_format_vector(fmt_vec);
-	test_format_vector_base(fmt_vec);
-	test_format_vector_base(fmt_vec.wzyx);
-	test_format_indexed_vector(fmt_vec.wzyx);
-	test_format_matrix(fmt_mat);
-#endif
 }
 
 #if defined(__clang__) && (__clang_major__ < 13)