Inline version of a function returns different value than non-inline version The 2019 Stack Overflow Developer Survey Results Are InIs floating point math broken?IEEE-754 floating-point precision: How much error is allowed?Benefits of inline functions in C++?When should I write the keyword 'inline' for a function/method?The meaning of static in C++setw within a function to return an ostreamstd::atomic_is_lock_free(shared_ptr<T>*) didn't compileWhy doesn't the istringstream eof flag become true when successfully converting a boolean string value to a bool?How to implement StringBuilder class which to be able to accept IO manipulatorsFunction overloading with different return typesProblems benchmarking simple code with googlebenchmarkC++ - Odd Reciprocal Inequivalence

What are the motivations for publishing new editions of an existing textbook, beyond new discoveries in a field?

Spanish for "widget"

What is the meaning of Triage in Cybersec world?

On the insanity of kings as an argument against monarchy

What does "sndry explns" mean in one of the Hitchhiker's guide books?

Is this food a bread or a loaf?

What is the use of option -o in the useradd command?

Why isn't airport relocation done gradually?

How to manage monthly salary

How to deal with fear of taking dependencies

Monty Hall variation

Deadlock Graph and Interpretation, solution to avoid

How are circuits which use complex ICs normally simulated?

Unbreakable Formation vs. Cry of the Carnarium

How to create dashed lines/arrows in Illustrator

In microwave frequencies, do you use a circulator when you need a (near) perfect diode?

I see my dog run

aging parents with no investments

Idiomatic way to prevent slicing?

Are USB sockets on wall outlets live all the time, even when the switch is off?

How to reverse every other sublist of a list?

Why is the maximum length of OpenWrt’s root password 8 characters?

Access elements in std::string where positon of string is greater than its size

Geography at the pixel level



Inline version of a function returns different value than non-inline version



The 2019 Stack Overflow Developer Survey Results Are InIs floating point math broken?IEEE-754 floating-point precision: How much error is allowed?Benefits of inline functions in C++?When should I write the keyword 'inline' for a function/method?The meaning of static in C++setw within a function to return an ostreamstd::atomic_is_lock_free(shared_ptr<T>*) didn't compileWhy doesn't the istringstream eof flag become true when successfully converting a boolean string value to a bool?How to implement StringBuilder class which to be able to accept IO manipulatorsFunction overloading with different return typesProblems benchmarking simple code with googlebenchmarkC++ - Odd Reciprocal Inequivalence



.everyoneloves__top-leaderboard:empty,.everyoneloves__mid-leaderboard:empty,.everyoneloves__bot-mid-leaderboard:empty height:90px;width:728px;box-sizing:border-box;








48















How can two versions of the same function, differing only in one being inline and the other one not, return different values? Here is some code I wrote today and I am not sure how it works.



#include <cmath>
#include <iostream>

bool is_cube(double r)

return floor(cbrt(r)) == cbrt(r);


bool inline is_cube_inline(double r)

return floor(cbrt(r)) == cbrt(r);


int main()

std::cout << (floor(cbrt(27.0)) == cbrt(27.0)) << std::endl;
std::cout << (is_cube(27.0)) << std::endl;
std::cout << (is_cube_inline(27.0)) << std::endl;




I would expect all outputs to be equal to 1, but it actually outputs this (g++ 8.3.1, no flags):



1
0
1


instead of



1
1
1


Edit: clang++ 7.0.0 outputs this:



0
0
0


and g++ -Ofast this:



1
1
1









share|improve this question









New contributor




zbrojny120 is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
Check out our Code of Conduct.















  • 3





    Can you please provide what compiler, compiler options are you using and what machine ? Works ok for me on GCC 7.1 on Windows.

    – Diodacus
    18 hours ago






  • 21





    Isn't == always a bit unpredictable with floating point values?

    – 500 - Internal Server Error
    18 hours ago






  • 2





    related stackoverflow.com/questions/588004/…

    – user463035818
    18 hours ago






  • 2





    Did you set the -Ofast option, which allows such optimizations?

    – cmdLP
    18 hours ago






  • 4





    Compiler returns for cbrt(27.0) the value of 0x0000000000000840 while the standard library returns 0x0100000000000840. The doubles differ in 16th number after comma. My system: archlinux4.20 x64 gcc8.2.1 glibc2.28 Checked with this. Wonder if gcc or glibc is right.

    – Kamil Cuk
    17 hours ago


















48















How can two versions of the same function, differing only in one being inline and the other one not, return different values? Here is some code I wrote today and I am not sure how it works.



#include <cmath>
#include <iostream>

bool is_cube(double r)

return floor(cbrt(r)) == cbrt(r);


bool inline is_cube_inline(double r)

return floor(cbrt(r)) == cbrt(r);


int main()

std::cout << (floor(cbrt(27.0)) == cbrt(27.0)) << std::endl;
std::cout << (is_cube(27.0)) << std::endl;
std::cout << (is_cube_inline(27.0)) << std::endl;




I would expect all outputs to be equal to 1, but it actually outputs this (g++ 8.3.1, no flags):



1
0
1


instead of



1
1
1


Edit: clang++ 7.0.0 outputs this:



0
0
0


and g++ -Ofast this:



1
1
1









share|improve this question









New contributor




zbrojny120 is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
Check out our Code of Conduct.















  • 3





    Can you please provide what compiler, compiler options are you using and what machine ? Works ok for me on GCC 7.1 on Windows.

    – Diodacus
    18 hours ago






  • 21





    Isn't == always a bit unpredictable with floating point values?

    – 500 - Internal Server Error
    18 hours ago






  • 2





    related stackoverflow.com/questions/588004/…

    – user463035818
    18 hours ago






  • 2





    Did you set the -Ofast option, which allows such optimizations?

    – cmdLP
    18 hours ago






  • 4





    Compiler returns for cbrt(27.0) the value of 0x0000000000000840 while the standard library returns 0x0100000000000840. The doubles differ in 16th number after comma. My system: archlinux4.20 x64 gcc8.2.1 glibc2.28 Checked with this. Wonder if gcc or glibc is right.

    – Kamil Cuk
    17 hours ago














48












48








48


8






How can two versions of the same function, differing only in one being inline and the other one not, return different values? Here is some code I wrote today and I am not sure how it works.



#include <cmath>
#include <iostream>

bool is_cube(double r)

return floor(cbrt(r)) == cbrt(r);


bool inline is_cube_inline(double r)

return floor(cbrt(r)) == cbrt(r);


int main()

std::cout << (floor(cbrt(27.0)) == cbrt(27.0)) << std::endl;
std::cout << (is_cube(27.0)) << std::endl;
std::cout << (is_cube_inline(27.0)) << std::endl;




I would expect all outputs to be equal to 1, but it actually outputs this (g++ 8.3.1, no flags):



1
0
1


instead of



1
1
1


Edit: clang++ 7.0.0 outputs this:



0
0
0


and g++ -Ofast this:



1
1
1









share|improve this question









New contributor




zbrojny120 is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
Check out our Code of Conduct.












How can two versions of the same function, differing only in one being inline and the other one not, return different values? Here is some code I wrote today and I am not sure how it works.



#include <cmath>
#include <iostream>

bool is_cube(double r)

return floor(cbrt(r)) == cbrt(r);


bool inline is_cube_inline(double r)

return floor(cbrt(r)) == cbrt(r);


int main()

std::cout << (floor(cbrt(27.0)) == cbrt(27.0)) << std::endl;
std::cout << (is_cube(27.0)) << std::endl;
std::cout << (is_cube_inline(27.0)) << std::endl;




I would expect all outputs to be equal to 1, but it actually outputs this (g++ 8.3.1, no flags):



1
0
1


instead of



1
1
1


Edit: clang++ 7.0.0 outputs this:



0
0
0


and g++ -Ofast this:



1
1
1






c++






share|improve this question









New contributor




zbrojny120 is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
Check out our Code of Conduct.











share|improve this question









New contributor




zbrojny120 is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
Check out our Code of Conduct.









share|improve this question




share|improve this question








edited 1 hour ago









chwarr

4,27811843




4,27811843






New contributor




zbrojny120 is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
Check out our Code of Conduct.









asked 18 hours ago









zbrojny120zbrojny120

32328




32328




New contributor




zbrojny120 is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
Check out our Code of Conduct.





New contributor





zbrojny120 is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
Check out our Code of Conduct.






zbrojny120 is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
Check out our Code of Conduct.







  • 3





    Can you please provide what compiler, compiler options are you using and what machine ? Works ok for me on GCC 7.1 on Windows.

    – Diodacus
    18 hours ago






  • 21





    Isn't == always a bit unpredictable with floating point values?

    – 500 - Internal Server Error
    18 hours ago






  • 2





    related stackoverflow.com/questions/588004/…

    – user463035818
    18 hours ago






  • 2





    Did you set the -Ofast option, which allows such optimizations?

    – cmdLP
    18 hours ago






  • 4





    Compiler returns for cbrt(27.0) the value of 0x0000000000000840 while the standard library returns 0x0100000000000840. The doubles differ in 16th number after comma. My system: archlinux4.20 x64 gcc8.2.1 glibc2.28 Checked with this. Wonder if gcc or glibc is right.

    – Kamil Cuk
    17 hours ago













  • 3





    Can you please provide what compiler, compiler options are you using and what machine ? Works ok for me on GCC 7.1 on Windows.

    – Diodacus
    18 hours ago






  • 21





    Isn't == always a bit unpredictable with floating point values?

    – 500 - Internal Server Error
    18 hours ago






  • 2





    related stackoverflow.com/questions/588004/…

    – user463035818
    18 hours ago






  • 2





    Did you set the -Ofast option, which allows such optimizations?

    – cmdLP
    18 hours ago






  • 4





    Compiler returns for cbrt(27.0) the value of 0x0000000000000840 while the standard library returns 0x0100000000000840. The doubles differ in 16th number after comma. My system: archlinux4.20 x64 gcc8.2.1 glibc2.28 Checked with this. Wonder if gcc or glibc is right.

    – Kamil Cuk
    17 hours ago








3




3





Can you please provide what compiler, compiler options are you using and what machine ? Works ok for me on GCC 7.1 on Windows.

– Diodacus
18 hours ago





Can you please provide what compiler, compiler options are you using and what machine ? Works ok for me on GCC 7.1 on Windows.

– Diodacus
18 hours ago




21




21





Isn't == always a bit unpredictable with floating point values?

– 500 - Internal Server Error
18 hours ago





Isn't == always a bit unpredictable with floating point values?

– 500 - Internal Server Error
18 hours ago




2




2





related stackoverflow.com/questions/588004/…

– user463035818
18 hours ago





related stackoverflow.com/questions/588004/…

– user463035818
18 hours ago




2




2





Did you set the -Ofast option, which allows such optimizations?

– cmdLP
18 hours ago





Did you set the -Ofast option, which allows such optimizations?

– cmdLP
18 hours ago




4




4





Compiler returns for cbrt(27.0) the value of 0x0000000000000840 while the standard library returns 0x0100000000000840. The doubles differ in 16th number after comma. My system: archlinux4.20 x64 gcc8.2.1 glibc2.28 Checked with this. Wonder if gcc or glibc is right.

– Kamil Cuk
17 hours ago






Compiler returns for cbrt(27.0) the value of 0x0000000000000840 while the standard library returns 0x0100000000000840. The doubles differ in 16th number after comma. My system: archlinux4.20 x64 gcc8.2.1 glibc2.28 Checked with this. Wonder if gcc or glibc is right.

– Kamil Cuk
17 hours ago













2 Answers
2






active

oldest

votes


















36














Explanation



Some compilers (notably GCC) use higher precision when evaluating expressions at compile time. If an expression depends only on constant inputs and literals, it may be evaluated at compile time even if the expression is not assigned to a constexpr variable. Whether or not this occurs depends on:



  • The complexity of the expression

  • The threshold the compiler uses as a cutoff when attempting to perform compile time evaluation

  • Other heuristics used in special cases (such as when clang elides loops)

If an expression is explicitly provided, as in the first case, it has lower complexity and the compiler is likely to evaluate it at compile time.



Similarly, if a function is marked inline, the compiler is more likely to evaluate it at compile time because inline functions raise the threshold at which evaluation can occur.



Higher optimization levels also increase this threshold, as in the -Ofast example, where all expressions evaluate to true on gcc due to higher precision compile-time evaluation.



We can observe this behavior here on compiler explorer. When compiled with -O1, only the function marked inline is evaluated at compile-time, but at -O3 both functions are evaluated at compile-time.




  • -O1: https://godbolt.org/z/u4gh0g


  • -O3: https://godbolt.org/z/nVK4So

NB: In the compiler-explorer examples, I use printf instead iostream because it reduces the complexity of the main function, making the effect more visible.



Demonstrating that inline doesn’t affect runtime evaluation



We can ensure that none of the expressions are evaluated at compile time by obtaining value from standard input, and when we do this, all 3 expressions return false as demonstrated here: https://ideone.com/QZbv6X



#include <cmath>
#include <iostream>

bool is_cube(double r)

return floor(cbrt(r)) == cbrt(r);

 
bool inline is_cube_inline(double r)

return floor(cbrt(r)) == cbrt(r);


int main()

double value;
std::cin >> value;
std::cout << (floor(cbrt(value)) == cbrt(value)) << std::endl; // false
std::cout << (is_cube(value)) << std::endl; // false
std::cout << (is_cube_inline(value)) << std::endl; // false



Contrast with this example, where we use the same compiler settings but provide the value at compile-time, resulting in the higher-precision compile-time evaluation.






share|improve this answer
































    13














    As observed, using the == operator to compare floating point values has resulted in different outputs with different compilers and at different optimization levels.



    One good way to compare floating point values is the relative tolerance test outlined in the article: Floating-point tolerances revisited.



    We first calculate the Epsilon (the relative tolerance) value which in this case would be:



    double Epsilon = std::max(std::cbrt(r), std::floor(std::cbrt(r))) * std::numeric_limits<double>::epsilon();


    And then use it in both the inline and non-inline functions in this manner:



    return (std::fabs(std::floor(std::cbrt(r)) - std::cbrt(r)) < Epsilon);


    The functions now are:



    bool is_cube(double r)

    double Epsilon = std::max(std::cbrt(r), std::floor(std::cbrt(r))) * std::numeric_limits<double>::epsilon();
    return (std::fabs(std::floor(std::cbrt(r)) - std::cbrt(r)) < Epsilon);


    bool inline is_cube_inline(double r)

    double Epsilon = std::max(std::cbrt(r), std::floor(std::cbrt(r))) * std::numeric_limits<double>::epsilon();
    return (std::fabs(std::round(std::cbrt(r)) - std::cbrt(r)) < Epsilon);



    Now the output will be as expected ([1 1 1]) with different compilers and at different optimization levels.



    Live demo






    share|improve this answer

























    • What's the purpose of the max() call? By definition, floor(x) is less than or equal to x, so max(x, floor(x)) will always equal x.

      – Ken Thomases
      1 hour ago











    • @KenThomases: In this particular case, where one argument to max is just the floor of the other, it is not required. But I considered a general case where arguments to max can be values or expressions which are independent of each other.

      – P.W
      28 mins ago











    Your Answer






    StackExchange.ifUsing("editor", function ()
    StackExchange.using("externalEditor", function ()
    StackExchange.using("snippets", function ()
    StackExchange.snippets.init();
    );
    );
    , "code-snippets");

    StackExchange.ready(function()
    var channelOptions =
    tags: "".split(" "),
    id: "1"
    ;
    initTagRenderer("".split(" "), "".split(" "), channelOptions);

    StackExchange.using("externalEditor", function()
    // Have to fire editor after snippets, if snippets enabled
    if (StackExchange.settings.snippets.snippetsEnabled)
    StackExchange.using("snippets", function()
    createEditor();
    );

    else
    createEditor();

    );

    function createEditor()
    StackExchange.prepareEditor(
    heartbeatType: 'answer',
    autoActivateHeartbeat: false,
    convertImagesToLinks: true,
    noModals: true,
    showLowRepImageUploadWarning: true,
    reputationToPostImages: 10,
    bindNavPrevention: true,
    postfix: "",
    imageUploader:
    brandingHtml: "Powered by u003ca class="icon-imgur-white" href="https://imgur.com/"u003eu003c/au003e",
    contentPolicyHtml: "User contributions licensed under u003ca href="https://creativecommons.org/licenses/by-sa/3.0/"u003ecc by-sa 3.0 with attribution requiredu003c/au003e u003ca href="https://stackoverflow.com/legal/content-policy"u003e(content policy)u003c/au003e",
    allowUrls: true
    ,
    onDemand: true,
    discardSelector: ".discard-answer"
    ,immediatelyShowMarkdownHelp:true
    );



    );






    zbrojny120 is a new contributor. Be nice, and check out our Code of Conduct.









    draft saved

    draft discarded


















    StackExchange.ready(
    function ()
    StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fstackoverflow.com%2fquestions%2f55590324%2finline-version-of-a-function-returns-different-value-than-non-inline-version%23new-answer', 'question_page');

    );

    Post as a guest















    Required, but never shown

























    2 Answers
    2






    active

    oldest

    votes








    2 Answers
    2






    active

    oldest

    votes









    active

    oldest

    votes






    active

    oldest

    votes









    36














    Explanation



    Some compilers (notably GCC) use higher precision when evaluating expressions at compile time. If an expression depends only on constant inputs and literals, it may be evaluated at compile time even if the expression is not assigned to a constexpr variable. Whether or not this occurs depends on:



    • The complexity of the expression

    • The threshold the compiler uses as a cutoff when attempting to perform compile time evaluation

    • Other heuristics used in special cases (such as when clang elides loops)

    If an expression is explicitly provided, as in the first case, it has lower complexity and the compiler is likely to evaluate it at compile time.



    Similarly, if a function is marked inline, the compiler is more likely to evaluate it at compile time because inline functions raise the threshold at which evaluation can occur.



    Higher optimization levels also increase this threshold, as in the -Ofast example, where all expressions evaluate to true on gcc due to higher precision compile-time evaluation.



    We can observe this behavior here on compiler explorer. When compiled with -O1, only the function marked inline is evaluated at compile-time, but at -O3 both functions are evaluated at compile-time.




    • -O1: https://godbolt.org/z/u4gh0g


    • -O3: https://godbolt.org/z/nVK4So

    NB: In the compiler-explorer examples, I use printf instead iostream because it reduces the complexity of the main function, making the effect more visible.



    Demonstrating that inline doesn’t affect runtime evaluation



    We can ensure that none of the expressions are evaluated at compile time by obtaining value from standard input, and when we do this, all 3 expressions return false as demonstrated here: https://ideone.com/QZbv6X



    #include <cmath>
    #include <iostream>

    bool is_cube(double r)

    return floor(cbrt(r)) == cbrt(r);

     
    bool inline is_cube_inline(double r)

    return floor(cbrt(r)) == cbrt(r);


    int main()

    double value;
    std::cin >> value;
    std::cout << (floor(cbrt(value)) == cbrt(value)) << std::endl; // false
    std::cout << (is_cube(value)) << std::endl; // false
    std::cout << (is_cube_inline(value)) << std::endl; // false



    Contrast with this example, where we use the same compiler settings but provide the value at compile-time, resulting in the higher-precision compile-time evaluation.






    share|improve this answer





























      36














      Explanation



      Some compilers (notably GCC) use higher precision when evaluating expressions at compile time. If an expression depends only on constant inputs and literals, it may be evaluated at compile time even if the expression is not assigned to a constexpr variable. Whether or not this occurs depends on:



      • The complexity of the expression

      • The threshold the compiler uses as a cutoff when attempting to perform compile time evaluation

      • Other heuristics used in special cases (such as when clang elides loops)

      If an expression is explicitly provided, as in the first case, it has lower complexity and the compiler is likely to evaluate it at compile time.



      Similarly, if a function is marked inline, the compiler is more likely to evaluate it at compile time because inline functions raise the threshold at which evaluation can occur.



      Higher optimization levels also increase this threshold, as in the -Ofast example, where all expressions evaluate to true on gcc due to higher precision compile-time evaluation.



      We can observe this behavior here on compiler explorer. When compiled with -O1, only the function marked inline is evaluated at compile-time, but at -O3 both functions are evaluated at compile-time.




      • -O1: https://godbolt.org/z/u4gh0g


      • -O3: https://godbolt.org/z/nVK4So

      NB: In the compiler-explorer examples, I use printf instead iostream because it reduces the complexity of the main function, making the effect more visible.



      Demonstrating that inline doesn’t affect runtime evaluation



      We can ensure that none of the expressions are evaluated at compile time by obtaining value from standard input, and when we do this, all 3 expressions return false as demonstrated here: https://ideone.com/QZbv6X



      #include <cmath>
      #include <iostream>

      bool is_cube(double r)

      return floor(cbrt(r)) == cbrt(r);

       
      bool inline is_cube_inline(double r)

      return floor(cbrt(r)) == cbrt(r);


      int main()

      double value;
      std::cin >> value;
      std::cout << (floor(cbrt(value)) == cbrt(value)) << std::endl; // false
      std::cout << (is_cube(value)) << std::endl; // false
      std::cout << (is_cube_inline(value)) << std::endl; // false



      Contrast with this example, where we use the same compiler settings but provide the value at compile-time, resulting in the higher-precision compile-time evaluation.






      share|improve this answer



























        36












        36








        36







        Explanation



        Some compilers (notably GCC) use higher precision when evaluating expressions at compile time. If an expression depends only on constant inputs and literals, it may be evaluated at compile time even if the expression is not assigned to a constexpr variable. Whether or not this occurs depends on:



        • The complexity of the expression

        • The threshold the compiler uses as a cutoff when attempting to perform compile time evaluation

        • Other heuristics used in special cases (such as when clang elides loops)

        If an expression is explicitly provided, as in the first case, it has lower complexity and the compiler is likely to evaluate it at compile time.



        Similarly, if a function is marked inline, the compiler is more likely to evaluate it at compile time because inline functions raise the threshold at which evaluation can occur.



        Higher optimization levels also increase this threshold, as in the -Ofast example, where all expressions evaluate to true on gcc due to higher precision compile-time evaluation.



        We can observe this behavior here on compiler explorer. When compiled with -O1, only the function marked inline is evaluated at compile-time, but at -O3 both functions are evaluated at compile-time.




        • -O1: https://godbolt.org/z/u4gh0g


        • -O3: https://godbolt.org/z/nVK4So

        NB: In the compiler-explorer examples, I use printf instead iostream because it reduces the complexity of the main function, making the effect more visible.



        Demonstrating that inline doesn’t affect runtime evaluation



        We can ensure that none of the expressions are evaluated at compile time by obtaining value from standard input, and when we do this, all 3 expressions return false as demonstrated here: https://ideone.com/QZbv6X



        #include <cmath>
        #include <iostream>

        bool is_cube(double r)

        return floor(cbrt(r)) == cbrt(r);

         
        bool inline is_cube_inline(double r)

        return floor(cbrt(r)) == cbrt(r);


        int main()

        double value;
        std::cin >> value;
        std::cout << (floor(cbrt(value)) == cbrt(value)) << std::endl; // false
        std::cout << (is_cube(value)) << std::endl; // false
        std::cout << (is_cube_inline(value)) << std::endl; // false



        Contrast with this example, where we use the same compiler settings but provide the value at compile-time, resulting in the higher-precision compile-time evaluation.






        share|improve this answer















        Explanation



        Some compilers (notably GCC) use higher precision when evaluating expressions at compile time. If an expression depends only on constant inputs and literals, it may be evaluated at compile time even if the expression is not assigned to a constexpr variable. Whether or not this occurs depends on:



        • The complexity of the expression

        • The threshold the compiler uses as a cutoff when attempting to perform compile time evaluation

        • Other heuristics used in special cases (such as when clang elides loops)

        If an expression is explicitly provided, as in the first case, it has lower complexity and the compiler is likely to evaluate it at compile time.



        Similarly, if a function is marked inline, the compiler is more likely to evaluate it at compile time because inline functions raise the threshold at which evaluation can occur.



        Higher optimization levels also increase this threshold, as in the -Ofast example, where all expressions evaluate to true on gcc due to higher precision compile-time evaluation.



        We can observe this behavior here on compiler explorer. When compiled with -O1, only the function marked inline is evaluated at compile-time, but at -O3 both functions are evaluated at compile-time.




        • -O1: https://godbolt.org/z/u4gh0g


        • -O3: https://godbolt.org/z/nVK4So

        NB: In the compiler-explorer examples, I use printf instead iostream because it reduces the complexity of the main function, making the effect more visible.



        Demonstrating that inline doesn’t affect runtime evaluation



        We can ensure that none of the expressions are evaluated at compile time by obtaining value from standard input, and when we do this, all 3 expressions return false as demonstrated here: https://ideone.com/QZbv6X



        #include <cmath>
        #include <iostream>

        bool is_cube(double r)

        return floor(cbrt(r)) == cbrt(r);

         
        bool inline is_cube_inline(double r)

        return floor(cbrt(r)) == cbrt(r);


        int main()

        double value;
        std::cin >> value;
        std::cout << (floor(cbrt(value)) == cbrt(value)) << std::endl; // false
        std::cout << (is_cube(value)) << std::endl; // false
        std::cout << (is_cube_inline(value)) << std::endl; // false



        Contrast with this example, where we use the same compiler settings but provide the value at compile-time, resulting in the higher-precision compile-time evaluation.







        share|improve this answer














        share|improve this answer



        share|improve this answer








        edited 17 hours ago

























        answered 18 hours ago









        Jorge PerezJorge Perez

        1,889619




        1,889619























            13














            As observed, using the == operator to compare floating point values has resulted in different outputs with different compilers and at different optimization levels.



            One good way to compare floating point values is the relative tolerance test outlined in the article: Floating-point tolerances revisited.



            We first calculate the Epsilon (the relative tolerance) value which in this case would be:



            double Epsilon = std::max(std::cbrt(r), std::floor(std::cbrt(r))) * std::numeric_limits<double>::epsilon();


            And then use it in both the inline and non-inline functions in this manner:



            return (std::fabs(std::floor(std::cbrt(r)) - std::cbrt(r)) < Epsilon);


            The functions now are:



            bool is_cube(double r)

            double Epsilon = std::max(std::cbrt(r), std::floor(std::cbrt(r))) * std::numeric_limits<double>::epsilon();
            return (std::fabs(std::floor(std::cbrt(r)) - std::cbrt(r)) < Epsilon);


            bool inline is_cube_inline(double r)

            double Epsilon = std::max(std::cbrt(r), std::floor(std::cbrt(r))) * std::numeric_limits<double>::epsilon();
            return (std::fabs(std::round(std::cbrt(r)) - std::cbrt(r)) < Epsilon);



            Now the output will be as expected ([1 1 1]) with different compilers and at different optimization levels.



            Live demo






            share|improve this answer

























            • What's the purpose of the max() call? By definition, floor(x) is less than or equal to x, so max(x, floor(x)) will always equal x.

              – Ken Thomases
              1 hour ago











            • @KenThomases: In this particular case, where one argument to max is just the floor of the other, it is not required. But I considered a general case where arguments to max can be values or expressions which are independent of each other.

              – P.W
              28 mins ago















            13














            As observed, using the == operator to compare floating point values has resulted in different outputs with different compilers and at different optimization levels.



            One good way to compare floating point values is the relative tolerance test outlined in the article: Floating-point tolerances revisited.



            We first calculate the Epsilon (the relative tolerance) value which in this case would be:



            double Epsilon = std::max(std::cbrt(r), std::floor(std::cbrt(r))) * std::numeric_limits<double>::epsilon();


            And then use it in both the inline and non-inline functions in this manner:



            return (std::fabs(std::floor(std::cbrt(r)) - std::cbrt(r)) < Epsilon);


            The functions now are:



            bool is_cube(double r)

            double Epsilon = std::max(std::cbrt(r), std::floor(std::cbrt(r))) * std::numeric_limits<double>::epsilon();
            return (std::fabs(std::floor(std::cbrt(r)) - std::cbrt(r)) < Epsilon);


            bool inline is_cube_inline(double r)

            double Epsilon = std::max(std::cbrt(r), std::floor(std::cbrt(r))) * std::numeric_limits<double>::epsilon();
            return (std::fabs(std::round(std::cbrt(r)) - std::cbrt(r)) < Epsilon);



            Now the output will be as expected ([1 1 1]) with different compilers and at different optimization levels.



            Live demo






            share|improve this answer

























            • What's the purpose of the max() call? By definition, floor(x) is less than or equal to x, so max(x, floor(x)) will always equal x.

              – Ken Thomases
              1 hour ago











            • @KenThomases: In this particular case, where one argument to max is just the floor of the other, it is not required. But I considered a general case where arguments to max can be values or expressions which are independent of each other.

              – P.W
              28 mins ago













            13












            13








            13







            As observed, using the == operator to compare floating point values has resulted in different outputs with different compilers and at different optimization levels.



            One good way to compare floating point values is the relative tolerance test outlined in the article: Floating-point tolerances revisited.



            We first calculate the Epsilon (the relative tolerance) value which in this case would be:



            double Epsilon = std::max(std::cbrt(r), std::floor(std::cbrt(r))) * std::numeric_limits<double>::epsilon();


            And then use it in both the inline and non-inline functions in this manner:



            return (std::fabs(std::floor(std::cbrt(r)) - std::cbrt(r)) < Epsilon);


            The functions now are:



            bool is_cube(double r)

            double Epsilon = std::max(std::cbrt(r), std::floor(std::cbrt(r))) * std::numeric_limits<double>::epsilon();
            return (std::fabs(std::floor(std::cbrt(r)) - std::cbrt(r)) < Epsilon);


            bool inline is_cube_inline(double r)

            double Epsilon = std::max(std::cbrt(r), std::floor(std::cbrt(r))) * std::numeric_limits<double>::epsilon();
            return (std::fabs(std::round(std::cbrt(r)) - std::cbrt(r)) < Epsilon);



            Now the output will be as expected ([1 1 1]) with different compilers and at different optimization levels.



            Live demo






            share|improve this answer















            As observed, using the == operator to compare floating point values has resulted in different outputs with different compilers and at different optimization levels.



            One good way to compare floating point values is the relative tolerance test outlined in the article: Floating-point tolerances revisited.



            We first calculate the Epsilon (the relative tolerance) value which in this case would be:



            double Epsilon = std::max(std::cbrt(r), std::floor(std::cbrt(r))) * std::numeric_limits<double>::epsilon();


            And then use it in both the inline and non-inline functions in this manner:



            return (std::fabs(std::floor(std::cbrt(r)) - std::cbrt(r)) < Epsilon);


            The functions now are:



            bool is_cube(double r)

            double Epsilon = std::max(std::cbrt(r), std::floor(std::cbrt(r))) * std::numeric_limits<double>::epsilon();
            return (std::fabs(std::floor(std::cbrt(r)) - std::cbrt(r)) < Epsilon);


            bool inline is_cube_inline(double r)

            double Epsilon = std::max(std::cbrt(r), std::floor(std::cbrt(r))) * std::numeric_limits<double>::epsilon();
            return (std::fabs(std::round(std::cbrt(r)) - std::cbrt(r)) < Epsilon);



            Now the output will be as expected ([1 1 1]) with different compilers and at different optimization levels.



            Live demo







            share|improve this answer














            share|improve this answer



            share|improve this answer








            edited 15 hours ago

























            answered 17 hours ago









            P.WP.W

            18.4k41758




            18.4k41758












            • What's the purpose of the max() call? By definition, floor(x) is less than or equal to x, so max(x, floor(x)) will always equal x.

              – Ken Thomases
              1 hour ago











            • @KenThomases: In this particular case, where one argument to max is just the floor of the other, it is not required. But I considered a general case where arguments to max can be values or expressions which are independent of each other.

              – P.W
              28 mins ago

















            • What's the purpose of the max() call? By definition, floor(x) is less than or equal to x, so max(x, floor(x)) will always equal x.

              – Ken Thomases
              1 hour ago











            • @KenThomases: In this particular case, where one argument to max is just the floor of the other, it is not required. But I considered a general case where arguments to max can be values or expressions which are independent of each other.

              – P.W
              28 mins ago
















            What's the purpose of the max() call? By definition, floor(x) is less than or equal to x, so max(x, floor(x)) will always equal x.

            – Ken Thomases
            1 hour ago





            What's the purpose of the max() call? By definition, floor(x) is less than or equal to x, so max(x, floor(x)) will always equal x.

            – Ken Thomases
            1 hour ago













            @KenThomases: In this particular case, where one argument to max is just the floor of the other, it is not required. But I considered a general case where arguments to max can be values or expressions which are independent of each other.

            – P.W
            28 mins ago





            @KenThomases: In this particular case, where one argument to max is just the floor of the other, it is not required. But I considered a general case where arguments to max can be values or expressions which are independent of each other.

            – P.W
            28 mins ago










            zbrojny120 is a new contributor. Be nice, and check out our Code of Conduct.









            draft saved

            draft discarded


















            zbrojny120 is a new contributor. Be nice, and check out our Code of Conduct.












            zbrojny120 is a new contributor. Be nice, and check out our Code of Conduct.











            zbrojny120 is a new contributor. Be nice, and check out our Code of Conduct.














            Thanks for contributing an answer to Stack Overflow!


            • Please be sure to answer the question. Provide details and share your research!

            But avoid


            • Asking for help, clarification, or responding to other answers.

            • Making statements based on opinion; back them up with references or personal experience.

            To learn more, see our tips on writing great answers.




            draft saved


            draft discarded














            StackExchange.ready(
            function ()
            StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fstackoverflow.com%2fquestions%2f55590324%2finline-version-of-a-function-returns-different-value-than-non-inline-version%23new-answer', 'question_page');

            );

            Post as a guest















            Required, but never shown





















































            Required, but never shown














            Required, but never shown












            Required, but never shown







            Required, but never shown

































            Required, but never shown














            Required, but never shown












            Required, but never shown







            Required, but never shown







            Popular posts from this blog

            Möglingen Índice Localización Historia Demografía Referencias Enlaces externos Menú de navegación48°53′18″N 9°07′45″E / 48.888333333333, 9.129166666666748°53′18″N 9°07′45″E / 48.888333333333, 9.1291666666667Sitio web oficial Mapa de Möglingen«Gemeinden in Deutschland nach Fläche, Bevölkerung und Postleitzahl am 30.09.2016»Möglingen

            Virtualbox - Configuration error: Querying “UUID” failed (VERR_CFGM_VALUE_NOT_FOUND)“VERR_SUPLIB_WORLD_WRITABLE” error when trying to installing OS in virtualboxVirtual Box Kernel errorFailed to open a seesion for the virtual machineFailed to open a session for the virtual machineUbuntu 14.04 LTS Virtualbox errorcan't use VM VirtualBoxusing virtualboxI can't run Linux-64 Bit on VirtualBoxUnable to insert the virtual optical disk (VBoxguestaddition) in virtual machine for ubuntu server in win 10VirtuaBox in Ubuntu 18.04 Issues with Win10.ISO Installation

            Torre de la Isleta Índice Véase también Referencias Bibliografía Enlaces externos Menú de navegación38°25′58″N 0°23′02″O / 38.43277778, -0.3838888938°25′58″N 0°23′02″O / 38.43277778, -0.38388889Torre de la Illeta de l’Horta o Torre Saleta. Base de datos de bienes inmuebles. Patrimonio Cultural. Secretaría de Estado de CulturaFicha BIC Torre de la Illeta de l’Horta. Dirección General de Patrimonio Cultural. Generalitat ValencianaLugares de interés. Ayuntamiento del CampelloTorre de la Isleta en CastillosNet.org