BaseFunctions.hpp

/*--------------------------------------------------------------------------------------------
Copyright (c) 2019, NDEVR LLC
tyler.parke@ndevr.org
  __    __   ____     _____ __     __  _______
 |  \  |  | |  __ \  |  ___|\ \   / / |   __  \
 |   \ |  | | |  \ \ | |___  \ \ / /  |  |__)  |
 |  . \|  | | |__/ / | |___   \ V /   |   _   /
 |  |\    |_|_____/__|_____|___\_/____|  | \  \
 |__| \__________________________________|  \__\
 
Subject to the terms of the Enterprise+ Agreement, NDEVR hereby grants 
Licensee a limited, non-exclusive, non-transferable, royalty-free license 
(without the right to sublicense) to use the API solely for the purpose of 
Licensee's internal development efforts to develop applications for which 
the API was provided.
 
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.
 
Library: Base
File: BaseFunctions
Included in API: True
Author(s): Tyler Parke
 *-----------------------------------------------------------------------------------------**/
#pragma once
#include <NDEVR/BaseValues.h>
#include <NDEVR/LibAssert.h>
namespace NDEVR
{

    template <typename t_type>
    constexpr t_type getMin(const t_type& left, const t_type& right) { return left < right ? left : right; }
    template <typename t_type>
    constexpr t_type getMin(const t_type& left, const t_type& middle, const t_type& right) { return getMin(getMin(left, middle), right); }
 
    template<>
    constexpr sint01 getMin(const sint01& left, const sint01& right) { return left ^ ((right ^ left) & -(right < left)); }
    template<>
    constexpr uint01 getMin(const uint01& left, const uint01& right) { return static_cast<uint01>(left ^ ((right ^ left) & -(right < left))); }
 
    template<>
    constexpr sint02 getMin(const sint02& left, const sint02& right) { return left ^ ((right ^ left) & -(right < left)); }
    template<>
    constexpr uint02 getMin(const uint02& left, const uint02& right) { return static_cast<uint02>(left ^ ((right ^ left) & -(right < left))); }
 
    template<>
    constexpr sint04 getMin(const sint04& left, const sint04& right) { return left ^ ((right ^ left) & -(right < left)); }
    template<>
    constexpr uint04 getMin(const uint04& left, const uint04& right) { return  static_cast<uint04>(left ^ ((right ^ left) & -(right < left))); }
 
    template<>
    constexpr sint08 getMin(const sint08& left, const sint08& right) { return left ^ ((right ^ left) & -(right < left)); }
    template<>
    constexpr uint08 getMin(const uint08& left, const uint08& right) { return static_cast<uint08>(left ^ ((right ^ left) & -(right < left))); }

    template <typename t_type>
    constexpr t_type getMax(const t_type& left, const t_type& right) { return left > right ? left : right; }
    template <typename t_type>
    constexpr t_type getMax(const t_type& left, const t_type& middle, const t_type& right) { return getMax(getMax(left, middle), right); }
 
    template<>
    constexpr sint01 getMax(const sint01& left, const sint01& right) { return left ^ ((left ^ right) & -(left < right)); }
    template<>
    constexpr uint01 getMax(const uint01& left, const uint01& right) { return static_cast<uint01>(left ^ ((left ^ right) & -(left < right))); }
 
    template<>
    constexpr sint02 getMax(const sint02& left, const sint02& right) { return left ^ ((left ^ right) & -(left < right)); }
    template<>
    constexpr uint02 getMax(const uint02& left, const uint02& right) { return static_cast<uint02>(left ^ ((left ^ right) & -(left < right))); }
 
    template<>
    constexpr sint04 getMax(const sint04& left, const sint04& right) { return left ^ ((left ^ right) & -(left < right)); }
    template<>
    constexpr uint04 getMax(const uint04& left, const uint04& right) { return static_cast<uint04>(left ^ ((left ^ right) & -(left < right))); }
 
    template<>
    constexpr sint08 getMax(const sint08& left, const sint08& right) { return left ^ ((left ^ right) & -(left < right)); }
    template<>
    constexpr uint08 getMax(const uint08& left, const uint08& right) { return static_cast<uint08>(left ^ ((left ^ right) & -(left < right))); }
 
 

    template <typename t_type>
    constexpr t_type quantize(t_type value, t_type d = cast<t_type>(1))
    {
        return cast<t_type>(cast<sint08>(value / d + cast<t_type>(value < 0 ? -0.5 : 0.5))) * d;
    }

    template <typename t_type>
    constexpr t_type sign(t_type value)
    {
        return value >= 0 ? cast<t_type>(1) : cast<t_type>(-1);
    }
 
    template<typename t_type>
    constexpr t_type makeNiceNumberA(t_type value)
    {
        t_type magnitude = pow(10, std::floor(std::log10(value)));
        t_type normalized_step = value / magnitude;
        if (normalized_step <= 1.5)
            normalized_step = 1.0;
        else if (normalized_step <= 3.0)
            normalized_step = 2.0;
        else if (normalized_step <= 7.5)
            normalized_step = 5.0;
        else
            normalized_step = 10.0;
        return normalized_step * magnitude;
    }
    template<typename t_type>
    constexpr t_type makeNiceNumberB(t_type value)
    {
        t_type magnitude = pow(10, std::floor(std::log10(value)));
        t_type normalized_step = value / magnitude;
        if (normalized_step <= 1.025)
            normalized_step = 1.0;
        else if (normalized_step <= 1.075)
            normalized_step = 1.05;
        else
            normalized_step = 0.1 * std::round(10.0 * normalized_step);
        return normalized_step * magnitude;
    }
    template<class t_type>
    constexpr bool IsInvalid(const t_type& value)
    {
        return value == Constant<t_type>::Invalid;
    }
    template<>
    constexpr bool IsInvalid(const fltp04& value)
    {
        // ReSharper disable once CppIdenticalOperandsInBinaryExpression
        return value != value;
    }
    template<>
    constexpr bool IsInvalid(const fltp08& value)
    {
        // ReSharper disable once CppIdenticalOperandsInBinaryExpression
        return value != value;
    }
    template<class t_type>
    constexpr bool IsValid(const t_type& value)
    {
        return !IsInvalid<t_type>(value);
    }
    template <typename t_type>
    constexpr t_type clip(const t_type& value, const t_type& lower_bound, const t_type& upper_bound)
    {
        lib_assert(IsInvalid(lower_bound) || IsInvalid(upper_bound) || (lower_bound <= upper_bound), "Invalid clip: upper bound is less than lower bound");
        return getMax(lower_bound, getMin(value, upper_bound));
    }
};