Среднее время работы функции, C++

[Александр222]

В experiment происходит измерение времени работы функции
В statistics необходимо найти среднее время работы функции. Не понимаю, как довести этот участок кода до ума.

experiment.cpp

#include <ratio>
#include <chrono>

using namespace std::chrono;

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);

    return time_span.count();
}

statistics.cpp

#include "statistics.h"
#include "cmath"
#include <iostream>
#include <chrono>
#include <ratio>

double statistics::meanTime(double* arr, size_t n){ //должна находить среднее время работы функции foo
    double x = 0;
    for (int i = 0; i < n; ++i)
        x += arr[i];
    return x / n;
}

double statistics::stdTime(double* t, size_t z){
    for (int i = 1; i <= z; i += 1) {
        *t += sqrt((1 / z) * pow((t[i] - *t), 2));
    }
    std::cout << "Standard deviation of time is " << t << std::endl;
    return 0;
}

main.cpp

#include <iostream>
#include "experiment.h"
#include "statistics.h"
#include <chrono>
#include <ratio>

int main(){
    experiment ex;
    using namespace std::chrono;
    std::cout << "wait...." << std::endl;
    const size_t n = 10; //000;
    double arr[n];
    for (size_t i = 0; i < n; ++i)    {
        const auto dt = ex.measureTime(10);

        arr[i] = duration_cast<duration<double>>(dt).count(); //здесь ошибка.(отсутствуют экземпляры шаблонной функции)
        std::cout << i << ": " << arr[i] << " sec" << std::endl;
    }
    statistics stat;
    std::cout << "Average time is " << stat.meanTime(arr, n) << " sec" << std::endl;
    //std::cout << "Std time is " << stdTime(arr, n); << " sec" << std::endl;

}

[Александр222]

Есть код, который вычисляет время функции
В main это время вычисляется 10 раз.
Далее надо все сложить и разделить на 10 (то есть, найти среднее). Вот в этом проблема. Как можно написать? Сейчас в результате получается -7.84591e+297, что, конечно, не верно

experiment.cpp

#include "experiment.h"
#include <chrono>
#include <iostream>
#include <thread>

using namespace std;
using namespace std::chrono;

int experiment::foo(int n){
    int s {0};
    for (int i = 0; i <= n; i+=1) {
        for (int j = 1; j <= n; j+=1) {
            s += i * j;
        }
    }
    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 me " << time_span.count() << " seconds\n";
    return time_span.count();
}

statistics.cpp

double statistics::meanTime(double* t, size_t z){
    double x = 0;
    for (int i = 0; i < z; ++i) {
        x += t[i];
    }
    std::cout << "Average time is " << x / z << " sec" << std::endl;
    return x / z;
}

main.cpp

#include <iostream>
#include "experiment.h"
#include "statistics.h"

int main(){

    int i{ 0 };
    int z{ 10 };
    size_t n{ 10 };
    
    experiment ex;   
    statistics stat;

    double* t = new double[i];
    for (size_t i = 0; i < n; ++i)  ex.measureTime(i);   
    
    stat.meanTime(t, n);

    delete[] t;
}

[BDA]

Во втором коде неверный размер массива t, и данные в этот массив не вносятся.

[Александр222]

BDA,
Еще была попытка писать не

for (size_t i = 0; i < n; ++i)  ex.measureTime(i);

, а

 for (size_t i = 0; i < n; ++i)  t[i] = ex.measureTime(i);

Но тогда программа дает примерно 6 результатов (из 10) и выскакивает исключение (из-за неверного размера массива?)

[BDA]

#include <iostream>
#include <chrono>
#include <thread>

using namespace std;
using namespace std::chrono;

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

double 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 me " << time_span.count() << " seconds\n";
    return time_span.count();
}

double meanTime(double* t, size_t z){
    double x = 0;
    for (size_t i = 0; i < z; ++i)
        x += t[i];
    std::cout << "Average time is " << x / z << " sec" << std::endl;
    return x / z;
}

int main(){
    size_t n {10};
    int nn {10000};

    double* t = new double [n];
    for (size_t i = 0; i < n; ++i)
        t[i] = measureTime(nn);

    meanTime(t, n);

    delete[] t;
}

[Александр222]

BDA, Работает!)

[Александр222]

Есть код:
statistics.h содержит объявления двух функций:
meanTime – возвращает в результате среднее время по массиву (double).
stdTime – возвращает в результате среднее квадратичное отклонение времени (double).
statistics.cpp содержит реализации двух вышеуказанных функций.

experiment.h содержит объявления следующих функций:
foo – исследуемая на скорость работы функция
measureTime – функция-измеритель времени работы foo().
experiment – функция, выполняющая основную работу в нашем численном эксперименте. Принимает на вход массив значений аргумента функции foo (int []), его размер (size_t), число запусков функции с одним и тем же аргументом (size_t), массив, в который будут записываться средние времена работы (double []) и массив для среднеквадратичных отклонений времени работы на заданном числе запусков для каждого значения аргумента исследуемой функции (double []).Она будет менять содержимое содержимое массивов means и stds. Обратите внимание на то, что размер этих массивов должен быть равен числу различных значений аргумента (размеру n массива arguments). В каждую ячейку массива means[i] должно быть записано среднее время работы функции foo (измеренное при помощи measureTime) по z запускам c заданным аргументом arguments[i]. Аналогично для stds[i], которая должна содержать среднеквадратичное отклонение по времени на z запусках функции foo при фиксированном аргументе arguments[i].

Функцию foo, которая берет входной аргумент n и вычисляет сумму 1.jpg . Ее сложность, O(n^2). Диапазон входных значений n должно быть от 1000 до 10000, шаг равным 1000, количество повторных запусков z = 10.

Вопрос: 1)Не совсем понимаю, что надо написать в реализации функции experiment
2)Как сделать так, чтобы n было от 1000 до 10000 (шаг равным 1000)?

Сейчас код работает, при построении графика зависимости среднего значения от среднеквадратичных отклонений времени работы получается парабола

experience.cpp

#include "experiment.h"
#include <chrono>
#include <iostream>
#include <thread>

using namespace std::chrono;

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(int* arguments, size_t n, size_t z, double* means, double* stds){

}

statistics.cpp

#include "statistics.h"
#include "cmath"
#include <iostream>

double x = 0;

double statistics::meanTime(double* t, size_t z){  
    for (size_t i = 1; i <= z; ++i) x += t[i]; 
    std::cout << "\t\tAverage time is " << x / z << " sec\n" << std::endl;
    return x / z;
}

double statistics::stdTime(double* t, size_t z){
    double STD{ 0 };   
    for (int i = 1; i <= z; i += 1)  STD += (pow((t[i] - (x / z)), 2))/z;     
    std::cout << "\t\tStandard deviation of time is " << STD << std::endl;
	return STD;
}

main.cpp

#include <iostream>
#include "experiment.h"
#include "statistics.h"

int main() {
    size_t n{ 10 };
    size_t z{ 10 };
    experiment ex;
    statistics stat;

    double* arguments = new double[11];
    double* means = new double[11];
    double* stds = new double[11];

    for (size_t j = 1; j <= 10; ++j) {
        std::cout << "[" << j << "]" << std::endl;
        for (size_t i = 1; i <= 10; i += 1) {
            arguments[i] = ex.measureTime(i);
        }
        means[j] = stat.meanTime(arguments, z);
        stds[j] = stat.stdTime(arguments, z);
    }
    
    delete[] arguments;
    delete[] means;
    delete[] stds;
}

[Александр222]

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

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.cpp

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;
}

[BDA]

#include <iostream>
#include <chrono>
#include "cmath"

using namespace std;
using namespace std::chrono;

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

double 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);
    double mTime = time_span.count();
    cout << "It took me " << mTime << " seconds" << endl;
    return mTime;
}

double meanTime(double* t, size_t z){
    double s{0};
    for (size_t i = 0; i < z; ++i)
        s += t[i];
    double aTime = s / z;
    cout << "Average time is " << aTime << " seconds" << endl;
    return aTime;
}

double stdTime(double* t, size_t z, double mean){
    double s{0};
    for (size_t i = 0; i < z; ++i)
        s += (t[i] - mean) * (t[i] - mean);
    double sTime = sqrt(s / z);
    cout << "Standard deviation of time is " << sTime << endl;
    return  sTime;
}

void experiment(int* arguments, size_t n, size_t z, double* means, double* stds){
    double* times = new double[z];
    for (size_t i = 0; i < n; ++i) {
        cout << "Argument is " << arguments[i] << endl;
        for (size_t j = 0; j < z; ++j)
            times[j] = measureTime(arguments[i]);
        means[i] = meanTime(times, z);
        stds[i] = stdTime(times, z, means[i]);
    }
    delete[] times;
}

int main(){
    size_t n{10};
    size_t z{10};
    int* arguments = new int[n];
    for (size_t i = 0; i < n; ++i)
        arguments[i] = (i + 1) * 1000;
    double* means = new double[n];
    double* stds = new double[n];
    experiment(arguments, n, z, means, stds);
    delete[] arguments;
    delete[] means;
    delete[] stds;
    return 0;
}

[Александр222]

BDA, Спасибо! Работает