Math/Random and its tests implementation

src/Magnum/Math/CMakeLists.txt

@@ -49,6 +49,7 @@ set(MagnumMath_HEADERS
     Quaternion.h
     Packing.h
     PackingBatch.h
+    Random.h
     Range.h
     RectangularMatrix.h
     StrictWeakOrdering.h

src/Magnum/Math/Random.h

@@ -0,0 +1,131 @@
+#ifndef Magnum_Math_Random_h
+#define Magnum_Math_Random_h
+
+// TO DO Licence things.
+
+#include <random>
+#include <chrono>
+#include "Magnum/Types.h"
+#include "Magnum/Math/Constants.h"
+#include "Magnum/Math/Vector2.h"
+#include "Magnum/Math/Vector3.h"
+#include "Magnum/Math/Quaternion.h"
+#include "Magnum/Math/Functions.h"
+
+namespace Magnum
+{
+namespace Math
+{
+
+namespace Implementation
+{
+static std::seed_seq seeds{{
+    static_cast<std::uintmax_t>(std::random_device{}()),
+    static_cast<std::uintmax_t>(std::chrono::steady_clock::now()
+                                    .time_since_epoch()
+                                    .count()),
+}};
+
+class RandomGenerator
+{
+public:
+    RandomGenerator() = delete;
+
+    template <typename T>
+    static typename std::enable_if<std::is_same<Int, T>::value, T>::type
+    generate(T start = -Magnum::Math::Constants<T>::inf(),
+             T end = Magnum::Math::Constants<T>::inf())
+    {
+        return std::uniform_int_distribution<T>{start, end}(generator());
+    }
+
+    template <typename T>
+    static typename std::enable_if<std::is_same<Float, T>::value, T>::type
+    generate(T start = -Magnum::Math::Constants<T>::inf(),
+             T end = Magnum::Math::Constants<T>::inf())
+    {
+        return std::uniform_real_distribution<T>{start, end}(generator());
+    }
+
+public:
+    static std::mt19937 &generator()
+    {
+        static std::mt19937 g{seeds};
+        return g;
+    }
+};
+} // namespace Implementation
+namespace Random
+{
+template <class T = Float>
+T randomUnsignedScalar() // range [0, 1]
+{
+    return Implementation::RandomGenerator::generate<T>(static_cast<T>(0.0f),
+                                                        static_cast<T>(1.0f));
+}
+template <class T = Float>
+T randomSignedScalar() // range [-1, 1]
+{
+    return Implementation::RandomGenerator::generate(static_cast<T>(-1.0f), static_cast<T>(1.0f));
+}
+
+template <class T = Float>
+Vector2<T> randomUnitVector2()
+{
+    auto a = Implementation::RandomGenerator::generate(0.0f, 2 * Math::Constants<T>::pi());
+    return {std::cos(a), std::sin(a)};
+}
+
+template <class T = Float>
+Vector3<T> randomUnitVector3()
+{
+    auto a = Implementation::RandomGenerator::generate(0.0f, 2 * Math::Constants<T>::pi());
+    auto z = randomSignedScalar();
+    auto r = sqrt<T>(1 - z * z);
+    return {r * std::cos(a), r * std::sin(a), z};
+}
+template <class T = Float>
+Vector2<T> randomPointInACircle() // always length < 1
+{
+    while (true)
+    {
+        auto p = Vector2<T>(
+            randomSignedScalar(), randomSignedScalar());
+        if (p.length() >= 1)
+            continue;
+        return p;
+    }
+}
+
+template <class T = Float>
+Vector3<T> randomPointInASphere() // always length < 1
+{
+
+    while (true)
+    {
+        auto p = Vector3<T>(randomSignedScalar(),
+                            randomSignedScalar(),
+                            randomSignedScalar());
+        if (p.length() >= 1)
+            continue;
+        return p;
+    }
+}
+
+bool randomBool()
+{
+    return static_cast<bool>(randomUnsignedScalar<Int>());
+}
+
+template <class T = Float>
+Quaternion<T> randomRotation()
+{
+    return Quaternion<T>({randomSignedScalar<T>(), randomSignedScalar<T>(), randomSignedScalar<T>()}, randomSignedScalar<T>()).normalized();
+}
+
+} // namespace Random
+
+} // namespace Math
+} // namespace Magnum
+
+#endif

src/Magnum/Math/Test/CMakeLists.txt

@@ -70,6 +70,8 @@ corrade_add_test(MathStrictWeakOrderingTest StrictWeakOrderingTest.cpp LIBRARIES
 
 corrade_add_test(MathMatrixBenchmark MatrixBenchmark.cpp LIBRARIES MagnumMathTestLib)
 
+corrade_add_test(MathRandomTest RandomTest.cpp LIBRARIES MagnumMathTestLib)
+
 set_property(TARGET
     MathVectorTest
     MathMatrixTest
@@ -85,6 +87,8 @@ set_property(TARGET
 
     MathDistanceTest
     MathIntersectionTest
+
+    MathRandomTest
     APPEND PROPERTY COMPILE_DEFINITIONS "CORRADE_GRACEFUL_ASSERT")
 
 set_target_properties(
@@ -130,4 +134,6 @@ set_target_properties(
 
     MathConfigurationValueTest
     MathStrictWeakOrderingTest
+
+    MathRandomTest
     PROPERTIES FOLDER "Magnum/Math/Test")

src/Magnum/Math/Test/RandomTest.cpp

@@ -0,0 +1,112 @@
+#include <Corrade/TestSuite/Tester.h>
+#include <Corrade/Utility/DebugStl.h>
+
+#include "Magnum/Math/Random.h"
+
+namespace Magnum
+{
+namespace Math
+{
+
+namespace Test
+{
+namespace
+{
+
+struct RandomTest : Corrade::TestSuite::Tester
+{
+    explicit RandomTest();
+
+    void unsignedScalar();
+    void signedScalar();
+    void unitVector2();
+    void unitVector3();
+    void pointInACircle();
+    void pointInASphere();
+    void randomRotation();
+};
+
+typedef Vector<2, Float> Vector2;
+typedef Vector<3, Float> Vector3;
+typedef Math::Constants<Float> Constants;
+
+RandomTest::RandomTest()
+{
+    addTests({&RandomTest::unsignedScalar,
+              &RandomTest::signedScalar,
+              &RandomTest::unitVector2,
+              &RandomTest::unitVector3,
+              &RandomTest::pointInACircle,
+              &RandomTest::pointInASphere,
+              &RandomTest::randomRotation});
+}
+
+// void RandomTest::construct() {
+//     constexpr Matrix4x4 a = {Vector4(3.0f,  5.0f, 8.0f, -3.0f),
+//                              Vector4(4.5f,  4.0f, 7.0f,  2.0f),
+//                              Vector4(1.0f,  2.0f, 3.0f, -1.0f),
+//                              Vector4(7.9f, -1.0f, 8.0f, -1.5f)};
+//     CORRADE_COMPARE(a, Matrix4x4(Vector4(3.0f,  5.0f, 8.0f, -3.0f),
+//                                  Vector4(4.5f,  4.0f, 7.0f,  2.0f),
+//                                  Vector4(1.0f,  2.0f, 3.0f, -1.0f),
+//                                  Vector4(7.9f, -1.0f, 8.0f, -1.5f)));
+
+//     CORRADE_VERIFY((std::is_nothrow_constructible<Matrix4x4, Vector4, Vector4, Vector4, Vector4>::value));
+// }
+void RandomTest::unsignedScalar()
+{
+    for (std::size_t i = 0; i < 10; i++)
+    {
+        CORRADE_VERIFY(Math::Random::randomUnsignedScalar<Float>() < 1.000000001);
+        CORRADE_VERIFY(Math::Random::randomUnsignedScalar<Float>() > -.000000001);
+    }
+}
+
+void RandomTest::signedScalar()
+{
+    for (std::size_t i = 0; i < 10; i++)
+    {
+        CORRADE_VERIFY(Math::Random::randomUnsignedScalar<Float>() < 1.000000001);
+        CORRADE_VERIFY(Math::Random::randomUnsignedScalar<Float>() > -1.000000001);
+    }
+}
+
+void RandomTest::unitVector2()
+{
+    for (std::size_t i = 0; i < 10; i++)
+    {
+        CORRADE_COMPARE((Math::Random::randomUnitVector2()).length(),1.0f);
+    }
+}
+void RandomTest::unitVector3()
+{
+    for (std::size_t i = 0; i < 10; i++)
+    {
+        CORRADE_COMPARE((Math::Random::randomUnitVector3()).length(),1.0f);
+    }
+}
+
+void RandomTest::pointInACircle(){
+    for (std::size_t i = 0; i < 10; i++)
+    {
+        CORRADE_VERIFY((Math::Random::randomPointInACircle()).length()<1.0f);
+    }
+}
+void RandomTest::pointInASphere(){
+    for (std::size_t i = 0; i < 10; i++)
+    {
+        CORRADE_VERIFY((Math::Random::randomPointInASphere()).length()<1.0f);
+    }
+}
+void RandomTest::randomRotation(){
+    for (std::size_t i = 0; i < 10; i++)
+    {
+        CORRADE_COMPARE(Math::Random::randomRotation().length(), 1.0f);
+    }
+}
+} // namespace
+} // namespace Test
+} // namespace Math
+} // namespace Magnum
+
+CORRADE_TEST_MAIN(Magnum::Math::Test::RandomTest)