gaussian-rng.cpp File Reference

#include "pch.h"

Functions
double	Median (vector< double > Cases)
	get the median of a vector
template<typename T >
T	Average (const vector< T > &vec)
	get the average of a vector
template<typename T >
T	CalculateStandardDeviation (const std::vector< T > &v)
	get the standard deviation of elements
double	MedianAbsoluteDeviationTest (vector< double > Data)
	get the Median Absolute Deviation (MAD) Test
double	Randn (double mu, double sigma)
	random generator based on calculations
VOID	GuassianGenerateRandom (vector< double > Data, UINT64 *AverageOfData, UINT64 *StandardDeviationOfData, UINT64 *MedianOfData)
	Calculate and generate random gaussian number.
VOID	TestGaussianFromFile ()
	A simple test for the data based on pre-defined numbers in a file.

Function Documentation

Average()

template<typename T >

T Average

(

const vector< T > &

vec

)

get the average of a vector

Template Parameters

T	type of vector

Parameters

vec	all the elements

Returns

T the average of elements

{
    size_t Sz;
    T      Mean;
    Sz = vec.size();
    if (Sz == 1)
        return 0.0;
 
    //
    // Calculate the mean
    //
    Mean = std::accumulate(vec.begin(), vec.end(), 0.0) / Sz;
 
    return Mean;
}

CalculateStandardDeviation()

template<typename T >

T CalculateStandardDeviation

(

const std::vector< T > &

v

)

get the standard deviation of elements

Template Parameters

T	type of vector

Parameters

v	all the elements

Returns

T the standard deviation of elements

{
    double Sum, Mean, SqSum, Stdev;
 
    Sum  = std::accumulate(v.begin(), v.end(), 0.0);
    Mean = Sum / v.size();
 
    SqSum = std::inner_product(v.begin(), v.end(), v.begin(), 0.0);
    Stdev = std::sqrt(SqSum / v.size() - Mean * Mean);
    return Stdev;
}

GuassianGenerateRandom()

VOID GuassianGenerateRandom	(	vector< double >	Data,
		UINT64 *	AverageOfData,
		UINT64 *	StandardDeviationOfData,
		UINT64 *	MedianOfData )

Calculate and generate random gaussian number.

Parameters

Data
AverageOfData
StandardDeviationOfData
MedianOfData

{
    vector<double> FinalData;
    int            CountOfOutliers = 0;
    double         Medians;
    double         Mad;
    double         StandardDeviation;
    double         DataAverage;
    double         DataMedian;
 
    vector<double> OriginalData  = Data;
    vector<double> ChangableData = std::move(Data);
 
    Mad     = MedianAbsoluteDeviationTest(ChangableData);
    Medians = Median(OriginalData);
 
    for (auto item : OriginalData)
    {
        if (item > (3 * Mad) + Medians || item < -(3 * Mad) + Medians)
        {
            CountOfOutliers++;
        }
        else
        {
            FinalData.push_back(item);
        }
    }
 
    StandardDeviation = CalculateStandardDeviation(FinalData);
    DataAverage       = Average(FinalData);
    DataMedian        = Median(FinalData);
 
    //
    // Set the values to return
    //
    *AverageOfData = (UINT64)DataAverage;
 
    //
    // We add 5 to the standard deviation because this value might be
    // 0 or 1 so we need more variance
    //
    *StandardDeviationOfData = (UINT64)StandardDeviation + 5;
    *MedianOfData            = (UINT64)DataMedian;
 
    //
    // ShowMessages("variance : %f\n", StandardDeviation);
    // ShowMessages("mean : %f\n", DataAverage);
    // ShowMessages("count of outliers : %d\n", CountOfOutliers);
    //
    //
    // for (int i = 0; i < 10000; i++)
    // {
    //  ShowMessages("final Random Time Stamp : %d\n", (int) Randn(DataAverage,
    // StandardDeviation));
    // _getch();
    // }
    //
}

Median()

double Median

(

vector< double >

Cases

)

get the median of a vector

Parameters

Cases

all the elements

Returns

double median of elements

{
    size_t Size = Cases.size();
 
    if (Size == 0)
    {
        return 0; // Undefined, really
    }
    else
    {
        sort(Cases.begin(), Cases.end());
        if (Size % 2 == 0)
        {
            return (Cases[Size / 2 - 1] + Cases[Size / 2]) / 2;
        }
        else
        {
            return Cases[Size / 2];
        }
    }
}

MedianAbsoluteDeviationTest()

double MedianAbsoluteDeviationTest

(

vector< double >

Data

)

get the Median Absolute Deviation (MAD) Test

Parameters

Data	all the elements

Returns

double result of MAD test

{
    double MedianData;
    double Mad;
 
    MedianData = Median(Data);
 
    for (int i = 0; i < Data.size(); i++)
    {
        Data[i] = abs(Data[i] - MedianData);
    }
    Mad = 1.4826 * Median(Data);
 
    return Mad;
}

Randn()

double Randn	(	double	mu,
		double	sigma )

random generator based on calculations

Parameters

mu
sigma

Returns

double random number in the range of gaussian curve

{
    double        U1, U2, W, mult;
    static double X1, X2;
    static int    call = 0;
 
    if (call == 1)
    {
        call = !call;
        return (mu + sigma * (double)X2);
    }
 
    do
    {
        U1 = -1 + ((double)rand() / RAND_MAX) * 2;
        U2 = -1 + ((double)rand() / RAND_MAX) * 2;
        W  = pow(U1, 2) + pow(U2, 2);
    } while (W >= 1 || W == 0);
 
    mult = sqrt((-2 * log(W)) / W);
    X1   = U1 * mult;
    X2   = U2 * mult;
 
    call = !call;
 
    return (mu + sigma * (double)X1);
}

TestGaussianFromFile()

VOID TestGaussianFromFile

(

)

A simple test for the data based on pre-defined numbers in a file.

Returns

VOID

{
    vector<double> MyVector;
    UINT64         AverageOfData;
    UINT64         StandardDeviationOfData;
    UINT64         MedianOfData;
 
    std::ifstream file("c:\\rev\\r.txt");
    if (file.is_open())
    {
        std::string line;
        while (std::getline(file, line))
        {
            MyVector.push_back(stod(line.c_str()));
        }
        file.close();
 
        GuassianGenerateRandom(MyVector, &AverageOfData, &StandardDeviationOfData, &MedianOfData);
    }
}