GammaLib

/* __ Includes ___________________________________________________________ */

#include <iostream>

#include "arguments.hpp"

/***********************************************************************//**

 * @brief arg_copy5

 ***************************************************************************/

void arg_copy5(int num)

{

    // Start timer

    clock_t t_start = clock();

    // Loop

    for (int i = 0; i < num; ++i) {

        int arg1 = i;

        int arg2 = i;

        int arg3 = i;

        int arg4 = i;

        int arg5 = i;

        ArgCopy5 arg(arg1, arg2, arg3, arg4, arg5);

        //double  a = arg.eval();

    }

    // Stop timer

    double t_elapse = (double)(clock() - t_start) / (double)CLOCKS_PER_SEC;

    std::cout << "arg_copy5: CPU usage = " << t_elapse << " sec" << std::endl;

    // Return

    return;

}

/***********************************************************************//**

 * @brief arg_copy5_once

 ***************************************************************************/

void arg_copy5_once(int num)

{

    // Setup once

    int arg1  = 1;

    int arg2  = 2;

    int arg3  = 3;

    int arg4  = 4;

    int arg5  = 5;

    // Start timer

    clock_t t_start = clock();

    // Loop

    for (int i = 0; i < num; ++i) {

        ArgCopy5 arg(arg1, arg2, arg3, arg4, arg5);

        //double  a = arg.eval();

    }

    // Stop timer

    double t_elapse = (double)(clock() - t_start) / (double)CLOCKS_PER_SEC;

    std::cout << "arg_copy5_once: CPU usage = " << t_elapse << " sec" << std::endl;

    // Return

    return;

}

/***********************************************************************//**

 * @brief arg_copy15

 ***************************************************************************/

void arg_copy15(int num)

{

    // Start timer

    clock_t t_start = clock();

    // Loop

    for (int i = 0; i < num; ++i) {

        int arg1 = i;

        int arg2 = i;

        int arg3 = i;

        int arg4 = i;

        int arg5 = i;

        int arg6 = i;

        int arg7 = i;

        int arg8 = i;

        int arg9 = i;

        int arg10 = i;

        int arg11 = i;

        int arg12 = i;

        int arg13 = i;

        int arg14 = i;

        int arg15 = i;

        ArgCopy15 arg(arg1, arg2, arg3, arg4, arg5,

                      arg6, arg7, arg8, arg9, arg10,

                      arg11, arg12, arg13, arg14, arg15);

        //double  a = arg.eval();

    }

    // Stop timer

    double t_elapse = (double)(clock() - t_start) / (double)CLOCKS_PER_SEC;

    std::cout << "arg_copy15: CPU usage = " << t_elapse << " sec" << std::endl;

    // Return

    return;

}

/***********************************************************************//**

 * @brief arg_copy15_once

 ***************************************************************************/

void arg_copy15_once(int num)

{

    // Setup once

    int arg1  = 1;

    int arg2  = 2;

    int arg3  = 3;

    int arg4  = 4;

    int arg5  = 5;

    int arg6  = 6;

    int arg7  = 7;

    int arg8  = 8;

    int arg9  = 9;

    int arg10 = 10;

    int arg11 = 11;

    int arg12 = 12;

    int arg13 = 13;

    int arg14 = 14;

    int arg15 = 15;

    // Start timer

    clock_t t_start = clock();

    // Loop

    for (int i = 0; i < num; ++i) {

        ArgCopy15 arg(arg1, arg2, arg3, arg4, arg5,

                      arg6, arg7, arg8, arg9, arg10,

                      arg11, arg12, arg13, arg14, arg15);

        //double  a = arg.eval();

    }

    // Stop timer

    double t_elapse = (double)(clock() - t_start) / (double)CLOCKS_PER_SEC;

    std::cout << "arg_copy15_once: CPU usage = " << t_elapse << " sec" << std::endl;

    // Return

    return;

}

/***********************************************************************//**

 * @brief arg_ref5

 ***************************************************************************/

void arg_ref5(int num)

{

    // Start timer

    clock_t t_start = clock();

    // Loop

    for (int i = 0; i < num; ++i) {

        int arg1 = i;

        int arg2 = i;

        int arg3 = i;

        int arg4 = i;

        int arg5 = i;

        ArgRef5 arg(arg1, arg2, arg3, arg4, arg5);

        //double  a = arg.eval();

    }

    // Stop timer

    double t_elapse = (double)(clock() - t_start) / (double)CLOCKS_PER_SEC;

    std::cout << "arg_ref5: CPU usage = " << t_elapse << " sec" << std::endl;

    // Return

    return;

}

/***********************************************************************//**

 * @brief arg_ref5_once

 ***************************************************************************/

void arg_ref5_once(int num)

{

    // Setup once

    int arg1  = 1;

    int arg2  = 2;

    int arg3  = 3;

    int arg4  = 4;

    int arg5  = 5;

    // Start timer

    clock_t t_start = clock();

    // Loop

    for (int i = 0; i < num; ++i) {

        ArgRef5 arg(arg1, arg2, arg3, arg4, arg5);

        //double  a = arg.eval();

    }

    // Stop timer

    double t_elapse = (double)(clock() - t_start) / (double)CLOCKS_PER_SEC;

    std::cout << "arg_ref5_once: CPU usage = " << t_elapse << " sec" << std::endl;

    // Return

    return;

}

/***********************************************************************//**

 * @brief arg_ref15

 ***************************************************************************/

void arg_ref15(int num)

{

    // Start timer

    clock_t t_start = clock();

    // Loop

    for (int i = 0; i < num; ++i) {

        int arg1  = i;

        int arg2  = i;

        int arg3  = i;

        int arg4  = i;

        int arg5  = i;

        int arg6  = i;

        int arg7  = i;

        int arg8  = i;

        int arg9  = i;

        int arg10 = i;

        int arg11 = i;

        int arg12 = i;

        int arg13 = i;

        int arg14 = i;

        int arg15 = i;

        ArgRef15 arg(arg1, arg2, arg3, arg4, arg5,

                     arg6, arg7, arg8, arg9, arg10,

                     arg11, arg12, arg13, arg14, arg15);

        //double  a = arg.eval();

    }

    // Stop timer

    double t_elapse = (double)(clock() - t_start) / (double)CLOCKS_PER_SEC;

    std::cout << "arg_ref15: CPU usage = " << t_elapse << " sec" << std::endl;

    // Return

    return;

}

/***********************************************************************//**

 * @brief arg_ref15_once

 ***************************************************************************/

void arg_ref15_once(int num)

{

    // Setup once

    int arg1  = 1;

    int arg2  = 2;

    int arg3  = 3;

    int arg4  = 4;

    int arg5  = 5;

    int arg6  = 6;

    int arg7  = 7;

    int arg8  = 8;

    int arg9  = 9;

    int arg10 = 10;

    int arg11 = 11;

    int arg12 = 12;

    int arg13 = 13;

    int arg14 = 14;

    int arg15 = 15;

    // Start timer

    clock_t t_start = clock();

    // Loop

    for (int i = 0; i < num; ++i) {

        ArgRef15 arg(arg1, arg2, arg3, arg4, arg5,

                     arg6, arg7, arg8, arg9, arg10,

                     arg11, arg12, arg13, arg14, arg15);

        //double  a = arg.eval();

    }

    // Stop timer

    double t_elapse = (double)(clock() - t_start) / (double)CLOCKS_PER_SEC;

    std::cout << "arg_ref15_once: CPU usage = " << t_elapse << " sec" << std::endl;

    // Return

    return;

}

/***********************************************************************//**

 * @brief arg_struct5

 ***************************************************************************/

void arg_struct5(int num)

{

    // Start timer

    clock_t t_start = clock();

    // Loop

    for (int i = 0; i < num; ++i) {

        args5 arg;

        arg.arg1 = i;

        arg.arg2 = i;

        arg.arg3 = i;

        arg.arg4 = i;

        arg.arg5 = i;

        ArgStruct5 argstruct(arg);

        //double  a = argstruct.eval();

    }

    // Stop timer

    double t_elapse = (double)(clock() - t_start) / (double)CLOCKS_PER_SEC;

    std::cout << "arg_struct5: CPU usage = " << t_elapse << " sec" << std::endl;

    // Return

    return;

}

/***********************************************************************//**

 * @brief arg_struct5_once

 ***************************************************************************/

void arg_struct5_once(int num)

{

    // Set argument once

    args5 arg;

    arg.arg1  = 1;

    arg.arg2  = 2;

    arg.arg3  = 3;

    arg.arg4  = 4;

    arg.arg5  = 5;

    // Start timer

    clock_t t_start = clock();

    // Loop

    for (int i = 0; i < num; ++i) {

        ArgStruct5 argstruct(arg);

        //double  a = argstruct.eval();

    }

    // Stop timer

    double t_elapse = (double)(clock() - t_start) / (double)CLOCKS_PER_SEC;

    std::cout << "arg_struct5_once: CPU usage = " << t_elapse << " sec" << std::endl;

    // Return

    return;

}

/***********************************************************************//**

 * @brief arg_struct15

 ***************************************************************************/

void arg_struct15(int num)

{

    // Start timer

    clock_t t_start = clock();

    // Loop

    for (int i = 0; i < num; ++i) {

        args15 arg;

        arg.arg1  = i;

        arg.arg2  = i;

        arg.arg3  = i;

        arg.arg4  = i;

        arg.arg5  = i;

        arg.arg6  = i;

        arg.arg7  = i;

        arg.arg8  = i;

        arg.arg9  = i;

        arg.arg10 = i;

        arg.arg11 = i;

        arg.arg12 = i;

        arg.arg13 = i;

        arg.arg14 = i;

        arg.arg15 = i;

        ArgStruct15 argstruct(arg);

        //double  a = argstruct.eval();

    }

    // Stop timer

    double t_elapse = (double)(clock() - t_start) / (double)CLOCKS_PER_SEC;

    std::cout << "arg_struct15: CPU usage = " << t_elapse << " sec" << std::endl;

    // Return

    return;

}

/***********************************************************************//**

 * @brief arg_struct15_once

 ***************************************************************************/

void arg_struct15_once(int num)

{

    // Set argument once

    args15 arg;

    arg.arg1  = 1;

    arg.arg2  = 2;

    arg.arg3  = 3;

    arg.arg4  = 4;

    arg.arg5  = 5;

    arg.arg6  = 6;

    arg.arg7  = 7;

    arg.arg8  = 8;

    arg.arg9  = 9;

    arg.arg10 = 10;

    arg.arg11 = 11;

    arg.arg12 = 12;

    arg.arg13 = 13;

    arg.arg14 = 14;

    arg.arg15 = 15;

    // Start timer

    clock_t t_start = clock();

    // Loop

    for (int i = 0; i < num; ++i) {

        ArgStruct15 argstruct(arg);

        //double  a = argstruct.eval();

    }

    // Stop timer

    double t_elapse = (double)(clock() - t_start) / (double)CLOCKS_PER_SEC;

    std::cout << "arg_struct15_once: CPU usage = " << t_elapse << " sec" << std::endl;

    // Return

    return;

}

/***********************************************************************//**

 * @brief Main

 ***************************************************************************/

int main(void)

{

    // Set number of rounds

    int num = 100000000;

    // Test 5

    std::cout << std::endl;

    arg_copy5(num);

    arg_ref5(num);

    arg_struct5(num);

    std::cout << std::endl;

    // Test 15

    arg_copy15(num);

    arg_ref15(num);

    arg_struct15(num);

    std::cout << std::endl;

    // Test 5 once

    arg_copy5_once(num);

    arg_ref5_once(num);

    arg_struct5_once(num);

    std::cout << std::endl;

    // Test 15 once

    arg_copy15_once(num);

    arg_ref15_once(num);

    arg_struct15_once(num);

    std::cout << std::endl;

    // Exit

    return 0;

}