Компилятор выдает неправильный результат (массивы)

Question

Есть 3 метода. measureTime () работает правильно. meanTime () и stdTime () дают мне значения вроде -3.13558e + 67. Как можно исправить это? Как я понимаю, проблема в массивах.

statistics.h

#pragma once

#ifndef STATISTICS
#define STATISTICS

class statistics{
public:
    double meanTime(double* array, size_t z);
    double stdTime(double* array, size_t z);
};
#endif

statistics.cpp

#include "statistics.h"
#include "cmath"
#include <iostream>
 
double means{ 0 };
 
double statistics::meanTime(double* array, size_t z){
    double sum1{ 0 };
 
    for (size_t i = 0; i < z; ++i) sum1 += array[i];
    means = sum1 / z;
    std::cout << "\t\tAverage time is " << sum1 / z << " sec" << std::endl;
    return means;
}
 
double statistics::stdTime(double* array, size_t z){
    double stds{ 0 };   
    double sum2{ 0 };
 
    for (int i = 1; i <= z; i += 1) sum2 += ((array[i] - means) * (array[i] - means));
    stds = sqrt(sum2 / (z - 1));
    std::cout << "\t\tStandard deviation of time is " << stds << std::endl;
    return  stds;
}

experiment.h

#pragma once
#include "statistics.h"

#ifndef EXPERIMENT
#define EXPERIMENT

class experiment{
public:
    int foo(int n);
    double measureTime(int n);
    void Experiment(double* arguments, size_t n, size_t z, double* means, double* stds);
};

#endif

experiment.cpp

int experiment::foo(int n) {
    int s{ 0 };
    for (int i = 1; i <= n; i += 1) {
        for (int j = 1; j <= n; j += 1) {
            s += i * j;
        }
       std::cout << "Sum is " << s << std::endl;
    }
    return 0;
}

double experiment::measureTime(int n) {
    steady_clock::time_point t1 = steady_clock::now();
    foo(n);
    steady_clock::time_point t2 = steady_clock::now();

    duration<double> time_span = duration_cast<duration<double>>(t2 - t1);
    std::cout << "It took " << time_span.count() << " seconds\n";
    
    return time_span.count();
}

void experiment::Experiment(double* arguments, size_t n, size_t z, double* means, double* stds){
 
    std::cout << "How many numbers would you like to input?" << std::endl;
    if (!(std::cin >> z >> n)) {
 
        std::cout << "Input was not valid";
    }
    else {
        if ((z < 1 || z > 10) && (n < 1000 || n > 10000)) {
            Experiment(arguments, n, z, means, stds);
        }
        for (size_t j{ 1 }; j <= z; j += 1) {
            std::cout << "[" << j << "]" << std::endl;
            for (size_t i{ 1000 }; i <= n; i += 1000) {
                arguments[i] = measureTime(i);
            }
            statistics stat;
 
            means[j] = stat.meanTime(arguments, z);
            stds[j] = stat.stdTime(arguments, z);
           
        }
    }
}

main.cpp

#include <iostream>
#include "experiment.h"
#include "statistics.h"
 
int main() {
 
    size_t z{ 10 };
    size_t n{ 10000 };
 
    double* arguments = new double[n];
    double* means = new double[z];
    double* stds = new double[1100000];
 
    experiment ex;
    ex.Experiment(arguments, n, z, means, stds);
    
    delete[] arguments;
    delete[] means;
    delete[] stds;
}

Answer 1

Вобщем, вот примерно что стоило бы сделать... Если уж нужно с классами.

#include <iostream>
#include <iomanip>
#include <chrono>
#include <cmath>

using namespace std;
using namespace chrono;

class Stat
{
public:
    Stat():x(0),x2(0),n(0){}
    void add(double y) { x += y; x2 += y*y; n++; }

    pair<double,double> get() const
    {
        pair<double,double> p;
        p.first = x/n;
        p.second = sqrt((n*x2-x*x)/n/(n-1));
        return p;
    }
private:
    double x, x2;
    int n;
};

class Experiment
{
public:
    Experiment(void (*f)(int), int cnt, int n)
    :f(f),cnt(cnt),n(n)
    {
    }
    pair<double,double> doit();
private:
    void (*f)(int);
    int cnt, n;
};


pair<double,double> Experiment::doit()
{
    using Clock = high_resolution_clock;
    Stat st;
    for(int i = 0; i < cnt; ++i)
    {
        Clock::time_point start_ = Clock::now();
        f(n);
        Clock::time_point stop_ = Clock::now();
        Clock::duration dt = stop_ - start_;
        st.add(static_cast<double>(duration_cast<microseconds>(dt).count()));
    }
    return st.get();
}

int sum = 0;  // Просто чтоб оптимизатор не выбросил...

void foo(int n)
{
    int s = 0;
    for(int i = 0; i < n; ++i)
        for(int j = 0; j < n; ++j)
            s += i*j;
    sum += s;
}

int main()
{

    for(int n = 1000; n < 100000; n+= 1000)
    {
        Experiment ex(foo,
                      100, // Число повторов для одного n
                      n);
        auto p = ex.doit();

        cout << " N = " << fixed << setw(7) << n <<
            "   time =  " << fixed << setprecision(1) << setw(12) << p.first
            << " +- " << p.second << " mks\n";
    }
    cout << sum;
}

Пример работы - с маленькими параметрами - https://ideone.com/kVEpOC

БЛОГ НА HUSL

Компилятор выдает неправильный результат (массивы)

Ответы (1 шт):