statistics.cpp

来自「股票分析源代码」· C++ 代码 · 共 146 行

#include "hbstock2/hbstock_config.h"

#include <math.h>
#include "gnu/statistics.h"

using namespace std;

static double
variance_calc (const std::vector<float>& vect_data, const size_t stride, const double mean);
static double 
covariance_calc(const std::vector<float>& vect_data1,const size_t stride1,
	const std::vector<float>& vect_data2,const size_t stride2,
	const size_t n,
	const double mean1,const double mean2);

double gnu::mean(const std::vector<float>& vect_data,const size_t stride)
{	
	/* Compute the arithmetic mean of a dataset using the recurrence relation
   	mean_(n) = mean(n-1) + (data[n] - mean(n-1))/(n+1)   */

	double d_mean = 0;
	size_t i;
	unsigned int i_size = vect_data.size();
	
	for (i = 0; i < i_size; i++)
  	{
  		//printf("vect_data[%d] : % lf\n",(i * stride),vect_data[i * stride]);  		  		
    	d_mean += (vect_data[i * stride] - d_mean) / (i + 1);
  	}

	//printf("mean : % lf\n",d_mean);
	
	return d_mean;
}

static double
variance_calc (const std::vector<float>& vect_data, const size_t stride, const double d_mean)
{
  	/* takes a dataset and finds the variance */

  	double d_variance = 0 ;

  	size_t i;
	unsigned int i_size = vect_data.size();
	
  	/* find the sum of the squares */
  	for (i = 0; i < i_size; i++)
    {
    	if ((i * stride) >= i_size)
  		{
  			break;	
  		}
  		
      	const double delta = (vect_data[i * stride] - d_mean);
      	d_variance += (delta * delta - d_variance) / (i + 1);
    }

	//printf("d_variance : % lf\n",d_variance);
	
  	return d_variance ;
}

double gnu::variance(const std::vector<float>& vect_data,const size_t stride)
{	
	const double d_mean = mean(vect_data, stride);
  	return variance_m(vect_data, stride, d_mean);
}

double gnu::variance_m(const std::vector<float>& vect_data,const size_t stride,const double mean)
{
	unsigned int n = vect_data.size();
	
	const double variance = variance_calc(vect_data, stride, mean);
  
  	return variance * ((double)n / (double)(n - 1));
}

double gnu::sd(const std::vector<float>& vect_data,const size_t stride)
{
	const double d_mean = mean(vect_data, stride);
  
  	return sd_m(vect_data, stride, d_mean);
}

double gnu::sd_m(const std::vector<float>& vect_data,const size_t stride,const double mean)
{
	unsigned int n = vect_data.size();
	
	const double d_variance = variance_calc(vect_data, stride, mean);
  	const double d_sd = sqrt (d_variance * ((double)n / (double)(n - 1)));

  	return d_sd;
}

static double 
covariance_calc(const std::vector<float>& vect_data1,const size_t stride1,
	const std::vector<float>& vect_data2,const size_t stride2,
	const size_t n,
	const double mean1,const double mean2)
{
	/* takes a dataset and finds the covariance */

  	double d_covariance = 0 ;

  	size_t i;
	
  	/* find the sum of the squares */
  	for (i = 0; i < n; i++)
    {
    	//printf("vect_data[%d] :  %lf  : %f\n",(i * stride1),vect_data1[i * stride1],vect_data2[i * stride1]);    	
      	const double delta1 = (vect_data1[i * stride1] - mean1);
      	const double delta2 = (vect_data2[i * stride2] - mean2);
      	d_covariance += (delta1 * delta2 - d_covariance) / (i + 1);
    }

	//printf("d_covariance : % lf\n",d_covariance);
	
  	return d_covariance ;
}

double gnu::covariance(const std::vector<float>& vect_data1,const size_t stride1,
	const std::vector<float>& vect_data2,const size_t stride2,const size_t n)
{
	const double mean1 = mean(vect_data1, stride1);
  	const double mean2 = mean(vect_data2, stride2);

  	return covariance_m(vect_data1, stride1, 
                        vect_data2, stride2, 
                        n, 
                        mean1, mean2);
}


double gnu::covariance_m(const std::vector<float>& vect_data1,const size_t stride1,
	const std::vector<float>& vect_data2,const size_t stride2,
	const size_t n,
	const double mean1,const double mean2)
{
	const double covariance = covariance_calc(vect_data1, stride1,
                                                vect_data2, stride2,
                                                n, 
                                                mean1, mean2);
  
 	return covariance * ((double)n / (double)(n - 1));
}