neoGFX
Cross-platform C++ app/game engine
Loading...
Searching...
No Matches
numerical.hpp
Go to the documentation of this file.
1// numerical.hpp
2/*
3 * Copyright (c) 2015, 2020 Leigh Johnston.
4 *
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions are
9 * met:
10 *
11 * * Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 *
14 * * Redistributions in binary form must reproduce the above copyright
15 * notice, this list of conditions and the following disclaimer in the
16 * documentation and/or other materials provided with the distribution.
17 *
18 * * Neither the name of Leigh Johnston nor the names of any
19 * other contributors to this software may be used to endorse or
20 * promote products derived from this software without specific prior
21 * written permission.
22 *
23 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
24 * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
25 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
26 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
27 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
28 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
29 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
30 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
31 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
32 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
33 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
34 */
35
36#pragma once
37
38#include <neolib/neolib.hpp>
39#include <type_traits>
40#include <stdexcept>
41#include <vector>
42#include <utility>
43#include <array>
44#include <algorithm>
45#include <ostream>
46#include <istream>
47#include <boost/math/constants/constants.hpp>
48#include <neolib/core/vecarray.hpp>
49#include <neolib/core/swizzle.hpp>
50#include <neolib/core/simd.hpp>
51#include <neolib/core/optional.hpp>
52#include <neolib/core/string_utils.hpp>
53
54namespace neolib
55{
56 namespace math
57 {
58#define USE_AVX
59#define USE_EMM
60
61 using namespace boost::math::constants;
62
63 typedef double scalar;
64 typedef double angle;
65
66 namespace constants
67 {
68 template <typename T>
69 constexpr T zero = static_cast<T>(0.0);
70 template <typename T>
71 constexpr T one = static_cast<T>(1.0);
72 template <typename T>
73 constexpr T two = static_cast<T>(2.0);
74 template <typename T>
75 constexpr T three = static_cast<T>(3.0);
76 template <typename T>
77 constexpr T four = static_cast<T>(4.0);
78 }
79
80 template <typename T, typename SFINAE = std::enable_if_t<std::is_scalar_v<T>, sfinae>>
81 inline T lerp(T aX1, T aX2, double aAmount)
82 {
83 double x1 = aX1;
84 double x2 = aX2;
85 return static_cast<T>((x2 - x1) * aAmount + x1);
86 }
87
88 inline angle to_rad(angle aDegrees)
89 {
90 return aDegrees / 180.0 * pi<angle>();
91 }
92
93 inline angle to_deg(angle aRadians)
94 {
95 return aRadians * 180.0 / pi<angle>();
96 }
97
98 struct column_vector {};
99 struct row_vector {};
100
101 template <typename T, uint32_t _Size, typename Type = column_vector>
102 class basic_vector;
103 }
104
105 template <typename T, uint32_t _Size, typename Type>
106 bool constexpr vecarray_trivial_v<math::basic_vector<T, _Size, Type>> = true;
107
108 namespace math
109 {
110 template <typename T, uint32_t _Size, typename Type>
111 class basic_vector
112 {
113 typedef basic_vector<T, _Size, Type> self_type;
114 public:
115 typedef self_type abstract_type; // todo: abstract base; std::array?
116 public:
117 typedef Type type;
118 public:
119 typedef T value_type;
120 typedef basic_vector<value_type, _Size, Type> vector_type;
121 typedef uint32_t size_type;
122 typedef std::array<value_type, _Size> array_type;
123 typedef typename array_type::const_iterator const_iterator;
124 typedef typename array_type::iterator iterator;
125 public:
126 template <uint32_t Size2> struct rebind { typedef basic_vector<T, Size2, Type> type; };
127 public:
128 static constexpr uint32_t Size = _Size;
129 public:
130 basic_vector() : v{} {}
131 template <typename SFINAE = int>
132 explicit basic_vector(value_type x, typename std::enable_if_t<Size == 1, SFINAE> = 0) : v{ {x} } {}
133 template <typename SFINAE = int>
134 explicit basic_vector(value_type x, value_type y, typename std::enable_if_t<Size == 2, SFINAE> = 0) : v{ {x, y} } {}
135 template <typename SFINAE = int>
136 explicit basic_vector(value_type x, value_type y, value_type z, typename std::enable_if_t<Size == 3, SFINAE> = 0) : v{ {x, y, z} } {}
137 template <typename SFINAE = int>
138 explicit basic_vector(value_type x, value_type y, value_type z, value_type w, typename std::enable_if_t<Size == 4, SFINAE> = 0) : v{ { x, y, z, w } } {}
139 template <typename... Arguments>
140 explicit basic_vector(const value_type& value, Arguments&&... aArguments) : v{ {value, std::forward<Arguments>(aArguments)...} } {}
141 template <typename... Arguments>
142 explicit basic_vector(value_type&& value, Arguments&&... aArguments) : v{ {std::move(value), std::forward<Arguments>(aArguments)...} } {}
143 explicit basic_vector(const array_type& v) : v{ v } {}
144 basic_vector(std::initializer_list<value_type> values) { if (values.size() > Size) throw std::out_of_range("neolib::basic_vector: initializer list too big"); std::uninitialized_copy(values.begin(), values.end(), v.begin()); std::uninitialized_fill(v.begin() + (values.end() - values.begin()), v.end(), value_type{}); }
145 template <typename V, typename A, uint32_t S, uint32_t... Indexes>
146 basic_vector(const swizzle<V, A, S, Indexes...>& aSwizzle) : self_type{ ~aSwizzle } {}
147 basic_vector(const self_type& other) : v{ other.v } {}
148 basic_vector(self_type&& other) : v{ std::move(other.v) } {}
149 template <typename T2>
150 basic_vector(const basic_vector<T2, Size, Type>& other) { std::transform(other.begin(), other.end(), v.begin(), [](T2 source) { return static_cast<value_type>(source); }); }
151 template <typename T2, uint32_t Size2, typename SFINAE = int>
152 basic_vector(const basic_vector<T2, Size2, Type>& other, typename std::enable_if_t<Size2 < Size, SFINAE> = 0) : v{} { std::transform(other.begin(), other.end(), v.begin(), [](T2 source) { return static_cast<value_type>(source); }); }
153 self_type& operator=(const self_type& other) { v = other.v; return *this; }
154 self_type& operator=(self_type&& other) { v = std::move(other.v); return *this; }
155 self_type& operator=(std::initializer_list<value_type> values) { if (values.size() > Size) throw std::out_of_range("neolib::basic_vector: initializer list too big"); std::copy(values.begin(), values.end(), v.begin()); std::fill(v.begin() + (values.end() - values.begin()), v.end(), value_type{}); return *this; }
156 public:
157 static uint32_t size() { return Size; }
158 value_type operator[](uint32_t aIndex) const { return v[aIndex]; }
159 value_type& operator[](uint32_t aIndex) { return v[aIndex]; }
160 const_iterator begin() const { return v.begin(); }
161 const_iterator end() const { return v.end(); }
162 iterator begin() { return v.begin(); }
163 iterator end() { return v.end(); }
164 operator const array_type&() const { return v; }
165 public:
166 template <typename T2>
167 basic_vector<T2, Size, Type> as() const
168 {
169 return basic_vector<T2, Size, Type>{ *this };
170 }
171 public:
172 bool operator==(const self_type& right) const { return v == right.v; }
173 bool operator!=(const self_type& right) const { return v != right.v; }
174 self_type& operator+=(value_type value) { for (uint32_t index = 0; index < Size; ++index) v[index] += value; return *this; }
175 self_type& operator-=(value_type value) { for (uint32_t index = 0; index < Size; ++index) v[index] -= value; return *this; }
176 self_type& operator*=(value_type value) { for (uint32_t index = 0; index < Size; ++index) v[index] *= value; return *this; }
177 self_type& operator/=(value_type value) { for (uint32_t index = 0; index < Size; ++index) v[index] /= value; return *this; }
178 self_type& operator+=(const self_type& right) { for (uint32_t index = 0; index < Size; ++index) v[index] += right.v[index]; return *this; }
179 self_type& operator-=(const self_type& right) { for (uint32_t index = 0; index < Size; ++index) v[index] -= right.v[index]; return *this; }
180 self_type& operator*=(const self_type& right) { for (uint32_t index = 0; index < Size; ++index) v[index] *= right.v[index]; return *this; }
181 self_type& operator/=(const self_type& right) { for (uint32_t index = 0; index < Size; ++index) v[index] /= right.v[index]; return *this; }
182 self_type operator-() const { self_type result; for (uint32_t index = 0; index < Size; ++index) result.v[index] = -v[index]; return result; }
183 self_type scale(const self_type& right) const { self_type result; for (uint32_t index = 0; index < Size; ++index) result[index] = v[index] * right[index]; return result; }
184 value_type magnitude() const { value_type ss = constants::zero<value_type>; for (uint32_t index = 0; index < Size; ++index) ss += (v[index] * v[index]); return std::sqrt(ss); }
185 self_type normalized() const { self_type result; value_type im = constants::one<value_type> / magnitude(); for (uint32_t index = 0; index < Size; ++index) result.v[index] = v[index] * im; return result; }
186 self_type min(const self_type& right) const { self_type result; for (uint32_t index = 0; index < Size; ++index) result[index] = std::min(v[index], right.v[index]); return result; }
187 self_type max(const self_type& right) const { self_type result; for (uint32_t index = 0; index < Size; ++index) result[index] = std::max(v[index], right.v[index]); return result; }
188 value_type min() const { value_type result = v[0]; for (uint32_t index = 1; index < Size; ++index) result = std::min(v[index], result); return result; }
189 self_type ceil() const { self_type result; for (uint32_t index = 0; index < Size; ++index) result[index] = std::ceil(v[index]); return result; }
190 self_type floor() const { self_type result; for (uint32_t index = 0; index < Size; ++index) result[index] = std::floor(v[index]); return result; }
191 self_type round() const { self_type result; for (uint32_t index = 0; index < Size; ++index) result[index] = std::round(v[index]); return result; }
192 value_type distance(const self_type& right) const { value_type total = 0; for (uint32_t index = 0; index < Size; ++index) total += ((v[index] - right.v[index]) * (v[index] - right.v[index])); return std::sqrt(total); }
193 value_type dot(const self_type& right) const
194 {
195 value_type result = constants::zero<value_type>;
196 for (uint32_t index = 0; index < Size; ++index)
197 result += (v[index] * right[index]);
198 return result;
199 }
200 template <typename SFINAE = self_type>
201 std::enable_if_t<Size == 3, SFINAE> cross(const self_type& right) const
202 {
203 return self_type{
204 y * right.z - z * right.y,
205 z * right.x - x * right.z,
206 x * right.y - y * right.x };
207 }
208 self_type hadamard_product(const self_type& right) const
209 {
210 self_type result = *this;
211 result *= right;
212 return result;
213 }
214 public:
215 friend void swap(self_type& a, self_type& b)
216 {
217 using std::swap;
218 swap(a.v, b.v);
219 }
220 public:
221 union
222 {
223 array_type v;
224 struct // todo: alignment, padding?
225 {
226 value_type x;
227 value_type y;
228 value_type z;
229 };
230 swizzle<vector_type, array_type, 2, 0, 0> xx;
231 swizzle<vector_type, array_type, 2, 0, 1> xy;
232 swizzle<vector_type, array_type, 2, 0, 2> xz;
233 swizzle<vector_type, array_type, 2, 1, 0> yx;
234 swizzle<vector_type, array_type, 2, 1, 1> yy;
235 swizzle<vector_type, array_type, 2, 1, 2> yz;
236 swizzle<vector_type, array_type, 2, 2, 0> zx;
237 swizzle<vector_type, array_type, 2, 2, 1> zy;
238 swizzle<vector_type, array_type, 2, 2, 2> zz;
239 swizzle<vector_type, array_type, 3, 0, 0, 0> xxx;
240 swizzle<vector_type, array_type, 3, 0, 0, 1> xxy;
241 swizzle<vector_type, array_type, 3, 0, 0, 2> xxz;
242 swizzle<vector_type, array_type, 3, 0, 1, 0> xyx;
243 swizzle<vector_type, array_type, 3, 0, 1, 1> xyy;
244 swizzle<vector_type, array_type, 3, 0, 1, 2> xyz;
245 swizzle<vector_type, array_type, 3, 1, 0, 0> yxx;
246 swizzle<vector_type, array_type, 3, 1, 0, 1> yxy;
247 swizzle<vector_type, array_type, 3, 1, 0, 2> yxz;
248 swizzle<vector_type, array_type, 3, 1, 1, 0> yyx;
249 swizzle<vector_type, array_type, 3, 1, 1, 1> yyy;
250 swizzle<vector_type, array_type, 3, 1, 1, 2> yyz;
251 swizzle<vector_type, array_type, 3, 1, 2, 0> yzx;
252 swizzle<vector_type, array_type, 3, 1, 2, 1> yzy;
253 swizzle<vector_type, array_type, 3, 1, 2, 2> yzz;
254 swizzle<vector_type, array_type, 3, 2, 0, 0> zxx;
255 swizzle<vector_type, array_type, 3, 2, 0, 1> zxy;
256 swizzle<vector_type, array_type, 3, 2, 0, 2> zxz;
257 swizzle<vector_type, array_type, 3, 2, 1, 0> zyx;
258 swizzle<vector_type, array_type, 3, 2, 1, 1> zyy;
259 swizzle<vector_type, array_type, 3, 2, 1, 2> zyz;
260 swizzle<vector_type, array_type, 3, 2, 2, 0> zzx;
261 swizzle<vector_type, array_type, 3, 2, 2, 1> zzy;
262 swizzle<vector_type, array_type, 3, 2, 2, 2> zzz;
263 };
264 };
265
266 template <typename T, typename Type>
267 class basic_vector<T, 2, Type>
268 {
269 typedef basic_vector<T, 2, Type> self_type;
270 public:
271 typedef self_type abstract_type; // todo: abstract base; std::array?
272 public:
273 typedef Type type;
274 public:
275 typedef T value_type;
276 typedef basic_vector<value_type, 2, Type> vector_type;
277 typedef uint32_t size_type;
278 typedef std::array<value_type, 2> array_type;
279 typedef typename array_type::const_iterator const_iterator;
280 typedef typename array_type::iterator iterator;
281 public:
282 template <uint32_t Size2> struct rebind { typedef basic_vector<T, Size2, Type> type; };
283 public:
284 static constexpr uint32_t Size = 2;
285 public:
286 basic_vector() : v{} {}
287 explicit basic_vector(value_type x, value_type y) : v{ {x, y} } {}
288 template <typename... Arguments>
289 explicit basic_vector(const value_type& value, Arguments&&... aArguments) : v{ {value, std::forward<Arguments>(aArguments)...} } {}
290 template <typename... Arguments>
291 explicit basic_vector(value_type&& value, Arguments&&... aArguments) : v{ {std::move(value), std::forward<Arguments>(aArguments)...} } {}
292 explicit basic_vector(const array_type& v) : v{ v } {}
293 basic_vector(std::initializer_list<value_type> values) { if (values.size() > Size) throw std::out_of_range("neolib::basic_vector: initializer list too big"); std::uninitialized_copy(values.begin(), values.end(), v.begin()); std::uninitialized_fill(v.begin() + (values.end() - values.begin()), v.end(), value_type{}); }
294 template <typename V, typename A, uint32_t S, uint32_t... Indexes>
295 basic_vector(const swizzle<V, A, S, Indexes...>& aSwizzle) : self_type{ ~aSwizzle } {}
296 basic_vector(const self_type& other) : v{ other.v } {}
297 basic_vector(self_type&& other) : v{ std::move(other.v) } {}
298 template <typename T2>
299 basic_vector(const basic_vector<T2, Size, Type>& other) { std::transform(other.begin(), other.end(), v.begin(), [](T2 source) { return static_cast<value_type>(source); }); }
300 template <typename T2, uint32_t Size2, typename SFINAE = int>
301 basic_vector(const basic_vector<T2, Size2, Type>& other, typename std::enable_if_t < Size2 < Size, SFINAE> = 0) : v{} { std::transform(other.begin(), other.end(), v.begin(), [](T2 source) { return static_cast<value_type>(source); }); }
302 self_type& operator=(const self_type& other) { v = other.v; return *this; }
303 self_type& operator=(self_type&& other) { v = std::move(other.v); return *this; }
304 self_type& operator=(std::initializer_list<value_type> values) { if (values.size() > Size) throw std::out_of_range("neolib::basic_vector: initializer list too big"); std::copy(values.begin(), values.end(), v.begin()); std::fill(v.begin() + (values.end() - values.begin()), v.end(), value_type{}); return *this; }
305 public:
306 static uint32_t size() { return Size; }
307 value_type operator[](uint32_t aIndex) const { return v[aIndex]; }
308 value_type& operator[](uint32_t aIndex) { return v[aIndex]; }
309 const_iterator begin() const { return v.begin(); }
310 const_iterator end() const { return v.end(); }
311 iterator begin() { return v.begin(); }
312 iterator end() { return v.end(); }
313 operator const array_type& () const { return v; }
314 public:
315 template <typename T2>
316 basic_vector<T2, Size, Type> as() const
317 {
318 return basic_vector<T2, Size, Type>{ *this };
319 }
320 public:
321 bool operator==(const self_type& right) const { return v == right.v; }
322 bool operator!=(const self_type& right) const { return v != right.v; }
323 self_type& operator+=(value_type value) { for (uint32_t index = 0; index < Size; ++index) v[index] += value; return *this; }
324 self_type& operator-=(value_type value) { for (uint32_t index = 0; index < Size; ++index) v[index] -= value; return *this; }
325 self_type& operator*=(value_type value) { for (uint32_t index = 0; index < Size; ++index) v[index] *= value; return *this; }
326 self_type& operator/=(value_type value) { for (uint32_t index = 0; index < Size; ++index) v[index] /= value; return *this; }
327 self_type& operator+=(const self_type& right) { for (uint32_t index = 0; index < Size; ++index) v[index] += right.v[index]; return *this; }
328 self_type& operator-=(const self_type& right) { for (uint32_t index = 0; index < Size; ++index) v[index] -= right.v[index]; return *this; }
329 self_type& operator*=(const self_type& right) { for (uint32_t index = 0; index < Size; ++index) v[index] *= right.v[index]; return *this; }
330 self_type& operator/=(const self_type& right) { for (uint32_t index = 0; index < Size; ++index) v[index] /= right.v[index]; return *this; }
331 self_type operator-() const { self_type result; for (uint32_t index = 0; index < Size; ++index) result.v[index] = -v[index]; return result; }
332 self_type scale(const self_type& right) const { self_type result; for (uint32_t index = 0; index < Size; ++index) result[index] = v[index] * right[index]; return result; }
333 value_type magnitude() const { value_type ss = constants::zero<value_type>; for (uint32_t index = 0; index < Size; ++index) ss += (v[index] * v[index]); return std::sqrt(ss); }
334 self_type normalized() const { self_type result; value_type im = constants::one<value_type> / magnitude(); for (uint32_t index = 0; index < Size; ++index) result.v[index] = v[index] * im; return result; }
335 self_type min(const self_type& right) const { self_type result; for (uint32_t index = 0; index < Size; ++index) result[index] = std::min(v[index], right.v[index]); return result; }
336 self_type max(const self_type& right) const { self_type result; for (uint32_t index = 0; index < Size; ++index) result[index] = std::max(v[index], right.v[index]); return result; }
337 value_type min() const { value_type result = v[0]; for (uint32_t index = 1; index < Size; ++index) result = std::min(v[index], result); return result; }
338 self_type ceil() const { self_type result; for (uint32_t index = 0; index < Size; ++index) result[index] = std::ceil(v[index]); return result; }
339 self_type floor() const { self_type result; for (uint32_t index = 0; index < Size; ++index) result[index] = std::floor(v[index]); return result; }
340 self_type round() const { self_type result; for (uint32_t index = 0; index < Size; ++index) result[index] = std::round(v[index]); return result; }
341 value_type distance(const self_type& right) const { value_type total = 0; for (uint32_t index = 0; index < Size; ++index) total += ((v[index] - right.v[index]) * (v[index] - right.v[index])); return std::sqrt(total); }
342 value_type dot(const self_type& right) const
343 {
344 value_type result = constants::zero<value_type>;
345 for (uint32_t index = 0; index < Size; ++index)
346 result += (v[index] * right[index]);
347 return result;
348 }
349 self_type hadamard_product(const self_type& right) const
350 {
351 self_type result = *this;
352 result *= right;
353 return result;
354 }
355 public:
356 friend void swap(self_type& a, self_type& b)
357 {
358 using std::swap;
359 swap(a.v, b.v);
360 }
361 public:
362 union
363 {
364 array_type v;
365 struct // todo: alignment, padding?
366 {
367 value_type x;
368 value_type y;
369 };
370 swizzle<vector_type, array_type, 2, 0, 0> xx;
371 swizzle<vector_type, array_type, 2, 0, 1> xy;
372 swizzle<vector_type, array_type, 2, 1, 0> yx;
373 swizzle<vector_type, array_type, 2, 1, 1> yy;
374 swizzle<vector_type, array_type, 3, 0, 0, 0> xxx;
375 swizzle<vector_type, array_type, 3, 0, 0, 1> xxy;
376 swizzle<vector_type, array_type, 3, 0, 1, 0> xyx;
377 swizzle<vector_type, array_type, 3, 0, 1, 1> xyy;
378 swizzle<vector_type, array_type, 3, 1, 0, 0> yxx;
379 swizzle<vector_type, array_type, 3, 1, 0, 1> yxy;
380 swizzle<vector_type, array_type, 3, 1, 1, 0> yyx;
381 swizzle<vector_type, array_type, 3, 1, 1, 1> yyy;
382 };
383 };
384
385 template <typename T, typename Type>
386 class basic_vector<T, 1, Type>
387 {
388 typedef basic_vector<T, 1, Type> self_type;
389 public:
390 typedef self_type abstract_type; // todo: abstract base; std::array?
391 public:
392 typedef Type type;
393 public:
394 typedef T value_type;
395 typedef basic_vector<value_type, 1, Type> vector_type;
396 typedef uint32_t size_type;
397 typedef std::array<value_type, 1> array_type;
398 typedef typename array_type::const_iterator const_iterator;
399 typedef typename array_type::iterator iterator;
400 public:
401 template <uint32_t Size2> struct rebind { typedef basic_vector<T, Size2, Type> type; };
402 public:
403 static constexpr uint32_t Size = 1;
404 public:
405 basic_vector() : v{} {}
406 explicit basic_vector(value_type x) : v{ {x} } {}
407 template <typename... Arguments>
408 explicit basic_vector(const value_type& value, Arguments&&... aArguments) : v{ {value, std::forward<Arguments>(aArguments)...} } {}
409 template <typename... Arguments>
410 explicit basic_vector(value_type&& value, Arguments&&... aArguments) : v{ {std::move(value), std::forward<Arguments>(aArguments)...} } {}
411 explicit basic_vector(const array_type& v) : v{ v } {}
412 basic_vector(std::initializer_list<value_type> values) { if (values.size() > Size) throw std::out_of_range("neolib::basic_vector: initializer list too big"); std::uninitialized_copy(values.begin(), values.end(), v.begin()); std::uninitialized_fill(v.begin() + (values.end() - values.begin()), v.end(), value_type{}); }
413 template <typename V, typename A, uint32_t S, uint32_t... Indexes>
414 basic_vector(const swizzle<V, A, S, Indexes...>& aSwizzle) : self_type{ ~aSwizzle } {}
415 basic_vector(const self_type& other) : v{ other.v } {}
416 basic_vector(self_type&& other) : v{ std::move(other.v) } {}
417 template <typename T2>
418 basic_vector(const basic_vector<T2, Size, Type>& other) { std::transform(other.begin(), other.end(), v.begin(), [](T2 source) { return static_cast<value_type>(source); }); }
419 template <typename T2, uint32_t Size2, typename SFINAE = int>
420 basic_vector(const basic_vector<T2, Size2, Type>& other, typename std::enable_if_t < Size2 < Size, SFINAE> = 0) : v{} { std::transform(other.begin(), other.end(), v.begin(), [](T2 source) { return static_cast<value_type>(source); }); }
421 self_type& operator=(const self_type& other) { v = other.v; return *this; }
422 self_type& operator=(self_type&& other) { v = std::move(other.v); return *this; }
423 self_type& operator=(std::initializer_list<value_type> values) { if (values.size() > Size) throw std::out_of_range("neolib::basic_vector: initializer list too big"); std::copy(values.begin(), values.end(), v.begin()); std::fill(v.begin() + (values.end() - values.begin()), v.end(), value_type{}); return *this; }
424 public:
425 static uint32_t size() { return Size; }
426 value_type operator[](uint32_t aIndex) const { return v[aIndex]; }
427 value_type& operator[](uint32_t aIndex) { return v[aIndex]; }
428 const_iterator begin() const { return v.begin(); }
429 const_iterator end() const { return v.end(); }
430 iterator begin() { return v.begin(); }
431 iterator end() { return v.end(); }
432 operator const array_type& () const { return v; }
433 public:
434 template <typename T2>
435 basic_vector<T2, Size, Type> as() const
436 {
437 return basic_vector<T2, Size, Type>{ *this };
438 }
439 public:
440 bool operator==(const self_type& right) const { return v == right.v; }
441 bool operator!=(const self_type& right) const { return v != right.v; }
442 self_type& operator+=(value_type value) { for (uint32_t index = 0; index < Size; ++index) v[index] += value; return *this; }
443 self_type& operator-=(value_type value) { for (uint32_t index = 0; index < Size; ++index) v[index] -= value; return *this; }
444 self_type& operator*=(value_type value) { for (uint32_t index = 0; index < Size; ++index) v[index] *= value; return *this; }
445 self_type& operator/=(value_type value) { for (uint32_t index = 0; index < Size; ++index) v[index] /= value; return *this; }
446 self_type& operator+=(const self_type& right) { for (uint32_t index = 0; index < Size; ++index) v[index] += right.v[index]; return *this; }
447 self_type& operator-=(const self_type& right) { for (uint32_t index = 0; index < Size; ++index) v[index] -= right.v[index]; return *this; }
448 self_type& operator*=(const self_type& right) { for (uint32_t index = 0; index < Size; ++index) v[index] *= right.v[index]; return *this; }
449 self_type& operator/=(const self_type& right) { for (uint32_t index = 0; index < Size; ++index) v[index] /= right.v[index]; return *this; }
450 self_type operator-() const { self_type result; for (uint32_t index = 0; index < Size; ++index) result.v[index] = -v[index]; return result; }
451 self_type scale(const self_type& right) const { self_type result; for (uint32_t index = 0; index < Size; ++index) result[index] = v[index] * right[index]; return result; }
452 value_type magnitude() const { value_type ss = constants::zero<value_type>; for (uint32_t index = 0; index < Size; ++index) ss += (v[index] * v[index]); return std::sqrt(ss); }
453 self_type normalized() const { self_type result; value_type im = constants::one<value_type> / magnitude(); for (uint32_t index = 0; index < Size; ++index) result.v[index] = v[index] * im; return result; }
454 self_type min(const self_type& right) const { self_type result; for (uint32_t index = 0; index < Size; ++index) result[index] = std::min(v[index], right.v[index]); return result; }
455 self_type max(const self_type& right) const { self_type result; for (uint32_t index = 0; index < Size; ++index) result[index] = std::max(v[index], right.v[index]); return result; }
456 value_type min() const { value_type result = v[0]; for (uint32_t index = 1; index < Size; ++index) result = std::min(v[index], result); return result; }
457 self_type ceil() const { self_type result; for (uint32_t index = 0; index < Size; ++index) result[index] = std::ceil(v[index]); return result; }
458 self_type floor() const { self_type result; for (uint32_t index = 0; index < Size; ++index) result[index] = std::floor(v[index]); return result; }
459 self_type round() const { self_type result; for (uint32_t index = 0; index < Size; ++index) result[index] = std::round(v[index]); return result; }
460 value_type distance(const self_type& right) const { value_type total = 0; for (uint32_t index = 0; index < Size; ++index) total += ((v[index] - right.v[index]) * (v[index] - right.v[index])); return std::sqrt(total); }
461 value_type dot(const self_type& right) const
462 {
463 value_type result = constants::zero<value_type>;
464 for (uint32_t index = 0; index < Size; ++index)
465 result += (v[index] * right[index]);
466 return result;
467 }
468 self_type hadamard_product(const self_type& right) const
469 {
470 self_type result = *this;
471 result *= right;
472 return result;
473 }
474 public:
475 friend void swap(self_type& a, self_type& b)
476 {
477 using std::swap;
478 swap(a.v, b.v);
479 }
480 public:
481 union
482 {
483 array_type v;
484 struct // todo: alignment, padding?
485 {
486 value_type x;
487 };
488 swizzle<vector_type, array_type, 2, 0, 0> xx;
489 swizzle<vector_type, array_type, 3, 0, 0, 0> xxx;
490 };
491 };
492
493 template <typename T, uint32_t Size, typename Type>
494 inline bool operator==(const basic_vector<T, Size, Type>& aLhs, const basic_vector<T, Size, Type>& aRhs)
495 {
496 return aLhs.v == aRhs.v;
497 }
498
499 template <typename T, uint32_t Size, typename Type>
500 inline bool operator<(const basic_vector<T, Size, Type>& aLhs, const basic_vector<T, Size, Type>& aRhs)
501 {
502 return aLhs.v < aRhs.v;
503 }
504
505 template <typename T, uint32_t Size, typename Type>
506 inline std::partial_ordering operator<=>(const basic_vector<T, Size, Type>& aLhs, const basic_vector<T, Size, Type>& aRhs)
507 {
508 return aLhs.v <=> aRhs.v;
509 }
510
511 typedef basic_vector<double, 1> vector1;
512 typedef basic_vector<double, 2> vector2;
513 typedef basic_vector<double, 3> vector3;
514 typedef basic_vector<double, 4> vector4;
515
516 typedef vector1 vec1;
517 typedef vector2 vec2;
518 typedef vector3 vec3;
519 typedef vector4 vec4;
520
521 typedef vec1 col_vec1;
522 typedef vec2 col_vec2;
523 typedef vec3 col_vec3;
524 typedef vec4 col_vec4;
525
526 typedef basic_vector<double, 1, row_vector> row_vec1;
527 typedef basic_vector<double, 2, row_vector> row_vec2;
528 typedef basic_vector<double, 3, row_vector> row_vec3;
529 typedef basic_vector<double, 4, row_vector> row_vec4;
530
531 typedef optional<vector1> optional_vector1;
532 typedef optional<vector2> optional_vector2;
533 typedef optional<vector3> optional_vector3;
534 typedef optional<vector4> optional_vector4;
535
536 typedef optional<vec1> optional_vec1;
537 typedef optional<vec2> optional_vec2;
538 typedef optional<vec3> optional_vec3;
539 typedef optional<vec4> optional_vec4;
540
541 typedef optional<col_vec1> optional_col_vec1;
542 typedef optional<col_vec2> optional_col_vec2;
543 typedef optional<col_vec3> optional_col_vec3;
544 typedef optional<col_vec4> optional_col_vec4;
545
546 typedef optional<row_vec1> optional_row_vec1;
547 typedef optional<row_vec2> optional_row_vec2;
548 typedef optional<row_vec3> optional_row_vec3;
549 typedef optional<row_vec4> optional_row_vec4;
550
551 typedef std::vector<vec2> vec2_list;
552 typedef std::vector<vec3> vec3_list;
553
554 typedef optional<vec2_list> optional_vec2_list;
555 typedef optional<vec3_list> optional_vec3_list;
556
557 typedef vec2_list vertices_2d;
558 typedef vec3_list vertices;
559
560 typedef optional_vec2_list optional_vertices_2d_t;
561 typedef optional_vec3_list optional_vertices_t;
562
563 typedef basic_vector<float, 1> vector1f;
564 typedef basic_vector<float, 2> vector2f;
565 typedef basic_vector<float, 3> vector3f;
566 typedef basic_vector<float, 4> vector4f;
567
568 typedef vector1f vec1f;
569 typedef vector2f vec2f;
570 typedef vector3f vec3f;
571 typedef vector4f vec4f;
572
573 typedef int32_t i32;
574 typedef int64_t i64;
575
576 typedef basic_vector<i32, 1> vector1i32;
577 typedef basic_vector<i32, 2> vector2i32;
578 typedef basic_vector<i32, 3> vector3i32;
579 typedef basic_vector<i32, 4> vector4i32;
580
581 typedef vector1i32 vec1i32;
582 typedef vector2i32 vec2i32;
583 typedef vector3i32 vec3i32;
584 typedef vector4i32 vec4i32;
585
586 typedef uint32_t u32;
587 typedef uint32_t u64;
588
589 typedef basic_vector<u32, 1> vector1u32;
590 typedef basic_vector<u32, 2> vector2u32;
591 typedef basic_vector<u32, 3> vector3u32;
592 typedef basic_vector<u32, 4> vector4u32;
593
594 typedef vector1u32 vec1u32;
595 typedef vector2u32 vec2u32;
596 typedef vector3u32 vec3u32;
597 typedef vector4u32 vec4u32;
598
599 template <std::size_t VertexCount>
600 using vec3_array = neolib::vecarray<vec3, VertexCount, VertexCount, neolib::check<neolib::vecarray_overflow>, std::allocator<vec3>>;
601
602 template <std::size_t VertexCount>
603 using vec2_array = neolib::vecarray<vec2, VertexCount, VertexCount, neolib::check<neolib::vecarray_overflow>, std::allocator<vec2>>;
604
605 typedef std::array<int8_t, 1> avec1i8;
606 typedef std::array<int8_t, 2> avec2i8;
607 typedef std::array<int8_t, 3> avec3i8;
608 typedef std::array<int8_t, 4> avec4i8;
609
610 typedef std::array<int16_t, 1> avec1i16;
611 typedef std::array<int16_t, 2> avec2i16;
612 typedef std::array<int16_t, 3> avec3i16;
613 typedef std::array<int16_t, 4> avec4i16;
614
615 typedef std::array<int32_t, 1> avec1i32;
616 typedef std::array<int32_t, 2> avec2i32;
617 typedef std::array<int32_t, 3> avec3i32;
618 typedef std::array<int32_t, 4> avec4i32;
619
620 typedef std::array<uint8_t, 1> avec1u8;
621 typedef std::array<uint8_t, 2> avec2u8;
622 typedef std::array<uint8_t, 3> avec3u8;
623 typedef std::array<uint8_t, 4> avec4u8;
624
625 typedef std::array<uint16_t, 1> avec1u16;
626 typedef std::array<uint16_t, 2> avec2u16;
627 typedef std::array<uint16_t, 3> avec3u16;
628 typedef std::array<uint16_t, 4> avec4u16;
629
630 typedef std::array<uint32_t, 1> avec1u32;
631 typedef std::array<uint32_t, 2> avec2u32;
632 typedef std::array<uint32_t, 3> avec3u32;
633 typedef std::array<uint32_t, 4> avec4u32;
634
635 typedef std::array<float, 1> avec1f;
636 typedef std::array<float, 2> avec2f;
637 typedef std::array<float, 3> avec3f;
638 typedef std::array<float, 4> avec4f;
639
640 typedef std::array<double, 1> avec1;
641 typedef std::array<double, 2> avec2;
642 typedef std::array<double, 3> avec3;
643 typedef std::array<double, 4> avec4;
644
645 typedef std::array<vec3, 3> triangle;
646 typedef std::array<vec3, 4> quad;
647
648 typedef std::array<vec2, 3> triangle_2d;
649 typedef std::array<vec2, 4> quad_2d;
650
651 typedef std::array<vec3f, 3> trianglef;
652 typedef std::array<vec3f, 4> quadf;
653
654 typedef std::array<vec2f, 3> trianglef_2d;
655 typedef std::array<vec2f, 4> quadf_2d;
656
657 template <typename T, uint32_t D, typename Type>
658 inline basic_vector<T, D, Type> operator+(const basic_vector<T, D, Type>& left, const basic_vector<T, D, Type>& right)
659 {
660 basic_vector<T, D, Type> result = left;
661 result += right;
662 return result;
663 }
664
665 template <typename T, uint32_t D, typename Type>
666 inline basic_vector<T, D, Type> operator-(const basic_vector<T, D, Type>& left, const basic_vector<T, D, Type>& right)
667 {
668 basic_vector<T, D, Type> result = left;
669 result -= right;
670 return result;
671 }
672
673 template <typename T, uint32_t D, typename Type, std::size_t VertexCount>
674 inline std::array<basic_vector<T, D, Type>, VertexCount> operator+(const basic_vector<T, D, Type>& left, const std::array<basic_vector<T, D, Type>, VertexCount>& right)
675 {
676 std::array<basic_vector<T, D, Type>, VertexCount> result = right;
677 for (auto& v : result)
678 v += left;
679 return result;
680 }
681
682 template <typename T, uint32_t D, typename Type, std::size_t VertexCount>
683 inline std::array<basic_vector<T, D, Type>, VertexCount> operator+(const std::array<basic_vector<T, D, Type>, VertexCount>& left, const basic_vector<T, D, Type>& right)
684 {
685 std::array<basic_vector<T, D, Type>, VertexCount> result = left;
686 for (auto& v : result)
687 v += right;
688 return result;
689 }
690
691 template <typename T, uint32_t D, typename Type, std::size_t VertexCount>
692 inline std::array<basic_vector<T, D, Type>, VertexCount>& operator+=(std::array<basic_vector<T, D, Type>, VertexCount>& left, const basic_vector<T, D, Type>& right)
693 {
694 for (auto& v : left)
695 v += right;
696 return left;
697 }
698
699 template <typename T, uint32_t D, typename Type, std::size_t VertexCount>
700 inline std::array<basic_vector<T, D, Type>, VertexCount> operator-(const basic_vector<T, D, Type>& left, const std::array<basic_vector<T, D, Type>, VertexCount>& right)
701 {
702 std::array<basic_vector<T, D, Type>, VertexCount> result = right;
703 for (auto& v : result)
704 v = left - v;
705 return result;
706 }
707
708 template <typename T, uint32_t D, typename Type, std::size_t VertexCount>
709 inline std::array<basic_vector<T, D, Type>, VertexCount> operator-(const std::array<basic_vector<T, D, Type>, VertexCount>& left, const basic_vector<T, D, Type>& right)
710 {
711 std::array<basic_vector<T, D, Type>, VertexCount> result = left;
712 for (auto& v : result)
713 v -= right;
714 return result;
715 }
716
717 template <typename T, uint32_t D, typename Type, std::size_t VertexCount>
718 inline std::array<basic_vector<T, D, Type>, VertexCount>& operator-=(std::array<basic_vector<T, D, Type>, VertexCount>& left, const basic_vector<T, D, Type>& right)
719 {
720 for (auto& v : left)
721 v -= right;
722 return left;
723 }
724
725 template <typename T, uint32_t D, typename Type>
726 inline basic_vector<T, D, Type> operator+(const basic_vector<T, D, Type>& left, const T& right)
727 {
728 basic_vector<T, D, Type> result = left;
729 for (uint32_t i = 0; i < D; ++i)
730 result[i] += right;
731 return result;
732 }
733
734 template <typename T, uint32_t D, typename Type>
735 inline basic_vector<T, D, Type> operator+(const T& left, const basic_vector<T, D, Type>& right)
736 {
737 basic_vector<T, D, Type> result = right;
738 for (uint32_t i = 0; i < D; ++i)
739 result[i] += left;
740 return result;
741 }
742
743 template <typename T, uint32_t D, typename Type>
744 inline basic_vector<T, D, Type> operator-(const basic_vector<T, D, Type>& left, const T& right)
745 {
746 basic_vector<T, D, Type> result = left;
747 for (uint32_t i = 0; i < D; ++i)
748 result[i] -= right;
749 return result;
750 }
751
752 template <typename T, uint32_t D, typename Type>
753 inline basic_vector<T, D, Type> operator-(const T& left, const basic_vector<T, D, Type>& right)
754 {
755 basic_vector<T, D, Type> result;
756 for (uint32_t i = 0; i < D; ++i)
757 result[i] = left - right[i];
758 return result;
759 }
760
761 template <typename T, uint32_t D, typename Type>
762 inline basic_vector<T, D, Type> operator*(const basic_vector<T, D, Type>& left, const T& right)
763 {
764 basic_vector<T, D, Type> result = left;
765 for (uint32_t i = 0; i < D; ++i)
766 result[i] *= right;
767 return result;
768 }
769
770 template <typename T, uint32_t D, typename Type>
771 inline basic_vector<T, D, Type> operator*(const T& left, const basic_vector<T, D, Type>& right)
772 {
773 basic_vector<T, D, Type> result = right;
774 for (uint32_t i = 0; i < D; ++i)
775 result[i] *= left;
776 return result;
777 }
778
779 template <typename T, uint32_t D, typename Type>
780 inline basic_vector<T, D, Type> operator/(const basic_vector<T, D, Type>& left, const T& right)
781 {
782 basic_vector<T, D, Type> result = left;
783 for (uint32_t i = 0; i < D; ++i)
784 result[i] /= right;
785 return result;
786 }
787
788 template <typename T, uint32_t D, typename Type>
789 inline basic_vector<T, D, Type> operator/(const T& left, const basic_vector<T, D, Type>& right)
790 {
791 basic_vector<T, D, Type> result;
792 for (uint32_t i = 0; i < D; ++i)
793 result[i] = left / right[i];
794 return result;
795 }
796
797 template <typename T, uint32_t D, typename Type>
798 inline basic_vector<T, D, Type> operator%(const basic_vector<T, D, Type>& left, const T& right)
799 {
800 basic_vector<T, D, Type> result;
801 for (uint32_t i = 0; i < D; ++i)
802 result[i] = std::fmod(left[i], right);
803 return result;
804 }
805
806 template <typename T, uint32_t D>
807 inline T operator*(const basic_vector<T, D, row_vector>& left, const basic_vector<T, D, column_vector>& right)
808 {
809 T result = {};
810 for (uint32_t index = 0; index < D; ++index)
811 result += (left[index] * right[index]);
812 return result;
813 }
814
815 template <typename T, typename Type>
816 inline basic_vector<T, 3, Type> operator+(const basic_vector<T, 3, Type>& left, const basic_vector<T, 3, Type>& right)
817 {
818 return basic_vector<T, 3, Type>{ left[0] + right[0], left[1] + right[1], left[2] + right[2] };
819 }
820
821 template <typename T, typename Type>
822 inline basic_vector<T, 3, Type> operator-(const basic_vector<T, 3, Type>& left, const basic_vector<T, 3, Type>& right)
823 {
824 return basic_vector<T, 3, Type>{ left[0] - right[0], left[1] - right[1], left[2] - right[2] };
825 }
826
827 template <typename T, typename Type>
828 inline basic_vector<T, 3, Type> operator+(const basic_vector<T, 3, Type>& left, const T& right)
829 {
830 return basic_vector<T, 3, Type>{ left[0] + right, left[1] + right, left[2] + right };
831 }
832
833 template <typename T, typename Type>
834 inline basic_vector<T, 3, Type> operator+(const T& left, const basic_vector<T, 3, Type>& right)
835 {
836 return basic_vector<T, 3, Type>{ left + right[0], left + right[1], left + right[2] };
837 }
838
839 template <typename T, typename Type>
840 inline basic_vector<T, 3, Type> operator-(const basic_vector<T, 3, Type>& left, const T& right)
841 {
842 return basic_vector<T, 3, Type>{ left[0] - right, left[1] - right, left[2] - right };
843 }
844
845 template <typename T, typename Type>
846 inline basic_vector<T, 3, Type> operator-(const T& left, const basic_vector<T, 3, Type>& right)
847 {
848 return basic_vector<T, 3, Type>{ left - right[0], left - right[1], left - right[2] };
849 }
850
851 template <typename T, typename Type>
852 inline basic_vector<T, 3, Type> operator*(const basic_vector<T, 3, Type>& left, const T& right)
853 {
854 return basic_vector<T, 3, Type>{ left[0] * right, left[1] * right, left[2] * right };
855 }
856
857 template <typename T, typename Type>
858 inline basic_vector<T, 3, Type> operator*(const T& left, const basic_vector<T, 3, Type>& right)
859 {
860 return basic_vector<T, 3, Type>{ left * right[0], left * right[1], left * right[2] };
861 }
862
863 template <typename T, typename Type>
864 inline basic_vector<T, 3, Type> operator/(const basic_vector<T, 3, Type>& left, const T& right)
865 {
866 return basic_vector<T, 3, Type>{ left[0] / right, left[1] / right, left[2] / right };
867 }
868
869 template <typename T, typename Type>
870 inline basic_vector<T, 3, Type> operator%(const basic_vector<T, 3, Type>& left, const T& right)
871 {
872 return basic_vector<T, 3, Type>{ std::fmod(left[0], right), std::fmod(left[1], right), std::fmod(left[2], right) };
873 }
874
875 template <typename T>
876 inline T operator*(const basic_vector<T, 3, row_vector>& left, const basic_vector<T, 3, column_vector>& right)
877 {
878 return left[0] * right[0] + left[1] * right[1] + left[2] * right[2];
879 }
880
881 template <typename T, typename Type>
882 inline basic_vector<T, 3, Type> midpoint(const basic_vector<T, 3, Type>& left, const basic_vector<T, 3, Type>& right)
883 {
884 return (left + right) / constants::two<T>;
885 }
886
887 template <typename T, uint32_t Size, typename Type>
888 inline basic_vector<T, Size, Type> lerp(const basic_vector<T, Size, Type>& aV1, const basic_vector<T, Size, Type>& aV2, double aAmount)
889 {
890 basic_vector<T, Size, Type> result;
891 for (uint32_t i = 0; i < Size; ++i)
892 {
893 double x1 = aV1[i];
894 double x2 = aV2[i];
895 result[i] = static_cast<T>((x2 - x1) * aAmount + x1);
896 }
897 return result;
898 }
899
900 /* todo: specializations that use SIMD intrinsics. */
901 template <typename T, uint32_t Rows, uint32_t Columns>
902 class basic_matrix
903 {
904 typedef basic_matrix<T, Rows, Columns> self_type;
905 public:
906 typedef self_type abstract_type; // todo: abstract base
907 public:
908 typedef T value_type;
909 typedef basic_vector<T, Columns, row_vector> row_type;
910 typedef basic_vector<T, Rows, column_vector> column_type;
911 typedef std::array<column_type, Columns> array_type;
912 public:
913 template <typename T2>
914 struct rebind { typedef basic_matrix<T2, Rows, Columns> type; };
915 public:
916 basic_matrix() : m{ {} } {}
917 basic_matrix(std::initializer_list<std::initializer_list<value_type>> aColumns) { std::copy(aColumns.begin(), aColumns.end(), m.begin()); }
918 basic_matrix(const self_type& other) : m{ other.m }, isIdentity{ other.isIdentity } {}
919 basic_matrix(self_type&& other) : m{ std::move(other.m) }, isIdentity{ other.isIdentity } {}
920 template <typename T2>
921 basic_matrix(const basic_matrix<T2, Rows, Columns>& other)
922 {
923 for (uint32_t column = 0; column < Columns; ++column)
924 for (uint32_t row = 0; row < Rows; ++row)
925 (*this)[column][row] = static_cast<value_type>(other[column][row]);
926 isIdentity = other.maybe_identity();
927 }
928 self_type& operator=(const self_type& other) { m = other.m; isIdentity = other.isIdentity; return *this; }
929 self_type& operator=(self_type&& other) { m = std::move(other.m); isIdentity = other.isIdentity; return *this; }
930 public:
931 template <typename T2>
936 public:
937 std::pair<uint32_t, uint32_t> size() const { return std::make_pair(Rows, Columns); }
938 const column_type& operator[](uint32_t aColumn) const { return m[aColumn]; }
939 column_type& operator[](uint32_t aColumn) { isIdentity = std::nullopt; return m[aColumn]; }
940 const value_type* data() const { return &m[0].v[0]; }
941 public:
942 bool operator==(const self_type& right) const { return m == right.m; }
943 bool operator!=(const self_type& right) const { return m != right.m; }
944 self_type& operator+=(const self_type& right) { for (uint32_t column = 0; column < Columns; ++column) (*this)[column] += right[column]; return *this; }
945 self_type& operator-=(const self_type& right) { for (uint32_t column = 0; column < Columns; ++column) (*this)[column] -= right[column]; return *this; }
946 self_type& operator*=(const self_type& right)
947 {
948 self_type result;
949 for (uint32_t column = 0; column < Columns; ++column)
950 for (uint32_t row = 0; row < Rows; ++row)
951 for (uint32_t index = 0; index < Columns; ++index)
952 result[column][row] += ((*this)[index][row] * right[column][index]);
953 *this = result;
954 return *this;
955 }
956 self_type operator-() const
957 {
958 self_type result = *this;
959 for (uint32_t column = 0; column < Columns; ++column)
960 for (uint32_t row = 0; row < Rows; ++row)
961 result[column][row] = -result[column][row];
962 return result;
963 }
964 self_type round_to(value_type aEpsilon) const
965 {
966 self_type result;
967 for (uint32_t column = 0; column < Columns; ++column)
968 for (uint32_t row = 0; row < Rows; ++row)
969 {
970 std::modf((*this)[column][row] / aEpsilon + 0.5, &result[column][row]);
971 result[column][row] *= aEpsilon;
972 }
973 return result;
974 }
975 basic_matrix<T, Columns, Rows> transposed() const
976 {
977 basic_matrix<T, Columns, Rows> result;
978 for (uint32_t column = 0; column < Columns; ++column)
979 for (uint32_t row = 0; row < Rows; ++row)
980 result[row][column] = (*this)[column][row];
981 return result;
982 }
983 template <typename SFINAE = self_type>
984 static const std::enable_if_t<Rows == Columns, SFINAE>& identity()
985 {
986 auto make_identity = []()
987 {
988 self_type result;
989 for (uint32_t diag = 0; diag < Rows; ++diag)
990 result[diag][diag] = static_cast<value_type>(1.0);
991 result.isIdentity = true;
992 return result;
993 };
994 static self_type const sIdentity = make_identity();
995 return sIdentity;
996 }
997 bool is_identity() const
998 {
999 if (isIdentity)
1000 return *isIdentity;
1001 else
1002 return *(isIdentity = ((*this) == identity()));
1003 }
1004 const std::optional<bool>& maybe_identity() const
1005 {
1006 return isIdentity;
1007 }
1008 public:
1009 friend void swap(self_type& a, self_type& b)
1010 {
1011 using std::swap;
1012 swap(a.m, b.m);
1013 swap(a.isIdentity, b.isIdentity);
1014 }
1015 private:
1016 array_type m;
1017 mutable std::optional<bool> isIdentity;
1018 };
1019
1020 typedef basic_matrix<double, 1, 1> matrix11;
1021 typedef basic_matrix<double, 2, 2> matrix22;
1022 typedef basic_matrix<double, 2, 1> matrix21;
1023 typedef basic_matrix<double, 1, 2> matrix12;
1024 typedef basic_matrix<double, 3, 3> matrix33;
1025 typedef basic_matrix<double, 3, 1> matrix31;
1026 typedef basic_matrix<double, 3, 2> matrix32;
1027 typedef basic_matrix<double, 1, 3> matrix13;
1028 typedef basic_matrix<double, 2, 3> matrix23;
1029 typedef basic_matrix<double, 4, 4> matrix44;
1030 typedef basic_matrix<double, 4, 1> matrix41;
1031 typedef basic_matrix<double, 4, 2> matrix42;
1032 typedef basic_matrix<double, 4, 3> matrix43;
1033 typedef basic_matrix<double, 1, 4> matrix14;
1034 typedef basic_matrix<double, 2, 4> matrix24;
1035 typedef basic_matrix<double, 3, 4> matrix34;
1036
1037 typedef matrix11 matrix1;
1038 typedef matrix22 matrix2;
1039 typedef matrix33 matrix3;
1040 typedef matrix44 matrix4;
1041
1042 typedef matrix11 mat11;
1043 typedef matrix22 mat22;
1044 typedef matrix21 mat21;
1045 typedef matrix12 mat12;
1046 typedef matrix33 mat33;
1047 typedef matrix31 mat31;
1048 typedef matrix32 mat32;
1049 typedef matrix13 mat13;
1050 typedef matrix23 mat23;
1051 typedef matrix44 mat44;
1052 typedef matrix41 mat41;
1053 typedef matrix42 mat42;
1054 typedef matrix43 mat43;
1055 typedef matrix14 mat14;
1056 typedef matrix24 mat24;
1057 typedef matrix34 mat34;
1058
1059 typedef mat11 mat1;
1060 typedef mat22 mat2;
1061 typedef mat33 mat3;
1062 typedef mat44 mat4;
1063
1064 typedef optional<matrix11> optional_matrix11;
1065 typedef optional<matrix22> optional_matrix22;
1066 typedef optional<matrix21> optional_matrix21;
1067 typedef optional<matrix12> optional_matrix12;
1068 typedef optional<matrix33> optional_matrix33;
1069 typedef optional<matrix31> optional_matrix31;
1070 typedef optional<matrix32> optional_matrix32;
1071 typedef optional<matrix13> optional_matrix13;
1072 typedef optional<matrix23> optional_matrix23;
1073 typedef optional<matrix44> optional_matrix44;
1074 typedef optional<matrix41> optional_matrix41;
1075 typedef optional<matrix42> optional_matrix42;
1076 typedef optional<matrix43> optional_matrix43;
1077 typedef optional<matrix14> optional_matrix14;
1078 typedef optional<matrix24> optional_matrix24;
1079 typedef optional<matrix34> optional_matrix34;
1080
1081 typedef optional<matrix11> optional_matrix1;
1082 typedef optional<matrix22> optional_matrix2;
1083 typedef optional<matrix33> optional_matrix3;
1084 typedef optional<matrix44> optional_matrix4;
1085
1086 typedef optional<mat11> optional_mat11;
1087 typedef optional<mat22> optional_mat22;
1088 typedef optional<mat21> optional_mat21;
1089 typedef optional<mat12> optional_mat12;
1090 typedef optional<mat33> optional_mat33;
1091 typedef optional<mat31> optional_mat31;
1092 typedef optional<mat32> optional_mat32;
1093 typedef optional<mat13> optional_mat13;
1094 typedef optional<mat23> optional_mat23;
1095 typedef optional<mat44> optional_mat44;
1096 typedef optional<mat41> optional_mat41;
1097 typedef optional<mat42> optional_mat42;
1098 typedef optional<mat43> optional_mat43;
1099 typedef optional<mat14> optional_mat14;
1100 typedef optional<mat24> optional_mat24;
1101 typedef optional<mat34> optional_mat34;
1102
1103 typedef optional<mat11> optional_mat1;
1104 typedef optional<mat22> optional_mat2;
1105 typedef optional<mat33> optional_mat3;
1106 typedef optional<mat44> optional_mat4;
1107
1108 typedef basic_matrix<float, 1, 1> matrix11f;
1109 typedef basic_matrix<float, 2, 2> matrix22f;
1110 typedef basic_matrix<float, 2, 1> matrix21f;
1111 typedef basic_matrix<float, 1, 2> matrix12f;
1112 typedef basic_matrix<float, 3, 3> matrix33f;
1113 typedef basic_matrix<float, 3, 1> matrix31f;
1114 typedef basic_matrix<float, 3, 2> matrix32f;
1115 typedef basic_matrix<float, 1, 3> matrix13f;
1116 typedef basic_matrix<float, 2, 3> matrix23f;
1117 typedef basic_matrix<float, 4, 4> matrix44f;
1118 typedef basic_matrix<float, 4, 1> matrix41f;
1119 typedef basic_matrix<float, 4, 2> matrix42f;
1120 typedef basic_matrix<float, 4, 3> matrix43f;
1121 typedef basic_matrix<float, 1, 4> matrix14f;
1122 typedef basic_matrix<float, 2, 4> matrix24f;
1123 typedef basic_matrix<float, 3, 4> matrix34f;
1124
1125 typedef matrix11f mat11f;
1126 typedef matrix22f mat22f;
1127 typedef matrix21f mat21f;
1128 typedef matrix12f mat12f;
1129 typedef matrix33f mat33f;
1130 typedef matrix31f mat31f;
1131 typedef matrix32f mat32f;
1132 typedef matrix13f mat13f;
1133 typedef matrix23f mat23f;
1134 typedef matrix44f mat44f;
1135 typedef matrix41f mat41f;
1136 typedef matrix42f mat42f;
1137 typedef matrix43f mat43f;
1138 typedef matrix14f mat14f;
1139 typedef matrix24f mat24f;
1140 typedef matrix34f mat34f;
1141
1142 typedef matrix11f mat1f;
1143 typedef matrix22f mat2f;
1144 typedef matrix33f mat3f;
1145 typedef matrix44f mat4f;
1146
1147 typedef optional<matrix11f> optional_matrix11f;
1148 typedef optional<matrix22f> optional_matrix22f;
1149 typedef optional<matrix21f> optional_matrix21f;
1150 typedef optional<matrix12f> optional_matrix12f;
1151 typedef optional<matrix33f> optional_matrix33f;
1152 typedef optional<matrix31f> optional_matrix31f;
1153 typedef optional<matrix32f> optional_matrix32f;
1154 typedef optional<matrix13f> optional_matrix13f;
1155 typedef optional<matrix23f> optional_matrix23f;
1156 typedef optional<matrix44f> optional_matrix44f;
1157 typedef optional<matrix41f> optional_matrix41f;
1158 typedef optional<matrix42f> optional_matrix42f;
1159 typedef optional<matrix43f> optional_matrix43f;
1160 typedef optional<matrix14f> optional_matrix14f;
1161 typedef optional<matrix24f> optional_matrix24f;
1162 typedef optional<matrix34f> optional_matrix34f;
1163
1164 typedef optional<matrix11f> optional_matrix1f;
1165 typedef optional<matrix22f> optional_matrix2f;
1166 typedef optional<matrix33f> optional_matrix3f;
1167 typedef optional<matrix44f> optional_matrix4f;
1168
1169 typedef optional<mat11f> optional_mat11f;
1170 typedef optional<mat22f> optional_mat22f;
1171 typedef optional<mat21f> optional_mat21f;
1172 typedef optional<mat12f> optional_mat12f;
1173 typedef optional<mat33f> optional_mat33f;
1174 typedef optional<mat31f> optional_mat31f;
1175 typedef optional<mat32f> optional_mat32f;
1176 typedef optional<mat13f> optional_mat13f;
1177 typedef optional<mat23f> optional_mat23f;
1178 typedef optional<mat44f> optional_mat44f;
1179 typedef optional<mat41f> optional_mat41f;
1180 typedef optional<mat42f> optional_mat42f;
1181 typedef optional<mat43f> optional_mat43f;
1182 typedef optional<mat14f> optional_mat14f;
1183 typedef optional<mat24f> optional_mat24f;
1184 typedef optional<mat34f> optional_mat34f;
1185
1186 typedef optional<mat11f> optional_mat1f;
1187 typedef optional<mat22f> optional_mat2f;
1188 typedef optional<mat33f> optional_mat3f;
1189 typedef optional<mat44f> optional_mat4f;
1190
1191 template <typename T, uint32_t Rows, uint32_t Columns>
1192 inline basic_matrix<T, Rows, Columns> operator+(const basic_matrix<T, Rows, Columns>& left, typename basic_matrix<T, Rows, Columns>::value_type right)
1193 {
1194 basic_matrix<T, Rows, Columns> result = left;
1195 result += right;
1196 return result;
1197 }
1198
1199 template <typename T, uint32_t Rows, uint32_t Columns>
1200 inline basic_matrix<T, Rows, Columns> operator-(const basic_matrix<T, Rows, Columns>& left, typename basic_matrix<T, Rows, Columns>::value_type right)
1201 {
1202 basic_matrix<T, Rows, Columns> result = left;
1203 result -= right;
1204 return result;
1205 }
1206
1207 template <typename T, uint32_t Rows, uint32_t Columns>
1208 inline basic_matrix<T, Rows, Columns> operator*(const basic_matrix<T, Rows, Columns>& left, typename basic_matrix<T, Rows, Columns>::value_type right)
1209 {
1210 basic_matrix<T, Rows, Columns> result = left;
1211 result *= right;
1212 return result;
1213 }
1214
1215 template <typename T, uint32_t Rows, uint32_t Columns>
1216 inline basic_matrix<T, Rows, Columns> operator/(const basic_matrix<T, Rows, Columns>& left, typename basic_matrix<T, Rows, Columns>::value_type right)
1217 {
1218 basic_matrix<T, Rows, Columns> result = left;
1219 result /= right;
1220 return result;
1221 }
1222
1223 template <typename T, uint32_t Rows, uint32_t Columns>
1224 inline basic_matrix<T, Rows, Columns> operator+(scalar left, const basic_matrix<T, Rows, Columns>& right)
1225 {
1226 basic_matrix<T, Rows, Columns> result = right;
1227 result += left;
1228 return result;
1229 }
1230
1231 template <typename T, uint32_t Rows, uint32_t Columns>
1232 inline basic_matrix<T, Rows, Columns> operator-(scalar left, const basic_matrix<T, Rows, Columns>& right)
1233 {
1234 return -right + left;
1235 }
1236
1237 template <typename T, uint32_t Rows, uint32_t Columns>
1238 inline basic_matrix<T, Rows, Columns> operator*(scalar left, const basic_matrix<T, Rows, Columns>& right)
1239 {
1240 basic_matrix<T, Rows, Columns> result = right;
1241 result *= left;
1242 return result;
1243 }
1244
1245 template <typename T, uint32_t Rows, uint32_t Columns>
1246 inline basic_matrix<T, Rows, Columns> operator+(const basic_matrix<T, Rows, Columns>& left, const basic_matrix<T, Rows, Columns>& right)
1247 {
1248 basic_matrix<T, Rows, Columns> result = left;
1249 result += right;
1250 return result;
1251 }
1252
1253 template <typename T, uint32_t Rows, uint32_t Columns>
1254 inline basic_matrix<T, Rows, Columns> operator-(const basic_matrix<T, Rows, Columns>& left, const basic_matrix<T, Rows, Columns>& right)
1255 {
1256 basic_matrix<T, Rows, Columns> result = left;
1257 result -= right;
1258 return result;
1259 }
1260
1261 template <typename T, uint32_t D1, uint32_t D2>
1262 inline basic_matrix<T, D1, D1> operator*(const basic_matrix<T, D1, D2>& left, const basic_matrix<T, D2, D1>& right)
1263 {
1264 if (left.is_identity())
1265 return right;
1266 if (right.is_identity())
1267 return left;
1268 basic_matrix<T, D1, D1> result;
1269 for (uint32_t column = 0u; column < D1; ++column)
1270 for (uint32_t row = 0u; row < D1; ++row)
1271 for (uint32_t index = 0; index < D2; ++index)
1272 result[column][row] += (left[index][row] * right[column][index]);
1273 return result;
1274 }
1275
1276 template <typename T>
1277 inline basic_matrix<T, 4u, 4u> operator*(const basic_matrix<T, 4u, 4u>& left, const basic_matrix<T, 4u, 4u>& right)
1278 {
1279 if (left.is_identity())
1280 return right;
1281 if (right.is_identity())
1282 return left;
1283 basic_matrix<T, 4u, 4u> result;
1284 for (uint32_t column = 0u; column < 4u; ++column)
1285 for (uint32_t row = 0u; row < 4u; ++row)
1286 result[column][row] = simd_fma_4d(left[0u][row], right[column][0u], left[1u][row], right[column][1u], left[2u][row], right[column][2u], left[3u][row], right[column][3u]);
1287 return result;
1288 }
1289
1290 template <typename T, uint32_t D>
1291 inline basic_vector<T, D, column_vector> operator*(const basic_matrix<T, D, D>& left, const basic_vector<T, D, column_vector>& right)
1292 {
1293 if (left.is_identity())
1294 return right;
1295 basic_vector<T, D, column_vector> result;
1296 for (uint32_t row = 0; row < D; ++row)
1297 for (uint32_t index = 0; index < D; ++index)
1298 result[row] += (left[index][row] * right[index]);
1299 return result;
1300 }
1301
1302 template <typename T, uint32_t D, std::size_t VertexCount>
1303 inline std::array<basic_vector<T, D, column_vector>, VertexCount> operator*(const basic_matrix<T, D, D>& left, const std::array<basic_vector<T, D, column_vector>, VertexCount>& right)
1304 {
1305 if (left.is_identity())
1306 return right;
1307 std::array<basic_vector<T, D, column_vector>, VertexCount> result;
1308 for (std::size_t vector = 0; vector < VertexCount; ++vector)
1309 result[vector] = left * right[vector];
1310 return result;
1311 }
1312
1313 template <typename T>
1314 inline basic_vector<T, 4u, column_vector> operator*(const basic_matrix<T, 4u, 4u>& left, const basic_vector<T, 4u, column_vector>& right)
1315 {
1316 if (left.is_identity())
1317 return right;
1318 basic_vector<T, 4u, column_vector> result;
1319 for (uint32_t row = 0u; row < 4u; ++row)
1320 result[row] = simd_fma_4d(left[0][row], right[0], left[1][row], right[1], left[2][row], right[2], left[3][row], right[3]);
1321 return result;
1322 }
1323
1324 template <typename T, std::size_t VertexCount>
1325 inline std::array<basic_vector<T, 4u, column_vector>, VertexCount> operator*(const basic_matrix<T, 4u, 4u>& left, const std::array<basic_vector<T, 4u, column_vector>, VertexCount>& right)
1326 {
1327 if (left.is_identity())
1328 return right;
1329 std::array<basic_vector<T, 4u, column_vector>, VertexCount> result;
1330 for (std::size_t vector = 0; vector < VertexCount; ++vector)
1331 result[vector] = left * right[vector];
1332 return result;
1333 }
1334
1335 template <typename T, uint32_t D>
1336 inline basic_vector<T, D, row_vector> operator*(const basic_vector<T, D, row_vector>& left, const basic_matrix<T, D, D>& right)
1337 {
1338 if (right.is_identity())
1339 return left;
1340 basic_vector<T, D, row_vector> result;
1341 for (uint32_t column = 0; column < D; ++column)
1342 for (uint32_t index = 0; index < D; ++index)
1343 result[column] += (left[index] * right[column][index]);
1344 return result;
1345 }
1346
1347 template <typename T, uint32_t D, std::size_t VertexCount>
1348 inline std::array<basic_vector<T, D, row_vector>, VertexCount> operator*(const std::array<basic_vector<T, D, row_vector>, VertexCount>& left, const basic_matrix<T, D, D>& right)
1349 {
1350 if (right.is_identity())
1351 return left;
1352 std::array<basic_vector<T, D, row_vector>, VertexCount> result;
1353 for (std::size_t vector = 0; vector < VertexCount; ++vector)
1354 result[vector] = left[vector] * right;
1355 return result;
1356 }
1357
1358 template <typename T>
1359 inline basic_vector<T, 4u, row_vector> operator*(const basic_vector<T, 4u, row_vector>& left, const basic_matrix<T, 4u, 4u>& right)
1360 {
1361 if (right.is_identity())
1362 return left;
1363 basic_vector<T, 4u, row_vector> result;
1364 for (uint32_t column = 0u; column < 4u; ++column)
1365 result[column] = simd_fma_4d(left[0], right[column][0], left[1], right[column][1], left[2], right[column][2], left[3], right[column][3]);
1366 return result;
1367 }
1368
1369 template <typename T, std::size_t VertexCount>
1370 inline basic_vector<T, 4u, row_vector> operator*(const std::array<basic_vector<T, 4u, row_vector>, VertexCount>& left, const basic_matrix<T, 4u, 4u>& right)
1371 {
1372 if (right.is_identity())
1373 return left;
1374 std::array<basic_vector<T, 4u, row_vector>, VertexCount> result;
1375 for (std::size_t vector = 0; vector < VertexCount; ++vector)
1376 result[vector] = left[vector] * right;
1377 return result;
1378 }
1379
1380 template <typename T, uint32_t D>
1381 inline basic_matrix<T, D, D> operator*(const basic_vector<T, D, column_vector>& left, const basic_vector<T, D, row_vector>& right)
1382 {
1383 basic_matrix<T, D, D> result;
1384 for (uint32_t column = 0; column < D; ++column)
1385 for (uint32_t row = 0; row < D; ++row)
1386 result[column][row] = (left[row] * right[column]);
1387 return result;
1388 }
1389
1390 template <typename T>
1391 inline basic_matrix<T, 4u, 4u> operator*(const basic_vector<T, 4u, column_vector>& left, const basic_vector<T, 4u, row_vector>& right)
1392 {
1393 basic_matrix<T, 4u, 4u> result;
1394 for (uint32_t column = 0; column < 4u; ++column)
1395 simd_mul_4d(left[0u], right[column], left[1u], right[column], left[2u], right[column], left[3u], right[column], result[column][0u], result[column][1u], result[column][2u], result[column][3u]);
1396 return result;
1397 }
1398
1399 template <typename T, uint32_t D>
1400 inline basic_matrix<T, D, D> without_translation(const basic_matrix<T, D, D>& matrix)
1401 {
1402 auto result = matrix;
1403 for (uint32_t row = 0; row < D - 1; ++row)
1404 result[D - 1][row] = 0.0;
1405 return result;
1406 }
1407
1408 template <typename Elem, typename Traits, typename T, uint32_t Size, typename Type>
1409 inline std::basic_ostream<Elem, Traits>& operator<<(std::basic_ostream<Elem, Traits>& aStream, const basic_vector<T, Size, Type>& aVector)
1410 {
1411 aStream << "[";
1412 for (uint32_t i = 0; i < Size; ++i)
1413 {
1414 if (i != 0)
1415 aStream << ", ";
1416 aStream << aVector[i];
1417 }
1418 aStream << "]";
1419 return aStream;
1420 }
1421
1422 template <typename Elem, typename Traits, typename T, uint32_t Size, typename Type>
1423 inline std::basic_istream<Elem, Traits>& operator>>(std::basic_istream<Elem, Traits>& aStream, basic_vector<T, Size, Type>& aVector)
1424 {
1425 auto previousImbued = aStream.getloc();
1426 if (typeid(std::use_facet<std::ctype<char>>(previousImbued)) != typeid(neolib::comma_and_brackets_as_whitespace))
1427 aStream.imbue(std::locale{ previousImbued, new neolib::comma_and_brackets_as_whitespace{} });
1428 for (uint32_t i = 0; i < Size; ++i)
1429 aStream >> aVector[i];
1430 aStream.imbue(previousImbued);
1431 return aStream;
1432 }
1433
1434 template <typename Elem, typename Traits, typename T, uint32_t Rows, uint32_t Columns>
1435 inline std::basic_ostream<Elem, Traits>& operator<<(std::basic_ostream<Elem, Traits>& aStream, const basic_matrix<T, Rows, Columns>& aMatrix)
1436 {
1437 aStream << "[";
1438 for (uint32_t row = 0; row < Rows; ++row)
1439 {
1440 if (row != 0)
1441 aStream << ", ";
1442 aStream << "[";
1443 for (uint32_t column = 0; column < Columns; ++column)
1444 {
1445 if (column != 0)
1446 aStream << ", ";
1447 aStream << aMatrix[column][row];
1448 }
1449 aStream << "]";
1450 }
1451 aStream << "]";
1452 return aStream;
1453 }
1454
1455 template <typename Elem, typename Traits, typename T, uint32_t Rows, uint32_t Columns>
1456 inline std::basic_ostream<Elem, Traits>& operator<<(std::basic_ostream<Elem, Traits>& aStream, const optional<basic_matrix<T, Rows, Columns>>& aMatrix)
1457 {
1458 if (aMatrix != std::nullopt)
1459 aStream << *aMatrix;
1460 else
1461 aStream << "[null]";
1462 return aStream;
1463 }
1464
1465 template <typename Elem, typename Traits, typename T, uint32_t Rows, uint32_t Columns>
1466 inline std::basic_ostream<Elem, Traits>& operator<<(std::basic_ostream<Elem, Traits>& aStream, const std::optional<basic_matrix<T, Rows, Columns>>& aMatrix)
1467 {
1468 if (aMatrix != std::nullopt)
1469 aStream << *aMatrix;
1470 else
1471 aStream << "[null]";
1472 return aStream;
1473 }
1474
1475 // 3D helpers
1476
1477 template <typename T>
1478 inline basic_vector<T, 3u, column_vector> operator*(const basic_matrix<T, 4u, 4u>& left, const basic_vector<T, 3u, column_vector>& right)
1479 {
1480 if (left.is_identity())
1481 return right;
1482 basic_vector<T, 3u, column_vector> result;
1483 for (uint32_t row = 0u; row < 3u; ++row)
1484 result[row] = static_cast<T>(simd_fma_4d(left[0][row], right[0], left[1][row], right[1], left[2][row], right[2], left[3][row], 1.0));
1485 return result;
1486 }
1487
1488 template <typename T>
1489 inline std::vector<basic_vector<T, 3u, column_vector>> operator*(const basic_matrix<T, 4u, 4u>& left, const std::vector<basic_vector<T, 3u, column_vector>>& right)
1490 {
1491 if (left.is_identity())
1492 return right;
1493 std::vector<basic_vector<T, 3u, column_vector>> result;
1494 result.reserve(right.size());
1495 for (auto const& v : right)
1496 result.push_back(left * v);
1497 return result;
1498 }
1499
1500 inline mat33 rotation_matrix(const vec3& axis, scalar angle, scalar epsilon = 0.00001)
1501 {
1502 if (std::abs(angle) <= epsilon)
1503 return mat33::identity();
1504 else if (std::abs(angle - boost::math::constants::pi<scalar>()) <= epsilon)
1505 return -mat33::identity();
1506 scalar const s = std::sin(angle);
1507 scalar const c = std::cos(angle);
1508 scalar const a = 1.0 - c;
1509 scalar const ax = a * axis.x;
1510 scalar const ay = a * axis.y;
1511 scalar const az = a * axis.z;
1512 return mat33{
1513 { ax * axis.x + c, ax * axis.y + axis.z * s, ax * axis.z - axis.y * s },
1514 { ay * axis.x - axis.z * s, ay * axis.y + c, ay * axis.z + axis.x * s },
1515 { az * axis.x + axis.y * s, az * axis.y - axis.x * s, az * axis.z + c } }.round_to(epsilon);
1516 }
1517
1518 inline mat33 rotation_matrix(const vec3& vectorA, const vec3& vectorB, scalar epsilon = 0.00001)
1519 {
1520 auto const nva = vectorA.normalized();
1521 auto const nvb = vectorB.normalized();
1522 return rotation_matrix(nva.cross(nvb).normalized(), std::acos(nva.dot(nvb)), epsilon);
1523 }
1524
1525 inline mat33 rotation_matrix(const vec3& angles)
1526 {
1527 scalar ax = angles.x;
1528 scalar ay = angles.y;
1529 scalar az = angles.z;
1530 if (ax != 0.0 || ay != 0.0)
1531 {
1532 mat33 rx = { { 1.0, 0.0, 0.0 },{ 0.0, std::cos(ax), std::sin(ax) },{ 0.0, -std::sin(ax), std::cos(ax) } };
1533 mat33 ry = { { std::cos(ay), 0.0, -std::sin(ay) },{ 0.0, 1.0, 0.0 },{ std::sin(ay), 0.0, std::cos(ay) } };
1534 mat33 rz = { { std::cos(az), std::sin(az), 0.0 },{ -std::sin(az), std::cos(az), 0.0 },{ 0.0, 0.0, 1.0 } };
1535 return rz * ry * rx;
1536 }
1537 else
1538 {
1539 return mat33{ { std::cos(az), std::sin(az), 0.0 },{ -std::sin(az), std::cos(az), 0.0 },{ 0.0, 0.0, 1.0 } };
1540 }
1541 }
1542
1543 inline mat44 affine_rotation_matrix(const vec3& angles)
1544 {
1545 scalar ax = angles.x;
1546 scalar ay = angles.y;
1547 scalar az = angles.z;
1548 if (ax != 0.0 || ay != 0.0)
1549 {
1550 mat44 rx = { { 1.0, 0.0, 0.0, 0.0 },{ 0.0, std::cos(ax), std::sin(ax), 0.0 },{ 0.0, -std::sin(ax), std::cos(ax), 0.0 },{0.0, 0.0, 0.0, 1.0} };
1551 mat44 ry = { { std::cos(ay), 0.0, -std::sin(ay), 0.0 },{ 0.0, 1.0, 0.0, 0.0 },{ std::sin(ay), 0.0, std::cos(ay), 0.0 },{0.0, 0.0, 0.0, 1.0} };
1552 mat44 rz = { { std::cos(az), std::sin(az), 0.0, 0.0 },{ -std::sin(az), std::cos(az), 0.0, 0.0 },{ 0.0, 0.0, 1.0, 0.0 },{0.0, 0.0, 0.0, 1.0} };
1553 return rz * ry * rx;
1554 }
1555 else
1556 {
1557 return mat44{ { std::cos(az), std::sin(az), 0.0, 0.0 },{ -std::sin(az), std::cos(az), 0.0, 0.0 },{ 0.0, 0.0, 1.0, 0.0 },{0.0, 0.0, 0.0, 1.0} };
1558 }
1559 }
1560
1561 inline mat44& apply_translation(mat44& aMatrix, const vec3& aTranslation)
1562 {
1563 // todo: SIMD
1564 aMatrix[3][0] += aTranslation.x;
1565 aMatrix[3][1] += aTranslation.y;
1566 aMatrix[3][2] += aTranslation.z;
1567 return aMatrix;
1568 }
1569
1570 inline mat44& apply_scaling(mat44& aMatrix, const vec3& aScaling)
1571 {
1572 // todo: SIMD
1573 aMatrix[0][0] *= aScaling.x;
1574 aMatrix[1][1] *= aScaling.y;
1575 aMatrix[2][2] *= aScaling.z;
1576 return aMatrix;
1577 }
1578
1579 // Function
1580
1581 template <typename T>
1582 inline bool nearly_equal(T lhs, T rhs, scalar epsilon = 0.00001, std::enable_if_t<std::is_floating_point_v<T>, sfinae> = {})
1583 {
1584 return static_cast<double>(std::abs(lhs - rhs)) < epsilon;
1585 }
1586 template <typename T>
1587 inline bool nearly_equal(T lhs, T rhs, scalar epsilon = 0.00001, std::enable_if_t<std::is_integral_v<T>, sfinae> = {})
1588 {
1589 return lhs == rhs;
1590 }
1591 template <typename T, uint32_t Size, typename Type = column_vector>
1592 inline bool nearly_equal(basic_vector<T, Size, Type> const& lhs, basic_vector<T, Size, Type> const& rhs, scalar epsilon = 0.00001)
1593 {
1594 for (uint32_t index = 0; index < Size; ++index)
1595 if (!nearly_equal(lhs[index], rhs[index], epsilon))
1596 return false;
1597 return true;
1598 }
1599 template <typename T>
1600 inline bool nearly_equal(optional<T> const& lhs, optional<T> const& rhs, scalar epsilon = 0.00001)
1601 {
1602 if (!!lhs != !!rhs)
1603 return false;
1604 if (!lhs)
1605 return true;
1606 return nearly_equal(*lhs, *rhs, epsilon);
1607 }
1608 template <typename T>
1609 inline bool nearly_equal(std::optional<T> const& lhs, std::optional<T> const& rhs, scalar epsilon = 0.00001)
1610 {
1611 if (!!lhs != !!rhs)
1612 return false;
1613 if (!lhs)
1614 return true;
1615 return nearly_equal(*lhs, *rhs, epsilon);
1616 }
1617 template <typename T1, typename T2>
1618 inline bool nearly_equal(std::pair<T1, T2> const& lhs, std::pair<T1, T2> const& rhs, scalar epsilon = 0.00001)
1619 {
1620 return nearly_equal(lhs.first, rhs.first, epsilon) && nearly_equal(lhs.second, rhs.second, epsilon);
1621 }
1622 template <typename T>
1623 inline bool nearly_equal(std::vector<T> const& lhs, std::vector<T> const& rhs, scalar epsilon = 0.00001)
1624 {
1625 return std::equal(lhs.begin(), lhs.end(), rhs.begin(), rhs.end(),
1626 [epsilon](auto const& lhs, auto const& rhs) { return nearly_equal(lhs, rhs, epsilon); });
1627 }
1628
1629 template <typename T, std::size_t D>
1630 basic_vector<T, D> quad_extents(std::array<basic_vector<T, D>, 4> const& aQuad)
1631 {
1632 return basic_vector<T, D>{
1633 (aQuad[1].distance(aQuad[0]) + aQuad[3].distance(aQuad[2])) / static_cast<T>(2.0),
1634 (aQuad[0].distance(aQuad[3]) + aQuad[1].distance(aQuad[2])) / static_cast<T>(2.0)
1635 };
1636 }
1637
1638 // AABB
1639
1640 struct aabb
1641 {
1642 typedef aabb abstract_type;
1643
1644 vec3 min;
1645 vec3 max;
1646 aabb() : min{}, max{} {}
1647 aabb(const vec3& aMin, const vec3& aMax) : min{ aMin }, max{ aMax } {}
1648 };
1649
1650 inline vec3 aabb_origin(const aabb& aAabb)
1651 {
1652 return aAabb.min + (aAabb.max - aAabb.min) / 2.0;
1653 }
1654
1655 inline vec3 aabb_extents(const aabb& aAabb)
1656 {
1657 return aAabb.max - aAabb.min;
1658 }
1659
1660 template <typename... Transforms>
1661 inline aabb aabb_transform(const aabb& aAabb, const Transforms&... aTransforms)
1662 {
1663 std::array<vec3, 8> boxVertices =
1664 {
1665 (aTransforms * ... * vec3{ aAabb.min.x, aAabb.min.y, aAabb.min.z }),
1666 (aTransforms * ... * vec3{ aAabb.max.x, aAabb.min.y, aAabb.min.z }),
1667 (aTransforms * ... * vec3{ aAabb.min.x, aAabb.max.y, aAabb.min.z }),
1668 (aTransforms * ... * vec3{ aAabb.max.x, aAabb.max.y, aAabb.min.z }),
1669 (aTransforms * ... * vec3{ aAabb.min.x, aAabb.min.y, aAabb.max.z }),
1670 (aTransforms * ... * vec3{ aAabb.max.x, aAabb.min.y, aAabb.max.z }),
1671 (aTransforms * ... * vec3{ aAabb.min.x, aAabb.max.y, aAabb.max.z }),
1672 (aTransforms * ... * vec3{ aAabb.max.x, aAabb.max.y, aAabb.max.z })
1673 };
1674 aabb result{ boxVertices[0], boxVertices[0] };
1675 for (auto const& v : boxVertices)
1676 {
1677 result.min = result.min.min(v);
1678 result.max = result.max.max(v);
1679 }
1680 return result;
1681 }
1682
1683 inline aabb to_aabb(const vec3& aOrigin, scalar aSize)
1684 {
1685 return aabb{ aOrigin - aSize / 2.0, aOrigin + aSize / 2.0 };
1686 }
1687
1688 inline aabb to_aabb(const vec3& aOrigin, const vec3& aSize)
1689 {
1690 return aabb{ aOrigin - aSize / 2.0, aOrigin + aSize / 2.0 };
1691 }
1692
1693 template <typename VertexIter>
1694 inline aabb to_aabb(VertexIter aBegin, VertexIter aEnd, const mat44& aTransformation = mat44::identity())
1695 {
1696 if (aBegin == aEnd)
1697 return aabb_transform(aabb{}, aTransformation);
1698 aabb result{ aBegin->xyz, aBegin->xyz };
1699 for (auto i = std::next(aBegin); i != aEnd; ++i)
1700 {
1701 result.min = result.min.min(i->xyz);
1702 result.max = result.max.max(i->xyz);
1703 }
1704 return aabb_transform(result, aTransformation);
1705 }
1706
1707 inline aabb to_aabb(const vertices& aVertices, const mat44& aTransformation = mat44::identity())
1708 {
1709 return to_aabb(aVertices.begin(), aVertices.end(), aTransformation);
1710 }
1711
1712 inline bool operator==(const aabb& left, const aabb& right)
1713 {
1714 return left.min == right.min && left.max == right.max;
1715 }
1716
1717 inline bool operator<(const aabb& left, const aabb& right)
1718 {
1719 return std::forward_as_tuple(left.min.z, left.min.y, left.min.x, left.max.z, left.max.y, left.max.x) <
1720 std::forward_as_tuple(right.min.z, right.min.y, right.min.x, right.max.z, right.max.y, right.max.x);
1721 }
1722
1723 inline std::partial_ordering operator<=>(const aabb& left, const aabb& right)
1724 {
1725 return std::forward_as_tuple(left.min.z, left.min.y, left.min.x, left.max.z, left.max.y, left.max.x) <=>
1726 std::forward_as_tuple(right.min.z, right.min.y, right.min.x, right.max.z, right.max.y, right.max.x);
1727 }
1728
1729 typedef optional<aabb> optional_aabb;
1730
1731 inline aabb aabb_union(const aabb& left, const aabb& right)
1732 {
1733 return aabb{ left.min.min(right.min), left.max.max(right.max) };
1734 }
1735
1736 inline scalar aabb_volume(const aabb& a)
1737 {
1738 auto extents = a.max - a.min;
1739 return extents.x * extents.y * (extents.z != 0.0 ? extents.z : 1.0);
1740 }
1741
1742 inline bool aabb_contains(const aabb& outer, const aabb& inner)
1743 {
1744 return inner.min >= outer.min && inner.max <= outer.max;
1745 }
1746
1747 inline bool aabb_contains(const aabb& outer, const vec3& point)
1748 {
1749 return point >= outer.min && point <= outer.max;
1750 }
1751
1752 inline bool aabb_intersects(const aabb& first, const aabb& second)
1753 {
1754 if (first.max.x < second.min.x)
1755 return false;
1756 if (first.min.x > second.max.x)
1757 return false;
1758 if (first.max.y < second.min.y)
1759 return false;
1760 if (first.min.y > second.max.y)
1761 return false;
1762 if (first.max.z < second.min.z)
1763 return false;
1764 if (first.min.z > second.max.z)
1765 return false;
1766 return true;
1767 }
1768
1769 inline bool aabb_intersects(const optional<aabb>& first, const std::optional<aabb>& second)
1770 {
1771 if (first == std::nullopt || second == std::nullopt)
1772 return false;
1773 return aabb_intersects(*first, *second);
1774 }
1775
1776 inline bool aabb_intersects(const optional<aabb>& first, const aabb& second)
1777 {
1778 if (first == std::nullopt)
1779 return false;
1780 return aabb_intersects(*first, second);
1781 }
1782
1783 inline bool aabb_intersects(const aabb& first, const std::optional<aabb>& second)
1784 {
1785 if (second == std::nullopt)
1786 return false;
1787 return aabb_intersects(first, *second);
1788 }
1789
1790 struct aabb_2d
1791 {
1792 typedef aabb_2d abstract_type;
1793
1794 vec2 min;
1795 vec2 max;
1796 aabb_2d() : min{}, max{} {}
1797 aabb_2d(const vec2& aMin, const vec2& aMax) : min{ aMin }, max{ aMax } {}
1798 aabb_2d(const aabb& aAabb) : min{ aAabb.min.xy }, max{ aAabb.max.xy } {}
1799 };
1800
1801 inline vec2 aabb_origin(const aabb_2d& aAabb)
1802 {
1803 return aAabb.min + (aAabb.max - aAabb.min) / 2.0;
1804 }
1805
1806 inline vec2 aabb_extents(const aabb_2d& aAabb)
1807 {
1808 return aAabb.max - aAabb.min;
1809 }
1810
1811 template <typename... Transforms>
1812 inline aabb_2d aabb_transform(const aabb_2d& aAabb, const Transforms&... aTransforms)
1813 {
1814 std::array<vec3, 4> boxVertices =
1815 {
1816 (aTransforms * ... * vec3{ aAabb.min.x, aAabb.min.y, 0.0 }),
1817 (aTransforms * ... * vec3{ aAabb.max.x, aAabb.min.y, 0.0 }),
1818 (aTransforms * ... * vec3{ aAabb.min.x, aAabb.max.y, 0.0 }),
1819 (aTransforms * ... * vec3{ aAabb.max.x, aAabb.max.y, 0.0 })
1820 };
1821 aabb_2d result{ boxVertices[0].xy, boxVertices[0].xy };
1822 for (auto const& v : boxVertices)
1823 {
1824 result.min = result.min.min(v.xy);
1825 result.max = result.max.max(v.xy);
1826 }
1827 return result;
1828 }
1829
1830 inline aabb_2d to_aabb_2d(const vec3& aOrigin, scalar aSize)
1831 {
1832 return aabb_2d{ (aOrigin - aSize / 2.0).xy, (aOrigin + aSize / 2.0).xy };
1833 }
1834
1835 inline aabb_2d to_aabb_2d(const vec3& aOrigin, const vec3& aSize)
1836 {
1837 return aabb_2d{ (aOrigin - aSize / 2.0).xy, (aOrigin + aSize / 2.0).xy };
1838 }
1839
1840 template <typename VertexIter>
1841 inline aabb_2d to_aabb_2d(VertexIter aBegin, VertexIter aEnd, const mat44& aTransformation = mat44::identity())
1842 {
1843 if (aBegin == aEnd)
1844 return aabb_transform(aabb_2d{}, aTransformation);
1845 aabb_2d result{ aBegin->xy, aBegin->xy };
1846 for (auto i = std::next(aBegin); i != aEnd; ++i)
1847 {
1848 result.min = result.min.min(i->xy);
1849 result.max = result.max.max(i->xy);
1850 }
1851 return aabb_transform(result, aTransformation);
1852 }
1853
1854 inline aabb_2d to_aabb_2d(const vertices& aVertices, const mat44& aTransformation = mat44::identity())
1855 {
1856 return to_aabb_2d(aVertices.begin(), aVertices.end(), aTransformation);
1857 }
1858
1859 inline bool operator==(const aabb_2d& left, const aabb_2d& right)
1860 {
1861 return left.min == right.min && left.max == right.max;
1862 }
1863
1864 inline bool operator<(const aabb_2d& left, const aabb_2d& right)
1865 {
1866 return std::forward_as_tuple(left.min.y, left.min.x, left.max.y, left.max.x) <
1867 std::forward_as_tuple(right.min.y, right.min.x, right.max.y, right.max.x);
1868 }
1869
1870 inline std::partial_ordering operator<=>(const aabb_2d& left, const aabb_2d& right)
1871 {
1872 return std::forward_as_tuple(left.min.y, left.min.x, left.max.y, left.max.x) <=>
1873 std::forward_as_tuple(right.min.y, right.min.x, right.max.y, right.max.x);
1874 }
1875
1876 typedef optional<aabb_2d> optional_aabb_2d;
1877
1878 inline aabb_2d aabb_union(const aabb_2d& left, const aabb_2d& right)
1879 {
1880 return aabb_2d{ left.min.min(right.min), left.max.max(right.max) };
1881 }
1882
1883 inline scalar aabb_volume(const aabb_2d& a)
1884 {
1885 auto extents = a.max - a.min;
1886 return extents.x * extents.y;
1887 }
1888
1889 inline bool aabb_contains(const aabb_2d& outer, const aabb_2d& inner)
1890 {
1891 return inner.min >= outer.min && inner.max <= outer.max;
1892 }
1893
1894 inline bool aabb_contains(const aabb_2d& outer, const vec2& point)
1895 {
1896 return point >= outer.min && point <= outer.max;
1897 }
1898
1899 inline bool aabb_intersects(const aabb_2d& first, const aabb_2d& second)
1900 {
1901 if (first.max.x < second.min.x)
1902 return false;
1903 if (first.min.x > second.max.x)
1904 return false;
1905 if (first.max.y < second.min.y)
1906 return false;
1907 if (first.min.y > second.max.y)
1908 return false;
1909 return true;
1910 }
1911
1912 inline bool aabb_intersects(const optional<aabb_2d>& first, const std::optional<aabb_2d>& second)
1913 {
1914 if (first == std::nullopt || second == std::nullopt)
1915 return false;
1916 return aabb_intersects(*first, *second);
1917 }
1918
1919 inline bool aabb_intersects(const optional<aabb_2d>& first, const aabb_2d& second)
1920 {
1921 if (first == std::nullopt)
1922 return false;
1923 return aabb_intersects(*first, second);
1924 }
1925
1926 inline bool aabb_intersects(const aabb_2d& first, const std::optional<aabb_2d>& second)
1927 {
1928 if (second == std::nullopt)
1929 return false;
1930 return aabb_intersects(first, *second);
1931 }
1932
1933 inline vec2 bezier_cubic(vec2 const& p0, vec2 const& p1, vec2 const& p2, vec2 const& p3, scalar t)
1934 {
1935 return std::pow(1.0 - t, 3.0) * p0 + 3.0 * std::pow(1.0 - t, 2.0) * t * p1 + 3 * (1.0 - t) * std::pow(t, 2.0) * p2 + std::pow(t, 3.0) * p3;
1936 }
1937
1938 inline vec2 bezier_cubic_x(vec2 const& p0, vec2 const& p1, vec2 const& p2, vec2 const& p3, scalar x)
1939 {
1940 return bezier_cubic(p0, p1, p2, p3, (x - p0.x) / (p3.x - p0.x));
1941 }
1942
1943 inline vec2 bezier_cubic_y(vec2 const& p0, vec2 const& p1, vec2 const& p2, vec2 const& p3, scalar y)
1944 {
1945 return bezier_cubic(p0, p1, p2, p3, (y - p0.y) / (p3.y - p0.y));
1946 }
1947
1948 template <typename T>
1949 inline basic_vector<T, 2> bezier_cubic(basic_vector<T, 2> const& p0, basic_vector<T, 2> const& p1, basic_vector<T, 2> const& p2, basic_vector<T, 2> const& p3, T t)
1950 {
1951 return bezier_cubic(p0.template as<scalar>(), p1.template as<scalar>(), p2.template as<scalar>(), p3.template as<scalar>(), static_cast<scalar>(t)).template as<T>();
1952 }
1953
1954 template <typename T>
1955 inline basic_vector<T, 2> bezier_cubic_x(basic_vector<T, 2> const& p0, basic_vector<T, 2> const& p1, basic_vector<T, 2> const& p2, basic_vector<T, 2> const& p3, T x)
1956 {
1957 return bezier_cubic_x(p0.template as<scalar>(), p1.template as<scalar>(), p2.template as<scalar>(), p3.template as<scalar>(), static_cast<scalar>(x)).template as<T>();
1958 }
1959
1960 template <typename T>
1961 inline basic_vector<T, 2> bezier_cubic_y(basic_vector<T, 2> const& p0, basic_vector<T, 2> const& p1, basic_vector<T, 2> const& p2, basic_vector<T, 2> const& p3, T y)
1962 {
1963 return bezier_cubic_y(p0.template as<scalar>(), p1.template as<scalar>(), p2.template as<scalar>(), p3.template as<scalar>(), static_cast<scalar>(y)).template as<T>();
1964 }
1965 }
1966
1967 using namespace math;
1968}
neolib::math::basic_matrix
Definition numerical.hpp:903
neolib::math::basic_matrix::abstract_type
self_type abstract_type
Definition numerical.hpp:906
neolib::math::basic_matrix::operator-=
self_type & operator-=(const self_type &right)
Definition numerical.hpp:945
neolib::math::basic_matrix::column_type
basic_vector< T, Rows, column_vector > column_type
Definition numerical.hpp:910
neolib::math::basic_matrix::operator!=
bool operator!=(const self_type &right) const
Definition numerical.hpp:943
neolib::math::basic_matrix::operator-
self_type operator-() const
Definition numerical.hpp:956
neolib::math::basic_matrix::round_to
self_type round_to(value_type aEpsilon) const
Definition numerical.hpp:964
neolib::math::basic_matrix::data
const value_type * data() const
Definition numerical.hpp:940
neolib::math::basic_matrix::array_type
std::array< column_type, Columns > array_type
Definition numerical.hpp:911
neolib::math::basic_matrix::basic_matrix
basic_matrix(const self_type &other)
Definition numerical.hpp:918
neolib::math::basic_matrix::size
std::pair< uint32_t, uint32_t > size() const
Definition numerical.hpp:937
neolib::math::basic_matrix::value_type
T value_type
Definition numerical.hpp:908
neolib::math::basic_matrix::as
basic_matrix< T2, Rows, Columns > as() const
Definition numerical.hpp:932
neolib::math::basic_matrix::row_type
basic_vector< T, Columns, row_vector > row_type
Definition numerical.hpp:909
neolib::math::basic_matrix::operator+=
self_type & operator+=(const self_type &right)
Definition numerical.hpp:944
neolib::math::basic_matrix::operator=
self_type & operator=(const self_type &other)
Definition numerical.hpp:928
neolib::math::basic_matrix::transposed
basic_matrix< T, Columns, Rows > transposed() const
Definition numerical.hpp:975
neolib::math::basic_matrix::identity
static const std::enable_if_t< Rows==Columns, SFINAE > & identity()
Definition numerical.hpp:984
neolib::math::basic_matrix::is_identity
bool is_identity() const
Definition numerical.hpp:997
neolib::math::basic_matrix::basic_matrix
basic_matrix(self_type &&other)
Definition numerical.hpp:919
neolib::math::basic_matrix::swap
friend void swap(self_type &a, self_type &b)
Definition numerical.hpp:1009
neolib::math::basic_matrix::operator==
bool operator==(const self_type &right) const
Definition numerical.hpp:942
neolib::math::basic_matrix::basic_matrix
basic_matrix(const basic_matrix< T2, Rows, Columns > &other)
Definition numerical.hpp:921
neolib::math::basic_matrix::maybe_identity
const std::optional< bool > & maybe_identity() const
Definition numerical.hpp:1004
neolib::math::basic_matrix::operator[]
column_type & operator[](uint32_t aColumn)
Definition numerical.hpp:939
neolib::math::basic_matrix::operator*=
self_type & operator*=(const self_type &right)
Definition numerical.hpp:946
neolib::math::basic_matrix::basic_matrix
basic_matrix(std::initializer_list< std::initializer_list< value_type > > aColumns)
Definition numerical.hpp:917
neolib::math::basic_matrix::basic_matrix
basic_matrix()
Definition numerical.hpp:916
neolib::math::basic_matrix::operator[]
const column_type & operator[](uint32_t aColumn) const
Definition numerical.hpp:938
neolib::math::basic_matrix::operator=
self_type & operator=(self_type &&other)
Definition numerical.hpp:929
neolib::math::basic_vector< T, 1, Type >
Definition numerical.hpp:387
neolib::math::basic_vector< T, 1, Type >::basic_vector
basic_vector(std::initializer_list< value_type > values)
Definition numerical.hpp:412
neolib::math::basic_vector< T, 1, Type >::operator+=
self_type & operator+=(value_type value)
Definition numerical.hpp:442
neolib::math::basic_vector< T, 1, Type >::operator*=
self_type & operator*=(const self_type &right)
Definition numerical.hpp:448
neolib::math::basic_vector< T, 1, Type >::basic_vector
basic_vector(self_type &&other)
Definition numerical.hpp:416
neolib::math::basic_vector< T, 1, Type >::ceil
self_type ceil() const
Definition numerical.hpp:457
neolib::math::basic_vector< T, 1, Type >::normalized
self_type normalized() const
Definition numerical.hpp:453
neolib::math::basic_vector< T, 1, Type >::operator[]
value_type operator[](uint32_t aIndex) const
Definition numerical.hpp:426
neolib::math::basic_vector< T, 1, Type >::floor
self_type floor() const
Definition numerical.hpp:458
neolib::math::basic_vector< T, 1, Type >::operator=
self_type & operator=(self_type &&other)
Definition numerical.hpp:422
neolib::math::basic_vector< T, 1, Type >::operator/=
self_type & operator/=(const self_type &right)
Definition numerical.hpp:449
neolib::math::basic_vector< T, 1, Type >::operator/=
self_type & operator/=(value_type value)
Definition numerical.hpp:445
neolib::math::basic_vector< T, 1, Type >::dot
value_type dot(const self_type &right) const
Definition numerical.hpp:461
neolib::math::basic_vector< T, 1, Type >::basic_vector
basic_vector(const basic_vector< T2, Size, Type > &other)
Definition numerical.hpp:418
neolib::math::basic_vector< T, 1, Type >::basic_vector
basic_vector(const array_type &v)
Definition numerical.hpp:411
neolib::math::basic_vector< T, 1, Type >::size_type
uint32_t size_type
Definition numerical.hpp:396
neolib::math::basic_vector< T, 1, Type >::end
iterator end()
Definition numerical.hpp:431
neolib::math::basic_vector< T, 1, Type >::array_type
std::array< value_type, 1 > array_type
Definition numerical.hpp:397
neolib::math::basic_vector< T, 1, Type >::vector_type
basic_vector< value_type, 1, Type > vector_type
Definition numerical.hpp:395
neolib::math::basic_vector< T, 1, Type >::magnitude
value_type magnitude() const
Definition numerical.hpp:452
neolib::math::basic_vector< T, 1, Type >::as
basic_vector< T2, Size, Type > as() const
Definition numerical.hpp:435
neolib::math::basic_vector< T, 1, Type >::const_iterator
array_type::const_iterator const_iterator
Definition numerical.hpp:398
neolib::math::basic_vector< T, 1, Type >::operator*=
self_type & operator*=(value_type value)
Definition numerical.hpp:444
neolib::math::basic_vector< T, 1, Type >::scale
self_type scale(const self_type &right) const
Definition numerical.hpp:451
neolib::math::basic_vector< T, 1, Type >::operator-
self_type operator-() const
Definition numerical.hpp:450
neolib::math::basic_vector< T, 1, Type >::operator+=
self_type & operator+=(const self_type &right)
Definition numerical.hpp:446
neolib::math::basic_vector< T, 1, Type >::basic_vector
basic_vector(const swizzle< V, A, S, Indexes... > &aSwizzle)
Definition numerical.hpp:414
neolib::math::basic_vector< T, 1, Type >::basic_vector
basic_vector(value_type &&value, Arguments &&... aArguments)
Definition numerical.hpp:410
neolib::math::basic_vector< T, 1, Type >::basic_vector
basic_vector(const self_type &other)
Definition numerical.hpp:415
neolib::math::basic_vector< T, 1, Type >::basic_vector
basic_vector(value_type x)
Definition numerical.hpp:406
neolib::math::basic_vector< T, 1, Type >::basic_vector
basic_vector(const basic_vector< T2, Size2, Type > &other, typename std::enable_if_t< Size2< Size, SFINAE >=0)
Definition numerical.hpp:420
neolib::math::basic_vector< T, 1, Type >::iterator
array_type::iterator iterator
Definition numerical.hpp:399
neolib::math::basic_vector< T, 1, Type >::xx
swizzle< vector_type, array_type, 2, 0, 0 > xx
Definition numerical.hpp:488
neolib::math::basic_vector< T, 1, Type >::hadamard_product
self_type hadamard_product(const self_type &right) const
Definition numerical.hpp:468
neolib::math::basic_vector< T, 1, Type >::begin
const_iterator begin() const
Definition numerical.hpp:428
neolib::math::basic_vector< T, 1, Type >::operator=
self_type & operator=(const self_type &other)
Definition numerical.hpp:421
neolib::math::basic_vector< T, 1, Type >::operator==
bool operator==(const self_type &right) const
Definition numerical.hpp:440
neolib::math::basic_vector< T, 1, Type >::value_type
T value_type
Definition numerical.hpp:394
neolib::math::basic_vector< T, 1, Type >::operator=
self_type & operator=(std::initializer_list< value_type > values)
Definition numerical.hpp:423
neolib::math::basic_vector< T, 1, Type >::swap
friend void swap(self_type &a, self_type &b)
Definition numerical.hpp:475
neolib::math::basic_vector< T, 1, Type >::operator-=
self_type & operator-=(value_type value)
Definition numerical.hpp:443
neolib::math::basic_vector< T, 1, Type >::v
array_type v
Definition numerical.hpp:483
neolib::math::basic_vector< T, 1, Type >::min
self_type min(const self_type &right) const
Definition numerical.hpp:454
neolib::math::basic_vector< T, 1, Type >::size
static uint32_t size()
Definition numerical.hpp:425
neolib::math::basic_vector< T, 1, Type >::round
self_type round() const
Definition numerical.hpp:459
neolib::math::basic_vector< T, 1, Type >::basic_vector
basic_vector(const value_type &value, Arguments &&... aArguments)
Definition numerical.hpp:408
neolib::math::basic_vector< T, 1, Type >::begin
iterator begin()
Definition numerical.hpp:430
neolib::math::basic_vector< T, 1, Type >::basic_vector
basic_vector()
Definition numerical.hpp:405
neolib::math::basic_vector< T, 1, Type >::x
value_type x
Definition numerical.hpp:486
neolib::math::basic_vector< T, 1, Type >::min
value_type min() const
Definition numerical.hpp:456
neolib::math::basic_vector< T, 1, Type >::type
Type type
Definition numerical.hpp:392
neolib::math::basic_vector< T, 1, Type >::operator[]
value_type & operator[](uint32_t aIndex)
Definition numerical.hpp:427
neolib::math::basic_vector< T, 1, Type >::xxx
swizzle< vector_type, array_type, 3, 0, 0, 0 > xxx
Definition numerical.hpp:489
neolib::math::basic_vector< T, 1, Type >::operator-=
self_type & operator-=(const self_type &right)
Definition numerical.hpp:447
neolib::math::basic_vector< T, 1, Type >::end
const_iterator end() const
Definition numerical.hpp:429
neolib::math::basic_vector< T, 1, Type >::abstract_type
self_type abstract_type
Definition numerical.hpp:390
neolib::math::basic_vector< T, 1, Type >::distance
value_type distance(const self_type &right) const
Definition numerical.hpp:460
neolib::math::basic_vector< T, 1, Type >::max
self_type max(const self_type &right) const
Definition numerical.hpp:455
neolib::math::basic_vector< T, 1, Type >::operator!=
bool operator!=(const self_type &right) const
Definition numerical.hpp:441
neolib::math::basic_vector< T, 2, Type >
Definition numerical.hpp:268
neolib::math::basic_vector< T, 2, Type >::end
const_iterator end() const
Definition numerical.hpp:310
neolib::math::basic_vector< T, 2, Type >::xyx
swizzle< vector_type, array_type, 3, 0, 1, 0 > xyx
Definition numerical.hpp:376
neolib::math::basic_vector< T, 2, Type >::operator/=
self_type & operator/=(value_type value)
Definition numerical.hpp:326
neolib::math::basic_vector< T, 2, Type >::yyx
swizzle< vector_type, array_type, 3, 1, 1, 0 > yyx
Definition numerical.hpp:380
neolib::math::basic_vector< T, 2, Type >::operator!=
bool operator!=(const self_type &right) const
Definition numerical.hpp:322
neolib::math::basic_vector< T, 2, Type >::basic_vector
basic_vector(const basic_vector< T2, Size2, Type > &other, typename std::enable_if_t< Size2< Size, SFINAE >=0)
Definition numerical.hpp:301
neolib::math::basic_vector< T, 2, Type >::xy
swizzle< vector_type, array_type, 2, 0, 1 > xy
Definition numerical.hpp:371
neolib::math::basic_vector< T, 2, Type >::basic_vector
basic_vector(const array_type &v)
Definition numerical.hpp:292
neolib::math::basic_vector< T, 2, Type >::dot
value_type dot(const self_type &right) const
Definition numerical.hpp:342
neolib::math::basic_vector< T, 2, Type >::basic_vector
basic_vector(const self_type &other)
Definition numerical.hpp:296
neolib::math::basic_vector< T, 2, Type >::xxy
swizzle< vector_type, array_type, 3, 0, 0, 1 > xxy
Definition numerical.hpp:375
neolib::math::basic_vector< T, 2, Type >::array_type
std::array< value_type, 2 > array_type
Definition numerical.hpp:278
neolib::math::basic_vector< T, 2, Type >::operator*=
self_type & operator*=(const self_type &right)
Definition numerical.hpp:329
neolib::math::basic_vector< T, 2, Type >::operator=
self_type & operator=(std::initializer_list< value_type > values)
Definition numerical.hpp:304
neolib::math::basic_vector< T, 2, Type >::const_iterator
array_type::const_iterator const_iterator
Definition numerical.hpp:279
neolib::math::basic_vector< T, 2, Type >::operator+=
self_type & operator+=(const self_type &right)
Definition numerical.hpp:327
neolib::math::basic_vector< T, 2, Type >::operator[]
value_type operator[](uint32_t aIndex) const
Definition numerical.hpp:307
neolib::math::basic_vector< T, 2, Type >::y
value_type y
Definition numerical.hpp:368
neolib::math::basic_vector< T, 2, Type >::min
value_type min() const
Definition numerical.hpp:337
neolib::math::basic_vector< T, 2, Type >::xx
swizzle< vector_type, array_type, 2, 0, 0 > xx
Definition numerical.hpp:370
neolib::math::basic_vector< T, 2, Type >::end
iterator end()
Definition numerical.hpp:312
neolib::math::basic_vector< T, 2, Type >::operator/=
self_type & operator/=(const self_type &right)
Definition numerical.hpp:330
neolib::math::basic_vector< T, 2, Type >::iterator
array_type::iterator iterator
Definition numerical.hpp:280
neolib::math::basic_vector< T, 2, Type >::size
static uint32_t size()
Definition numerical.hpp:306
neolib::math::basic_vector< T, 2, Type >::abstract_type
self_type abstract_type
Definition numerical.hpp:271
neolib::math::basic_vector< T, 2, Type >::v
array_type v
Definition numerical.hpp:364
neolib::math::basic_vector< T, 2, Type >::vector_type
basic_vector< value_type, 2, Type > vector_type
Definition numerical.hpp:276
neolib::math::basic_vector< T, 2, Type >::basic_vector
basic_vector(self_type &&other)
Definition numerical.hpp:297
neolib::math::basic_vector< T, 2, Type >::yx
swizzle< vector_type, array_type, 2, 1, 0 > yx
Definition numerical.hpp:372
neolib::math::basic_vector< T, 2, Type >::basic_vector
basic_vector()
Definition numerical.hpp:286
neolib::math::basic_vector< T, 2, Type >::basic_vector
basic_vector(value_type &&value, Arguments &&... aArguments)
Definition numerical.hpp:291
neolib::math::basic_vector< T, 2, Type >::operator*=
self_type & operator*=(value_type value)
Definition numerical.hpp:325
neolib::math::basic_vector< T, 2, Type >::scale
self_type scale(const self_type &right) const
Definition numerical.hpp:332
neolib::math::basic_vector< T, 2, Type >::hadamard_product
self_type hadamard_product(const self_type &right) const
Definition numerical.hpp:349
neolib::math::basic_vector< T, 2, Type >::round
self_type round() const
Definition numerical.hpp:340
neolib::math::basic_vector< T, 2, Type >::basic_vector
basic_vector(const swizzle< V, A, S, Indexes... > &aSwizzle)
Definition numerical.hpp:295
neolib::math::basic_vector< T, 2, Type >::basic_vector
basic_vector(std::initializer_list< value_type > values)
Definition numerical.hpp:293
neolib::math::basic_vector< T, 2, Type >::size_type
uint32_t size_type
Definition numerical.hpp:277
neolib::math::basic_vector< T, 2, Type >::as
basic_vector< T2, Size, Type > as() const
Definition numerical.hpp:316
neolib::math::basic_vector< T, 2, Type >::normalized
self_type normalized() const
Definition numerical.hpp:334
neolib::math::basic_vector< T, 2, Type >::operator=
self_type & operator=(const self_type &other)
Definition numerical.hpp:302
neolib::math::basic_vector< T, 2, Type >::basic_vector
basic_vector(const value_type &value, Arguments &&... aArguments)
Definition numerical.hpp:289
neolib::math::basic_vector< T, 2, Type >::distance
value_type distance(const self_type &right) const
Definition numerical.hpp:341
neolib::math::basic_vector< T, 2, Type >::yxy
swizzle< vector_type, array_type, 3, 1, 0, 1 > yxy
Definition numerical.hpp:379
neolib::math::basic_vector< T, 2, Type >::operator=
self_type & operator=(self_type &&other)
Definition numerical.hpp:303
neolib::math::basic_vector< T, 2, Type >::operator+=
self_type & operator+=(value_type value)
Definition numerical.hpp:323
neolib::math::basic_vector< T, 2, Type >::x
value_type x
Definition numerical.hpp:367
neolib::math::basic_vector< T, 2, Type >::max
self_type max(const self_type &right) const
Definition numerical.hpp:336
neolib::math::basic_vector< T, 2, Type >::operator[]
value_type & operator[](uint32_t aIndex)
Definition numerical.hpp:308
neolib::math::basic_vector< T, 2, Type >::xxx
swizzle< vector_type, array_type, 3, 0, 0, 0 > xxx
Definition numerical.hpp:374
neolib::math::basic_vector< T, 2, Type >::swap
friend void swap(self_type &a, self_type &b)
Definition numerical.hpp:356
neolib::math::basic_vector< T, 2, Type >::yxx
swizzle< vector_type, array_type, 3, 1, 0, 0 > yxx
Definition numerical.hpp:378
neolib::math::basic_vector< T, 2, Type >::value_type
T value_type
Definition numerical.hpp:275
neolib::math::basic_vector< T, 2, Type >::ceil
self_type ceil() const
Definition numerical.hpp:338
neolib::math::basic_vector< T, 2, Type >::basic_vector
basic_vector(value_type x, value_type y)
Definition numerical.hpp:287
neolib::math::basic_vector< T, 2, Type >::yyy
swizzle< vector_type, array_type, 3, 1, 1, 1 > yyy
Definition numerical.hpp:381
neolib::math::basic_vector< T, 2, Type >::operator-
self_type operator-() const
Definition numerical.hpp:331
neolib::math::basic_vector< T, 2, Type >::xyy
swizzle< vector_type, array_type, 3, 0, 1, 1 > xyy
Definition numerical.hpp:377
neolib::math::basic_vector< T, 2, Type >::begin
const_iterator begin() const
Definition numerical.hpp:309
neolib::math::basic_vector< T, 2, Type >::yy
swizzle< vector_type, array_type, 2, 1, 1 > yy
Definition numerical.hpp:373
neolib::math::basic_vector< T, 2, Type >::operator-=
self_type & operator-=(const self_type &right)
Definition numerical.hpp:328
neolib::math::basic_vector< T, 2, Type >::basic_vector
basic_vector(const basic_vector< T2, Size, Type > &other)
Definition numerical.hpp:299
neolib::math::basic_vector< T, 2, Type >::floor
self_type floor() const
Definition numerical.hpp:339
neolib::math::basic_vector< T, 2, Type >::begin
iterator begin()
Definition numerical.hpp:311
neolib::math::basic_vector< T, 2, Type >::type
Type type
Definition numerical.hpp:273
neolib::math::basic_vector< T, 2, Type >::min
self_type min(const self_type &right) const
Definition numerical.hpp:335
neolib::math::basic_vector< T, 2, Type >::operator-=
self_type & operator-=(value_type value)
Definition numerical.hpp:324
neolib::math::basic_vector< T, 2, Type >::magnitude
value_type magnitude() const
Definition numerical.hpp:333
neolib::math::basic_vector< T, 2, Type >::operator==
bool operator==(const self_type &right) const
Definition numerical.hpp:321
neolib::math::basic_vector
Definition numerical.hpp:112
neolib::math::basic_vector::begin
const_iterator begin() const
Definition numerical.hpp:160
neolib::math::basic_vector::zy
swizzle< vector_type, array_type, 2, 2, 1 > zy
Definition numerical.hpp:237
neolib::math::basic_vector::hadamard_product
self_type hadamard_product(const self_type &right) const
Definition numerical.hpp:208
neolib::math::basic_vector::basic_vector
basic_vector(const swizzle< V, A, S, Indexes... > &aSwizzle)
Definition numerical.hpp:146
neolib::math::basic_vector::max
self_type max(const self_type &right) const
Definition numerical.hpp:187
neolib::math::basic_vector::operator-
self_type operator-() const
Definition numerical.hpp:182
neolib::math::basic_vector::yx
swizzle< vector_type, array_type, 2, 1, 0 > yx
Definition numerical.hpp:233
neolib::math::basic_vector::basic_vector
basic_vector(const basic_vector< T2, Size2, Type > &other, typename std::enable_if_t< Size2< Size, SFINAE >=0)
Definition numerical.hpp:152
neolib::math::basic_vector::xz
swizzle< vector_type, array_type, 2, 0, 2 > xz
Definition numerical.hpp:232
neolib::math::basic_vector::operator=
self_type & operator=(const self_type &other)
Definition numerical.hpp:153
neolib::math::basic_vector::xx
swizzle< vector_type, array_type, 2, 0, 0 > xx
Definition numerical.hpp:230
neolib::math::basic_vector::size
static uint32_t size()
Definition numerical.hpp:157
neolib::math::basic_vector::yyz
swizzle< vector_type, array_type, 3, 1, 1, 2 > yyz
Definition numerical.hpp:250
neolib::math::basic_vector::value_type
T value_type
Definition numerical.hpp:119
neolib::math::basic_vector::cross
std::enable_if_t< Size==3, SFINAE > cross(const self_type &right) const
Definition numerical.hpp:201
neolib::math::basic_vector::yxy
swizzle< vector_type, array_type, 3, 1, 0, 1 > yxy
Definition numerical.hpp:246
neolib::math::basic_vector::zxx
swizzle< vector_type, array_type, 3, 2, 0, 0 > zxx
Definition numerical.hpp:254
neolib::math::basic_vector::xxx
swizzle< vector_type, array_type, 3, 0, 0, 0 > xxx
Definition numerical.hpp:239
neolib::math::basic_vector::end
const_iterator end() const
Definition numerical.hpp:161
neolib::math::basic_vector::scale
self_type scale(const self_type &right) const
Definition numerical.hpp:183
neolib::math::basic_vector::basic_vector
basic_vector(const value_type &value, Arguments &&... aArguments)
Definition numerical.hpp:140
neolib::math::basic_vector::zxy
swizzle< vector_type, array_type, 3, 2, 0, 1 > zxy
Definition numerical.hpp:255
neolib::math::basic_vector::operator[]
value_type & operator[](uint32_t aIndex)
Definition numerical.hpp:159
neolib::math::basic_vector::operator-=
self_type & operator-=(const self_type &right)
Definition numerical.hpp:179
neolib::math::basic_vector::xyy
swizzle< vector_type, array_type, 3, 0, 1, 1 > xyy
Definition numerical.hpp:243
neolib::math::basic_vector::operator*=
self_type & operator*=(const self_type &right)
Definition numerical.hpp:180
neolib::math::basic_vector::zx
swizzle< vector_type, array_type, 2, 2, 0 > zx
Definition numerical.hpp:236
neolib::math::basic_vector::yzz
swizzle< vector_type, array_type, 3, 1, 2, 2 > yzz
Definition numerical.hpp:253
neolib::math::basic_vector::yyx
swizzle< vector_type, array_type, 3, 1, 1, 0 > yyx
Definition numerical.hpp:248
neolib::math::basic_vector::operator+=
self_type & operator+=(const self_type &right)
Definition numerical.hpp:178
neolib::math::basic_vector::xxy
swizzle< vector_type, array_type, 3, 0, 0, 1 > xxy
Definition numerical.hpp:240
neolib::math::basic_vector::normalized
self_type normalized() const
Definition numerical.hpp:185
neolib::math::basic_vector::zyy
swizzle< vector_type, array_type, 3, 2, 1, 1 > zyy
Definition numerical.hpp:258
neolib::math::basic_vector::basic_vector
basic_vector(const array_type &v)
Definition numerical.hpp:143
neolib::math::basic_vector::ceil
self_type ceil() const
Definition numerical.hpp:189
neolib::math::basic_vector::basic_vector
basic_vector(value_type x, value_type y, value_type z, typename std::enable_if_t< Size==3, SFINAE >=0)
Definition numerical.hpp:136
neolib::math::basic_vector::const_iterator
array_type::const_iterator const_iterator
Definition numerical.hpp:123
neolib::math::basic_vector::basic_vector
basic_vector(std::initializer_list< value_type > values)
Definition numerical.hpp:144
neolib::math::basic_vector::basic_vector
basic_vector(value_type x, typename std::enable_if_t< Size==1, SFINAE >=0)
Definition numerical.hpp:132
neolib::math::basic_vector::begin
iterator begin()
Definition numerical.hpp:162
neolib::math::basic_vector::array_type
std::array< value_type, _Size > array_type
Definition numerical.hpp:122
neolib::math::basic_vector::x
value_type x
Definition numerical.hpp:226
neolib::math::basic_vector::basic_vector
basic_vector()
Definition numerical.hpp:130
neolib::math::basic_vector::operator*=
self_type & operator*=(value_type value)
Definition numerical.hpp:176
neolib::math::basic_vector::Size
static constexpr uint32_t Size
Definition numerical.hpp:128
neolib::math::basic_vector::zyx
swizzle< vector_type, array_type, 3, 2, 1, 0 > zyx
Definition numerical.hpp:257
neolib::math::basic_vector::operator==
bool operator==(const self_type &right) const
Definition numerical.hpp:172
neolib::math::basic_vector::yxx
swizzle< vector_type, array_type, 3, 1, 0, 0 > yxx
Definition numerical.hpp:245
neolib::math::basic_vector::type
Type type
Definition numerical.hpp:117
neolib::math::basic_vector::magnitude
value_type magnitude() const
Definition numerical.hpp:184
neolib::math::basic_vector::vector_type
basic_vector< value_type, _Size, Type > vector_type
Definition numerical.hpp:120
neolib::math::basic_vector::operator[]
value_type operator[](uint32_t aIndex) const
Definition numerical.hpp:158
neolib::math::basic_vector::v
array_type v
Definition numerical.hpp:223
neolib::math::basic_vector::xy
swizzle< vector_type, array_type, 2, 0, 1 > xy
Definition numerical.hpp:231
neolib::math::basic_vector::distance
value_type distance(const self_type &right) const
Definition numerical.hpp:192
neolib::math::basic_vector::yy
swizzle< vector_type, array_type, 2, 1, 1 > yy
Definition numerical.hpp:234
neolib::math::basic_vector::yz
swizzle< vector_type, array_type, 2, 1, 2 > yz
Definition numerical.hpp:235
neolib::math::basic_vector::min
self_type min(const self_type &right) const
Definition numerical.hpp:186
neolib::math::basic_vector::operator/=
self_type & operator/=(const self_type &right)
Definition numerical.hpp:181
neolib::math::basic_vector::iterator
array_type::iterator iterator
Definition numerical.hpp:124
neolib::math::basic_vector::end
iterator end()
Definition numerical.hpp:163
neolib::math::basic_vector::xyx
swizzle< vector_type, array_type, 3, 0, 1, 0 > xyx
Definition numerical.hpp:242
neolib::math::basic_vector::basic_vector
basic_vector(const self_type &other)
Definition numerical.hpp:147
neolib::math::basic_vector::dot
value_type dot(const self_type &right) const
Definition numerical.hpp:193
neolib::math::basic_vector::yzy
swizzle< vector_type, array_type, 3, 1, 2, 1 > yzy
Definition numerical.hpp:252
neolib::math::basic_vector::zzx
swizzle< vector_type, array_type, 3, 2, 2, 0 > zzx
Definition numerical.hpp:260
neolib::math::basic_vector::yyy
swizzle< vector_type, array_type, 3, 1, 1, 1 > yyy
Definition numerical.hpp:249
neolib::math::basic_vector::operator=
self_type & operator=(self_type &&other)
Definition numerical.hpp:154
neolib::math::basic_vector::abstract_type
self_type abstract_type
Definition numerical.hpp:115
neolib::math::basic_vector::swap
friend void swap(self_type &a, self_type &b)
Definition numerical.hpp:215
neolib::math::basic_vector::yzx
swizzle< vector_type, array_type, 3, 1, 2, 0 > yzx
Definition numerical.hpp:251
neolib::math::basic_vector::y
value_type y
Definition numerical.hpp:227
neolib::math::basic_vector::floor
self_type floor() const
Definition numerical.hpp:190
neolib::math::basic_vector::operator+=
self_type & operator+=(value_type value)
Definition numerical.hpp:174
neolib::math::basic_vector::zzy
swizzle< vector_type, array_type, 3, 2, 2, 1 > zzy
Definition numerical.hpp:261
neolib::math::basic_vector::as
basic_vector< T2, Size, Type > as() const
Definition numerical.hpp:167
neolib::math::basic_vector::xyz
swizzle< vector_type, array_type, 3, 0, 1, 2 > xyz
Definition numerical.hpp:244
neolib::math::basic_vector::operator/=
self_type & operator/=(value_type value)
Definition numerical.hpp:177
neolib::math::basic_vector::basic_vector
basic_vector(value_type x, value_type y, value_type z, value_type w, typename std::enable_if_t< Size==4, SFINAE >=0)
Definition numerical.hpp:138
neolib::math::basic_vector::zxz
swizzle< vector_type, array_type, 3, 2, 0, 2 > zxz
Definition numerical.hpp:256
neolib::math::basic_vector::zzz
swizzle< vector_type, array_type, 3, 2, 2, 2 > zzz
Definition numerical.hpp:262
neolib::math::basic_vector::round
self_type round() const
Definition numerical.hpp:191
neolib::math::basic_vector::xxz
swizzle< vector_type, array_type, 3, 0, 0, 2 > xxz
Definition numerical.hpp:241
neolib::math::basic_vector::basic_vector
basic_vector(value_type x, value_type y, typename std::enable_if_t< Size==2, SFINAE >=0)
Definition numerical.hpp:134
neolib::math::basic_vector::yxz
swizzle< vector_type, array_type, 3, 1, 0, 2 > yxz
Definition numerical.hpp:247
neolib::math::basic_vector::operator-=
self_type & operator-=(value_type value)
Definition numerical.hpp:175
neolib::math::basic_vector::operator!=
bool operator!=(const self_type &right) const
Definition numerical.hpp:173
neolib::math::basic_vector::basic_vector
basic_vector(value_type &&value, Arguments &&... aArguments)
Definition numerical.hpp:142
neolib::math::basic_vector::min
value_type min() const
Definition numerical.hpp:188
neolib::math::basic_vector::operator=
self_type & operator=(std::initializer_list< value_type > values)
Definition numerical.hpp:155
neolib::math::basic_vector::zyz
swizzle< vector_type, array_type, 3, 2, 1, 2 > zyz
Definition numerical.hpp:259
neolib::math::basic_vector::z
value_type z
Definition numerical.hpp:228
neolib::math::basic_vector::basic_vector
basic_vector(const basic_vector< T2, Size, Type > &other)
Definition numerical.hpp:150
neolib::math::basic_vector::zz
swizzle< vector_type, array_type, 2, 2, 2 > zz
Definition numerical.hpp:238
neolib::math::basic_vector::basic_vector
basic_vector(self_type &&other)
Definition numerical.hpp:148
neolib::math::basic_vector::size_type
uint32_t size_type
Definition numerical.hpp:121
neogfx::operator<<
std::basic_ostream< Elem, Traits > & operator<<(std::basic_ostream< Elem, Traits > &aStream, const basic_point< T > &aPoint)
Definition geometrical.hpp:1330
neolib::math::avec3
std::array< double, 3 > avec3
Definition numerical.hpp:642
neolib::math::optional_row_vec4
optional< row_vec4 > optional_row_vec4
Definition numerical.hpp:549
neolib::math::mat41
matrix41 mat41
Definition numerical.hpp:1052
neolib::math::matrix43
basic_matrix< double, 4, 3 > matrix43
Definition numerical.hpp:1032
neolib::math::optional_vector3
optional< vector3 > optional_vector3
Definition numerical.hpp:533
neolib::math::optional_matrix32f
optional< matrix32f > optional_matrix32f
Definition numerical.hpp:1153
neolib::math::matrix11f
basic_matrix< float, 1, 1 > matrix11f
Definition numerical.hpp:1108
neolib::math::matrix11
basic_matrix< double, 1, 1 > matrix11
Definition numerical.hpp:1020
neolib::math::matrix24
basic_matrix< double, 2, 4 > matrix24
Definition numerical.hpp:1034
neolib::math::matrix1
matrix11 matrix1
Definition numerical.hpp:1037
neolib::math::vector1i32
basic_vector< i32, 1 > vector1i32
Definition numerical.hpp:576
neolib::math::to_deg
angle to_deg(angle aRadians)
Definition numerical.hpp:93
neolib::math::optional_mat11f
optional< mat11f > optional_mat11f
Definition numerical.hpp:1169
neolib::math::optional_matrix44f
optional< matrix44f > optional_matrix44f
Definition numerical.hpp:1156
neolib::math::optional_mat1f
optional< mat11f > optional_mat1f
Definition numerical.hpp:1186
neolib::math::matrix2
matrix22 matrix2
Definition numerical.hpp:1038
neolib::math::to_aabb
aabb to_aabb(const vec3 &aOrigin, scalar aSize)
Definition numerical.hpp:1683
neolib::math::vertices
vec3_list vertices
Definition numerical.hpp:558
neolib::math::mat24f
matrix24f mat24f
Definition numerical.hpp:1139
neolib::math::matrix34
basic_matrix< double, 3, 4 > matrix34
Definition numerical.hpp:1035
neolib::math::optional_mat41f
optional< mat41f > optional_mat41f
Definition numerical.hpp:1179
neolib::math::trianglef_2d
std::array< vec2f, 3 > trianglef_2d
Definition numerical.hpp:654
neolib::math::mat24
matrix24 mat24
Definition numerical.hpp:1056
neolib::math::optional_vector1
optional< vector1 > optional_vector1
Definition numerical.hpp:531
neolib::math::matrix33
basic_matrix< double, 3, 3 > matrix33
Definition numerical.hpp:1024
neolib::math::optional_matrix22f
optional< matrix22f > optional_matrix22f
Definition numerical.hpp:1148
neolib::math::avec3u8
std::array< uint8_t, 3 > avec3u8
Definition numerical.hpp:622
neolib::math::mat31f
matrix31f mat31f
Definition numerical.hpp:1130
neolib::math::trianglef
std::array< vec3f, 3 > trianglef
Definition numerical.hpp:651
neolib::math::optional_mat13
optional< mat13 > optional_mat13
Definition numerical.hpp:1093
neolib::math::optional_mat11
optional< mat11 > optional_mat11
Definition numerical.hpp:1086
neolib::math::midpoint
basic_vector< T, 3, Type > midpoint(const basic_vector< T, 3, Type > &left, const basic_vector< T, 3, Type > &right)
Definition numerical.hpp:882
neolib::math::bezier_cubic_y
vec2 bezier_cubic_y(vec2 const &p0, vec2 const &p1, vec2 const &p2, vec2 const &p3, scalar y)
Definition numerical.hpp:1943
neolib::math::vec1i32
vector1i32 vec1i32
Definition numerical.hpp:581
neolib::math::optional_matrix11
optional< matrix11 > optional_matrix11
Definition numerical.hpp:1064
neolib::math::optional_vector2
optional< vector2 > optional_vector2
Definition numerical.hpp:532
neolib::math::row_vec1
basic_vector< double, 1, row_vector > row_vec1
Definition numerical.hpp:526
neolib::math::vertices_2d
vec2_list vertices_2d
Definition numerical.hpp:557
neolib::math::aabb_volume
scalar aabb_volume(const aabb &a)
Definition numerical.hpp:1736
neolib::math::avec2i8
std::array< int8_t, 2 > avec2i8
Definition numerical.hpp:606
neolib::math::mat12
matrix12 mat12
Definition numerical.hpp:1045
neolib::math::quad_2d
std::array< vec2, 4 > quad_2d
Definition numerical.hpp:649
neolib::math::mat33
matrix33 mat33
Definition numerical.hpp:1046
neolib::math::matrix23f
basic_matrix< float, 2, 3 > matrix23f
Definition numerical.hpp:1116
neolib::math::avec2
std::array< double, 2 > avec2
Definition numerical.hpp:641
neolib::math::to_rad
angle to_rad(angle aDegrees)
Definition numerical.hpp:88
neolib::math::optional_mat3f
optional< mat33f > optional_mat3f
Definition numerical.hpp:1188
neolib::math::optional_mat43
optional< mat43 > optional_mat43
Definition numerical.hpp:1098
neolib::math::optional_mat33f
optional< mat33f > optional_mat33f
Definition numerical.hpp:1173
neolib::math::optional_matrix31f
optional< matrix31f > optional_matrix31f
Definition numerical.hpp:1152
neolib::math::optional_vec2_list
optional< vec2_list > optional_vec2_list
Definition numerical.hpp:554
neolib::math::optional_vector4
optional< vector4 > optional_vector4
Definition numerical.hpp:534
neolib::math::optional_mat2f
optional< mat22f > optional_mat2f
Definition numerical.hpp:1187
neolib::math::avec3i16
std::array< int16_t, 3 > avec3i16
Definition numerical.hpp:612
neolib::math::matrix23
basic_matrix< double, 2, 3 > matrix23
Definition numerical.hpp:1028
neolib::math::optional_mat33
optional< mat33 > optional_mat33
Definition numerical.hpp:1090
neolib::math::optional_col_vec2
optional< col_vec2 > optional_col_vec2
Definition numerical.hpp:542
neolib::math::optional_vertices_t
optional_vec3_list optional_vertices_t
Definition numerical.hpp:561
neolib::math::vector1u32
basic_vector< u32, 1 > vector1u32
Definition numerical.hpp:589
neolib::math::matrix32
basic_matrix< double, 3, 2 > matrix32
Definition numerical.hpp:1026
neolib::math::matrix3
matrix33 matrix3
Definition numerical.hpp:1039
neolib::math::operator%
basic_vector< T, D, Type > operator%(const basic_vector< T, D, Type > &left, const T &right)
Definition numerical.hpp:798
neolib::math::avec1i32
std::array< int32_t, 1 > avec1i32
Definition numerical.hpp:615
neolib::math::optional_mat14f
optional< mat14f > optional_mat14f
Definition numerical.hpp:1182
neolib::math::avec4u8
std::array< uint8_t, 4 > avec4u8
Definition numerical.hpp:623
neolib::math::mat44f
matrix44f mat44f
Definition numerical.hpp:1134
neolib::math::rotation_matrix
mat33 rotation_matrix(const vec3 &axis, scalar angle, scalar epsilon=0.00001)
Definition numerical.hpp:1500
neolib::math::avec1f
std::array< float, 1 > avec1f
Definition numerical.hpp:635
neolib::math::optional_matrix42
optional< matrix42 > optional_matrix42
Definition numerical.hpp:1075
neolib::math::avec1i16
std::array< int16_t, 1 > avec1i16
Definition numerical.hpp:610
neolib::math::optional_mat12f
optional< mat12f > optional_mat12f
Definition numerical.hpp:1172
neolib::math::quad
std::array< vec3, 4 > quad
Definition numerical.hpp:646
neolib::math::optional_matrix13
optional< matrix13 > optional_matrix13
Definition numerical.hpp:1071
neolib::math::aabb_extents
vec3 aabb_extents(const aabb &aAabb)
Definition numerical.hpp:1655
neolib::math::avec1u16
std::array< uint16_t, 1 > avec1u16
Definition numerical.hpp:625
neolib::math::vector4u32
basic_vector< u32, 4 > vector4u32
Definition numerical.hpp:592
neolib::math::vector4i32
basic_vector< i32, 4 > vector4i32
Definition numerical.hpp:579
neolib::math::mat41f
matrix41f mat41f
Definition numerical.hpp:1135
neolib::math::optional_matrix21
optional< matrix21 > optional_matrix21
Definition numerical.hpp:1066
neolib::math::optional_matrix31
optional< matrix31 > optional_matrix31
Definition numerical.hpp:1069
neolib::math::without_translation
basic_matrix< T, D, D > without_translation(const basic_matrix< T, D, D > &matrix)
Definition numerical.hpp:1400
neolib::math::matrix13f
basic_matrix< float, 1, 3 > matrix13f
Definition numerical.hpp:1115
neolib::math::mat34f
matrix34f mat34f
Definition numerical.hpp:1140
neolib::math::optional_mat32
optional< mat32 > optional_mat32
Definition numerical.hpp:1092
neolib::math::optional_vec1
optional< vec1 > optional_vec1
Definition numerical.hpp:536
neolib::math::optional_mat42f
optional< mat42f > optional_mat42f
Definition numerical.hpp:1180
neolib::math::optional_col_vec3
optional< col_vec3 > optional_col_vec3
Definition numerical.hpp:543
neolib::math::aabb_contains
bool aabb_contains(const aabb &outer, const aabb &inner)
Definition numerical.hpp:1742
neolib::math::avec2u16
std::array< uint16_t, 2 > avec2u16
Definition numerical.hpp:626
neolib::math::vec4u32
vector4u32 vec4u32
Definition numerical.hpp:597
neolib::math::matrix22
basic_matrix< double, 2, 2 > matrix22
Definition numerical.hpp:1021
neolib::math::mat32f
matrix32f mat32f
Definition numerical.hpp:1131
neolib::math::matrix31
basic_matrix< double, 3, 1 > matrix31
Definition numerical.hpp:1025
neolib::math::mat31
matrix31 mat31
Definition numerical.hpp:1047
neolib::math::optional_matrix41
optional< matrix41 > optional_matrix41
Definition numerical.hpp:1074
neolib::math::matrix14
basic_matrix< double, 1, 4 > matrix14
Definition numerical.hpp:1033
neolib::math::row_vec4
basic_vector< double, 4, row_vector > row_vec4
Definition numerical.hpp:529
neolib::math::avec4
std::array< double, 4 > avec4
Definition numerical.hpp:643
neolib::math::avec2i16
std::array< int16_t, 2 > avec2i16
Definition numerical.hpp:611
neolib::math::avec3f
std::array< float, 3 > avec3f
Definition numerical.hpp:637
neolib::math::operator-=
std::array< basic_vector< T, D, Type >, VertexCount > & operator-=(std::array< basic_vector< T, D, Type >, VertexCount > &left, const basic_vector< T, D, Type > &right)
Definition numerical.hpp:718
neolib::math::mat14f
matrix14f mat14f
Definition numerical.hpp:1138
neolib::math::optional_mat3
optional< mat33 > optional_mat3
Definition numerical.hpp:1105
neolib::math::mat43f
matrix43f mat43f
Definition numerical.hpp:1137
neolib::math::vec4f
vector4f vec4f
Definition numerical.hpp:571
neolib::math::aabb_union
aabb aabb_union(const aabb &left, const aabb &right)
Definition numerical.hpp:1731
neolib::math::mat43
matrix43 mat43
Definition numerical.hpp:1054
neolib::math::mat22f
matrix22f mat22f
Definition numerical.hpp:1126
neolib::math::optional_matrix43f
optional< matrix43f > optional_matrix43f
Definition numerical.hpp:1159
neolib::math::vec4i32
vector4i32 vec4i32
Definition numerical.hpp:584
neolib::math::avec2u8
std::array< uint8_t, 2 > avec2u8
Definition numerical.hpp:621
neolib::math::vector2i32
basic_vector< i32, 2 > vector2i32
Definition numerical.hpp:577
neolib::math::optional_matrix34
optional< matrix34 > optional_matrix34
Definition numerical.hpp:1079
neolib::math::mat32
matrix32 mat32
Definition numerical.hpp:1048
neolib::math::avec1u8
std::array< uint8_t, 1 > avec1u8
Definition numerical.hpp:620
neolib::math::optional_vertices_2d_t
optional_vec2_list optional_vertices_2d_t
Definition numerical.hpp:560
neolib::math::vec2_list
std::vector< vec2 > vec2_list
Definition numerical.hpp:551
neolib::math::avec3u16
std::array< uint16_t, 3 > avec3u16
Definition numerical.hpp:627
neolib::math::optional_mat21
optional< mat21 > optional_mat21
Definition numerical.hpp:1088
neolib::math::mat34
matrix34 mat34
Definition numerical.hpp:1057
neolib::math::optional_vec3_list
optional< vec3_list > optional_vec3_list
Definition numerical.hpp:555
neolib::math::mat13f
matrix13f mat13f
Definition numerical.hpp:1132
neolib::math::optional_matrix24f
optional< matrix24f > optional_matrix24f
Definition numerical.hpp:1161
neolib::math::row_vec2
basic_vector< double, 2, row_vector > row_vec2
Definition numerical.hpp:527
neolib::math::affine_rotation_matrix
mat44 affine_rotation_matrix(const vec3 &angles)
Definition numerical.hpp:1543
neolib::math::mat21f
matrix21f mat21f
Definition numerical.hpp:1127
neolib::math::optional_mat32f
optional< mat32f > optional_mat32f
Definition numerical.hpp:1175
neolib::math::optional_mat22f
optional< mat22f > optional_mat22f
Definition numerical.hpp:1170
neolib::math::quadf
std::array< vec3f, 4 > quadf
Definition numerical.hpp:652
neolib::math::lerp
T lerp(T aX1, T aX2, double aAmount)
Definition numerical.hpp:81
neolib::math::avec1u32
std::array< uint32_t, 1 > avec1u32
Definition numerical.hpp:630
neolib::math::vector1f
basic_vector< float, 1 > vector1f
Definition numerical.hpp:563
neolib::math::aabb_intersects
bool aabb_intersects(const aabb &first, const aabb &second)
Definition numerical.hpp:1752
neolib::math::matrix34f
basic_matrix< float, 3, 4 > matrix34f
Definition numerical.hpp:1123
neolib::math::mat14
matrix14 mat14
Definition numerical.hpp:1055
neolib::math::apply_translation
mat44 & apply_translation(mat44 &aMatrix, const vec3 &aTranslation)
Definition numerical.hpp:1561
neolib::math::optional_mat12
optional< mat12 > optional_mat12
Definition numerical.hpp:1089
neolib::math::optional_matrix33f
optional< matrix33f > optional_matrix33f
Definition numerical.hpp:1151
neolib::math::optional_matrix14
optional< matrix14 > optional_matrix14
Definition numerical.hpp:1077
neolib::math::optional_col_vec1
optional< col_vec1 > optional_col_vec1
Definition numerical.hpp:541
neolib::math::bezier_cubic_x
vec2 bezier_cubic_x(vec2 const &p0, vec2 const &p1, vec2 const &p2, vec2 const &p3, scalar x)
Definition numerical.hpp:1938
neolib::math::optional_matrix13f
optional< matrix13f > optional_matrix13f
Definition numerical.hpp:1154
neolib::math::optional_mat13f
optional< mat13f > optional_mat13f
Definition numerical.hpp:1176
neolib::math::vec2u32
vector2u32 vec2u32
Definition numerical.hpp:595
neolib::math::optional_matrix1
optional< matrix11 > optional_matrix1
Definition numerical.hpp:1081
neolib::math::mat23
matrix23 mat23
Definition numerical.hpp:1050
neolib::math::avec2f
std::array< float, 2 > avec2f
Definition numerical.hpp:636
neolib::math::optional_mat31
optional< mat31 > optional_mat31
Definition numerical.hpp:1091
neolib::math::optional_matrix14f
optional< matrix14f > optional_matrix14f
Definition numerical.hpp:1160
neolib::math::mat13
matrix13 mat13
Definition numerical.hpp:1049
neolib::math::optional_matrix42f
optional< matrix42f > optional_matrix42f
Definition numerical.hpp:1158
neolib::math::optional_mat24f
optional< mat24f > optional_mat24f
Definition numerical.hpp:1183
neolib::math::avec4i32
std::array< int32_t, 4 > avec4i32
Definition numerical.hpp:618
neolib::math::avec4i8
std::array< int8_t, 4 > avec4i8
Definition numerical.hpp:608
neolib::math::avec1i8
std::array< int8_t, 1 > avec1i8
Definition numerical.hpp:605
neolib::math::optional_matrix3
optional< matrix33 > optional_matrix3
Definition numerical.hpp:1083
neolib::math::mat42f
matrix42f mat42f
Definition numerical.hpp:1136
neolib::math::vector3f
basic_vector< float, 3 > vector3f
Definition numerical.hpp:565
neolib::math::mat12f
matrix12f mat12f
Definition numerical.hpp:1128
neolib::math::optional_vec3
optional< vec3 > optional_vec3
Definition numerical.hpp:538
neolib::math::mat3f
matrix33f mat3f
Definition numerical.hpp:1144
neolib::math::scalar
double scalar
Definition numerical.hpp:63
neolib::math::quad_extents
basic_vector< T, D > quad_extents(std::array< basic_vector< T, D >, 4 > const &aQuad)
Definition numerical.hpp:1630
neolib::math::optional_mat23f
optional< mat23f > optional_mat23f
Definition numerical.hpp:1177
neolib::math::vec2i32
vector2i32 vec2i32
Definition numerical.hpp:582
neolib::math::optional_mat4f
optional< mat44f > optional_mat4f
Definition numerical.hpp:1189
neolib::math::vector4f
basic_vector< float, 4 > vector4f
Definition numerical.hpp:566
neolib::math::vec2f
vector2f vec2f
Definition numerical.hpp:569
neolib::math::mat1f
matrix11f mat1f
Definition numerical.hpp:1142
neolib::math::optional_matrix23f
optional< matrix23f > optional_matrix23f
Definition numerical.hpp:1155
neolib::math::avec1
std::array< double, 1 > avec1
Definition numerical.hpp:640
neolib::math::optional_row_vec2
optional< row_vec2 > optional_row_vec2
Definition numerical.hpp:547
neolib::math::optional_mat21f
optional< mat21f > optional_mat21f
Definition numerical.hpp:1171
neolib::math::vec3i32
vector3i32 vec3i32
Definition numerical.hpp:583
neolib::math::avec2u32
std::array< uint32_t, 2 > avec2u32
Definition numerical.hpp:631
neolib::math::avec4f
std::array< float, 4 > avec4f
Definition numerical.hpp:638
neolib::math::matrix21
basic_matrix< double, 2, 1 > matrix21
Definition numerical.hpp:1022
neolib::math::matrix43f
basic_matrix< float, 4, 3 > matrix43f
Definition numerical.hpp:1120
neolib::math::optional_mat14
optional< mat14 > optional_mat14
Definition numerical.hpp:1099
neolib::math::triangle_2d
std::array< vec2, 3 > triangle_2d
Definition numerical.hpp:648
neolib::math::matrix41f
basic_matrix< float, 4, 1 > matrix41f
Definition numerical.hpp:1118
neolib::math::vec1u32
vector1u32 vec1u32
Definition numerical.hpp:594
neolib::math::mat22
matrix22 mat22
Definition numerical.hpp:1043
neolib::math::optional_matrix44
optional< matrix44 > optional_matrix44
Definition numerical.hpp:1073
neolib::math::aabb_origin
vec3 aabb_origin(const aabb &aAabb)
Definition numerical.hpp:1650
neolib::math::matrix24f
basic_matrix< float, 2, 4 > matrix24f
Definition numerical.hpp:1122
neolib::math::optional_matrix43
optional< matrix43 > optional_matrix43
Definition numerical.hpp:1076
neolib::math::avec4u32
std::array< uint32_t, 4 > avec4u32
Definition numerical.hpp:633
neolib::math::mat23f
matrix23f mat23f
Definition numerical.hpp:1133
neolib::math::optional_mat2
optional< mat22 > optional_mat2
Definition numerical.hpp:1104
neolib::math::avec3i32
std::array< int32_t, 3 > avec3i32
Definition numerical.hpp:617
neolib::math::optional_matrix4f
optional< matrix44f > optional_matrix4f
Definition numerical.hpp:1167
neolib::math::optional_mat34f
optional< mat34f > optional_mat34f
Definition numerical.hpp:1184
neolib::math::mat4f
matrix44f mat4f
Definition numerical.hpp:1145
neolib::math::matrix12f
basic_matrix< float, 1, 2 > matrix12f
Definition numerical.hpp:1111
neolib::math::optional_matrix21f
optional< matrix21f > optional_matrix21f
Definition numerical.hpp:1149
neolib::math::quadf_2d
std::array< vec2f, 4 > quadf_2d
Definition numerical.hpp:655
neolib::math::matrix33f
basic_matrix< float, 3, 3 > matrix33f
Definition numerical.hpp:1112
neolib::math::vector1
basic_vector< double, 1 > vector1
Definition numerical.hpp:511
neolib::math::optional_mat22
optional< mat22 > optional_mat22
Definition numerical.hpp:1087
neolib::math::optional_mat34
optional< mat34 > optional_mat34
Definition numerical.hpp:1101
neolib::math::mat42
matrix42 mat42
Definition numerical.hpp:1053
neolib::math::mat11f
matrix11f mat11f
Definition numerical.hpp:1125
neolib::math::optional_matrix3f
optional< matrix33f > optional_matrix3f
Definition numerical.hpp:1166
neolib::math::optional_matrix2f
optional< matrix22f > optional_matrix2f
Definition numerical.hpp:1165
neolib::math::vector3i32
basic_vector< i32, 3 > vector3i32
Definition numerical.hpp:578
neolib::math::optional_mat31f
optional< mat31f > optional_mat31f
Definition numerical.hpp:1174
neolib::math::optional_matrix22
optional< matrix22 > optional_matrix22
Definition numerical.hpp:1065
neolib::math::matrix44f
basic_matrix< float, 4, 4 > matrix44f
Definition numerical.hpp:1117
neolib::math::u64
uint32_t u64
Definition numerical.hpp:587
neolib::math::mat11
matrix11 mat11
Definition numerical.hpp:1042
neolib::math::matrix42
basic_matrix< double, 4, 2 > matrix42
Definition numerical.hpp:1031
neolib::math::optional_matrix12f
optional< matrix12f > optional_matrix12f
Definition numerical.hpp:1150
neolib::math::avec3i8
std::array< int8_t, 3 > avec3i8
Definition numerical.hpp:607
neolib::math::mat2f
matrix22f mat2f
Definition numerical.hpp:1143
neolib::math::optional_mat44f
optional< mat44f > optional_mat44f
Definition numerical.hpp:1178
neolib::math::optional_matrix23
optional< matrix23 > optional_matrix23
Definition numerical.hpp:1072
neolib::math::optional_matrix33
optional< matrix33 > optional_matrix33
Definition numerical.hpp:1068
neolib::math::optional_mat24
optional< mat24 > optional_mat24
Definition numerical.hpp:1100
neolib::math::matrix22f
basic_matrix< float, 2, 2 > matrix22f
Definition numerical.hpp:1109
neolib::math::mat33f
matrix33f mat33f
Definition numerical.hpp:1129
neolib::math::optional_col_vec4
optional< col_vec4 > optional_col_vec4
Definition numerical.hpp:544
neolib::math::optional_matrix1f
optional< matrix11f > optional_matrix1f
Definition numerical.hpp:1164
neolib::math::avec3u32
std::array< uint32_t, 3 > avec3u32
Definition numerical.hpp:632
neolib::math::optional_matrix12
optional< matrix12 > optional_matrix12
Definition numerical.hpp:1067
neolib::math::row_vec3
basic_vector< double, 3, row_vector > row_vec3
Definition numerical.hpp:528
neolib::math::matrix32f
basic_matrix< float, 3, 2 > matrix32f
Definition numerical.hpp:1114
neolib::math::vector2u32
basic_vector< u32, 2 > vector2u32
Definition numerical.hpp:590
neolib::math::vector3u32
basic_vector< u32, 3 > vector3u32
Definition numerical.hpp:591
neolib::math::aabb_transform
aabb aabb_transform(const aabb &aAabb, const Transforms &... aTransforms)
Definition numerical.hpp:1661
neolib::math::optional_matrix41f
optional< matrix41f > optional_matrix41f
Definition numerical.hpp:1157
neolib::math::optional_mat23
optional< mat23 > optional_mat23
Definition numerical.hpp:1094
neolib::math::u32
uint32_t u32
Definition numerical.hpp:586
neolib::math::vector2f
basic_vector< float, 2 > vector2f
Definition numerical.hpp:564
neolib::math::matrix14f
basic_matrix< float, 1, 4 > matrix14f
Definition numerical.hpp:1121
neolib::math::optional_matrix2
optional< matrix22 > optional_matrix2
Definition numerical.hpp:1082
neolib::math::to_aabb_2d
aabb_2d to_aabb_2d(const vec3 &aOrigin, scalar aSize)
Definition numerical.hpp:1830
neolib::math::optional_row_vec1
optional< row_vec1 > optional_row_vec1
Definition numerical.hpp:546
neolib::math::avec4u16
std::array< uint16_t, 4 > avec4u16
Definition numerical.hpp:628
neolib::math::avec2i32
std::array< int32_t, 2 > avec2i32
Definition numerical.hpp:616
neolib::math::optional_mat41
optional< mat41 > optional_mat41
Definition numerical.hpp:1096
neolib::math::optional_mat42
optional< mat42 > optional_mat42
Definition numerical.hpp:1097
neolib::math::matrix12
basic_matrix< double, 1, 2 > matrix12
Definition numerical.hpp:1023
neolib::math::matrix41
basic_matrix< double, 4, 1 > matrix41
Definition numerical.hpp:1030
neolib::math::matrix13
basic_matrix< double, 1, 3 > matrix13
Definition numerical.hpp:1027
neolib::math::optional_aabb
optional< aabb > optional_aabb
Definition numerical.hpp:1729
neolib::math::vec3_list
std::vector< vec3 > vec3_list
Definition numerical.hpp:552
neolib::math::optional_mat1
optional< mat11 > optional_mat1
Definition numerical.hpp:1103
neolib::math::optional_matrix11f
optional< matrix11f > optional_matrix11f
Definition numerical.hpp:1147
neolib::math::apply_scaling
mat44 & apply_scaling(mat44 &aMatrix, const vec3 &aScaling)
Definition numerical.hpp:1570
neolib::math::optional_matrix4
optional< matrix44 > optional_matrix4
Definition numerical.hpp:1084
neolib::math::mat21
matrix21 mat21
Definition numerical.hpp:1044
neolib::math::optional_mat43f
optional< mat43f > optional_mat43f
Definition numerical.hpp:1181
neolib::math::matrix31f
basic_matrix< float, 3, 1 > matrix31f
Definition numerical.hpp:1113
neolib::math::bezier_cubic
vec2 bezier_cubic(vec2 const &p0, vec2 const &p1, vec2 const &p2, vec2 const &p3, scalar t)
Definition numerical.hpp:1933
neolib::math::optional_row_vec3
optional< row_vec3 > optional_row_vec3
Definition numerical.hpp:548
neolib::math::optional_matrix34f
optional< matrix34f > optional_matrix34f
Definition numerical.hpp:1162
neolib::math::matrix42f
basic_matrix< float, 4, 2 > matrix42f
Definition numerical.hpp:1119
neolib::math::vec3u32
vector3u32 vec3u32
Definition numerical.hpp:596
neolib::math::matrix21f
basic_matrix< float, 2, 1 > matrix21f
Definition numerical.hpp:1110
neolib::math::vec3f
vector3f vec3f
Definition numerical.hpp:570
neolib::math::triangle
std::array< vec3, 3 > triangle
Definition numerical.hpp:645
neolib::math::avec4i16
std::array< int16_t, 4 > avec4i16
Definition numerical.hpp:613
neolib::math::optional_matrix24
optional< matrix24 > optional_matrix24
Definition numerical.hpp:1078
neolib::math::optional_matrix32
optional< matrix32 > optional_matrix32
Definition numerical.hpp:1070
neolib::math::vec1f
vector1f vec1f
Definition numerical.hpp:568
neolib::operator+=
i_string & operator+=(i_string &lhs, const i_string &rhs)
Definition i_string.hpp:89
std
Definition plf_hive.h:79
std::swap
void swap(plf::hive< element_type, allocator_type > &a, plf::hive< element_type, allocator_type > &b) noexcept(std::allocator_traits< allocator_type >::propagate_on_container_swap::value||std::allocator_traits< allocator_type >::is_always_equal::value)
Definition plf_hive.h:4776
std::next
it_type next(it_type it, const typename iterator_traits< it_type >::difference_type distance=1)
Definition plf_hive.h:89
simd_fma_4d
#define simd_fma_4d
Definition simd.hpp:108
simd_mul_4d
#define simd_mul_4d
Definition simd.hpp:143
string_utils.hpp
neolib::comma_and_brackets_as_whitespace
Definition string_utils.hpp:65
neolib::math::aabb_2d
Definition numerical.hpp:1791
neolib::math::aabb_2d::aabb_2d
aabb_2d(const aabb &aAabb)
Definition numerical.hpp:1798
neolib::math::aabb_2d::max
vec2 max
Definition numerical.hpp:1795
neolib::math::aabb_2d::aabb_2d
aabb_2d(const vec2 &aMin, const vec2 &aMax)
Definition numerical.hpp:1797
neolib::math::aabb_2d::min
vec2 min
Definition numerical.hpp:1794
neolib::math::aabb_2d::aabb_2d
aabb_2d()
Definition numerical.hpp:1796
neolib::math::aabb_2d::abstract_type
aabb_2d abstract_type
Definition numerical.hpp:1792
neolib::math::aabb::aabb
aabb(const vec3 &aMin, const vec3 &aMax)
Definition numerical.hpp:1647
neolib::math::basic_matrix::rebind
Definition numerical.hpp:914
neolib::math::basic_matrix::rebind::type
basic_matrix< T2, Rows, Columns > type
Definition numerical.hpp:914
neolib::math::basic_vector::rebind
Definition numerical.hpp:126
neolib::math::basic_vector::rebind::type
basic_vector< T, Size2, Type > type
Definition numerical.hpp:126
neolib::math::basic_vector< T, 1, Type >::rebind::type
basic_vector< T, Size2, Type > type
Definition numerical.hpp:401
neolib::math::basic_vector< T, 2, Type >::rebind::type
basic_vector< T, Size2, Type > type
Definition numerical.hpp:282
neolib::math::column_vector
Definition numerical.hpp:98
neolib::math::row_vector
Definition numerical.hpp:99