functionutils.hpp

Go to the documentation of this file.

/******************************************************************************
* Copyright (c) ATTX INC 2025. All Rights Reserved.
*
* This software and associated documentation (the "Software") are the 
* proprietary and confidential information of ATTX, INC. The Software is 
* furnished under a license agreement between ATTX and the user organization 
* and may be used or copied only in accordance with the terms of the agreement.
* Refer to 'license/attx_license.adoc' for standard license terms.
*
* EXPORT CONTROL NOTICE: THIS SOFTWARE MAY INCLUDE CONTENT CONTROLLED UNDER THE
* INTERNATIONAL TRAFFIC IN ARMS REGULATIONS (ITAR) OR THE EXPORT ADMINISTRATION 
* REGULATIONS (EAR99). No part of the Software may be used, reproduced, or 
* transmitted in any form or by any means, for any purpose, without the express 
* written permission of ATTX, INC.
******************************************************************************/
/*
Function Utils header file
-------------------------
The function utilities header file contains utiltities for 
less common but practical functions. E.g. saturation functions
and activation functions.
 
Author: James Tabony
 
Update Log
----------
Date, Name, Description
*/
 
#ifndef UTILS_FUNCTION_UTILS_HPP
#define UTILS_FUNCTION_UTILS_HPP
 
#include "core/clockwerkerrors.h"
#include <cmath>
 
namespace warptwin {
 
    // Lookup table of factorials for optimaized computation organized as {n, n!}
    const std::map<int, double> FACTORIAL_CACHE = {
        { 0, 1.0}, 
        { 5, 120.0},
        {10, 3628800.0}, 
        {15, 1307674368000.0},
        {20, 2432902008176640000.0}, 
        {25, 15511210043330985984000000.0},
        {30, 265252859812191058636308480000000.0},
    };

    template<typename T>
    int satlin(T input, T &output, T limit = 1.0) {
 
        if      (input > limit) {output = limit;}
        else if (input < 0)     {output = 0.0;}
        else                    {output = input;}
        return NO_ERROR;
    }

    template<typename T>
    int satlins(T input, T &output, T limit = 1.0) {
 
        if      (input >  limit) {output =  limit;}
        else if (input < -limit) {output = -limit;}
        else                     {output =  input;}
        return NO_ERROR;
    }

    template<typename T>
    int poslin(T input, T &output) {
 
        if   (input > 0) {output = input;}
        else             {output = 0.0;}
        return NO_ERROR;
    }

    template<typename T>
    int Heaviside(T input, T &output, T center = 0.0) {
 
        if   (input < center) {output = 0.0;}
        else                  {output = 1.0;}
        return NO_ERROR;
    }

    template<typename T>
    int signum(T input, T &output) {
        output = (input > 0) - (input < 0);
        return NO_ERROR;
    }

    template<typename T>
    int deadzoneTrimmed(T input, T bounds, T &output) {
        if (bounds < 0.0) {return ERROR_INVALID_RANGE;}
        T _signum_input; signum(input, _signum_input);
        output = (std::abs(input) > bounds) ? (input - _signum_input*bounds) : 0.0;
        return NO_ERROR;
    }

    template<typename T>
    int deadzone(T input, T bounds, T &output) {
        if (bounds < 0.0) {return ERROR_INVALID_RANGE;}
        output = (std::abs(input) > bounds) ? (input) : 0.0;
        return NO_ERROR;
    }

    template<typename T>
    int clamp(T input, T min_val, T max_val, T &output) {
        output = std::max(min_val, std::min(input, max_val));
        return NO_ERROR;
    }

    template<typename T>
    int factorial(int n, T &output) {
        if (n < 0) return ERROR_DIVIDE_BY_ZERO;
 
        // Check if n is in cache
        auto it = FACTORIAL_CACHE.find(n);
        if (it != FACTORIAL_CACHE.end()) {
            output = it->second;
            return NO_ERROR;
        }
 
        // Find the largest key <= n
        auto upper = FACTORIAL_CACHE.upper_bound(n);  // First element with key > n
        if (upper == FACTORIAL_CACHE.begin()) {
            // Shouldn't happen since n >= 0 and cache has 0
            return ERROR_INVALID_RANGE;
        }
        --upper; // Now upper->first <= n
 
        int base = upper->first;
        T result = upper->second;
        for (int i = base + 1; i <= n; ++i)
            result *= (T)i;
 
        output = result;
        return NO_ERROR;
    }

    template <typename T>
    T factorial(int n) {
        T output;
        factorial(n, output);
        return output;
    }
 
}
 
#endif