/**
 * \brief Calculates the pooled variance of two vectors of numbers.
 * \param[in] values1 The first vector of numbers.
 * \param[in] values2 The second vector of numbers
 * \return The pooled sample variance.
 */
double StatisticalTesting::pooledVariance(const std::vector<double>& values1, const std::vector<double>& values2) {
	double pv = 0.0;
	// TODO
	double s1 = standardDeviation(values1);
	double s2 = standardDeviation(values2);
	int n1 = values1.size();
	int n2 = values2.size();
/*
	 int Mean =mean(values1);
	std::vector<double>::const_iterator it;
		for (it=values1.begin();it!=values1.end();it++) 	{
			s1 += pow(Mean-(*it),2);
		}
		s1 /= n1;

	Mean =mean(values2);
		for (it=values2.begin();it!=values2.end();it++) 	{
			s2 += pow(Mean-(*it),2);
		}
		s2 /= n2;

*/

	//pv =(double) (((n1-1) * s1*s1 )+((n2-1) * s2*s2 ))/(n1+n2-2);
	pv = (double)(n1*s1*s1+n2*s2*s2)/(n1+n2-2);
	return pv;
}
Beispiel #2
0
int main() {
	int size, rank;
	double startTime, endTime;
	double *arrayA = (double *) malloc(sizeof(double) * 1000000);
	double *arrayB = (double *) malloc(sizeof(double) * 1000000);
	double pearsonCCoefficient = 0.0;
	long n = 1000000;

	double standardDeviationA, standardDeviationB;
	double meanA, meanB;
	// call to initializer function for initializing arrays with sin(i) and sin(i+1) values,
	//	and calculating mean for both the arrays
	initializer(arrayA, arrayB, n, &meanA, &meanB);
	// call to Standard Deviation function,with arrays and mean calculated previously
	standardDeviation(arrayA, arrayB, &standardDeviationA, &standardDeviationB,
			meanA, meanB, n);
	startTime = omp_get_wtime();
	// call to Pearson Correlation Coefficient with mean ,array and 
	//standard Deviation calculated previously
	pearsonCoefficient(meanA, meanB, arrayA, arrayB, &pearsonCCoefficient,
			standardDeviationA, standardDeviationB, n);
	;
	printf("Pearson Coefficient:%f\n", pearsonCCoefficient);
	endTime = omp_get_wtime();
	printf("Total Execution Time : \n %f Sec \n %f ms", endTime - startTime,
			(endTime - startTime) * 1000);
	printf("\n");
	return 0;
}
Beispiel #3
0
int main() {
	int size, rank;
	MPI_Init(NULL, NULL);
	MPI_Comm_size(MPI_COMM_WORLD, &size);
	MPI_Comm_rank(MPI_COMM_WORLD, &rank);
	double startTime, endTime;
	startTime = MPI_Wtime();
	double *arrayA = (double *) malloc(sizeof(double) * 1000000);
	double *arrayB = (double *) malloc(sizeof(double) * 1000000);
	double pearsonCCoefficient = 0.0;
	long n = 1000000;
	double standardDeviationA, standardDeviationB;
	double meanA, meanB;
	initializer(arrayA, arrayB, n, &meanA, &meanB);
	standardDeviation(arrayA, arrayB, &standardDeviationA, &standardDeviationB,
			meanA, meanB, n);
	pearsonCoefficient(meanA, meanB, arrayA, arrayB, &pearsonCCoefficient,
			standardDeviationA, standardDeviationB, n);

	printf("Pearson Coefficient:%f\n", pearsonCCoefficient);
	endTime = MPI_Wtime();
	printf("Total Elapsed Time for Serial Version : %f \n",
			endTime - startTime);
//	system("pause");
}
/**
 * \brief Calculates the t value of a vector of numbers.
 * \param[in] values The vector of numbers.
 * \param[in] distributionMean The mean of the entire population.
 * \return The t value.
 */
double StatisticalTesting::tValue(const std::vector<double>& values, const double& distributionMean) {
	double t = 0.0;
	// TODO Calculate the t value. Estimate the standard deviation from the sample.
	double samplesigma =standardDeviation(values) ;
	double Mean = mean(values);
	t= (Mean - distributionMean)/(samplesigma /sqrt(values.size()));
	return t;
}
Beispiel #5
0
std::vector<double> repeatFunction(F function) {
   std::vector<clock_t> numCalls(9);
   std::vector<double> info;

   std::generate(numCalls.begin(), numCalls.end(), [&](){ timer(function); });
   info.push_back(std::mean(numCalls));
   info.push_back(standardDeviation(numCalls));
   return info;
}
Beispiel #6
0
double pearsonCorrelationCoefficient(double *a, double *b) {
    
    double meanA = mean(a);
    double meanB = mean(b);
    
    double standardDeviationA = standardDeviation(a,&meanA);
    double standardDeviationB = standardDeviation(b,&meanB);
    
    // TOP of fraction
    double value = 0.0;
	for(size_t i =0; i < vec_size; i++) {
		value += ((a[i] - meanA) * (b[i] - meanB));
	}
	value *= 1.0/vec_size;
    
    // BOTTOM of fraction
	value /= (standardDeviationA*standardDeviationB);
    
    return value;
}
double estPi(double precision, int numTrials){
	double numNeedles = NUM_NEEDLES;
	double sDev=precision;
	double result;
	while(sDev>=precision/2.0){
		result = getEst(numNeedles, numTrials);
		sDev = standardDeviation(estimates, mean(estimates, numTrials), numTrials);
		numNeedles*=2;
	}
	return result;
}
Beispiel #8
0
//频域 峰度
double kurt(double data[],int length){
    if(data == NULL || length == 0) return 0.0;
    double meanD = mean(data,length);
    double dev = standardDeviation(data,length);
    double sum=0;
    int i;
    for(i=0;i<length;i++){
        sum+=pow((data[i]-meanD)/dev,4)-3;
    }
    return sum/length;
}
    Real GeneralStatistics::skewness() const {
        Size N = samples();
        QL_REQUIRE(N > 2,
                   "sample number <=2, unsufficient");

        Real x = expectationValue(compose(cube<Real>(),
                                          subtract<Real>(mean())),
                                  everywhere()).first;
        Real sigma = standardDeviation();

        return (x/(sigma*sigma*sigma))*(N/(N-1.0))*(N/(N-2.0));
    }
Beispiel #10
0
void colorization(float *LABs, float *LABt, float *LABd, int colst, int rowst, int colss, int rowss) {
	float meanss[3];
	float deviationss[3];
	float meanst[3];
	float deviationst[3];

	// Calcul des moyennes et écarts-types des images source et target
	mean(LABs, meanss, colss, rowss);
	mean(LABt, meanst, colst, rowst);
	standardDeviation(LABs, deviationss, colss, rowss);
	standardDeviation(LABt, deviationst, colst, rowst);

	// Luminance remapping de l'image source
	luminanceRemapping(LABs, LABt, colss, rowss, colst, rowst);
	int n = getJitteredSamplingN(colss, rowss);
	printf("%d\n", n);

	// Colorisation
	float tmp = 0.0;
	for (int i = 0; i < rowst; ++i)
 	{
 		for (int j = 0; j < colst; ++j)
 		{
 			for (int k = 0; k < 3; ++k)
 			{
 				LABs++;
 				LABt++;
 				LABd++;
 			}
 		}
 	}

 	LABs -= colss * rowss * 3;
 	LABt -= colst * rowst * 3;
 	LABd -= colst * rowst * 3;
}
Beispiel #11
0
int main()
{
    int N = _1000;

    char ** content = readFromFile(N);
    initHashTable(N);
    int i = 0;
    while (i < N) {
        insertElement(content[i]);
        i++;
    }
    computeDistributionsPerBucket();
    printf("Standard deviation: %.3f\n", standardDeviation());
    return 0;
}
Beispiel #12
0
void luminanceRemapping(float *imgA, float *imgB, int colsA, int rowsA, int colsB, int rowsB) {

	float meansA[3];
	float deviationsA[3];
	float meansB[3];
	float deviationsB[3];

	mean(imgA, meansA, colsA, rowsA);
	mean(imgB, meansB, colsB, rowsB);
	standardDeviation(imgA, deviationsA, colsA, rowsA);
	standardDeviation(imgB, deviationsB, colsB, rowsB);

	for (int i = 0; i < rowsA; ++i)
	{
		for (int j = 0; j < colsA; ++j)
		{
			*imgA = (deviationsB[0]/deviationsA[0]) * (*imgA - meansA[0]) + meansB[0];

			imgA += 3;
		}
	}

	imgA -= colsA * rowsA;
}
    Real IncrementalStatistics::skewness() const {
        QL_REQUIRE(sampleNumber_>2,
                   "sample number <=2, unsufficient");
        Real s = standardDeviation();

        if (s==0.0) return 0.0;

        Real m = mean();
        Real result = cubicSum_/sampleWeight_;
        result -= 3.0*m*(quadraticSum_/sampleWeight_);
        result += 2.0*m*m*m;
        result /= s*s*s;
        result *= sampleNumber_/(sampleNumber_-1.0);
        result *= sampleNumber_/(sampleNumber_-2.0);
        return result;
    }
/* Thresholding the Y channel of the image on the basis of the sigma obtained
    After this we are doing window based thresholding
 */
cv::Mat shadowDetection(cv::Mat &image){
    int sigma = standardDeviation(image);
    // First threshold on the basis of sigma
    cv::Mat binary(image.rows,image.cols,CV_8UC1,cvScalarAll(0));
    for (int i=0;i<image.rows;i++){
        for (int j=0;j<image.cols;j++){
            if (image.at<cv::Vec3b>(i,j)[0] > 1.5*sigma){
                binary.at<uchar>(i,j) = 255; 
            }
            else
                binary.at<uchar>(i,j) = 0; 
        }
    }

    // Window based thresholding
    
    /*int mean = 0, count = 0;
    cv::Mat binary_final(image.rows,image.cols,CV_8UC1,cvScalarAll(0));
    for (int i=1;i<image.rows-1;i++){
        for (int j=1;j<image.cols-1;j++){
            mean = sigma =0;
            if (binary.at<uchar>(i,j) == 255){
                for (int k = i-1;k<=i+1;k++){
                    for (int l= j-1;l<=j+1;l++){
                        mean += image.at<cv::Vec3b>(k,l)[0];
                    }
                }
                mean /=9;
                for (int k = i-1;k<=i+1;k++){
                    for (int l= j-1;l<=j+1;l++){
                        sigma += (mean - image.at<cv::Vec3b>(k,l)[0])*(mean - image.at<cv::Vec3b>(k,l)[0]);
                    }
                }
                sigma /= 9;
                sigma = sqrt((float)sigma);
                if (image.at<cv::Vec3b>(i,j)[0] > 1*sigma)
                    binary_final.at<uchar>(i,j)=255;
                else
                    binary_final.at<uchar>(i,j)=0;
            }
            else
                binary_final.at<uchar>(i,j) = 0;
        }
    }*/
    return binary;
}
Beispiel #15
0
void ViStatistician::process()
{
	QObject::disconnect(mCurrentObject.data(), SIGNAL(decoded()), this, SLOT(process()));

	ViAudioReadData data(mCurrentObject->buffer(ViAudio::Target));
	data.setSampleCount(mWindowSize);
	qreal value = 0;
	qint64 count = 0;

	qreal top = 0, bottom1 = 0, bottom2 = 0;
	qreal valuePos = 0, valueNeg = 0;
	int countPos = 0, countNeg = 0;

	while(data.hasData())
	{
		data.read();
		ViSampleChunk &samples1 = data.splitSamples(0);
		ViSampleChunk &samples2 = data.splitSamples(1);

		if(mMode == Mean)
		{
			value += mean(samples1);
			value += mean(samples2);
			count += 2;
		}
		else if(mMode == StandardDeviation)
		{
			value += standardDeviation(samples1);
			value +standardDeviation(samples2);
			count += 2;
		}
		else if(mMode == Pearson)
		{
			qreal theTopA = 0, theBottom1A = 0, theBottom2A = 0;
			qreal theTopB = 0, theBottom1B = 0, theBottom2B = 0;

			qreal value1 = pearson(samples1, theTopA, theBottom1A, theBottom2A);
			qreal value2 = pearson(samples2, theTopB, theBottom1B, theBottom2B);
			/*if(value1 != 0)
			{
				top += theTopA;
				bottom1 += theBottom1A;
				bottom2 += theBottom2A;
			}
			if(value2 != 0)
			{
				top += theTopB;
				bottom1 += theBottom1B;
				bottom2 += theBottom2B;
			}*/
			if(value1 > 0)
			{
				valuePos += value1;
				++countPos;
			}
			else if(value1 < 0)
			{
				valueNeg += value1;
				++countNeg;
			}
			if(value2 > 0)
			{
				valuePos += value2;
				++countPos;
			}
			else if(value2 < 0)
			{
				valueNeg += value2;
				++countNeg;
			}
		}
	}

	if(mMode == Pearson)
	{
		/*value = top / (qSqrt(bottom1) * qSqrt(bottom2));
		mValue += value;
		mCount += 1;

		printFileData(value);
		printTerminal(value);*/


		mValuePos += valuePos;
		mCountPos += countPos;
		mValueNeg += valueNeg;
		mCountNeg += countNeg;

		valuePos /= countPos;
		valueNeg /= countNeg;

		printFileDataPearson(valuePos, valueNeg);
		printTerminalPearson(valuePos, valueNeg);
	}
	else
	{
		mValue += value;
		mCount += count;
		value /= count;
		printFileData(value);
		printTerminal(value);
	}

	nextFile();
}
Beispiel #16
0
//频域 标准备差
double fdev(double data[],int length){
    return standardDeviation(data,length);
}
Beispiel #17
0
int testStandardDeviation() {
	acc vals[] = { 3, 4, 7, 10, TERMINATION_VALUE };
	printf("StdDev: %.3f", standardDeviation(vals, -1));
}
Beispiel #18
0
void printBenchmark(SortBenchmark b)
{
    printf("%s sort: %.6lf s (± %.6lf)\n", b.algorithm, averageSortTime(b), standardDeviation(b));
}
Beispiel #19
0
int main(int argc, char **argv) {
    int size, rank;
    MPI_Init(&argc, &argv);
    MPI_Comm_size(MPI_COMM_WORLD, &size);
    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
    long localArraySize = 1000000 / size;
    double *arrayA = (double *) malloc(sizeof(double) * localArraySize);
    double *arrayB = (double *) malloc(sizeof(double) * localArraySize);
    double *combinedA;
    double *combinedB;
    double pearsonCCoefficient = 0.0;
    double pearsonCC = 0.0;
    double sdA, sdB;
    double standardDeviationA, standardDeviationB;
    double localMeanA, localMeanB;
    double MeanA, MeanB;
    double localStart, localEnd, localElapsed, Elapsed;
    localStart = MPI_Wtime();
    int test = 0;
    int status = -1;
    localMeanA = 0;
    localMeanB = 0;
    initializer(arrayA, arrayB, localArraySize, &localMeanA, &localMeanB, rank,
                size); // For initializing A values and Y values with random values and calculation mean

    if (rank == 0) {
        combinedA = malloc(localArraySize * size * (sizeof(double)));
        combinedB = malloc(localArraySize * size * (sizeof(double)));
    }
    //MPI_Barrier(MPI_COMM_WORLD);

    // Combining the distributed arrays to single array.

    // MPI GATHER statement
    MPI_Gather(arrayA, localArraySize, MPI_DOUBLE, combinedA, localArraySize,
               MPI_DOUBLE, 0, MPI_COMM_WORLD);
    MPI_Gather(arrayB, localArraySize, MPI_DOUBLE, combinedB, localArraySize,
               MPI_DOUBLE, 0, MPI_COMM_WORLD);

    // Calculation of overall mean
    MPI_Reduce(&localMeanA, &MeanA, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
    MPI_Reduce(&localMeanB, &MeanB, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);


    // Assigning global mean to process local mean for standard deviation
    MPI_Bcast(&MeanA, 1, MPI_DOUBLE, 0, MPI_COMM_WORLD);
    MPI_Bcast(&MeanB, 1, MPI_DOUBLE, 0, MPI_COMM_WORLD);


    // Calculation of Standard deviation on every chunk
    standardDeviation(arrayA, arrayB, &sdA, &sdB, MeanA, MeanB, localArraySize,
                      size);
    // Combining local standard deviation to overall standard deviation
    MPI_Reduce(&sdA, &standardDeviationA, 1, MPI_DOUBLE, MPI_SUM, 0,
               MPI_COMM_WORLD);
    MPI_Reduce(&sdB, &standardDeviationB, 1, MPI_DOUBLE, MPI_SUM, 0,
               MPI_COMM_WORLD);


    if (rank == 0) {
        standardDeviationA = sqrt(standardDeviationA);
        standardDeviationB = sqrt(standardDeviationB);
    }

    // Assigning overall standard deviation to process local standard deviation
    MPI_Bcast(&standardDeviationA, 1, MPI_DOUBLE, 0, MPI_COMM_WORLD);
    MPI_Bcast(&standardDeviationB, 1, MPI_DOUBLE, 0, MPI_COMM_WORLD);


    // Calculation of Pearson Correlation Coefficient
    pearsonCoefficient(MeanA, MeanB, arrayA, arrayB, &pearsonCC,
                       standardDeviationA, standardDeviationB, localArraySize, size);


    // Calculation of total Pearson Correlation Coefficient
    MPI_Reduce(&pearsonCC, &pearsonCCoefficient, 1, MPI_DOUBLE, MPI_SUM, 0,
               MPI_COMM_WORLD);

    localEnd = MPI_Wtime();
    localElapsed = localEnd - localStart;
    printf("\n Elapsed time for process %d is %f", rank, localElapsed);
    MPI_Reduce(&localElapsed, &Elapsed, 1, MPI_DOUBLE, MPI_MAX, 0,
               MPI_COMM_WORLD);
    if (rank == 0) {

        int j = 0;

        printf("\n pearson coefficient total %f", pearsonCCoefficient);
        printf("\n Total Elapsed Time %f", Elapsed);
        printf("\n");
    }
    MPI_Finalize();
    return 0;
}