statistics.hpp

/******************************************************************************
* Copyright (c) ATTX LLC 2024. All Rights Reserved.
*
* This software and associated documentation (the "Software") are the 
* proprietary and confidential information of ATTX, LLC. 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, LLC.
******************************************************************************/
#ifndef STATISTICS_HPP
#define STATISTICS_HPP
 
#include "core/clockwerkerrors.h"
#include "core/safemath.hpp"
 
namespace modelspace {
 
    template <typename T>
    int mean(T* array, unsigned int size, T& result) {
        T sum = 0;
        T* val = array;
        for(unsigned int i = 0; i < size; i++) {
            sum += *val;
            val++;
        }
 
        return clockwerk::safeDivide(sum, (T)size, result);
    }
 
    template <typename T>
    int variance(T* array, unsigned int size, T& result) {
        // Calculate mean
        int err = mean(array, size, result);
        if(err) {return err;}
 
        T sum = 0;
        T var = 0;
        T* val = array;
        for(unsigned int i = 0; i < size; i++) {
            var = *val - result;
            sum += var*var;
            val++;
        }
 
        return clockwerk::safeDivide(sum, (T)(size - 1), result);
    }
 
    template <typename T>
    int stdev(T* array, unsigned int size, T& result) {
        // Calculate mean
        int err = variance(array, size, result);
        if(err) {return err;}
 
        double tmp;
        err = clockwerk::safeSqrt((double)result, tmp);
        result = (T)tmp;
        return err;
    }
 
    template <typename T>
    int max(T* array, unsigned int size, T& result) {
        if(size > 0) {
            result = *array;
        } else {
            return ERROR_DIMENSIONS;
        }
        T* val = array;
        for(unsigned int i = 0; i < size; i++) {
            if(*val > result) {
                result = *val;
            }
            val++;
        }
 
        return NO_ERROR;
    }
 
    template <typename T>
    int min(T* array, unsigned int size, T& result) {
        if(size > 0) {
            result = *array;
        } else {
            return ERROR_DIMENSIONS;
        }
        T* val = array;
        for(unsigned int i = 0; i < size; i++) {
            if(*val < result) {
                result = *val;
            }
            val++;
        }
 
        return NO_ERROR;
    }
 
}
 
#endif