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

Is there a name of the flying bionic bird?

How to create dashed lines/arrows in Illustrator

Why don't Unix/Linux systems traverse through directories until they find the required version of a linked library?

Where does the "burst of radiance" from Holy Weapon originate?

Which Sci-Fi work first showed weapon of galactic-scale mass destruction?

What is this 4-propeller plane?

What is the purpose of the constant in the probability density function

Time travel alters history but people keep saying nothing's changed

Should I write numbers in words or as numerals when there are multiple next to each other?

It's possible to achieve negative score?

Why could you hear an Amstrad CPC working?

Springs with some finite mass

A poker game description that does not feel gimmicky

The difference between dialogue marks

What could be the right powersource for 15 seconds lifespan disposable giant chainsaw?

On the insanity of kings as an argument against monarchy

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

Output the Arecibo Message

What can other administrators access on my machine?

Why isn't airport relocation done gradually?

Why Did Howard Stark Use All The Vibranium They Had On A Prototype Shield?

How can I create a character who can assume the widest possible range of creature sizes?

Pristine Bit Checking

What do hard-Brexiteers want with respect to the Irish border?



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;








46















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
    17 hours ago






  • 20





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

    – 500 - Internal Server Error
    17 hours ago






  • 2





    related stackoverflow.com/questions/588004/…

    – user463035818
    17 hours ago






  • 2





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

    – cmdLP
    17 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
    16 hours ago


















46















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
    17 hours ago






  • 20





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

    – 500 - Internal Server Error
    17 hours ago






  • 2





    related stackoverflow.com/questions/588004/…

    – user463035818
    17 hours ago






  • 2





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

    – cmdLP
    17 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
    16 hours ago














46












46








46


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 52 mins 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 17 hours ago









zbrojny120zbrojny120

31328




31328




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
    17 hours ago






  • 20





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

    – 500 - Internal Server Error
    17 hours ago






  • 2





    related stackoverflow.com/questions/588004/…

    – user463035818
    17 hours ago






  • 2





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

    – cmdLP
    17 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
    16 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
    17 hours ago






  • 20





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

    – 500 - Internal Server Error
    17 hours ago






  • 2





    related stackoverflow.com/questions/588004/…

    – user463035818
    17 hours ago






  • 2





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

    – cmdLP
    17 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
    16 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
17 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
17 hours ago




20




20





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

– 500 - Internal Server Error
17 hours ago





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

– 500 - Internal Server Error
17 hours ago




2




2





related stackoverflow.com/questions/588004/…

– user463035818
17 hours ago





related stackoverflow.com/questions/588004/…

– user463035818
17 hours ago




2




2





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

– cmdLP
17 hours ago





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

– cmdLP
17 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
16 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
16 hours ago













2 Answers
2






active

oldest

votes


















34














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
































    12














    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
      46 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









    34














    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





























      34














      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



























        34












        34








        34







        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 16 hours ago

























        answered 17 hours ago









        Jorge PerezJorge Perez

        1,869618




        1,869618























            12














            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
              46 mins ago















            12














            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
              46 mins ago













            12












            12








            12







            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 14 hours ago

























            answered 16 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
              46 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
              46 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
            46 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
            46 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

            Can not update quote_id field of “quote_item” table magento 2Magento 2.1 - We can't remove the item. (Shopping Cart doesnt allow us to remove items before becomes empty)Add value for custom quote item attribute using REST apiREST API endpoint v1/carts/cartId/items always returns error messageCorrect way to save entries to databaseHow to remove all associated quote objects of a customer completelyMagento 2 - Save value from custom input field to quote_itemGet quote_item data using quote id and product id filter in Magento 2How to set additional data to quote_item table from controller in Magento 2?What is the purpose of additional_data column in quote_item table in magento2Set Custom Price to Quote item magento2 from controller

            How to solve knockout JS error in Magento 2 Planned maintenance scheduled April 23, 2019 at 23:30 UTC (7:30pm US/Eastern) Announcing the arrival of Valued Associate #679: Cesar Manara Unicorn Meta Zoo #1: Why another podcast?(Magento2) knockout.js:3012 Uncaught ReferenceError: Unable to process bindingUnable to process binding Knockout.js magento 2Cannot read property `scopeLabel` of undefined on Product Detail PageCan't get Customer Data on frontend in Magento 2Magento2 Order Summary - unable to process bindingKO templates are not loading in Magento 2.1 applicationgetting knockout js error magento 2Product grid not load -— Unable to process binding Knockout.js magento 2Product form not loaded in magento2Uncaught ReferenceError: Unable to process binding “if: function()return (isShowLegend()) ” magento 2

            Nissan Patrol Зміст Перше покоління — 4W60 (1951-1960) | Друге покоління — 60 series (1960-1980) | Третє покоління (1980–2002) | Четверте покоління — Y60 (1987–1998) | П'яте покоління — Y61 (1997–2013) | Шосте покоління — Y62 (2010- ) | Посилання | Зноски | Навігаційне менюОфіційний український сайтТест-драйв Nissan Patrol 2010 7-го поколінняNissan PatrolКак мы тестировали Nissan Patrol 2016рвиправивши або дописавши її