Inline version of a function returns different value than non-inline version The 2019 Stack...
Does a dangling wire really electrocute me if I'm standing in water?
Which Sci-Fi work first showed weapon of galactic-scale mass destruction?
Patience, young "Padovan"
It's possible to achieve negative score?
How to make payment on the internet without leaving a money trail?
Can distinct morphisms between curves induce the same morphism on singular cohomology?
Why Did Howard Stark Use All The Vibranium They Had On A Prototype Shield?
What tool would a Roman-age civilization have to grind silver and other metals into dust?
Is it possible for the two major parties in the UK to form a coalition with each other instead of a much smaller party?
What could be the right powersource for 15 seconds lifespan disposable giant chainsaw?
What is this 4-propeller plane?
Why is the maximum length of OpenWrt’s root password 8 characters?
Inversion Puzzle
Output the Arecibo Message
What is a mixture ratio of propellant?
Where does the "burst of radiance" from Holy Weapon originate?
Is three citations per paragraph excessive for undergraduate research paper?
Does it makes sense to buy a new cycle to learn riding?
Realistic Alternatives to Dust: What Else Could Feed a Plankton Bloom?
Is "plugging out" electronic devices an American expression?
In microwave frequencies, do you use a circulator when you need a (near) perfect diode?
Should I use my personal or workplace e-mail when registering to external websites for work purpose?
What are the motivations for publishing new editions of an existing textbook, beyond new discoveries in a field?
"What time...?" or "At what time...?" - what is more grammatically correct?
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;
}
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++
New contributor
|
show 14 more comments
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++
New contributor
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
16 hours ago
4
Compiler returns forcbrt(27.0)
the value of0x0000000000000840
while the standard library returns0x0100000000000840
. 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
|
show 14 more comments
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++
New contributor
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++
c++
New contributor
New contributor
edited 28 mins ago
chwarr
4,27811843
4,27811843
New contributor
asked 17 hours ago
zbrojny120zbrojny120
31328
31328
New contributor
New contributor
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
16 hours ago
4
Compiler returns forcbrt(27.0)
the value of0x0000000000000840
while the standard library returns0x0100000000000840
. 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
|
show 14 more comments
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
16 hours ago
4
Compiler returns forcbrt(27.0)
the value of0x0000000000000840
while the standard library returns0x0100000000000840
. 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
16 hours ago
Did you set the
-Ofast
option, which allows such optimizations?– cmdLP
16 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
|
show 14 more comments
2 Answers
2
active
oldest
votes
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.
add a comment |
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
What's the purpose of themax()
call? By definition,floor(x)
is less than or equal tox
, somax(x, floor(x))
will always equalx
.
– Ken Thomases
22 mins ago
add a comment |
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.
Sign up or log in
StackExchange.ready(function () {
StackExchange.helpers.onClickDraftSave('#login-link');
});
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Required, but never shown
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
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.
add a comment |
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.
add a comment |
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.
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.
edited 15 hours ago
answered 16 hours ago
Jorge PerezJorge Perez
1,869618
1,869618
add a comment |
add a comment |
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
What's the purpose of themax()
call? By definition,floor(x)
is less than or equal tox
, somax(x, floor(x))
will always equalx
.
– Ken Thomases
22 mins ago
add a comment |
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
What's the purpose of themax()
call? By definition,floor(x)
is less than or equal tox
, somax(x, floor(x))
will always equalx
.
– Ken Thomases
22 mins ago
add a comment |
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
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
edited 14 hours ago
answered 16 hours ago
P.WP.W
18.4k41758
18.4k41758
What's the purpose of themax()
call? By definition,floor(x)
is less than or equal tox
, somax(x, floor(x))
will always equalx
.
– Ken Thomases
22 mins ago
add a comment |
What's the purpose of themax()
call? By definition,floor(x)
is less than or equal tox
, somax(x, floor(x))
will always equalx
.
– Ken Thomases
22 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
22 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
22 mins ago
add a comment |
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.
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.
Sign up or log in
StackExchange.ready(function () {
StackExchange.helpers.onClickDraftSave('#login-link');
});
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Required, but never shown
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
Sign up or log in
StackExchange.ready(function () {
StackExchange.helpers.onClickDraftSave('#login-link');
});
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Required, but never shown
Sign up or log in
StackExchange.ready(function () {
StackExchange.helpers.onClickDraftSave('#login-link');
});
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Required, but never shown
Sign up or log in
StackExchange.ready(function () {
StackExchange.helpers.onClickDraftSave('#login-link');
});
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
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
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
16 hours ago
4
Compiler returns for
cbrt(27.0)
the value of0x0000000000000840
while the standard library returns0x0100000000000840
. 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