GammaLib

/* __ Includes ___________________________________________________________ */

#include <iostream>

#include <cmath>

#include "arithmetics.hpp"

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

 * @brief power of 2

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

void power2(int num)

{

    // Start timer

    clock_t t_start = clock();

    // Loop using pow

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

        double arg    = double(i);

        double result = std::pow(arg, 2.0);

    }

    // Stop timer

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

    // Start timer

    t_start = clock();

    // Loop using multiplication

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

        double arg    = double(i);

        double result = arg*arg;

    }

    // Stop timer

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

    // Dump result

    std::cout << "power2:";

    std::cout << " pow(x,2)=" << t_elapse_pow;

    std::cout << " x*x=" << t_elapse_mult;

    std::cout << " sec" << std::endl;

    // Return

    return;

}

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

 * @brief power of 2p

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

void power2p(int num)

{

    // Start timer

    clock_t t_start = clock();

    // Loop using pow

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

        double arg    = double(i);

        double result = std::pow(arg, 2.01);

    }

    // Stop timer

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

    // Start timer

    t_start = clock();

    // Loop using multiplication

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

        double arg    = double(i);

        double result = arg*arg;

    }

    // Stop timer

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

    // Dump result

    std::cout << "power2p:";

    std::cout << " pow(x,2.01)=" << t_elapse_pow;

    std::cout << " x*x=" << t_elapse_mult;

    std::cout << " sec" << std::endl;

    // Return

    return;

}

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

 * @brief multidiv

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

void multidiv(int num)

{

    // Set divider

    double div  = 3.0;

    double fact = 1.0 / div;

    // Start timer

    clock_t t_start = clock();

    // Loop using division

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

        double arg    = double(i);

        double result = arg / div;

    }

    // Stop timer

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

    // Start timer

    t_start = clock();

    // Loop using multiplication

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

        double arg    = double(i);

        double result = arg * fact;

    }

    // Stop timer

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

    // Dump result

    std::cout << "multidiv:";

    std::cout << " div=" << t_elapse_div;

    std::cout << " mult=" << t_elapse_mult;

    std::cout << " sec" << std::endl;

    // Return

    return;

}

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

 * @brief addsub

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

void addsub(int num)

{

    // Start timer

    clock_t t_start = clock();

    // Loop using addition

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

        double arg    = double(i);

        double result = arg + 1.5;

    }

    // Stop timer

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

    // Start timer

    t_start = clock();

    // Loop using subtraction

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

        double arg    = double(i);

        double result = arg - 1.5;

    }

    // Stop timer

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

    // Dump result

    std::cout << "addsub:";

    std::cout << " add=" << t_elapse_add;

    std::cout << " sub=" << t_elapse_sub;

    std::cout << " sec" << std::endl;

    // Return

    return;

}

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

 * @brief sin, cos, tan, acos

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

void sincos(int num)

{

    // Start timer

    clock_t t_start = clock();

    // Loop using sin

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

        double arg    = double(i);

        double result = std::sin(arg);

    }

    // Stop timer

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

    // Start timer

    t_start = clock();

    // Loop using cos

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

        double arg    = double(i);

        double result = std::cos(arg);

    }

    // Stop timer

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

    // Start timer

    t_start = clock();

    // Loop using tan

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

        double arg    = double(i);

        double result = std::tan(arg);

    }

    // Stop timer

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

    // Start timer

    t_start = clock();

    // Loop using acos

    double arg2 = 0.798;

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

        double arg    = double(i);

        double result = std::acos(arg2);

    }

    // Stop timer

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

    // Dump result

    std::cout << "sincos:";

    std::cout << " sin(x)=" << t_elapse_sin;

    std::cout << " cos(x)=" << t_elapse_cos;

    std::cout << " tan(x)=" << t_elapse_tan;

    std::cout << " acos(x)=" << t_elapse_acos;

    std::cout << " sec" << std::endl;

    // Return

    return;

}

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

 * @brief sqrt

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

void sqrt(int num)

{

    // Start timer

    clock_t t_start = clock();

    // Loop using pow

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

        double arg    = double(i);

        double result = std::sqrt(arg);

    }

    // Stop timer

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

    // Dump result

    std::cout << "sqrt:";

    std::cout << " sqrt(x)=" << t_elapse_sqrt;

    std::cout << " sec" << std::endl;

    // Return

    return;

}

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

 * @brief log

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

void log(int num)

{

    // Start timer

    clock_t t_start = clock();

    // Loop using pow

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

        double arg    = double(i);

        double result = std::log10(arg);

    }

    // Stop timer

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

    // Start timer

    t_start = clock();

    // Loop using acos

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

        double arg    = double(i);

        double result = std::log(arg);

    }

    // Stop timer

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

    // Dump result

    std::cout << "log:";

    std::cout << " log10(x)=" << t_elapse_log10;

    std::cout << " log(x)=" << t_elapse_log;

    std::cout << " sec" << std::endl;

    // Return

    return;

}

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

 * @brief Main

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

int main(void)

{

    // Set number of rounds

    int num = 100000000;

    std::cout << "Loops: " << num << std::endl;

    // Tests

    power2(num);

    power2p(num);

    multidiv(num);

    addsub(num);

    sincos(num);

    sqrt(num);

    log(num);

    // Exit

    return 0;

}