https://pastebin.com/1D3N9iA4
I just need the 8 number to be the actual I wanted output 27000000000000000000
#Any fix for this without using static? I don't know if Im just doing the data types wrong
raw spear
native steepleBOT
raw spear
kind reef
27000000000000000000 is way bigger than the max limit of uint64_t
Can you describe what exactly you're trying to do?
raw spear
I wanted to mulitply these two numbers together
So I made a multiply function however it seems to not work due to my data types. I only wanted the output to be a long double but I get an error if I don't also make those numbers above long doubles too
obtuse leaf
unsigned long long multiplied with unsigned long long gives unsigned long long.
raw spear
Understood. So have to keep everything same types for multiplication
obtuse leaf
Not really, the result type is determined based on the operands' types and not the variable in which the result is stored.
raw spear
isn't it still possible to have different operand types and still multiply them for the corrected value like in my case
obtuse leaf
When operands are of different types they are converted to one common type based on a few rules.
But what you are having is not.
Your result variable's type is different but the two operand types are the same.
raw spear
Ok thank you so static is the kinda the other only option
native steepleBOT
@raw spear Has your question been resolved? If so, type !solved :)
obtuse leaf
Wot, how is static related to this?
grave dagger
you could do result = static_cast<double>(large_number) * even_larger_number;
to force the result into a double, but double is not 'large' enough to store all the digits
I get the feeling this is a homework where one has to write a custom multiplication that can take very large numbers.
possibly as strings of digits
shrewd gate
https://pastebin.com/1D3N9iA4
I just need the 8 number to be the actual I wanted...
long double on most common platforms won't be able to store 27000000000000000000 precisely either, you'll need C++23's std::float_128, or another representation such as strings, or byte arrays for this
;cpp << std::setprecision(1000000000) << 27000000000000000001.L;
odd ledgeBOT
shrewd gate
For example, you can see here that the last 1 is truncated from the output as it can't be represented by a 80bit float (which is used on godbolt, and most other machines
Also, you might want to check out GMP
grave dagger
`27000000000000000000` is way bigger than the max limit of `uint64_t`
you might want to re-calibrate your intuition - it's only out by about 1.5x
maybe the font made it look wider 😆
(let ME be the nerd-out nitpicker for once)
grave dagger
`long double` on most common platforms won't be able to store `27000000000000000...
the question which numbers can be stored/represented precisely is quite involved - and should not be taken lightly 😆
I would venture the guess that 2.7e19 can be represented in 80bit float while 2.7e19+1 can't
again, curious that the number is just around the brink
shrewd gate
the question which numbers can be stored/represented precisely is quite involved...
Since it’s an even number it can be represented precisely (which is why I added the +1 to demonstrate) though it shouldn’t be assumed to be an even number
grave dagger
let's only use even numbers then 
native steepleBOT