Vfrdtyky

so i've posted a few times and previously my problems were pretty vague

i started C++ this week and have been doing a little project

so i'm trying to calc standard deviation & variance

my code loads a file of 100 integers and put them into an array, counts them, calcs mean, sum, var and sd

but i'm having a little trouble with variance

i keep getting a huge number - i have a feeling it's to do with its calculation

my mean and sum are ok

any help or tips?

NB:

Cheers,

Jack

 using namespace std;

    int main()



{



int n = 0;

int Array[100];

float mean;

float var;

float sd;

string line;

float numPoints;



ifstream myfile(“numbers.txt");



if (myfile.is_open())



{

    while (!myfile.eof())



    {

        getline(myfile, line);



        stringstream convert(line);



        if (!(convert >> Array[n]))



        {

            Array[n] = 0;

        }

        cout << Array[n] << endl;



        n++;



    }



    myfile.close();



    numPoints = n;



}

else cout<< "Error loading file" <<endl;



int sum = accumulate(begin(Array), end(Array), 0, plus<int>());



cout << "The sum of all integers: " << sum << endl;



mean = sum/numPoints;



cout << "The mean of all integers: " << mean <<endl;



var = ((Array[n] - mean) * (Array[n] - mean)) / numPoints;



sd = sqrt(var);



cout << "The standard deviation is: " << sd <<endl;



return 0;



}

As the other answer by horseshoe correctly suggests, you will have to use a loop to calculate variance otherwise the statement

var = ((Array[n] - mean) * (Array[n] - mean)) / numPoints;

will just consider a single element from the array.

Just improved horseshoe's suggested code:

var = 0;

for( n = 0; n < numPoints; n++ )

{

  var += (Array[n] - mean) * (Array[n] - mean);

}

var /= numPoints;

sd = sqrt(var);

Your sum works fine even without using loop because you are using accumulate function which already has a loop inside it, but which is not evident in the code, take a look at the equivalent behavior of accumulate for a clear understanding of what it is doing.

Note: X ?= Y is short for X = X ? Y where ? can be any operator.
Also you can use pow(Array[n] - mean, 2) to take the square instead of multiplying it by itself making it more tidy.

Your variance calculation is outside the loop and thus it is only based on the n== 100 value. You need an additional loop.

You need:

var = 0;

n=0;

while (n<numPoints){

   var = var + ((Array[n] - mean) * (Array[n] - mean));

   n++;

}

var /= numPoints;

sd = sqrt(var);

Two simple methods to calculate Standard Deviation & Variance in C++.

#include <math.h>

#include <vector>



double StandardDeviation(std::vector<double>);

double Variance(std::vector<double>);



int main()

{

     std::vector<double> samples;

     samples.push_back(2.0);

     samples.push_back(3.0);

     samples.push_back(4.0);

     samples.push_back(5.0);

     samples.push_back(6.0);

     samples.push_back(7.0);



     double std = StandardDeviation(samples);

     return 0;

}



double StandardDeviation(std::vector<double> samples)

{

     return sqrt(Variance(samples));

}



double Variance(std::vector<double> samples)

{

     int size = samples.size();



     double variance = 0;

     double t = samples[0];

     for (int i = 1; i < size; i++)

     {

          t += samples[i];

          double diff = ((i + 1) * samples[i]) - t;

          variance += (diff * diff) / ((i + 1.0) *i);

     }



     return variance / (size - 1);

}

Rather than writing out more loops, you can create a function object to pass to std::accumulate to calculate the mean.

template <typename T>

struct normalize {

    T operator()(T initial, T value) {

        return initial + pow(value - mean, 2);

    }

    T mean;

}

While we are at it, we can use std::istream_iterator to do the file loading, and std::vector because we don't know how many values there are at compile time. This gives us:

int main()

{

    std::vector<int> values(100); // initial capacity, no contents yet



    ifstream myfile(“numbers.txt");

    if (myfile.is_open())

    {

        std::copy(std::istream_iterator<int>(myfile), std::istream_iterator<int>(), std::back_inserter(values));

        myfile.close();

    }

    else { cout<< "Error loading file" <<endl; }



    float sum = std::accumulate(values.begin(), values.end(), 0, plus<int>()); // plus is the default for accumulate, can be omitted

    std::cout << "The sum of all integers: " << sum << std::endl;

    float mean = sum / values.size();

    std::cout << "The mean of all integers: " << mean << std::endl;

    float var = std::accumulate(values.begin(), values.end(), 0, normalize<float>{ mean });

    float sd = sqrt(var);

    std::cout << "The standard deviation is: " << sd << std::endl;

    return 0;

}

Here's another approach using std::accumulate but without using pow. In addition, we can use an anonymous function to define how to calculate the variance after we calculate the mean. Note that this computes the unbiased sample variance.

#include <vector>

#include <algorithm>

#include <numeric>



template<typename T>

T variance(const std::vector<T> &vec)

{

    size_t sz = vec.size();

    if (sz == 1)

        return 0.0;



    // Calculate the mean

    T mean = std::accumulate(vec.begin(), vec.end(), 0.0) / sz;



    // Now calculate the variance

    auto variance_func = [&mean, &sz](T accumulator, const T& val)

    {

        return accumulator + ((val - mean)*(val - mean) / (sz - 1));

    };



    return std::accumulate(vec.begin(), vec.end(), 0.0, variance_func);

}

A sample of how to use this function:

int main()

{

    std::vector<double> vec = {1.0, 5.0, 6.0, 3.0, 4.5};

    std::cout << variance(vec) << std::endl;

}