hyperdrone 0.1.0__py3-none-any.whl

hyperdrone/_vendor/rl-tools/include/rl_tools/math/operations_generic.h

@@ -0,0 +1,297 @@
+#include "../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_UTILS_GENERIC_MATH_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_UTILS_GENERIC_MATH_H
+
+#ifndef RL_TOOLS_FUNCTION_PLACEMENT
+#define RL_TOOLS_FUNCTION_PLACEMENT
+#endif
+
+#ifdef _MSC_VER
+#include <limits>
+#endif
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools::math {
+
+    template<typename T>
+    constexpr T PI = 3.141592653589793238462643383279502884L;
+
+    template<typename T>
+    constexpr T FRAC_2_SQRTPI = 1.128379167095512573896158903121545172L;
+    template<typename T>
+    constexpr T SQRT1_2 = 0.707106781186547524400844362104849039L;
+
+    // Implementing sqrt using the Babylonian method (also known as Heron's method)
+    template<typename T>
+    T sqrt(const devices::math::Generic&, T x) {
+        if (x < 0) return -1; // Return -1 for negative numbers to indicate an error
+        T guess = x / 2.0;
+        T epsilon = 0.00001;
+        while ((guess * guess - x) > epsilon || (x - guess * guess) > epsilon) {
+            guess = (guess + x / guess) / 2.0;
+        }
+        return guess;
+    }
+
+    template<typename T>
+    T exp(const devices::math::Generic&, T x) {
+        T sum = 1.0;
+        T term = 1.0;
+        for (int i = 1; i < 20; ++i) {
+            term *= x / i;
+            sum += term;
+        }
+        return sum;
+    }
+
+    template<typename T>
+    T tanh(const devices::math::Generic&, T x) {
+        if (x > 20.0) return 1.0;
+        if (x < -20.0) return -1.0;
+        T ex = exp(devices::math::Generic(), x);
+        T emx = exp(devices::math::Generic(), -x);
+        return (ex - emx) / (ex + emx);
+    }
+
+
+    template<typename T>
+    T sin(const devices::math::Generic&, T x) {
+        T term = x;
+        T sum = x;
+        for (int i = 1; i < 10; ++i) {
+            term *= -x * x / (2 * i * (2 * i + 1));
+            sum += term;
+        }
+        return sum;
+    }
+
+    template<typename T>
+    T cos(const devices::math::Generic&, T x) {
+        T term = 1.0;
+        T sum = 1.0;
+        for (int i = 1; i < 10; ++i) {
+            term *= -x * x / (2 * i * (2 * i - 1));
+            sum += term;
+        }
+        return sum;
+    }
+
+    // based on https://git.musl-libc.org/cgit/musl/tree/src/math/acosf.c?h=v1.2.5
+    /* origin: FreeBSD /usr/src/lib/msun/src/e_acosf.c */
+    /*
+     * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.
+     */
+    /*
+     * ====================================================
+     * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
+     *
+     * Developed at SunPro, a Sun Microsystems, Inc. business.
+     * Permission to use, copy, modify, and distribute this
+     * software is freely granted, provided that this notice
+     * is preserved.
+     * ====================================================
+     */
+
+    namespace generic::acos{
+        static constexpr float
+        pio2_hi = 1.5707962513e+00f, /* 0x3fc90fda */
+        pio2_lo = 7.5497894159e-08f, /* 0x33a22168 */
+        pS0 =  1.6666586697e-01f,
+        pS1 = -4.2743422091e-02f,
+        pS2 = -8.6563630030e-03f,
+        qS1 = -7.0662963390e-01f;
+        static inline float R(float z){
+            float p, q;
+            p = z*(pS0+z*(pS1+z*pS2));
+            q = 1.0f+z*qS1;
+            return p/q;
+        }
+        inline uint32_t get_float_bits(float f) {
+            uint32_t bits = 0;
+            unsigned char* f_bytes = reinterpret_cast<unsigned char*>(&f);
+            unsigned char* bits_bytes = reinterpret_cast<unsigned char*>(&bits);
+
+            for (uint32_t i = 0; i < sizeof(float); ++i) {
+                bits_bytes[i] = f_bytes[i];  // Copy byte by byte
+            }
+
+            return bits;
+        }
+        inline float set_float_bits(uint32_t bits) {
+            float f = 0.0f;
+            unsigned char* f_bytes = reinterpret_cast<unsigned char*>(&f);
+            unsigned char* bits_bytes = reinterpret_cast<unsigned char*>(&bits);
+
+            for (uint32_t i = 0; i < sizeof(float); ++i) {
+                f_bytes[i] = bits_bytes[i];  // Copy byte by byte
+            }
+
+            return f;
+        }
+    }
+    template<typename T>
+    T acos(const devices::math::Generic& dev, T x) {
+        float z,w,s,c,df;
+        uint32_t hx,ix;
+
+        hx = generic::acos::get_float_bits(x);
+        ix = hx & 0x7fffffff;
+        /* |x| >= 1 or nan */
+        if (ix >= 0x3f800000) {
+            if (ix == 0x3f800000) {
+                if (hx >> 31)
+                    return 2*generic::acos::pio2_hi + 0x1p-120f;
+                return 0;
+            }
+            return 0/(x-x);
+        }
+        /* |x| < 0.5 */
+        if (ix < 0x3f000000) {
+            if (ix <= 0x32800000) /* |x| < 2**-26 */
+                return generic::acos::pio2_hi + 0x1p-120f;
+            return generic::acos::pio2_hi - (x - (generic::acos::pio2_lo-x*generic::acos::R(x*x)));
+        }
+        /* x < -0.5 */
+        if (hx >> 31) {
+            z = (1+x)*0.5f;
+            s = math::sqrt(dev, z);
+            w = generic::acos::R(z)*s-generic::acos::pio2_lo;
+            return 2*(generic::acos::pio2_hi - (s+w));
+        }
+        /* x > 0.5 */
+        z = (1-x)*0.5f;
+        s = math::sqrt(dev, z);
+        hx = generic::acos::get_float_bits(s);
+        df = generic::acos::set_float_bits(hx&0xfffff000);
+        c = (z-df*df)/(s+df);
+        w = generic::acos::R(z)*s+c;
+        return 2*(df+w);
+    }
+
+    template<typename TX, typename TY>
+    RL_TOOLS_FUNCTION_PLACEMENT auto pow(const devices::math::Generic&, const TX x, const TY y) {
+        if (y == 0) return static_cast<TX>(1);
+        if (y < 0) return static_cast<TX>(1) / pow(devices::math::Generic(), x, -y);
+        TX temp = pow(devices::math::Generic(), x, y / 2);
+        if (static_cast<int>(y) % 2 == 0)
+            return temp * temp;
+        else
+            return x * temp * temp;
+    }
+
+    template<typename T>
+    T log(const devices::math::Generic&, T x) {
+        if (x <= 0) return -1; // log is only defined for positive numbers
+        T sum = 0.0;
+        T term = (x - 1) / (x + 1);
+        T term_squared = term * term;
+        for (int i = 0; i < 10; ++i) {
+            sum += term / (2 * i + 1);
+            term *= term_squared;
+        }
+        return 2 * sum;
+    }
+
+    template<typename T>
+    T floor(const devices::math::Generic&, const T x) {
+        return static_cast<int>(x);
+    }
+
+    template<typename T>
+    RL_TOOLS_FUNCTION_PLACEMENT bool is_nan(const devices::math::Generic&, const T x) {
+        return x != x;
+    }
+
+    // template<typename T>
+    // bool is_finite(const devices::math::Generic&, const T x) {
+    //     if constexpr (std::is_same_v<T, float>) {
+    //         return x <= 3.402823e+38f && x >= -3.402823e+38f;
+    //     } else if constexpr (std::is_same_v<T, double>) {
+    //         return x <= 1.7976931348623158e+308 && x >= -1.7976931348623158e+308;
+    //     } else {
+    //         return true; // Assume finite for other types
+    //     }
+    // }
+
+    template<typename T>
+    RL_TOOLS_FUNCTION_PLACEMENT T clamp(const devices::math::Generic&, T x, T min, T max) {
+        return x < min ? min : (x > max ? max : x);
+    }
+
+    template<typename T>
+    T min(const devices::math::Generic&, T x, T y) {
+        return x < y ? x : y;
+    }
+
+    template<typename T>
+    T max(const devices::math::Generic&, T x, T y) {
+        return x > y ? x : y;
+    }
+
+    template<typename T>
+    T abs(const devices::math::Generic&, T x) {
+        return x > 0 ? x : -x;
+    }
+
+    template<typename T>
+    T nan(const devices::math::Generic&) {
+#ifndef _MSC_VER
+        return 0.0 / 0.0; // Produces NaN
+#else
+        return std::numeric_limits<T>::quiet_NaN();
+#endif
+    }
+
+    template<typename T>
+    RL_TOOLS_FUNCTION_PLACEMENT T fast_tanh(const devices::math::Generic& dev, T x){
+        x = clamp(dev, x, static_cast<T>(-3.0), static_cast<T>(3.0));
+        T x_squared = x * x;
+        return x * (27 + x_squared) / (27 + 9 * x_squared);
+    }
+    template<typename T>
+    RL_TOOLS_FUNCTION_PLACEMENT T fast_sigmoid(const devices::math::Generic& dev, T x){
+        return (T)0.5 * fast_tanh(dev, (T)0.5 * x) + (T)0.5;
+    }
+
+
+    template<typename T>
+    T atan(const devices::math::Generic&, T x) {
+        // Constants for polynomial approximation
+        T a = 0.9998660;
+        T b = -0.3302995;
+        T c = 0.1801410;
+        T d = -0.0851330;
+        T e = 0.0208351;
+
+        // Polynomial approximation for atan(x) in the range [-1, 1]
+        T abs_x = x < 0 ? -x : x;
+        T x2 = x * x;
+        T result = ((a * x2 + b) * x2 + c) * x2 + d;
+        result = result * x2 + e;
+        result = result * abs_x;
+
+        // Adjust for input sign
+        result = x < 0 ? -result : result;
+
+        return result;
+    }
+
+    template<typename T>
+    T atan2(const devices::math::Generic&, T y, T x) {
+        if (x > 0) {
+            return atan(y / x);
+        } else if (x < 0 && y >= 0) {
+            return atan(y / x) + PI<T>;
+        } else if (x < 0 && y < 0) {
+            return atan(y / x) - PI<T>;
+        } else if (x == 0 && y > 0) {
+            return PI<T> / 2;
+        } else if (x == 0 && y < 0) {
+            return -PI<T> / 2;
+        }
+        return 0;
+    }
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+#endif

hyperdrone/_vendor/rl-tools/include/rl_tools/math/operations_wasm32.h

@@ -0,0 +1,225 @@
+#include "../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_MATH_OPERATIONS_WASM32_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_MATH_OPERATIONS_WASM32_H
+
+#include "../devices/wasm32.h"
+
+
+#include "operations_generic.h"
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools::math {
+
+    template<typename T>
+    T sqrt(const devices::math::WASM32&, const T x) {
+        return sqrt(devices::math::Generic{}, x);
+    }
+	// based on https://git.musl-libc.org/cgit/musl/tree/src/math/cbrt.c?h=v1.2.5
+	/* origin: FreeBSD /usr/src/lib/msun/src/s_cbrt.c */
+	/*
+	 * ====================================================
+	 * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
+	 *
+	 * Developed at SunPro, a Sun Microsystems, Inc. business.
+	 * Permission to use, copy, modify, and distribute this
+	 * software is freely granted, provided that this notice
+	 * is preserved.
+	 * ====================================================
+	 *
+	 * Optimized by Bruce D. Evans.
+	 */
+    template<typename T_T>
+    T_T cbrt(const devices::math::WASM32&, const T_T x) {
+        if constexpr(utils::typing::is_same_v<T_T, float>) {
+            static constexpr unsigned
+            B1 = 709958130, /* B1 = (127-127.0/3-0.03306235651)*2**23 */
+            B2 = 642849266; /* B2 = (127-127.0/3-24/3-0.03306235651)*2**23 */
+            double r,T;
+            union {float f; uint32_t i;} u = {x};
+            uint32_t hx = u.i & 0x7fffffff;
+            if (hx >= 0x7f800000)  /* cbrt(NaN,INF) is itself */
+                return x + x;
+            /* rough cbrt to 5 bits */
+            if (hx < 0x00800000) {  /* zero or subnormal? */
+                if (hx == 0)
+                    return x;  /* cbrt(+-0) is itself */
+                u.f = x*0x1p24f;
+                hx = u.i & 0x7fffffff;
+                hx = hx/3 + B2;
+            } else
+                hx = hx/3 + B1;
+            u.i &= 0x80000000;
+            u.i |= hx;
+            /*
+             * First step Newton iteration (solving t*t-x/t == 0) to 16 bits.  In
+             * double precision so that its terms can be arranged for efficiency
+             * without causing overflow or underflow.
+             */
+            T = u.f;
+            r = T*T*T;
+            T = T*((double)x+x+r)/(x+r+r);
+            /*
+             * Second step Newton iteration to 47 bits.  In double precision for
+             * efficiency and accuracy.
+             */
+            r = T*T*T;
+            T = T*((double)x+x+r)/(x+r+r);
+            /* rounding to 24 bits is perfect in round-to-nearest mode */
+            return T;
+        } else {
+        	static constexpr uint32_t
+			B1 = 715094163, /* B1 = (1023-1023/3-0.03306235651)*2**20 */
+			B2 = 696219795; /* B2 = (1023-1023/3-54/3-0.03306235651)*2**20 */
+
+        	/* |1/cbrt(x) - p(x)| < 2**-23.5 (~[-7.93e-8, 7.929e-8]). */
+        	static constexpr double
+			P0 =  1.87595182427177009643,  /* 0x3ffe03e6, 0x0f61e692 */
+			P1 = -1.88497979543377169875,  /* 0xbffe28e0, 0x92f02420 */
+			P2 =  1.621429720105354466140, /* 0x3ff9f160, 0x4a49d6c2 */
+			P3 = -0.758397934778766047437, /* 0xbfe844cb, 0xbee751d9 */
+			P4 =  0.145996192886612446982; /* 0x3fc2b000, 0xd4e4edd7 */
+            union {double f; uint64_t i;} u = {x};
+			double r,s,t,w;
+			uint32_t hx = u.i>>32 & 0x7fffffff;
+			if (hx >= 0x7ff00000)  /* cbrt(NaN,INF) is itself */
+				return x+x;
+			/*
+			 * Rough cbrt to 5 bits:
+			 *    cbrt(2**e*(1+m) ~= 2**(e/3)*(1+(e%3+m)/3)
+			 * where e is integral and >= 0, m is real and in [0, 1), and "/" and
+			 * "%" are integer division and modulus with rounding towards minus
+			 * infinity.  The RHS is always >= the LHS and has a maximum relative
+			 * error of about 1 in 16.  Adding a bias of -0.03306235651 to the
+			 * (e%3+m)/3 term reduces the error to about 1 in 32. With the IEEE
+			 * floating point representation, for finite positive normal values,
+			 * ordinary integer divison of the value in bits magically gives
+			 * almost exactly the RHS of the above provided we first subtract the
+			 * exponent bias (1023 for doubles) and later add it back.  We do the
+			 * subtraction virtually to keep e >= 0 so that ordinary integer
+			 * division rounds towards minus infinity; this is also efficient.
+			 */
+			if (hx < 0x00100000) { /* zero or subnormal? */
+				u.f = x*0x1p54;
+				hx = u.i>>32 & 0x7fffffff;
+				if (hx == 0)
+					return x;  /* cbrt(0) is itself */
+				hx = hx/3 + B2;
+			} else
+				hx = hx/3 + B1;
+			u.i &= 1ULL<<63;
+			u.i |= (uint64_t)hx << 32;
+			t = u.f;
+
+			/*
+			 * New cbrt to 23 bits:
+			 *    cbrt(x) = t*cbrt(x/t**3) ~= t*P(t**3/x)
+			 * where P(r) is a polynomial of degree 4 that approximates 1/cbrt(r)
+			 * to within 2**-23.5 when |r - 1| < 1/10.  The rough approximation
+			 * has produced t such than |t/cbrt(x) - 1| ~< 1/32, and cubing this
+			 * gives us bounds for r = t**3/x.
+			 *
+			 * Try to optimize for parallel evaluation as in __tanf.c.
+			 */
+			r = (t*t)*(t/x);
+			t = t*((P0+r*(P1+r*P2))+((r*r)*r)*(P3+r*P4));
+
+			/*
+			 * Round t away from zero to 23 bits (sloppily except for ensuring that
+			 * the result is larger in magnitude than cbrt(x) but not much more than
+			 * 2 23-bit ulps larger).  With rounding towards zero, the error bound
+			 * would be ~5/6 instead of ~4/6.  With a maximum error of 2 23-bit ulps
+			 * in the rounded t, the infinite-precision error in the Newton
+			 * approximation barely affects third digit in the final error
+			 * 0.667; the error in the rounded t can be up to about 3 23-bit ulps
+			 * before the final error is larger than 0.667 ulps.
+			 */
+			u.f = t;
+			u.i = (u.i + 0x80000000) & 0xffffffffc0000000ULL;
+			t = u.f;
+
+			/* one step Newton iteration to 53 bits with error < 0.667 ulps */
+			s = t*t;         /* t*t is exact */
+			r = x/s;         /* error <= 0.5 ulps; |r| < |t| */
+			w = t+t;         /* t+t is exact */
+			r = (r-t)/(w+r); /* r-t is exact; w+r ~= 3*t */
+			t = t+t*r;       /* error <= 0.5 + 0.5/3 + epsilon */
+			return t;
+        }
+    }
+    template<typename T>
+    T tanh(const devices::math::WASM32&, const T x) {
+        return tanh(devices::math::Generic{}, x);
+    }
+    template<typename T>
+    T exp(const devices::math::WASM32&, const T x) {
+        return exp(devices::math::Generic{}, x);
+    }
+    template<typename T>
+    T sin(const devices::math::WASM32&, const T x) {
+        return sin(devices::math::Generic{}, x);
+    }
+    template<typename T>
+    T cos(const devices::math::WASM32&, const T x) {
+        return cos(devices::math::Generic{}, x);
+    }
+    template<typename T>
+    T acos(const devices::math::WASM32&, const T x) {
+        return acos(devices::math::Generic{}, x);
+    }
+    template<typename TX, typename TY>
+    TX pow(const devices::math::WASM32&, const TX x, const TY y) {
+        return pow(devices::math::Generic{}, x, y);
+    }
+    template<typename T>
+    T log(const devices::math::WASM32&, const T x) {
+        return log(devices::math::Generic{}, x);
+    }
+    template<typename T>
+    T floor(const devices::math::WASM32&, const T x) {
+        return floor(devices::math::Generic{}, x);
+    }
+    template<typename T>
+    bool is_nan(const devices::math::WASM32&, const T x) {
+        return is_nan(devices::math::Generic{}, x);
+    }
+    template<typename T>
+    bool is_finite(const devices::math::WASM32&, const T x) {
+        return is_finite(devices::math::Generic{}, x);
+    }
+    template<typename T>
+    T clamp(const devices::math::WASM32&, T x, T min, T max){
+        return clamp(devices::math::Generic{}, x, min, max);
+    }
+    template<typename T>
+    T min(const devices::math::WASM32&, T x, T y){
+        return min(devices::math::Generic{}, x, y);
+    }
+    template<typename T>
+    T max(const devices::math::WASM32&, T x, T y){
+        return max(devices::math::Generic{}, x, y);
+    }
+    template<typename T>
+    T abs(const devices::math::WASM32&, T x){
+        return abs(devices::math::Generic{}, x);
+    }
+    template<typename T>
+    T nan(const devices::math::WASM32&){
+        return nan<T>(devices::math::Generic{});
+    }
+    template<typename T>
+    T atan2(const devices::math::WASM32&, T a, T b){
+        return atan2(devices::math::Generic{}, a, b);
+    }
+    template<typename T>
+    T fast_sigmoid(const devices::math::WASM32& dev, T x) {
+        return fast_sigmoid(devices::math::Generic{}, x);
+    }
+    template<typename T>
+    T fast_tanh(const devices::math::WASM32& dev, T x) {
+        return fast_tanh(devices::math::Generic{}, x);
+    }
+
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+#endif

hyperdrone/_vendor/rl-tools/include/rl_tools/mode/mode.h

@@ -0,0 +1,75 @@
+#include "../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_MODE_MODE_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_MODE_MODE_H
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools{
+    // note: please always check for the mode by using utils::typing::is_base_of_v, e.g. `utils::typing::is_base_of_v<mode::Evaluation, MODE>`. This ensures that when some layers of e.g. an nn_models::Sequential model are using specific modes that there are no side-effects
+    // note: please use the same mode for affiliated forward and backward passes
+    template <typename T_MODE>
+    struct Mode: T_MODE{
+        using MODE = T_MODE;
+    };
+    namespace mode{
+        struct Final{ };
+        template <typename T_BASE = Final, typename T_SPEC = bool>
+        struct Default: Final{
+            using SPEC = bool;
+            using BASE = Final;
+        };
+        template <typename T_BASE = Final, typename T_SPEC = bool>
+        struct Rollout: T_BASE{
+            // this is what is passed by on/off-policy runners
+            // semantics: randomness for exploration
+            using SPEC = T_SPEC;
+            using BASE = T_BASE;
+        };
+        template <typename T_BASE = Final, typename T_SPEC = bool>
+        struct Evaluation: T_BASE{
+            // this is what is passed by rl::utils::evaluation
+            // semantics: no randomness
+            using SPEC = T_SPEC;
+            using BASE = T_BASE;
+        };
+        template <typename MODE>
+        constexpr bool _check_carrier(MODE){
+            return false;
+        }
+        template <typename MODE>
+        constexpr bool _check_carrier(Mode<MODE>){
+            return true;
+        }
+
+        template <typename INPUT, template <typename, typename> typename MODE>
+        constexpr bool _is(){
+            static_assert(!_check_carrier(INPUT{}), "You should only check the unwrapped mode => execute mode::is<MODE> if you have a Mode<MODE>");
+            if constexpr (utils::typing::is_same_v<typename INPUT::BASE, Final>){
+                return utils::typing::is_same_v<INPUT, MODE<Final, bool>>;
+            }
+            else{
+                return utils::typing::is_same_v<MODE<typename INPUT::BASE, typename INPUT::SPEC>, INPUT> || _is<typename INPUT::BASE, MODE>();
+            }
+        }
+
+        template <typename INPUT, template <typename, typename> typename MODE>
+        constexpr bool is = _is<INPUT, MODE>();
+
+        namespace sequential{
+            template <typename T_RESET_CONTAINER_TYPE>
+            struct ResetMaskSpecification{
+                using RESET_CONTAINER_TYPE = T_RESET_CONTAINER_TYPE;
+            };
+            template <typename T_BASE, typename T_SPEC>
+            struct ResetMask: T_BASE{
+                using SPEC = T_SPEC;
+                using BASE = T_BASE;
+                typename SPEC::RESET_CONTAINER_TYPE mask;
+            };
+
+        }
+    }
+
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+#endif