Introduce new types: fraction, fraction_timespec; its constants & literals as well adoption in latch, ringbuffer, service_runner and simple_timer.

Also adds string -> fraction conversion via to_fraction_i64(), supported by environment.

fraction provides similar properties like C++11's `std::ratio`,
but is evaluated at runtime time without `constexpr` constraints using a common integral template type.
std::ratio is evaluated at compile time and must use `constexpr` literal values.

fraction provides similar properties like C++11's `std::chrono::duration`,
but is flexible with its denominator and always reduce() its fraction to the lowest terms.
`std::chrono::duration` uses a fixed `std::ratio` denominator and hence is inflexible.

Further, fraction can be converted to std::chrono::duration,
matching the selected duration's period, see to_duration_count() and to_duration().

... see fraction_type.hpp

6 files changed, 2000 insertions, 0 deletions

diff --git a/include/jau/environment.hpp b/include/jau/environment.hpp
index c2f855f..261f103 100644
--- a/include/jau/environment.hpp
+++ b/include/jau/environment.hpp
@@ -70,11 +70,37 @@ namespace jau {
 
         public:
             /**
+             * Module startup time t0 in monotonic time using high precision and range of fraction_timespec.
+             */
+            static const fraction_timespec startupTimeMonotonic;
+
+            /**
              * Module startup time t0 in monotonic time in milliseconds.
              */
             static const uint64_t startupTimeMilliseconds;
 
             /**
+             * Returns elapsed monotonic time using fraction_timespec since module startup,
+             * see {@link #startupTimeMonotonic} and getMonotonicTime().
+             * <pre>
+             *    return getMonotonicTime() - startupTimeMonotonic;
+             * </pre>
+             */
+            static fraction_timespec getElapsedMonotonicTime() noexcept {
+                return getMonotonicTime() - startupTimeMonotonic;
+            }
+
+            /**
+             * Returns elapsed monotonic time using fraction_timespec since module startup up to the given current_ts, see {@link #startupTimeMonotonic}.
+             * <pre>
+             *    return current_ts - startupTimeMonotonic;
+             * </pre>
+             */
+            static fraction_timespec getElapsedMonotonicTime(const fraction_timespec& current_ts) noexcept {
+                return current_ts - startupTimeMonotonic;
+            }
+
+            /**
              * Returns current elapsed monotonic time in milliseconds since module startup, see {@link #startupTimeMilliseconds}.
              */
             static uint64_t getElapsedMillisecond() noexcept {
@@ -158,6 +184,21 @@ namespace jau {
                                               const uint32_t min_allowed=0, const uint32_t max_allowed=UINT32_MAX) noexcept;
 
             /**
+             * Returns the fraction_i64 value of the environment's variable 'name' in format `<num>/<denom>`,
+             * with white space allowed, if within given fraction_i64 value range.
+             *
+             * Otherwise returns the 'default_value' if the environment variable's value is null
+             * or of invalid format or not within given fraction_i64 value range.
+             * <p>
+             * Implementation uses {@link #getProperty(const std::string & name)}
+             * and hence attempts to also find a Unix conform name,
+             * e.g. 'direct_bt_debug' if ''direct_bt.debug' wasn't found.
+             * </p>
+             */
+            static fraction_i64 getFractionProperty(const std::string & name, const fraction_i64& default_value,
+                                                    const fraction_i64& min_allowed, const fraction_i64& max_allowed) noexcept;
+
+            /**
              * Fetches exploding variable-name (prefix_domain) values.
              * <p>
              * Implementation uses {@link #getProperty(const std::string & name)}
diff --git a/include/jau/fraction_type.hpp b/include/jau/fraction_type.hpp
new file mode 100644
index 0000000..73aa67b
--- /dev/null
+++ b/include/jau/fraction_type.hpp
@@ -0,0 +1,1045 @@
+/*
+ * Author: Sven Gothel <[email protected]>
+ * Copyright (c) 2022 Gothel Software e.K.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef JAU_FRACTION_TYPE_HPP_
+#define JAU_FRACTION_TYPE_HPP_
+
+#include <ratio>
+#include <chrono>
+#include <condition_variable>
+
+#include <stdio.h>
+#include <cinttypes>
+
+#include <sstream>
+#include <cstdint>
+#include <cmath>
+
+#include <jau/int_types.hpp>
+#include <jau/int_math.hpp>
+#include <jau/ordered_atomic.hpp>
+
+namespace jau {
+
+    extern void print_backtrace(const bool skip_anon_frames, const jau::snsize_t max_frames, const jau::snsize_t skip_frames) noexcept;
+
+    // Remember: constexpr specifier used in a function or static data member (since C++17) declaration implies inline.
+
+    /**
+     * Fraction template type using integral values, evaluated at runtime.
+     *
+     * All operations reduce its fraction to the lowest terms using
+     * the greatest common divisor (gcd()) following Euclid's algorithm from Euclid's Elements ~300 BC,
+     * see reduce().
+     *
+     * fraction provides similar properties like C++11's `std::ratio`,
+     * but is evaluated at runtime time without `constexpr` constraints using a common integral template type.
+     * std::ratio is evaluated at compile time and must use `constexpr` literal values.
+     *
+     * fraction provides similar properties like C++11's `std::chrono::duration`,
+     * but is flexible with its denominator and always reduce() its fraction to the lowest terms.
+     * `std::chrono::duration` uses a fixed `std::ratio` denominator and hence is inflexible.
+     *
+     * Further, fraction can be converted to std::chrono::duration,
+     * matching the selected duration's period, see to_duration_count() and to_duration().
+     *
+     * The following properties are exposed:
+     * - Numerator carries sign and hence can be negative and can be of signed type
+     * - Denominator is always positive and is always an unsigned type
+     * - All operations incl. construction will result in a reduced fraction using the greatest common denominator, see gcd().
+     * - No exceptions are thrown, a zero denominator is undefined behavior, implementation will return zero { n=0, d=1 }.
+     *
+     * See usable fixed typedef's
+     * - fraction_i64
+     * - fraction_ui64
+     *
+     * fraction_timespec covers high precision and almost infinite range of time
+     * similar to `struct timespec_t`.
+     *
+     * Counting nanoseconds in int64_t only lasts until `2262-04-12`,
+     * since INT64_MAX is 9'223'372'036'854'775'807 for 9'223'372'036 seconds or 292 years.
+     *
+     * Hence using one may use fraction_i64 for durations up to 292 years
+     * and fraction_timespec for almost infinite range of time-points or durations beyond 292 years.
+     *
+     * Constants are provided in in namespace jau::fractions_i64,
+     * from fractions_i64::pico to fractions_i64::tera, including fractions::fractions_i64 to fractions::fractions_i64, etc.
+     *
+     * Literal operators are provided in namespace jau::fractions_i64_literals,
+     * e.g. for `3_s`, `100_ns` ... literals.
+     *
+     * @tparam int_type
+     * @tparam
+     */
+    template<typename Int_type,
+             std::enable_if_t< std::is_integral_v<Int_type>, bool> = true>
+    class fraction {
+        public:
+            /** User defined integral integer template type, used for numerator and may be signed. */
+            typedef Int_type                        int_type;
+
+            /** unsigned variant of template int_type, used for denominator. */
+            typedef std::make_unsigned_t<int_type> uint_type;
+
+            /** Numerator, carries the sign. */
+            int_type num;
+            /** Denominator, always positive. */
+            uint_type denom;
+            /** Overflow flag. If set, last arithmetic operation produced an overflow. Must be cleared manually. */
+            bool overflow;
+
+        private:
+            void set_overflow() noexcept {
+                overflow = true;
+                print_backtrace(true /* skip_anon_frames */, 6 /* max_frames */, 2 /* skip_frames */);
+                num = std::numeric_limits<int_type>::max();
+                denom = std::numeric_limits<uint_type>::max();
+            }
+
+        public:
+#if 0
+            template<typename _ToDur, typename _Rep, typename _Period>
+              constexpr __enable_if_is_duration<_ToDur>
+              duration_cast(const duration<_Rep, _Period>& __d)
+              {
+            typedef typename _ToDur::period             __to_period;
+            typedef typename _ToDur::rep                __to_rep;
+            typedef ratio_divide<_Period, __to_period>      __cf;
+            typedef typename common_type<__to_rep, _Rep, intmax_t>::type
+                                        __cr;
+            typedef  __duration_cast_impl<_ToDur, __cf, __cr,
+                              __cf::num == 1, __cf::den == 1> __dc;
+            return __dc::__cast(__d);
+              }
+#endif
+
+            /**
+             * Constructs a zero fraction instance { 0, 1 }
+             */
+            constexpr fraction() noexcept
+            : num(0), denom(1), overflow(false) { }
+
+
+            /**
+             * Constructs a fraction instance with smallest numerator and denominator using gcd()
+             *
+             * Note: sign is always stored in fraction's numerator, i.e. the denominator is always positive.
+             *
+             * @param n the given numerator
+             * @param d the given denominator
+             */
+            template <typename T,
+                      std::enable_if_t<  std::is_same_v<int_type, T> &&
+                                        !std::is_unsigned_v<T>, bool> = true>
+            constexpr fraction(const int_type n, const T d) noexcept
+            : num(0), denom(1), overflow(false)
+            {
+                if( n != 0 && d != 0 ) {
+                    // calculate smallest num and denom, both arguments 'n' and 'd' may be negative
+                    const uint_type abs_d = abs(d);
+                    const uint_type _gcd = gcd<uint_type>( (uint_type)abs(n), abs_d );
+                    num = ( n * jau::sign(d) ) / (int_type)_gcd;
+                    denom = abs_d / _gcd;
+                }
+            }
+
+
+            /**
+             * Constructs a fraction instance with smallest numerator and denominator using gcd()
+             *
+             * Note: sign is always stored in fraction's numerator, i.e. the denominator is always positive and hence unsigned.
+             *
+             * @param n the given numerator
+             * @param d the given denominator
+             */
+            constexpr fraction(const int_type n, const uint_type abs_d) noexcept
+            : num(0), denom(1), overflow(false)
+            {
+                if( n != 0 && abs_d != 0 ) {
+                    // calculate smallest num and denom, only given argument 'n' can be negative
+                    const uint_type _gcd = gcd<uint_type>( (uint_type)abs(n), abs_d );
+                    num = n / (int_type)_gcd;
+                    denom = abs_d / _gcd;
+                }
+            }
+
+            // We use the implicit default copy- and move constructor and assignment operations,
+            // rendering fraction TriviallyCopyable
+#if 0
+            constexpr fraction(const fraction<int_type> &o) noexcept
+            : num(o.num), denom(o.denom) { }
+
+            constexpr fraction(fraction<int_type> &&o) noexcept
+            : num(std::move(o.num)), denom(std::move(o.denom)) { }
+
+            constexpr fraction& operator=(const fraction<int_type> &o) noexcept {
+                num = o.num;
+                denom = o.denom;
+                return *this;
+            }
+            constexpr fraction& operator=(fraction<int_type> &&o) noexcept {
+                num = std::move( o.num );
+                denom = std::move( o.denom );
+                return *this;
+            }
+#endif
+
+            /**
+             * Reduce this fraction to the lowest terms using the greatest common denominator, see gcd(), i.e. normalization.
+             *
+             * Might need to be called after manual modifications on numerator or denominator.
+             *
+             * Not required after applying any provided operation as they normalize the fraction.
+             */
+            constexpr fraction<int_type>& reduce() noexcept {
+                if( num != 0 && denom != 0 ) {
+                    const uint_type _gcd = gcd<uint_type>( (uint_type)abs(num), denom );
+                    num /= static_cast<int_type>(_gcd);
+                    denom /= _gcd;
+                }
+                return *this;
+            }
+
+            /**
+             * Converts this this fraction to a numerator for the given new base fraction.
+             *
+             * If overflow_ptr is not nullptr, true is stored if an overflow occurred otherwise false.
+             *
+             * @param new_base the new base fraction for conversion
+             * @param overflow_ptr optional pointer to overflow result, defaults to nullptr
+             * @return numerator representing this fraction on the new base, or std::numeric_limits<int_type>::max() if an overflow occurred.
+             */
+            constexpr int_type to_num_of(const fraction<int_type>& new_base, bool * overflow_ptr=nullptr) const noexcept {
+                // const uint_type _lcm = lcm<uint_type>( denom, new_base.denom );
+                // return ( num * (int_type)( _lcm / denom ) ) / new_base.num;
+                //
+                int_type r;
+                if( mul_overflow(num, (int_type)new_base.denom, r) ) {
+                    if( nullptr != overflow_ptr ) {
+                        *overflow_ptr = true;
+                    }
+                    return std::numeric_limits<int_type>::max();
+                } else {
+                    if( nullptr != overflow_ptr ) {
+                        *overflow_ptr = false;
+                    }
+                    return r / (int_type)denom / new_base.num;
+                }
+            }
+
+            /**
+             * Converts this this fraction to a numerator for the given new base fraction.
+             *
+             * If overflow_ptr is not nullptr, true is stored if an overflow occurred otherwise false.
+             *
+             * @param new_base_num the new base numerator for conversion
+             * @param new_base_denom the new base denominator for conversion
+             * @param new_base the new base fraction for conversion
+             * @param overflow_ptr optional pointer to overflow result, defaults to nullptr
+             * @return numerator representing this fraction on the new base, or std::numeric_limits<int_type>::max() if an overflow occurred.
+             */
+            constexpr int_type to_num_of(const int_type new_base_num, const uint_type new_base_denom, bool * overflow_ptr=nullptr) const noexcept {
+                int_type r;
+                if( mul_overflow(num, (int_type)new_base_denom, r) ) {
+                    if( nullptr != overflow_ptr ) {
+                        *overflow_ptr = true;
+                    }
+                    return std::numeric_limits<int_type>::max();
+                } else {
+                    if( nullptr != overflow_ptr ) {
+                        *overflow_ptr = false;
+                    }
+                    return r / (int_type)denom / new_base_num;
+                }
+            }
+
+            /**
+             * Convenient shortcut to `to_num_of(1_ms)`
+             * @return time in milliseconds
+             * @see to_num_of()
+             */
+            constexpr int_type to_ms() const noexcept { return to_num_of(1l, 1'000lu); }
+
+            /**
+             * Convenient shortcut to `to_num_of(1_ns)`
+             * @return time in nanoseconds
+             * @see to_num_of()
+             */
+            constexpr int_type to_ns() const noexcept { return to_num_of(1l, 1'000'000'000lu); }
+
+            /** Returns the converted fraction to lossy float */
+            constexpr float to_float() const noexcept { return (float)num / (float)denom; }
+
+            /** Returns the converted fraction to lossy double */
+            constexpr double to_double() const noexcept { return (double)num / (double)denom; }
+
+            /** Returns the converted fraction to lossy long double */
+            constexpr long double to_ldouble() const noexcept { return (long double)num / (long double)denom; }
+
+            /**
+             * Constructs a fraction from the given std::chrono::duration and its Rep and Period
+             * with smallest numerator and denominator using gcd()
+             *
+             * Note: sign is always stored in fraction's numerator, i.e. the denominator is always positive and hence unsigned.
+             *
+             * @tparam Rep Rep of given std::chrono::duration
+             * @tparam Period Period of given std::chrono::duration
+             * @param dur std::chrono::duration reference to convert into a fraction
+             */
+            template<typename Rep, typename Period>
+            constexpr fraction(const std::chrono::duration<Rep, Period>& dur) noexcept
+            : num(0), denom(1), overflow(false)
+            {
+                if( dur.count()*Period::num != 0 && Period::den != 0 ) {
+                    // calculate smallest num and denom, both arguments 'n' and 'd' may be negative
+                    const int_type n = dur.count()*Period::num;
+                    const int_type d = Period::den;
+                    const uint_type abs_d = abs(d);
+                    const uint_type _gcd = gcd<uint_type>( (uint_type)abs(n), abs_d );
+                    num = ( n * jau::sign(d) ) / (int_type)_gcd;
+                    denom = abs_d / _gcd;
+                }
+            }
+
+            /**
+             * Convert this fraction into std::chrono::duration with given Rep and Period
+             *
+             * If overflow_ptr is not nullptr, true is stored if an overflow occurred otherwise false.
+             *
+             * @tparam Rep std::chrono::duration numerator type
+             * @tparam Period std::chrono::duration denominator type, i.e. a std::ratio
+             * @param dur_ref std::chrono::duration reference to please automated template type deduction and ease usage
+             * @param overflow_ptr optional pointer to overflow result, defaults to nullptr
+             * @return fraction converted into given std::chrono::duration Rep and Period, or using (Rep)std::numeric_limits<Rep>::max() if an overflow occurred
+             */
+            template<typename Rep, typename Period>
+            std::chrono::duration<Rep, Period> to_duration(const std::chrono::duration<Rep, Period>& dur_ref, bool * overflow_ptr=nullptr) const noexcept {
+                (void)dur_ref; // just to please template type deduction
+                bool overflow_ = false;
+                const int_type num_ = to_num_of( fraction<int_type>( (int_type)Period::num, (uint_type)Period::den ), &overflow_ );
+                if( overflow_ ) {
+                    if( nullptr != overflow_ptr ) {
+                        *overflow_ptr = true;
+                    }
+                    return std::chrono::duration<Rep, Period>( (Rep)std::numeric_limits<Rep>::max() );
+                } else {
+                    if( nullptr != overflow_ptr ) {
+                        *overflow_ptr = false;
+                    }
+                    return std::chrono::duration<Rep, Period>( (Rep)num_ );
+                }
+            }
+
+            /**
+             * Returns a string representation of this fraction.
+             *
+             * If the overflow flag is set, ` O! ` will be appended.
+             *
+             * @param show_double true to show the double value, otherwise false (default)
+             * @return
+             */
+            std::string to_string(const bool show_double=false) const noexcept {
+                std::string r = std::to_string(num) + "/" + std::to_string(denom);
+                if( overflow ) {
+                    r.append(" O! ");
+                } else if( show_double ) {
+                    std::ostringstream out;
+                    out.precision( std::max<nsize_t>( 6, digits10(denom, false /* sign_is_digit */) ) );
+                    out << to_double();
+                    r.append(" ( " + out.str() + " )");
+                }
+                return r;
+            }
+
+            /**
+             * Returns true if numerator is zero.
+             */
+            constexpr bool is_zero() const noexcept {
+                return 0 == num;
+            }
+
+            /**
+             * Returns the value of the sign function applied to numerator.
+             * <pre>
+             * -1 for numerator < 0
+             *  0 for numerator = 0
+             *  1 for numerator > 0
+             * </pre>
+             * @return function result
+             */
+            constexpr snsize_t sign() const noexcept {
+                return sign(num);
+            }
+
+            /**
+             * Unary minus
+             *
+             * @return new instance with negated value, reduced
+             */
+            constexpr fraction<int_type> operator-() const noexcept {
+                fraction<int_type> r(*this);
+                r.num *= (int_type)-1;
+                return r;
+            }
+
+            /**
+             * Multiplication of this fraction's numerator with scalar in place.
+             *
+             * Operation may set the overflow flag if occurring.
+             *
+             * @param rhs the scalar
+             * @return reference to this instance, reduced
+             */
+            constexpr fraction<int_type>& operator*=(const int_type& rhs ) noexcept {
+                if( mul_overflow(num, rhs, num) ) {
+                    set_overflow();
+                    return *this;
+                } else {
+                    return reduce();
+                }
+            }
+
+            /**
+             * Division of this fraction's numerator with scalar in place.
+             *
+             * @param rhs the scalar
+             * @return reference to this instance, reduced
+             */
+            constexpr fraction<int_type>& operator/=(const int_type& rhs ) noexcept {
+                return this->operator/=(fraction<int_type>(rhs, (int_type)1));
+            }
+
+            /**
+             * Compound assignment (addition)
+             *
+             * Operation may set the overflow flag if occurring.
+             *
+             * @param rhs the other fraction
+             * @return reference to this instance, reduced
+             */
+            constexpr fraction<int_type>& operator+=(const fraction<int_type>& rhs ) noexcept {
+                if( denom == rhs.denom ) {
+                    num += rhs.num;
+                } else {
+                    uint_type _lcm;
+                    if( lcm_overflow<uint_type>(denom, rhs.denom, _lcm) ) {
+                        set_overflow();
+                        return *this;
+                    } else {
+                        const int_type num_new = ( num * (int_type)( _lcm / denom ) ) + ( rhs.num * (int_type)( _lcm / rhs.denom ) );
+                        num = num_new;
+                        denom = _lcm;
+                    }
+                }
+                return reduce();
+            }
+
+            /**
+             * Negative compound assignment (subtraction)
+             *
+             * Operation may set the overflow flag if occurring.
+             *
+             * @param rhs the other fraction
+             * @return reference to this instance, reduced
+             */
+            constexpr fraction<int_type>& operator-=(const fraction<int_type>& rhs ) noexcept {
+                if( denom == rhs.denom ) {
+                    num -= rhs.num;
+                } else {
+                    uint_type _lcm;
+                    if( lcm_overflow<uint_type>(denom, rhs.denom, _lcm) ) {
+                        set_overflow();
+                        return *this;
+                    } else {
+                        const int_type num_new = ( num * (int_type)( _lcm / denom ) ) - ( rhs.num * (int_type)( _lcm / rhs.denom ) );
+                        num = num_new;
+                        denom = _lcm;
+                    }
+                }
+                return reduce();
+            }
+
+
+            /**
+             * Multiplication in place.
+             *
+             * Operation may set the overflow flag if occurring.
+             *
+             * @param rhs the other fraction
+             * @return reference to this instance, reduced
+             */
+            constexpr fraction<int_type>& operator*=(const fraction<int_type>& rhs ) noexcept {
+                const uint_type gcd1 = gcd<uint_type>( (uint_type)abs(num),     rhs.denom );
+                const uint_type gcd2 = gcd<uint_type>( (uint_type)abs(rhs.num), denom );
+                const int_type n1 = num / (int_type)gcd1;
+                const int_type n2 = rhs.num / (int_type)gcd2;
+                const uint_type d1 = denom / gcd2;
+                const uint_type d2 = rhs.denom / gcd1;
+
+                if( mul_overflow(n1, n2, num) || mul_overflow(d1, d2, denom) ) {
+                    set_overflow();
+                }
+                return *this;
+            }
+
+            /**
+             * Division in place.
+             *
+             * @param rhs the other fraction
+             * @return reference to this instance, reduced
+             */
+            constexpr fraction<int_type>& operator/=(const fraction<int_type>& rhs ) noexcept {
+                // flipped rhs num and denom as compared to multiply
+                const uint_type abs_num2 = abs(rhs.num);
+                const uint_type gcd1 = gcd<uint_type>( (uint_type)abs(num),  abs_num2 );
+                const uint_type gcd2 = gcd<uint_type>(          rhs.denom ,  denom );
+
+                num = ( num / (int_type)gcd1 ) * jau::sign(rhs.num) * ( rhs.denom / (int_type)gcd2 );
+                denom = ( denom / gcd2 ) * ( abs_num2 / gcd1 );
+                return *this;
+            }
+    };
+
+    template<typename int_type>
+    inline std::string to_string(const fraction<int_type>& v) noexcept { return v.to_string(); }
+
+    template<typename int_type>
+    constexpr bool operator!=(const fraction<int_type>& lhs, const fraction<int_type>& rhs ) noexcept {
+        return lhs.denom != rhs.denom || lhs.num != rhs.num;
+    }
+
+    template<typename int_type>
+    constexpr bool operator==(const fraction<int_type>& lhs, const fraction<int_type>& rhs ) noexcept {
+        return !( lhs != rhs );
+    }
+
+    template<typename int_type>
+    constexpr bool operator>(const fraction<int_type>& lhs, const fraction<int_type>& rhs ) noexcept {
+        return lhs.num * (int_type)rhs.denom > (int_type)lhs.denom * rhs.num;
+    }
+
+    template<typename int_type>
+    constexpr bool operator>=(const fraction<int_type>& lhs, const fraction<int_type>& rhs ) noexcept {
+        return lhs.num * (int_type)rhs.denom >= (int_type)lhs.denom * rhs.num;
+    }
+
+    template<typename int_type>
+    constexpr bool operator<(const fraction<int_type>& lhs, const fraction<int_type>& rhs ) noexcept {
+        return lhs.num * (int_type)rhs.denom < (int_type)lhs.denom * rhs.num;
+    }
+
+    template<typename int_type>
+    constexpr bool operator<=(const fraction<int_type>& lhs, const fraction<int_type>& rhs ) noexcept {
+        return lhs.num * (int_type)rhs.denom <= (int_type)lhs.denom * rhs.num;
+    }
+
+    /** Return the maximum of the two given fractions */
+    template<typename int_type>
+    constexpr const fraction<int_type>& max(const fraction<int_type>& lhs, const fraction<int_type>& rhs ) noexcept {
+        return lhs >= rhs ? lhs : rhs;
+    }
+
+    /** Return the minimum of the two given fractions */
+    template<typename int_type>
+    constexpr const fraction<int_type>& min(const fraction<int_type>& lhs, const fraction<int_type>& rhs ) noexcept {
+        return lhs <= rhs ? lhs : rhs;
+    }
+
+    /**
+     * Returns the value of the sign function applied to numerator.
+     * <pre>
+     * -1 for numerator < 0
+     *  0 for numerator = 0
+     *  1 for numerator > 0
+     * </pre>
+     * @return function result
+     */
+    template<typename int_type>
+    constexpr snsize_t sign(const fraction<int_type>& rhs) noexcept {
+        return sign(rhs.num);
+    }
+
+    /**
+     * Returns the absolute fraction
+     */
+    template<typename int_type>
+    constexpr fraction<int_type> abs(const fraction<int_type>& rhs) noexcept {
+        fraction<int_type> copy(rhs); // skip normalize
+        copy.num = abs(rhs.num);
+        return copy;
+    }
+
+    /**
+     * Returns multiplication of fraction with scalar.
+     *
+     * Operation may set the overflow flag in the returned instance, if occurring.
+     *
+     * @tparam int_type integral type
+     * @param lhs the fraction
+     * @param rhs the scalar
+     * @return resulting new fraction, reduced
+     */
+    template<typename int_type>
+    constexpr fraction<int_type> operator*(const fraction<int_type>& lhs, const int_type& rhs ) noexcept {
+        return fraction<int_type>( lhs.num*rhs, lhs.denom );
+    }
+
+    /**
+     * Returns multiplication of fraction with scalar.
+     *
+     * Operation may set the overflow flag in the returned instance, if occurring.
+     *
+     * @tparam int_type integral type
+     * @param lhs the scalar
+     * @param rhs the fraction
+     * @return resulting new fraction, reduced
+     */
+    template<typename int_type>
+    constexpr fraction<int_type> operator*(const int_type& lhs, const fraction<int_type>& rhs) noexcept {
+        return fraction<int_type>( rhs.num*lhs, rhs.denom );
+    }
+
+    /**
+     * Returns division of fraction with scalar.
+     * @tparam int_type integral type
+     * @param lhs the fraction
+     * @param rhs the scalar
+     * @return resulting new fraction, reduced
+     */
+    template<typename int_type>
+    constexpr fraction<int_type> operator/(const fraction<int_type>& lhs, const int_type& rhs ) noexcept {
+        fraction<int_type> r(lhs);
+        return r /= rhs;
+    }
+
+    /**
+     * Returns division of fraction with scalar.
+     * @tparam int_type integral type
+     * @param lhs the scalar
+     * @param rhs the fraction
+     * @return resulting new fraction, reduced
+     */
+    template<typename int_type>
+    constexpr fraction<int_type> operator/(const int_type& lhs, const fraction<int_type>& rhs) noexcept {
+        fraction<int_type> r( lhs, (int_type)1 );
+        return r /= rhs;
+    }
+
+    /**
+     * Returns sum of two fraction.
+     *
+     * Operation may set the overflow flag in the returned instance, if occurring.
+     *
+     * @tparam int_type integral type
+     * @param lhs a fraction
+     * @param rhs a fraction
+     * @return resulting new fraction, reduced
+     */
+    template<typename int_type>
+    constexpr fraction<int_type> operator+(const fraction<int_type>& lhs, const fraction<int_type>& rhs ) noexcept {
+        fraction<int_type> r(lhs);
+        r += rhs; // implicit reduce
+        return r;
+    }
+
+    /**
+     * Returns difference of two fraction.
+     *
+     * Operation may set the overflow flag in the returned instance, if occurring.
+     *
+     * @tparam int_type integral type
+     * @param lhs a fraction
+     * @param rhs a fraction
+     * @return resulting new fraction, reduced
+     */
+    template<typename int_type>
+    constexpr fraction<int_type> operator-(const fraction<int_type>& lhs, const fraction<int_type>& rhs ) noexcept {
+        fraction<int_type> r(lhs);
+        r -= rhs; // implicit reduce
+        return r;
+    }
+
+    /**
+     * Returns product of two fraction.
+     *
+     * Operation may set the overflow flag in the returned instance, if occurring.
+     *
+     * @tparam int_type integral type
+     * @param lhs a fraction
+     * @param rhs a fraction
+     * @return resulting new fraction, reduced
+     */
+    template<typename int_type>
+    constexpr fraction<int_type> operator*(const fraction<int_type>& lhs, const fraction<int_type>& rhs ) noexcept {
+        fraction<int_type> r(lhs);
+        r *= rhs; // implicit reduce
+        return r;
+    }
+
+    /**
+     * Returns division of two fraction.
+     * @tparam int_type integral type
+     * @param lhs a fraction
+     * @param rhs a fraction
+     * @return resulting new fraction, reduced
+     */
+    template<typename int_type>
+    constexpr fraction<int_type> operator/(const fraction<int_type>& lhs, const fraction<int_type>& rhs ) noexcept {
+        fraction<int_type> r(lhs);
+        r /= rhs; // implicit reduce
+        return r;
+    }
+
+    /** fraction using int64_t as integral type */
+    typedef fraction<int64_t> fraction_i64;
+
+    /**
+     * Stores the fraction_i64 value of the given string value in format `<num>/<denom>`,
+     * which may contain whitespace.
+     *
+     * It the given string value does not conform with the format
+     * or exceeds the given value range, `false` is being returned.
+     *
+     * If the given string value has been accepted, it is stored in the result reference
+     * and `true` is being returned.
+     *
+     * @param result storage for result is value is parsed successfully and within range.
+     * @param value the string value
+     * @param min_allowed the minimum allowed value
+     * @param max_allowed the maximum allowed value
+     * @return true if value has been accepted, otherwise false
+     */
+    bool to_fraction_i64(fraction_i64& result, const std::string & value, const fraction_i64& min_allowed, const fraction_i64& max_allowed) noexcept;
+
+
+    /** fraction using uint64_t as integral type */
+    typedef fraction<uint64_t> fraction_u64;
+
+    /** fractions namespace to provide fraction constants using int64_t as underlying integral integer type. */
+    namespace fractions_i64 { // Note: int64_t == intmax_t -> 10^18 or 19 digits (for intmax_t on 64bit platforms)
+        /** tera is 10^12 */
+        inline constexpr const jau::fraction_i64 tera ( 1'000'000'000'000l,                 1lu );
+        /** giga is 10^9 */
+        inline constexpr const jau::fraction_i64 giga (     1'000'000'000l,                 1lu );
+        /** mega is 10^6 */
+        inline constexpr const jau::fraction_i64 mega (         1'000'000l,                 1lu );
+        /** days is 86400/1 */
+        inline constexpr const jau::fraction_i64 days (            86'400l,                 1lu );
+        /** hours is 3660/1 */
+        inline constexpr const jau::fraction_i64 hours (            3'600l,                 1lu );
+        /** kilo is 10^3 */
+        inline constexpr const jau::fraction_i64 kilo (             1'000l,                 1lu );
+        /** minutes is 60/1 */
+        inline constexpr const jau::fraction_i64 minutes (             60l,                 1lu );
+        /** seconds is 1/1 */
+        inline constexpr const jau::fraction_i64 seconds (              1l,                 1lu );
+        /** one is 10^0 or 1/1 */
+        inline constexpr const jau::fraction_i64 one  (                 1l,                 1lu );
+        /** zero is 0/1 */
+        inline constexpr const jau::fraction_i64 zero (                 0l,                 1lu );
+        /** milli is 10^-3 */
+        inline constexpr const jau::fraction_i64 milli(                 1l,             1'000lu );
+        /** micro is 10^-6 */
+        inline constexpr const jau::fraction_i64 micro(                 1l,         1'000'000lu );
+        /** nano is 10^-9 */
+        inline constexpr const jau::fraction_i64 nano (                 1l,     1'000'000'000lu );
+        /** pico is 10^-12 */
+        inline constexpr const jau::fraction_i64 pico (                 1l, 1'000'000'000'000lu );
+    } // namespace fractions_i64
+
+    namespace fractions_i64_literals {
+        /** Literal for fractions_i64::tera */
+        constexpr fraction_i64 operator ""_T(unsigned long long int __T)     { return (int64_t)__T    * fractions_i64::tera; }
+        /** Literal for fractions_i64::giga */
+        constexpr fraction_i64 operator ""_G(unsigned long long int __G)     { return (int64_t)__G    * fractions_i64::giga; }
+        /** Literal for fractions_i64::mega */
+        constexpr fraction_i64 operator ""_M(unsigned long long int __M)     { return (int64_t)__M    * fractions_i64::mega; }
+        /** Literal for fractions_i64::kilo */
+        constexpr fraction_i64 operator ""_k(unsigned long long int __k)     { return (int64_t)__k    * fractions_i64::kilo; }
+        /** Literal for fractions_i64::one */
+        constexpr fraction_i64 operator ""_one(unsigned long long int __one) { return (int64_t)__one  * fractions_i64::one; }
+        /** Literal for fractions_i64::milli */
+        constexpr fraction_i64 operator ""_m(unsigned long long int __m)     { return (int64_t)__m    * fractions_i64::milli; }
+        /** Literal for fractions_i64::micro */
+        constexpr fraction_i64 operator ""_u(unsigned long long int __u)     { return (int64_t)__u    * fractions_i64::micro; }
+        /** Literal for fractions_i64::nano */
+        constexpr fraction_i64 operator ""_n(unsigned long long int __n)     { return (int64_t)__n    * fractions_i64::nano; }
+        /** Literal for fractions_i64::pico */
+        constexpr fraction_i64 operator ""_p(unsigned long long int __p)     { return (int64_t)__p    * fractions_i64::pico; }
+
+        /** Literal for fractions_i64::days */
+        constexpr fraction_i64 operator ""_d(unsigned long long int __d)     { return (int64_t)__d    * fractions_i64::days; }
+        /** Literal for fractions_i64::hours */
+        constexpr fraction_i64 operator ""_h(unsigned long long int __h)     { return (int64_t)__h    * fractions_i64::hours; }
+        /** Literal for fractions_i64::minutes */
+        constexpr fraction_i64 operator ""_min(unsigned long long int __min) { return (int64_t)__min  * fractions_i64::minutes; }
+        /** Literal for fractions_i64::seconds */
+        constexpr fraction_i64 operator ""_s(unsigned long long int __s)     { return (int64_t)__s    * fractions_i64::seconds; }
+        /** Literal for fractions_i64::milli */
+        constexpr fraction_i64 operator ""_ms(unsigned long long int __ms)   { return (int64_t)__ms   * fractions_i64::milli; }
+        /** Literal for fractions_i64::micro */
+        constexpr fraction_i64 operator ""_us(unsigned long long int __us)   { return (int64_t)__us   * fractions_i64::micro; }
+        /** Literal for fractions_i64::nano */
+        constexpr fraction_i64 operator ""_ns(unsigned long long int __ns)   { return (int64_t)__ns   * fractions_i64::nano; }
+    } // namespace fractions_i64_literals
+
+    /**
+     * Timespec structure using fraction_i64 for its components
+     * in analogy to `struct timespec_t`.
+     *
+     * fraction_timespec allows to cover an almost infinite range of time
+     * while maintaining high precision like `struct timespec_t`.
+     *
+     * Note: Counting nanoseconds in int64_t only lasts until `2262-04-12`,
+     * since INT64_MAX is 9'223'372'036'854'775'807 for 9'223'372'036 seconds or 292 years.
+     *
+     * If used as time-point, zero is time since Unix Epoch `00:00:00 UTC on 1970-01-01`.
+     *
+     * @see to_fraction_i64()
+     * @see getMonotonicTime()
+     */
+    struct fraction_timespec {
+        /**
+         * Seconds component, with its absolute value in range [0..inf[ or [0..inf).
+         */
+        int64_t tv_sec;
+
+        /**
+         * Positive fraction of seconds for the nanoseconds component,
+         * where its value shall be in range [0..1'000'000'000[ or [0..1'000'000'000).
+         */
+        int64_t tv_nsec;
+
+        /**
+         * Constructs a zero fraction_timespec instance
+         */
+        constexpr fraction_timespec() noexcept
+        : tv_sec(0), tv_nsec(0) { }
+
+        /**
+         * Constructs a fraction_timespec instance with given components, normalized.
+         */
+        constexpr fraction_timespec(const int64_t& s, const int64_t ns) noexcept
+        : tv_sec(s), tv_nsec(ns) { normalize(); }
+
+        /**
+         * Construct a fraction_timespec via fraction_i64 conversion.
+         *
+         * If overflow_ptr is not nullptr, true is stored if an overflow occurred, otherwise false.
+         *
+         * In case of an overflow, tv_sec and tv_nsec will also be set to INT64_MAX
+         *
+         * @param r the conversion input
+         * @param overflow_ptr optional pointer to overflow result, defaults to nullptr
+         */
+        constexpr fraction_timespec(const fraction_i64& r, bool * overflow_ptr=nullptr) noexcept
+        : tv_sec(0), tv_nsec(0)
+        {
+            bool overflow = false;
+            tv_sec = r.to_num_of(fractions_i64::seconds, &overflow);
+            if( !overflow ) {
+                const fraction_i64 ns = r - tv_sec * fractions_i64::seconds;
+                tv_nsec = ns.to_num_of(fractions_i64::nano, &overflow);
+            }
+            if( overflow ) {
+                if( nullptr != overflow_ptr ) {
+                    *overflow_ptr = true;
+                }
+                tv_sec = INT64_MAX;
+                tv_nsec = INT64_MAX;
+            }
+        }
+
+        /**
+         * Returns the sum of both components.
+         *
+         * If applied to relative duration, i.e. difference of two time points,
+         * its range is good for 292 years and exceeds that of an `int64_t nanoseconds` timepoint-difference greatly.
+         *
+         * <pre>
+         *   fraction_timespec t0 = getMonotonicTime();
+         *   // do something
+         *
+         *   // Exact duration
+         *   fraction_timespec td_1 = getMonotonicTime() - t0;
+         *
+         *   // or for durations <= 292 years
+         *   fraction_i64 td_2 = (getMonotonicTime() - t0).to_fraction_i64();
+         * </pre>
+         * @see getMonotonicTime()
+         */
+        constexpr fraction_i64 to_fraction_i64() const noexcept {
+            return ( tv_sec * fractions_i64::seconds ) + ( tv_nsec * fractions_i64::nano );
+        }
+
+        /**
+         * Normalize tv_nsec to be in range [0..1'000'000'000[ or [0..1'000'000'000),
+         * used after an arithmetic operation.
+         *
+         * @returns reference to this instance
+         */
+        constexpr fraction_timespec& normalize() noexcept {
+            using namespace jau::int_literals;
+            const int64_t ns_per_sec = 1'000'000'000_i64;
+            if( tv_nsec < 0 ) {
+                tv_nsec += ns_per_sec;
+                tv_sec -= 1;
+            } else if( tv_nsec >= ns_per_sec ) {
+                const int64_t c = tv_nsec / ns_per_sec;
+                tv_nsec -= c * ns_per_sec;
+                tv_sec += c;
+            }
+            return *this;
+        }
+
+        /**
+         * Compound assignment (addition)
+         *
+         * @param rhs the other fraction_timespec
+         * @return reference to this instance, normalized
+         */
+        constexpr fraction_timespec& operator+=(const fraction_timespec& rhs ) noexcept {
+            tv_sec += rhs.tv_sec;
+            tv_nsec += rhs.tv_nsec;
+            return normalize();
+        }
+
+        /**
+         * Negative compound assignment (subtraction)
+         *
+         * @param rhs the other fraction_timespec
+         * @return reference to this instance, normalized
+         */
+        constexpr fraction_timespec& operator-=(const fraction_timespec& rhs ) noexcept {
+            tv_sec -= rhs.tv_sec;
+            tv_nsec -= rhs.tv_nsec;
+            return normalize();
+        }
+
+        std::string to_string() const noexcept {
+            return std::to_string(tv_sec) + "s + " + std::to_string(tv_nsec) + "ns";
+        }
+    };
+
+    inline std::string to_string(const fraction_timespec& v) noexcept { return v.to_string(); }
+
+
+    constexpr bool operator!=(const fraction_timespec& lhs, const fraction_timespec& rhs ) noexcept {
+        return lhs.tv_sec != rhs.tv_sec || lhs.tv_nsec != rhs.tv_nsec;
+    }
+
+    constexpr bool operator==(const fraction_timespec& lhs, const fraction_timespec& rhs ) noexcept {
+        return !( lhs != rhs );
+    }
+
+    constexpr bool operator>(const fraction_timespec& lhs, const fraction_timespec& rhs ) noexcept {
+        return ( lhs.tv_sec > rhs.tv_sec ) || ( lhs.tv_sec == rhs.tv_sec && lhs.tv_nsec > rhs.tv_nsec );
+    }
+
+    constexpr bool operator>=(const fraction_timespec& lhs, const fraction_timespec& rhs ) noexcept {
+        return ( lhs.tv_sec > rhs.tv_sec ) || ( lhs.tv_sec == rhs.tv_sec && lhs.tv_nsec >= rhs.tv_nsec );
+    }
+
+    constexpr bool operator<(const fraction_timespec& lhs, const fraction_timespec& rhs ) noexcept {
+        return ( lhs.tv_sec < rhs.tv_sec ) || ( lhs.tv_sec == rhs.tv_sec && lhs.tv_nsec < rhs.tv_nsec );
+    }
+
+    constexpr bool operator<=(const fraction_timespec& lhs, const fraction_timespec& rhs ) noexcept {
+        return ( lhs.tv_sec < rhs.tv_sec ) || ( lhs.tv_sec == rhs.tv_sec && lhs.tv_nsec <= rhs.tv_nsec );
+    }
+
+    /** Return the maximum of the two given fraction_timespec */
+    constexpr const fraction_timespec& max(const fraction_timespec& lhs, const fraction_timespec& rhs ) noexcept {
+        return lhs >= rhs ? lhs : rhs;
+    }
+
+    /** Return the minimum of the two given fraction_timespec */
+    constexpr const fraction_timespec& min(const fraction_timespec& lhs, const fraction_timespec& rhs ) noexcept {
+        return lhs <= rhs ? lhs : rhs;
+    }
+
+    /**
+     * Returns sum of two fraction_timespec.
+     *
+     * @param lhs a fraction_timespec
+     * @param rhs a fraction_timespec
+     * @return resulting new fraction_timespec, each component reduced and both fraction_timespec::normalize() 'ed
+     */
+    constexpr fraction_timespec operator+(const fraction_timespec& lhs, const fraction_timespec& rhs ) noexcept {
+        fraction_timespec r(lhs);
+        r += rhs; // implicit normalize
+        return r;
+    }
+
+    /**
+     * Returns difference of two fraction_timespec.
+     *
+     * See fraction_timespec::to_fraction_i64().
+     *
+     * @param lhs a fraction_timespec
+     * @param rhs a fraction_timespec
+     * @return resulting new fraction_timespec, each component reduced and both fraction_timespec::normalize() 'ed
+     */
+    constexpr fraction_timespec operator-(const fraction_timespec& lhs, const fraction_timespec& rhs ) noexcept {
+        fraction_timespec r(lhs);
+        r -= rhs; // implicit normalize
+        return r;
+    }
+
+    namespace fraction_tv {
+
+        /** jau::fraction_timespec zero is { 0, 0 } */
+        inline constexpr const jau::fraction_timespec zero(0, 0);
+
+    } // namespace fraction_tv
+
+    /** SC atomic integral scalar jau::fraction_i64. Memory-Model (MM) guaranteed sequential consistency (SC) between acquire (read) and release (write). Requires libatomic with libstdc++10. */
+    typedef ordered_atomic<jau::fraction_i64, std::memory_order_seq_cst> sc_atomic_fraction_i64;
+
+    /** Relaxed non-SC atomic integral scalar jau::fraction_i64. Memory-Model (MM) only guarantees the atomic value, _no_ sequential consistency (SC) between acquire (read) and release (write). Requires libatomic with libstdc++10. */
+    typedef ordered_atomic<jau::fraction_i64, std::memory_order_relaxed> relaxed_atomic_fraction_i64;
+
+    /** SC atomic integral scalar jau::fraction_u64. Memory-Model (MM) guaranteed sequential consistency (SC) between acquire (read) and release (write). Requires libatomic with libstdc++10. */
+    typedef ordered_atomic<jau::fraction_u64, std::memory_order_seq_cst> sc_atomic_fraction_u64;
+
+    /** Relaxed non-SC atomic integral scalar jau::fraction_u64. Memory-Model (MM) only guarantees the atomic value, _no_ sequential consistency (SC) between acquire (read) and release (write). Requires libatomic with libstdc++10. */
+    typedef ordered_atomic<jau::fraction_u64, std::memory_order_relaxed> relaxed_atomic_fraction_u64;
+
+} // namespace jau
+
+namespace std {
+
+    inline std::ostream& operator<<(std::ostream& os, const jau::fraction_timespec& v) noexcept {
+        os << v.to_string();
+        return os;
+    }
+
+    template<typename int_type>
+    inline std::ostream& operator<<(std::ostream& os, const jau::fraction<int_type>& v) noexcept {
+        os << v.to_string();
+        return os;
+    }
+} // namespace std
+
+#endif /* JAU_FRACTION_TYPE_HPP_ */
diff --git a/include/jau/int_math.hpp b/include/jau/int_math.hpp
index a6d5abe..5259569 100644
--- a/include/jau/int_math.hpp
+++ b/include/jau/int_math.hpp
@@ -231,6 +231,96 @@ namespace jau {
     }
 
     /**
+     * Returns the greatest common divisor (GCD) of the two given integer values following Euclid's algorithm from Euclid's Elements ~300 BC,
+     * using the absolute positive value of given integers.
+     *
+     * Returns zero if a and b is zero.
+     *
+     * Note implementation uses modulo operator `(a/b)*b + a%b = a`,
+     * i.e. remainder of the integer division - hence implementation uses abs(a)%abs(b) to avoid negative numbers.
+     *
+     * Implementation is similar to std::gcd(), however, it uses a fixed common type T
+     * and a while loop instead of recursion.
+     *
+     * @tparam T integral type
+     * @tparam
+     * @param a integral value a
+     * @param b integral value b
+     * @return zero if a and b are zero, otherwise the greatest common divisor (GCD) of a and b,
+     */
+    template <typename T,
+              std::enable_if_t<  std::is_integral_v<T> &&
+                                !std::is_unsigned_v<T>, bool> = true>
+    constexpr T gcd(T a, T b) noexcept
+    {
+        T a_ = abs(a);
+        T b_ = abs(b);
+        while( b_ != 0 ) {
+            const T t = b_;
+            b_ = a_ % b_;
+            a_ = t;
+        }
+        return a_;
+    }
+
+    /**
+     * Returns the greatest common divisor (GCD) of the two given positive integer values following Euclid's algorithm from Euclid's Elements ~300 BC.
+     *
+     * Returns zero if a and b is zero.
+     *
+     * Since both operands are of type unsigned, no negative numbers can be produced by the modulo operator.
+     *
+     * Implementation is similar to std::gcd(), however, it uses a fixed common type T
+     * and a while loop instead of recursion.
+     *
+     * @tparam T integral type
+     * @tparam
+     * @param a positive integral value a
+     * @param b positive integral value b
+     * @return zero if a and b are zero, otherwise the greatest common divisor (GCD) of a and b,
+     */
+    template <typename T,
+              std::enable_if_t< std::is_integral_v<T> &&
+                                std::is_unsigned_v<T>, bool> = true>
+    constexpr T gcd(T a, T b) noexcept
+    {
+        while( b != 0 ) {
+            const T t = b;
+            b = a % b;
+            a = t;
+        }
+        return a;
+    }
+
+    /**
+     * Integer overflow aware calculation of least common multiple (LCM) following Euclid's algorithm from Euclid's Elements ~300 BC.
+     * @tparam T integral type
+     * @tparam
+     * @param result storage for lcm result: zero if a and b are zero, otherwise lcm of a and b
+     * @param a integral value a
+     * @param b integral value b
+     * @return true if overflow, otherwise false for success
+     */
+    template <typename T,
+              std::enable_if_t<  std::is_integral_v<T>, bool> = true>
+    constexpr bool lcm_overflow(const T a, const T b, T& result) noexcept
+    {
+        const T _gcd = gcd<T>( a, b );
+        if( 0 < _gcd ) {
+            T r;
+            if( mul_overflow(a, b, r) ) {
+                return true;
+            } else {
+                result = r / _gcd;
+                return false;
+            }
+        } else {
+            result = 0;
+            return false;
+        }
+    }
+
+    /**
      * Returns the number of decimal digits of the given integral value number using std::log10<T>().<br>
      * If sign_is_digit == true (default), treats a potential negative sign as a digit.
      * <pre>
diff --git a/src/basic_types.cpp b/src/basic_types.cpp
index e761bbc..6e14c61 100644
--- a/src/basic_types.cpp
+++ b/src/basic_types.cpp
@@ -277,3 +277,76 @@ std::string jau::to_string(const endian& v) noexcept {
     return "unlisted";
 }
 
+static bool to_integer(long long & result, const char * str, size_t str_len, const char limiter, const char *limiter_pos) {
+    static constexpr const bool _debug = false;
+    char *endptr = NULL;
+    if( nullptr == limiter_pos ) {
+        limiter_pos = str + str_len;
+    }
+    const long long num = std::strtoll(str, &endptr, 10);
+    if( 0 != errno ) {
+        // value under- or overflow occured
+        if constexpr ( _debug ) {
+            INFO_PRINT("Value under- or overflow occurred, value %lld in: '%s', errno %d %s", num, str, errno, strerror(errno));
+        }
+        return false;
+    }
+    if( nullptr == endptr || endptr == str ) {
+        // no digits consumed
+        if constexpr ( _debug ) {
+            INFO_PRINT("Value no digits consumed @ idx %d, %p == start, in: '%s'", endptr-str, endptr, str);
+        }
+        return false;
+    }
+    if( endptr < limiter_pos ) {
+        while( endptr < limiter_pos && ::isspace(*endptr) ) { // only accept whitespace
+            ++endptr;
+        }
+    }
+    if( *endptr != limiter || endptr != limiter_pos ) {
+        // numerator value not completely valid
+        if constexpr ( _debug ) {
+            INFO_PRINT("Value end not '%c' @ idx %d, %p != %p, in: %p '%s' len %zd", limiter, endptr-str, endptr, limiter_pos, str, str, str_len);
+        }
+        return false;
+    }
+    result = num;
+    return true;
+}
+
+bool jau::to_fraction_i64(fraction_i64& result, const std::string & value, const fraction_i64& min_allowed, const fraction_i64& max_allowed) noexcept {
+    static constexpr const bool _debug = false;
+    const char * str = const_cast<const char*>(value.c_str());
+    const size_t str_len = value.length();
+    const char *divptr = NULL;
+
+    divptr = std::strstr(str, "/");
+    if( nullptr == divptr ) {
+        if constexpr ( _debug ) {
+            INFO_PRINT("Missing '/' in: '%s'", str);
+        }
+        return false;
+    }
+
+    long long num;
+    if( !to_integer(num, str, str_len, '/', divptr) ) {
+        return false;
+    }
+
+    long long denom; // 0x7ffc7090d904 != 0x7ffc7090d907 " 10 / 1000000 "
+    if( !to_integer(denom, divptr+1, str_len-(divptr-str)-1, '\0', str + str_len) ) {
+        return false;
+    }
+
+    fraction_i64 temp((int64_t)num, (uint64_t)denom);
+    if( ! ( min_allowed <= temp && temp <= max_allowed ) ) {
+        // invalid user value range
+        if constexpr ( _debug ) {
+            INFO_PRINT("Numerator out of range, not %s <= %s <= %s, in: '%s'", min_allowed.to_string().c_str(), temp.to_string().c_str(), max_allowed.to_string().c_str(), str);
+        }
+        return false;
+    }
+    result = std::move(temp);
+    return true;
+}
+
diff --git a/src/environment.cpp b/src/environment.cpp
index 84e4b1d..3e3699b 100644
--- a/src/environment.cpp
+++ b/src/environment.cpp
@@ -37,6 +37,7 @@
 using namespace jau;
 
 const uint64_t environment::startupTimeMilliseconds = jau::getCurrentMilliseconds();
+const fraction_timespec environment::startupTimeMonotonic = jau::getMonotonicTime();
 
 bool environment::local_debug = false;
 
@@ -171,6 +172,22 @@ uint32_t environment::getUint32Property(const std::string & name, const uint32_t
     }
 }
 
+fraction_i64 environment::getFractionProperty(const std::string & name, const fraction_i64& default_value,
+                                              const fraction_i64& min_allowed, const fraction_i64& max_allowed) noexcept {
+    const std::string value = getProperty(name);
+    if( 0 == value.length() ) {
+        COND_PRINT(local_debug, "env::getFractionProperty %s: null -> %s (default)", name.c_str(), default_value.to_string().c_str());
+        return default_value;
+    } else {
+        fraction_i64 result = default_value;
+        if( !to_fraction_i64(result, value, min_allowed, max_allowed) ) {
+            ERR_PRINT("env::getFractionProperty %s: value %s not valid or in range[%s .. %s] -> %s (default)",
+                    name.c_str(), value.c_str(), min_allowed.to_string().c_str(), max_allowed.to_string().c_str(), default_value.to_string().c_str());
+        }
+        return result;
+    }
+}
+
 void environment::envSet(std::string prefix_domain, std::string basepair) noexcept {
     trimInPlace(basepair);
     if( basepair.length() > 0 ) {
diff --git a/test/test_fractions_01.cpp b/test/test_fractions_01.cpp
new file mode 100644
index 0000000..b297f8f
--- /dev/null
+++ b/test/test_fractions_01.cpp
@@ -0,0 +1,734 @@
+/*
+ * Author: Sven Gothel <[email protected]>
+ * Copyright (c) 2022 Gothel Software e.K.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+#include <iostream>
+#include <thread>
+#include <cassert>
+#include <cinttypes>
+#include <cstring>
+
+#define CATCH_CONFIG_RUNNER
+// #define CATCH_CONFIG_MAIN
+#include <catch2/catch_amalgamated.hpp>
+#include <jau/test/catch2_ext.hpp>
+
+#include <jau/basic_types.hpp>
+
+using namespace jau;
+using namespace jau::fractions_i64_literals;
+using namespace jau::int_literals;
+
+#if 0
+static fraction<int64_t> ratio_multiply(const fraction<int64_t>& r1, const fraction<int64_t>& r2) {
+    const uint64_t gcd1 = gcd<uint64_t>((uint64_t)abs(r1.num), r2.denom);
+    const uint64_t gcd2 = gcd<uint64_t>((uint64_t)abs(r2.num), r1.denom);
+
+    return fraction<int64_t>( ( r1.num / gcd1 ) * ( r2.num / gcd2),
+                              ( r1.denom / gcd2 ) * ( r2.denom / gcd1) );
+}
+
+static fraction<int64_t> ratio_divide(const fraction<int64_t>& r1, const fraction<int64_t>& r2) {
+    return ratio_multiply(r1, fraction<int64_t>(r2.denom, r2.num));
+}
+
+static fraction<int64_t> duration_common_type(const fraction<int64_t>& p1, const fraction<int64_t>& p2) {
+    const uint64_t gcd_num = gcd<uint64_t>((uint64_t)abs(p1.num), (uint64_t)abs(p2.num));
+    const uint64_t gcd_den = gcd<uint64_t>(p1.denom, p2.denom);
+    return fraction<int64_t>( gcd_num * jau::sign(p1.num) * jau::sign(p2.num), ( p1.denom / gcd_den ) * p2.denom );
+}
+#endif
+
+
+template<typename int_type>
+static void test_gcd_fract(const int_type n, const std::make_unsigned_t<int_type> d,
+                           const int_type exp_gcd, const int_type exp_num, const std::make_unsigned_t<int_type> exp_denom) {
+    {
+        const int_type n1 = sign(n) * abs(n);
+        const std::make_unsigned_t<int_type> d1 = sign(d) * abs(d);
+        REQUIRE( n == n1 );
+        REQUIRE( d == d1 );
+    }
+
+    const int_type _gcd = gcd( n, static_cast<int_type>(d) );
+    REQUIRE( exp_gcd == _gcd );
+
+    fraction<int_type> f1(n, d);
+    REQUIRE( exp_num == f1.num );
+    REQUIRE( exp_denom == f1.denom);
+}
+
+template<typename int_type>
+static void test_gcd_fract_pm(const int_type n, const std::make_unsigned_t<int_type> d,
+                              const int_type exp_gcd, const int_type exp_num, const std::make_unsigned_t<int_type> exp_denom) {
+    test_gcd_fract( n,  d,  exp_gcd,  exp_num,  exp_denom);
+    test_gcd_fract(-n,  d,  exp_gcd, -exp_num,  exp_denom);
+}
+
+template<typename int_type>
+static void test_comp_fract(const fraction<int_type>& a, const fraction<int_type>& b,
+                            const fraction<int_type>& exp_max, const fraction<int_type>& exp_min,
+                            const fraction<int_type>& exp_sum, const fraction<int_type>& exp_diff,
+                            const fraction<int_type>& exp_mul, const fraction<int_type>& exp_div)
+{
+    const bool show_double = true;
+    INFO_STR( "max(a "+a.to_string(show_double)+", b "+b.to_string(show_double)+") = "+max(a,b).to_string(show_double));
+    INFO_STR( "min(a "+a.to_string(show_double)+", b "+b.to_string(show_double)+") = "+min(a,b).to_string(show_double));
+    INFO_STR( "a "+a.to_string(show_double)+" + b "+b.to_string(show_double)+" = "+(a+b).to_string(show_double));
+    INFO_STR( "a "+a.to_string(show_double)+" - b "+b.to_string(show_double)+" = "+(a-b).to_string(show_double));
+    INFO_STR( "a "+a.to_string(show_double)+" * b "+b.to_string(show_double)+" = "+(a*b).to_string(show_double));
+    INFO_STR( "a "+a.to_string(show_double)+" / b "+b.to_string(show_double)+" = "+(a/b).to_string(show_double));
+    {
+        const double epsilon = std::numeric_limits<double>::epsilon();
+        const double ad = a.to_double();
+        const double bd = b.to_double();
+        if( std::abs( ad - bd ) <= epsilon ) {
+            REQUIRE(   a == b );
+            REQUIRE( !(a != b) );
+            REQUIRE(   a <= b );
+            REQUIRE(   a >= b );
+        } else if( std::abs( ad - bd ) > epsilon ) {
+            REQUIRE(   a != b );
+            REQUIRE( !(a == b) );
+            if( ad - bd < -epsilon ) {
+                REQUIRE( a <  b );
+                REQUIRE( a <= b );
+                REQUIRE( b >  a );
+                REQUIRE( b >= a );
+            } else {
+                REQUIRE( a >  b );
+                REQUIRE( a >= b );
+                REQUIRE( b <  a );
+                REQUIRE( b <= a );
+            }
+        }
+    }
+    {
+        fraction<int_type> has_max = max(a, b);
+        fraction<int_type> has_min = min(a, b);
+        REQUIRE_MSG( "exp "+to_string(exp_max)+" == has "+to_string(has_max), exp_max == has_max );
+        REQUIRE_MSG( "exp "+to_string(exp_min)+" == has "+to_string(has_min), exp_min == has_min );
+        REQUIRE( has_max >= has_min );
+        REQUIRE( has_min <= has_max );
+    }
+    {
+        const fraction<int_type> has_sum = a + b;
+        const double exp_double = a.to_double() + b.to_double();
+        const double has_double = has_sum.to_double();
+        REQUIRE_MSG( "exp "+std::to_string(exp_double)+" == has "+std::to_string(has_double), abs( exp_double - has_double ) <= std::numeric_limits<double>::epsilon() );
+        REQUIRE_MSG( "exp "+to_string(exp_sum)+" == has "+to_string(has_sum), exp_sum == has_sum );
+    }
+    {
+        fraction<int_type> has_diff = a - b;
+        const double exp_double = a.to_double() - b.to_double();
+        const double has_double = has_diff.to_double();
+        REQUIRE_MSG( "exp "+std::to_string(exp_double)+" == has "+std::to_string(has_double), abs( exp_double - has_double ) <= std::numeric_limits<double>::epsilon() );
+        REQUIRE_MSG( "exp "+to_string(exp_diff)+" == has "+to_string(has_diff), exp_diff == has_diff );
+    }
+    {
+        fraction<int_type> has_mul = a * b;
+        const double exp_double = a.to_double() * b.to_double();
+        const double has_double = has_mul.to_double();
+        REQUIRE_MSG( "exp "+std::to_string(exp_double)+" == has "+std::to_string(has_double), abs( exp_double - has_double ) <= std::numeric_limits<double>::epsilon() );
+        REQUIRE_MSG( "exp "+to_string(exp_mul)+" == has "+to_string(has_mul), exp_mul == has_mul);
+    }
+    {
+        fraction<int_type> has_div = a / b;
+        const double exp_double = a.to_double() / b.to_double();
+        const double has_double = has_div.to_double();
+        REQUIRE_MSG( "exp "+std::to_string(exp_double)+" == has "+std::to_string(has_double), abs( exp_double - has_double ) <= std::numeric_limits<double>::epsilon() );
+        REQUIRE_MSG( "exp "+to_string(exp_div)+" == has "+to_string(has_div), exp_div == has_div);
+    }
+    {
+        const fraction<int_type> step(1, a.denom);
+        const fraction<int_type> lim(a + ( step * (int_type)10 ));
+        fraction<int_type> i(a);
+        int count;
+        for(count = 0; i < lim; i+=step, ++count) { }
+        REQUIRE( i == lim );
+        REQUIRE( i > a );
+        REQUIRE( 10 == count );
+
+        i+=step;
+        REQUIRE( i > lim );
+        REQUIRE( i == lim + step );
+    }
+    if( !std::is_unsigned_v<int_type> ) {
+        const fraction<int_type> step(1, a.denom);
+        const fraction<int_type> lim(a - ( step * (int_type)10 ));
+        fraction<int_type> i(a);
+        int count;
+        for(count = 0; i > lim; i-=step, ++count) { }
+        REQUIRE( i == lim );
+        REQUIRE( i < a );
+        REQUIRE( 10 == count );
+
+        i-=step;
+        REQUIRE( i < lim );
+        REQUIRE( i == lim - step );
+    }
+}
+
+template<typename Rep, typename Period, typename int_type>
+static void test_duration(const fraction<int_type>& a, const std::chrono::duration<Rep, Period>& dur_ref,
+                          const Rep exp_count)
+{
+    INFO_STR( " given duration: ( " + std::to_string(dur_ref.count()) + " * " + std::to_string(Period::num) + " = " + std::to_string(dur_ref.count() * Period::num) + " ) / " + std::to_string(Period::den) );
+    {
+        const int64_t d_num = a.to_num_of( fraction_i64(Period::num, Period::den) );
+        std::chrono::duration<Rep, Period> d = a.to_duration( dur_ref );
+        INFO_STR( " fraction-1 " + a.to_string(true) + " -> duration_count " + std::to_string( d_num ) + ", duration " + std::to_string( d.count() ) );
+        INFO_STR( " resulting duration-1: ( " + std::to_string(d.count()) + " * " + std::to_string(Period::num) + " = " + std::to_string(d.count() * Period::num) + " ) / " + std::to_string(Period::den) );
+
+        // fully functional conversion check
+        fraction<int_type> b(d);
+        INFO_STR( " reconverted fraction-2 " + b.to_string(true));
+        REQUIRE( exp_count == d_num );
+        REQUIRE( exp_count == d.count() );
+        REQUIRE( a == b );
+    }
+#if 0
+    {
+        typename std::chrono::duration<Rep, Period>::rep d_count = a.to_duration_count( dur_ref );
+        auto d = a.to_auto_duration();
+        INFO_STR( " fraction-2 " + a.to_string(true) + " -> duration_count " + std::to_string( d_count ) + ", duration " + std::to_string( d.count() ) );
+        INFO_STR( " resulting duration-2: ( " + std::to_string(d.count()) + " * " + std::to_string(Period::num) + " = " + std::to_string(d.count() * Period::num) + " ) / " + std::to_string(Period::den) );
+        INFO_STR( " resulting duration-2: ( " + std::to_string(d.count()) + " * " + std::to_string(decltype(d)::num) + " = " + std::to_string(d.count() * decltype(d)::num) + " ) / " + std::to_string(decltype(d)::den) );
+
+        // fully functional conversion check
+        fraction<int_type> b(d);
+        INFO_STR( " reconverted fraction-2 " + b.to_string(true));
+        REQUIRE( exp_count == d_count );
+        REQUIRE( exp_count == d.count() );
+        REQUIRE( a == b );
+    }
+#endif
+}
+
+
+TEST_CASE( "Fraction Types Test 00", "[fraction][type]" ) {
+    {
+        INFO_STR(" is_trivially_copyable_v<fraction_i64>:    " + std::to_string(std::is_trivially_copyable_v<fraction_i64>));
+        INFO_STR(" is_trivially_copyable<fraction_timespec>: " + std::to_string(std::is_trivially_copyable_v<fraction_timespec>));
+        REQUIRE( true == std::is_trivially_copyable_v<fraction_i64> );
+        REQUIRE( true == std::is_trivially_copyable_v<fraction_timespec> );
+        sc_atomic_fraction_i64 check_type_01 = fractions_i64::seconds;
+        (void)check_type_01;
+    }
+    {
+        INFO_STR(" is_trivially_copyable_v<fraction_i64>:    " + std::to_string(std::is_trivially_copyable_v<fraction_i64>));
+        REQUIRE( true == std::is_trivially_copyable_v<fraction_i64> );
+        sc_atomic_fraction_i64 check_type_01 = fractions_i64::seconds;
+        (void)check_type_01;
+    }
+    {
+        REQUIRE( INT64_MAX == std::numeric_limits<int64_t>::max() );
+        REQUIRE( INT64_MIN == std::numeric_limits<int64_t>::min() );
+
+        REQUIRE( UINT64_MAX == std::numeric_limits<uint64_t>::max() );
+    }
+    {
+        // copy-ctor
+        fraction<int> a(1, 6);
+        fraction<int> b(a);
+        REQUIRE( a == b );
+    }
+    {
+        // move-ctor
+        fraction<int> a(1, 6);
+        fraction<int> b( std::move(a) );
+        REQUIRE( a == b );
+    }
+    {
+        // assignment
+        fraction<int> a(1, 6);
+        fraction<int> b(6, 1);
+        b = a;
+        REQUIRE( a == b );
+    }
+    {
+        // move-assignment
+        fraction<int> a(1, 6);
+        fraction<int> a2(a);
+        fraction<int> b(6, 1);
+        b = std::move(a2);
+        REQUIRE( a == b );
+    }
+    {
+        REQUIRE( fractions_i64::zero == 0_s );
+        REQUIRE( fractions_i64::zero == 0_one );
+
+        REQUIRE( fractions_i64::one == 1_one );
+        REQUIRE( fractions_i64::one == 1_s );
+
+        REQUIRE( 3_i64*fractions_i64::tera == 3_T );
+        REQUIRE( 3_i64*fractions_i64::giga == 3_G );
+        REQUIRE( 3_i64*fractions_i64::mega == 3_M );
+        REQUIRE( 3_i64*fractions_i64::kilo == 3_k );
+        REQUIRE( 3_i64*fractions_i64::one == 3_one );
+        REQUIRE( 3_i64*fractions_i64::milli == 3_m );
+        REQUIRE( 3_i64*fractions_i64::micro == 3_u );
+        REQUIRE( 3_i64*fractions_i64::nano == 3_n );
+        REQUIRE( 3_i64*fractions_i64::pico == 3_p );
+
+        REQUIRE( 3_i64*fractions_i64::days == 3_d );
+        REQUIRE( 3_i64*fractions_i64::hours == 3_h );
+        REQUIRE( 3_i64*fractions_i64::minutes == 3_min );
+        REQUIRE( 3_i64*fractions_i64::seconds == 3_s );
+        REQUIRE( 3_i64*fractions_i64::milli == 3_ms );
+        REQUIRE( 3_i64*fractions_i64::micro == 3_us );
+        REQUIRE( 3_i64*fractions_i64::nano == 3_ns );
+    }
+}
+
+TEST_CASE( "Fraction GCD and Modulo Test 00", "[integer][fraction][gcd]" ) {
+    test_gcd_fract<int>(0, 0, 0, 0, 1);
+    test_gcd_fract<uint32_t>(0, 0, 0, 0, 1);
+
+    test_gcd_fract_pm<int>(15, 5, 5,  3, 1);
+    test_gcd_fract_pm<int>(17, 5, 1, 17, 5);
+
+    test_gcd_fract<uint32_t>(15, 5, 5,  3, 1);
+    test_gcd_fract<uint32_t>(17, 5, 1, 17, 5);
+}
+
+static void test_to_num_of(const int64_t exp, const fraction<int64_t>& v, const fraction<int64_t>& new_base, bool exp_overflow=false) noexcept {
+    bool overflow = false;
+    int64_t rr = v.to_num_of(new_base, &overflow);
+    INFO_STR(" value " + v.to_string() );
+    INFO_STR(" new_base " + new_base.to_string() );
+    std::string rr_s = exp == rr ? " - OK " : " - ********* ERROR ";
+    INFO_STR(" rr " + std::to_string(rr) + " =?= " + std::to_string(exp) + rr_s + ", overflow[exp " + std::to_string(exp_overflow) + ", has " + std::to_string(overflow) + "]");
+    if constexpr ( false ) {
+        // leaving elaboration code in .. for future testing overflows
+        const uint64_t _gcd = gcd<uint64_t>( v.denom, new_base.denom );
+        const uint64_t _lcm = ( v.denom * new_base.denom ) / _gcd;
+        int64_t r0 = ( v.num * (int64_t)( _lcm / v.denom ) ) / new_base.num;
+        int64_t r2 = ( v.num * (int64_t)new_base.denom ) / ( (int64_t) v.denom ) / new_base.num;
+        INFO_STR(" gcd " + std::to_string(_gcd) );
+        INFO_STR(" lcm " + std::to_string(_lcm) );
+        INFO_STR(" lcm / v_denom " + std::to_string( _lcm / v.denom) );
+        INFO_STR(" v_num * nb_denum " + std::to_string( v.num * (int64_t)new_base.denom ) );
+        std::string r0_s = exp == r0 ? " - OK " : " - ********* ERROR ";
+        INFO_STR(" r0 " + std::to_string(r0) + " =?= " + std::to_string(exp) + r0_s);
+        std::string r2_s = exp == r2 ? " - OK " : " - ********* ERROR ";
+        INFO_STR(" r2 " + std::to_string(r2) + " =?= " + std::to_string(exp) + r2_s);
+    }
+    REQUIRE( exp_overflow == overflow );
+    if( !exp_overflow ) {
+        REQUIRE( exp == rr );
+    }
+}
+
+TEST_CASE( "Fraction Cast Test 01.1", "[integer][fraction][type][to_num_of]" ) {
+    {
+        test_to_num_of(    2_i64, fractions_i64::one, fraction_i64(1_i64, 2_u64) ); // one -> halves
+        test_to_num_of( 1000_i64, fractions_i64::milli, fractions_i64::micro );
+        test_to_num_of(   60_i64, fractions_i64::minutes, fractions_i64::seconds );
+        test_to_num_of(  120_i64, fractions_i64::hours * 2_i64, fractions_i64::minutes );
+        test_to_num_of(   48_i64, 2_i64 * fractions_i64::days, fractions_i64::hours );
+    }
+    {
+        fraction_i64 a ( 10_s + 400_ms );
+        fraction_i64 b (  0_s + 400_ms );
+        fraction_i64 exp_sum (  10_s + 800_ms );
+
+        test_to_num_of(  10_i64, a, fractions_i64::seconds );
+        test_to_num_of( 10'400'000'000_i64, a, fractions_i64::nano );
+        test_to_num_of(   0_i64, b, fractions_i64::seconds );
+        test_to_num_of(    400'000'000_i64, b, fractions_i64::nano );
+        test_to_num_of(             10_i64, exp_sum, fractions_i64::seconds );
+        test_to_num_of( 10'800'000'000_i64, exp_sum, fractions_i64::nano );
+    }
+    {
+        fraction_i64 n1 ( 999'999'999_ns );
+        fraction_i64 n2 ( 999'999'999_ns );
+        fraction_i64 exp_nsum ( 1'999'999'998_ns );
+        REQUIRE( exp_nsum == n1 + n2 );
+        test_to_num_of(   999'999'999_i64, n1, fractions_i64::nano );
+        test_to_num_of( 1'999'999'998_i64, exp_nsum, fractions_i64::nano );
+        test_to_num_of(   999'999_i64, n1, fractions_i64::micro );
+        test_to_num_of( 1'999'999_i64, exp_nsum, fractions_i64::micro );
+        // OVERFLOW
+        test_to_num_of(   999'999'999'000_i64, n1, fractions_i64::pico, true /* overflow */ );
+        test_to_num_of( 1'999'999'998'000_i64, exp_nsum, fractions_i64::pico, true /* overflow */ );
+    }
+    { // OVERFLOW
+        // 1'000'000'000'000
+        //   999'999'999'999
+        // 1'999'999'999'998
+        fraction_i64 p1 ( 999'999'999'999_p );
+        // fraction_i64 p2 ( 999'999'999'999_p );
+        fraction_i64 exp_sum ( 1'999'999'999'998_p );
+        test_to_num_of(   999'999'999_i64, p1, fractions_i64::pico, true /* overflow */ );
+        test_to_num_of( 1'999'999'999'998_i64, exp_sum, fractions_i64::pico, true /* overflow */);
+        // REQUIRE( exp_sum == p1 + p2 );
+    }
+}
+
+TEST_CASE( "Fraction String Test 01.2", "[integer][fraction][type][string]" ) {
+    {
+        fraction_i64 a;
+        fraction_i64 exp = 10_s;
+
+        REQUIRE( true  == to_fraction_i64(a, "10/1", 0_s, 365_d) );
+        REQUIRE( exp == a );
+        {
+            fraction_i64 b;
+            REQUIRE( true  == to_fraction_i64(b, a.to_string(), a, a) );
+            REQUIRE( exp == b );
+        }
+
+        REQUIRE( true  == to_fraction_i64(a, "10/1", 10_s, 10_s) );
+        REQUIRE( exp == a );
+        {
+            fraction_i64 b;
+            REQUIRE( true  == to_fraction_i64(b, a.to_string(), a, a) );
+            REQUIRE( exp == b );
+        }
+
+        REQUIRE( false == to_fraction_i64(a, "10/1",  100_ns, 9_s) );
+        REQUIRE( false == to_fraction_i64(a, "10/1",  11_s, 365_d) );
+    }
+    {
+        fraction_i64 a;
+        REQUIRE( true  == to_fraction_i64(a, " 10 / 1000000 ", 0_s, 365_d) );
+        REQUIRE( 10_us == a );
+        {
+            fraction_i64 b;
+            REQUIRE( true  == to_fraction_i64(b, a.to_string(), a, a) );
+            REQUIRE( 10_us == b );
+        }
+
+        REQUIRE( false == to_fraction_i64(a, " 10x / 1000000 ", 0_s, 365_d) );
+        REQUIRE( false == to_fraction_i64(a, " 10 / 1000000x ", 0_s, 365_d) );
+        REQUIRE( false == to_fraction_i64(a, " 10 % 1000000x ", 0_s, 365_d) );
+        REQUIRE( false == to_fraction_i64(a, " 10 ", 0_s, 365_d) );
+    }
+}
+
+TEST_CASE( "Fraction Arithmetic Test 02", "[integer][fraction]" ) {
+    {
+        fraction<int> b(1, 6);
+        REQUIRE( b == fraction<int>(2, 12U));
+    }
+    {
+        fraction<int> b(6, 1);
+        REQUIRE( b == fraction<int>(12, 2U));
+    }
+    {
+        fraction<int> a(1, 4), b(1, 6);
+        fraction<int> exp_sum(5, 12);
+        fraction<int> exp_diff(1, 12);
+        fraction<int> exp_mul(1, 24);
+        fraction<int> exp_div(3, 2);
+        test_comp_fract(a, b, a, b, exp_sum, exp_diff, exp_mul, exp_div);
+    }
+    {
+        fraction<int> a(1, 4), b(6, 1);
+        fraction<int> exp_sum(25, 4);
+        fraction<int> exp_diff(-23, 4);
+        fraction<int> exp_mul(3, 2);
+        fraction<int> exp_div(1, 24);
+        test_comp_fract(a, b, b, a, exp_sum, exp_diff, exp_mul, exp_div);
+    }
+    {
+        fraction<int64_t> a(-1, 4), b(-1, 6);
+        fraction<int64_t> exp_sum(-5, 12);
+        fraction<int64_t> exp_diff(-1, 12);
+        fraction<int64_t> exp_mul(1, 24);
+        fraction<int64_t> exp_div(3, 2);
+        test_comp_fract(a, b, b, a, exp_sum, exp_diff, exp_mul, exp_div);
+    }
+    {
+        fraction<int> a(-1, 4), b(-1, 6);
+        fraction<int> exp_sum(-5, 12);
+        fraction<int> exp_diff(-1, 12);
+        fraction<int> exp_mul(1, 24);
+        fraction<int> exp_div(3, 2);
+        test_comp_fract(a, b, b, a, exp_sum, exp_diff, exp_mul, exp_div);
+    }
+    {
+        fraction<int> a(-1, 4), b( 1, 6);
+        fraction<int> exp_sum(-1, 12);
+        fraction<int> exp_diff(-5, 12);
+        fraction<int> exp_mul(-1, 24);
+        fraction<int> exp_div(-3, 2);
+        test_comp_fract(a, b, b, a, exp_sum, exp_diff, exp_mul, exp_div);
+    }
+    {
+        fraction<int> a(1, 4), b(-1, 6);
+        fraction<int> exp_sum(1, 12);
+        fraction<int> exp_diff(5, 12);
+        fraction<int> exp_mul(-1, 24);
+        fraction<int> exp_div(-3, 2);
+        test_comp_fract(a, b, a, b, exp_sum, exp_diff, exp_mul, exp_div);
+    }
+    {
+        // unsigned: micro + nano
+        fraction_u64 a(1, 1'000_u64), b(1, 1'000'000'000_u64);
+        fraction_u64 exp_sum(  1000001_u64,      100'0000'000_u64);
+        fraction_u64 exp_diff(  999999_u64,     1'000'000'000_u64);
+        fraction_u64 exp_mul(        1_u64, 1'000'000'000'000_u64);
+        fraction_u64 exp_div(  1000000_u64,                 1_u64);
+        test_comp_fract(a, b, a, b, exp_sum, exp_diff, exp_mul, exp_div);
+    }
+    {
+        // signed: micro + nano
+        fraction_i64 a(1_m), b(1_n);
+        fraction_i64 exp_sum(  1000001_n);
+        fraction_i64 exp_diff(  999999_n);
+        fraction_i64 exp_mul(        1_p);
+        fraction_i64 exp_div(  1000000_one);
+        test_comp_fract(a, b, a, b, exp_sum, exp_diff, exp_mul, exp_div);
+    }
+    {
+        // signed: 100 micro + 1'000'000 nano
+        fraction_i64 a(100_i64*fractions_i64::milli), b(1'000'000_i64*fractions_i64::nano);
+        fraction_i64 exp_sum(      101_i64,   1'000_u64);
+        fraction_i64 exp_diff(      99_i64,   1'000_u64);
+        fraction_i64 exp_mul(        1_i64,  10'000_u64);
+        fraction_i64 exp_div(      100_i64,       1_u64);
+        test_comp_fract(a, b, a, b, exp_sum, exp_diff, exp_mul, exp_div);
+    }
+    {
+        const std::chrono::milliseconds::rep exp_count = 100;
+        const fraction<int64_t> a(exp_count * fractions_i64::milli);
+        test_duration(a, std::chrono::milliseconds::zero(), exp_count);
+    }
+    {
+        const std::chrono::nanoseconds::rep exp_count = -50;
+        const fraction_i64 a(exp_count * fractions_i64::nano);
+        test_duration(a, std::chrono::nanoseconds::zero(), exp_count);
+    }
+    {
+        const std::chrono::hours::rep exp_count = 24;
+        const fraction_i64 a(exp_count * fractions_i64::hours);
+        test_duration(a, std::chrono::hours::zero(), exp_count);
+    }
+    {
+        const fraction_i64 refresh_rate = 60_i64/1_s;
+        const fraction_i64 fps = 1_i64 / refresh_rate;
+        REQUIRE( 1_i64 / fps == refresh_rate );
+        REQUIRE( fps == 1_i64 / refresh_rate );
+        REQUIRE( 2_i64 * fps == 1_i64 / ( refresh_rate / 2_i64 ) );
+
+        REQUIRE( fractions_i64::milli / 2_i64 ==   500_i64 * fractions_i64::micro );
+        REQUIRE( 1_m / 2_one                  ==   500_one * 1_u );
+        REQUIRE(    1_i64 / fractions_i64::milli == fractions_i64::kilo );
+        REQUIRE( fractions_i64::milli/-1000_i64 == -fractions_i64::micro );
+        REQUIRE(  500_i64 * fractions_i64::milli == fractions_i64::seconds/2_i64 );
+        REQUIRE( 1000_ms == fractions_i64::seconds );
+        REQUIRE(  1_i64 * fractions_i64::seconds == 60_i64/fractions_i64::minutes );
+        REQUIRE( 60_s == fractions_i64::minutes );
+        REQUIRE( 60_s                         == 1_min );
+        REQUIRE( 60_i64 * fractions_i64::minutes == fractions_i64::hours );
+        REQUIRE( 24_i64 * fractions_i64::hours   == fractions_i64::days );
+        REQUIRE( 24_h                         == 1_d );
+
+        const fraction_i64 m(720_i64 * fractions_i64::minutes); // 12 hours
+        const fraction_i64 h( 48_i64 * fractions_i64::hours);
+        const fraction_i64 d(  2_i64 * fractions_i64::days);
+        const fraction_i64 t = m + h + d;
+        REQUIRE( m == h/4_i64 );
+        REQUIRE( h == d );
+        REQUIRE( t > 4_i64 * fractions_i64::days );
+    }
+    {
+        fraction_i64 a ( 1'000l,             1lu ); // 1'000s
+        fraction_i64 b ( 1'000l, 1'000'000'000lu ); // 1'000ns
+        REQUIRE( 1000_s  == a );
+        REQUIRE( 1000_ns == b );
+        fraction_i64 c = a + b;
+        fraction_i64 exp_c ( 1'000'000'000lu + 1lu, 1'000'000lu ); // 1'000ns
+        REQUIRE( exp_c == c );
+    }
+}
+
+TEST_CASE( "Fraction Time Arithmetic Add Test 03.1", "[fraction][fraction_timespec][add]" ) {
+    // 10.4 + 0.4 = 10.8
+    {
+        fraction_timespec a ( 10_i64, 400000000_i64 );
+        fraction_timespec b (  0_i64, 400000000_i64 );
+        fraction_timespec exp_sum (  10_i64, 800000000_i64 );
+        REQUIRE( ( a + b ) == exp_sum );
+    }
+    // 10.4 + 0.4 = 10.8
+    {
+        fraction_i64 a ( 10_s + 400_ms );
+        fraction_i64 b (  0_s + 400_ms );
+        fraction_i64 exp_sum (  10_s + 800_ms );
+        INFO_STR(" a " + a.to_string() );
+        INFO_STR(" b " + b.to_string() );
+        INFO_STR(" a+b " + (a+b).to_string() );
+        REQUIRE( ( a + b ) == exp_sum );
+    }
+    // 10.4 + 0.4 = 10.8
+    {
+        fraction_timespec a ( 10_s + 400_ms );
+        fraction_timespec b (  0_s + 400_ms );
+        fraction_timespec exp_sum (  10_s + 800_ms );
+        INFO_STR(" a " + a.to_string() );
+        INFO_STR(" b " + b.to_string() );
+        INFO_STR(" a+b " + (a+b).to_string() );
+        REQUIRE( ( a + b ) == exp_sum );
+    }
+    // 10.4 + 0.7 = 11.1
+    {
+        fraction_timespec a { 10_s + 400_ms };
+        fraction_timespec b {  0_s + 700_ms };
+        fraction_timespec exp_sum {  11_s + 100_ms };
+        INFO_STR(" a " + a.to_string() );
+        INFO_STR(" b " + b.to_string() );
+        INFO_STR(" a+b " + (a+b).to_string() );
+        REQUIRE( ( a + b ) == exp_sum );
+    }
+    // 10.4 + 2.7 (in denominator) = 13.1
+    {
+        fraction_timespec a { 10_s +  400_ms };
+        fraction_timespec b {  0_s + 2700_ms };
+        fraction_timespec exp_sum {  13_s + 100_ms };
+        INFO_STR(" a " + a.to_string() );
+        INFO_STR(" b " + b.to_string() );
+        INFO_STR(" a+b " + (a+b).to_string() );
+        REQUIRE( ( a + b ) == exp_sum );
+    }
+    // 10.4 + -0.3 = 10.1
+    {
+        fraction_timespec a { 10_s + 400_ms };
+        fraction_timespec b {  0_s + -300_ms };
+        fraction_timespec exp_sum {  10_s + 100_ms };
+        REQUIRE( ( a + b ) == exp_sum );
+    }
+    // 10.-3 + 0.4 = 10.1
+    {
+        fraction_timespec a { 10_s + -300_ms };
+        fraction_timespec b {  0_s + 400_ms };
+        fraction_timespec exp_sum {  10_s + 100_ms };
+        REQUIRE( ( a + b ) == exp_sum );
+    }
+    // 10.4 + -0.9 = 9.5
+    {
+        fraction_timespec a { 10_s + 400_ms };
+        fraction_timespec b {  0_s + -900_ms };
+        fraction_timespec exp_sum {  9_s + 500_ms };
+        INFO_STR(" a " + a.to_string() );
+        INFO_STR(" b " + b.to_string() );
+        INFO_STR(" a+b " + (a+b).to_string() );
+        REQUIRE( ( a + b ) == exp_sum );
+    }
+    // 10.4 + -2.7 = 7.7
+    {
+        fraction_timespec a { 10_s +   400_ms };
+        fraction_timespec b {  0_s + -2700_ms };
+        fraction_timespec exp_sum {  7_s + 700_ms };
+        INFO_STR(" a " + a.to_string() );
+        INFO_STR(" b " + b.to_string() );
+        INFO_STR(" a+b " + (a+b).to_string() );
+        REQUIRE( ( a + b ) == exp_sum );
+    }
+    // 10.-9 + 0.4 = 9.5
+    {
+        fraction_timespec a { 10_s + -900_ms };
+        fraction_timespec b {  0_s +  400_ms };
+        fraction_timespec exp_sum {  9_s + 500_ms };
+        INFO_STR(" a " + a.to_string() );
+        INFO_STR(" b " + b.to_string() );
+        INFO_STR(" a+b " + (a+b).to_string() );
+        REQUIRE( ( a + b ) == exp_sum );
+    }
+}
+
+TEST_CASE( "Fraction Time Arithmetic Sub Test 03.2", "[fraction][fraction_timespec][sub]" ) {
+    // 10.4 - 0.3 = 10.1
+    {
+        fraction_timespec a ( 10_i64, 400000000_i64 );
+        fraction_timespec b (  0_i64, 300000000_i64 );
+        fraction_timespec exp_sum (  10_i64, 100000000_i64 );
+        REQUIRE( ( a - b ) == exp_sum );
+    }
+    // 10.4 - 0.3 = 10.1
+    {
+        fraction_timespec a ( 10_s + 400_ms );
+        fraction_timespec b (  0_s + 300_ms );
+        fraction_timespec exp_sum (  10_s + 100_ms );
+        REQUIRE( ( a - b ) == exp_sum );
+    }
+    // 10.4 - 0.7 = 9.7
+    {
+        fraction_timespec a { 10_s + 400_ms };
+        fraction_timespec b {  0_s + 700_ms };
+        fraction_timespec exp_sum {  9_s + 700_ms };
+        INFO_STR(" a " + a.to_string() );
+        INFO_STR(" b " + b.to_string() );
+        INFO_STR(" a-b " + (a-b).to_string() );
+        REQUIRE( ( a - b ) == exp_sum );
+    }
+    // 10.4 - 2.7 (in denominator) = 7.7
+    {
+        fraction_timespec a { 10_s +  400_ms };
+        fraction_timespec b {  0_s + 2700_ms };
+        fraction_timespec exp_sum {  7_s + 700_ms };
+        INFO_STR(" a " + a.to_string() );
+        INFO_STR(" b " + b.to_string() );
+        INFO_STR(" a-b " + (a-b).to_string() );
+        REQUIRE( ( a - b ) == exp_sum );
+    }
+    // 10.4 - -0.3 = 10.7
+    {
+        fraction_timespec a { 10_s + 400_ms };
+        fraction_timespec b {  0_s + -300_ms };
+        fraction_timespec exp_sum {  10_s + 700_ms };
+        REQUIRE( ( a - b ) == exp_sum );
+    }
+    // 10.-2 - 0.4 = 9.4
+    {
+        fraction_timespec a { 10_s + -200_ms };
+        fraction_timespec b {  0_s + 400_ms };
+        fraction_timespec exp_sum {  9_s + 400_ms };
+        INFO_STR(" a " + a.to_string() );
+        INFO_STR(" b " + b.to_string() );
+        INFO_STR(" a-b " + (a-b).to_string() );
+        REQUIRE( ( a - b ) == exp_sum );
+    }
+    // 10.4 - -0.9 = 11.3
+    {
+        fraction_timespec a { 10_s + 400_ms };
+        fraction_timespec b {  0_s + -900_ms };
+        fraction_timespec exp_sum { 11_s + 300_ms };
+        INFO_STR(" a " + a.to_string() );
+        INFO_STR(" b " + b.to_string() );
+        INFO_STR(" a-b " + (a-b).to_string() );
+        REQUIRE( ( a - b ) == exp_sum );
+    }
+    // 10.-9 - 0.4 = 8.7
+    {
+        fraction_timespec a { 10_s + -900_ms };
+        fraction_timespec b {  0_s +  400_ms };
+        fraction_timespec exp_sum {  8_s + 700_ms };
+        INFO_STR(" a " + a.to_string() );
+        INFO_STR(" b " + b.to_string() );
+        INFO_STR(" a-b " + (a-b).to_string() );
+        REQUIRE( ( a - b ) == exp_sum );
+    }
+}
+