Found another alternative to using the int32_max constant,

std::numeric_limits<int32_t>::max() from the limits.h file could also be used and ive found that it doesnt cause as much of a problem as trying to sort it through other means.

Not really a bug, just a feature suggestion lol

format_from_stream should return decimal_format, not basic_decimal_format.
Since the function returns by value, it will be truncated.

It would be of great use if your decimal class supported overloading cmath functions std::pow() and std::sqrt().
I could not implement it myself, so don't have a pull request.

Is it possible to add modulo operator? Thank you.

Hello. When i tried decimal_for_cpp with decimal10 i got this error:

decimal.h(72) :warning C4307: '*' : integral constant overflow
decimal.h(311) : see reference to class template instantiation 'decc::DecimalFactor' being compiled with [Prec=10]
decimal.h(308) : while compiling class template member function 'void decc::decimal::init(double)' with [Prec=10]

So i changed line 72 from:

static const int value = 10 * DecimalFactor<Prec - 1>::value;

to

static const int64 value = 10 * DecimalFactor<Prec - 1>::value;

And it worked: "57380.543000" 5738054300000 573805430000000
Before that, precision 10 was showing a very different number...

PS. I also had to change more lines because of truncation warnings:

131: explicit decimal(int64 value, int64 precFactor) { initWithPrec(value, precFactor); }
135: inline int64 getPrecFactor() const { return DecimalFactor::value; }
323: void initWithPrec(int64 value, int64 precFactor) {
324: int64 ownFactor = DecimalFactor::value;

Do you think thats ok, to put all those int64 there?

Hello,

[
these are my first steps with this lib ,
btw, its awesome , thanks for sharing it.
]

is there a way to perform assignment from std::string, something like
DEC_NAMESPACE::decimal<8> TempDec8Value
for (...)
{
TempDec8Value = std::string
}

thanks,
Omer.

Hello
Thx very mutch for your decimal_for_cpp. Its working great.
But there is one littel issue.
If you use decimal_for_cpp with Qt you have to rename the namespace, because the namespace "dec"
is allready taken by Qt.
You maybe consider to change that namespace name.

Regards Sascha

for example template
decimal & operator+=(const decimal &rhs) :

       dec::decimal<8> p8(1);
       dec::decimal<4> p4(0);

        p8 += p4;
        p4 += p8;

both operations fail on either one of the static asserts. They cannot removed, because else one branch creates an infinite template recursion. This is on linux with gcc 7.3.

Hello!

Can you explain the difference between your implementation vs IEEE 754-2008?
What about Intel Decimal Floating-Point Math Library?
Have you done some benchmarks of the library?

I would suggest making constructors and init methods constexpr.
Also it would be convenient to have user defined literal (for example 0.0_dec)

  decimal<2> x;

  x = 5.6;

  if (x == 5.6) {
      puts("ok");
  }

I get with vs2012, this error :

error C2678: binary '==' : no operator found which takes a left-hand operand of type 'dec::decimal' (or there is no acceptable conversion)

Hello,

Could you please take a look at vincentlaucsb/csv-parser#159 ?

thanks,
Omer.

Example in README gives me those warnings when DEC_NO_CPP11is defined before inclusion of decimal.h (commit of version 1.18), with AppleClang 12 on Macos without forcing C++11 standard or higher:

/Users/spaceim/.conan/data/decimal_for_cpp/1.18/_/_/package/5ab84d6acfe1f23c4fae0ab88f26e3a396351ac9/include/decimal.h:129:9: warning: 'static_assert' macro redefined [-Wmacro-redefined]
#define static_assert(a,b)
        ^
/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/__config:880:10: note: previous definition is here
# define static_assert(...) _Static_assert(__VA_ARGS__)
         ^
In file included from ../../test_package.cpp:2:
/Users/spaceim/.conan/data/decimal_for_cpp/1.18/_/_/package/5ab84d6acfe1f23c4fae0ab88f26e3a396351ac9/include/decimal.h:1602:36: warning: 'override' keyword is a C++11 extension [-Wc++11-extensions]
        char decimal_point() const override {
                                   ^
/Users/spaceim/.conan/data/decimal_for_cpp/1.18/_/_/package/5ab84d6acfe1f23c4fae0ab88f26e3a396351ac9/include/decimal.h:1606:36: warning: 'override' keyword is a C++11 extension [-Wc++11-extensions]
        char thousands_sep() const override {
                                   ^
/Users/spaceim/.conan/data/decimal_for_cpp/1.18/_/_/package/5ab84d6acfe1f23c4fae0ab88f26e3a396351ac9/include/decimal.h:1610:41: warning: 'override' keyword is a C++11 extension [-Wc++11-extensions]
        bool thousands_grouping() const override {
                                        ^
/Users/spaceim/.conan/data/decimal_for_cpp/1.18/_/_/package/5ab84d6acfe1f23c4fae0ab88f26e3a396351ac9/include/decimal.h:1614:38: warning: 'override' keyword is a C++11 extension [-Wc++11-extensions]
        std::string grouping() const override {
                                     ^

Hello Piotr

First I must thank you for creation, its really a must in the cpp space.

I'm using 1.18,
and am unable to compile the following
struct MyStruct
{
decimal<2> myVariable(0);
}

also can't
struct MyStruct
{
decimal<2> myVariable = 0;
}
error : could not convert ‘0’ from ‘int’ to ‘dec::decimal<2>’
^

I can set a value in the constructor mil. this is a decent workaround , but less convenient for me at this time.

please advise,
Omer.

The following code snippet returns an invalid string.

cout << "Test with <4> is: " << decimal<4>(-0.5) << endl;

Nice lib. Tried it, it works OK.

It just miss a serialization/deserialization (to string) feature so I can save the values in my database without any loss.

Existing "to string" convert to double first, with potential precision loss. And there is no "from string", need to import from double, too.

Thanks.

To test the numerical precision of your implementation, there is a simple test to perform: compute Muller's recursion.
This simple formula shows that usual floating point diverges rapidly from expected result.
Muller's formula is:

   f(y, z) = 108 - (815 - 1500/z) / y
   x_0 = 4
   x_1 = 4.25
   x_i = f(x_[i-1], x_[i-2])

This formula has 2 poles: 5 and 100. Typically, if x happens to be 5, it'll stay 5. The closer it is to 5, the more likely it'll reach 5. Similarly, if x happens to be 100, it'll stay 100.

The expected result with the starting values above should be 5, reached after 30 iterations.
Used with standard floating point, it's deviating and converging towards 100 rapidly.

See my godbolt for example code

I had a problem with CLANG compiler for ARM. In release build the code below was optimized in a way that the multiplication and division did not occur as separate operations and no overflow was detected (there should have been an overflow). When I turned off optimization it worked as intended. In the VS 2017 compiler this worked as intended in both release and debug.

Original code that was optimized to "true" as in no overflow detected although there was an overflow:

        int64 resDecPart = value1dec * value2dec;
	if (resDecPart / value1dec == value2dec) { // no overflow

I changed the code to this and that works in CLANG and VS compiler, both release and debug

if (value1dec != 0 && (std::numeric_limits<int64>::max() / value1dec) >= value2dec) { // no overflow

incorrect constructing from fp

dec::decimal2(9999999999999998.0); // 9999999999999997.44
dec::decimal4(9999999999999998.0); // -92233720368547758.08

incorrect round
dec::decimal2(3.1549999999999998); // must be 3.15, but 3.16

test condition and test condition is incorrect

hi.

I've been using this lib (1.18) for a few months now. ( thanks for building it btw).

now I've encountered a situation were I've realized I need to change many existing decimal2 variables to decimal4 .
when I change one of them, i get the complication error
..../decimal.h:793: error: no matching function for call to ‘dec::decimal<4>::decimal(const dec::decimal<2>&)’
793 | return (*this == static_cast(rhs));
| ^~~~~~~~~~~~~~~~~~~~~~~~~

using gcc/g++ 9.4.0.

I was not able to find in my code cases of of the changed variable construction using another dec2 variable, that would match the error msg [i.e my_dec4_variable = decimal4(old_dec2_variable)].
the compiler is unable to pinpoint the location of the error ( I guess its because this is a template class).
but there are many assignments [ i.e. changed_dec4_variable = .... unchanged_dec2_variable ... ; ]

I was wondering how I can proceed.
i'd rather avoid manually changing a lot of code to add explicit decimal_cast<4>.
id rather have some sort of built in support for the required assignment. ( an overload of the constructor or assignment operator ???)

I noticed config parameter DEC_TYPE_LEVEL, but did not understand if/how it can be applied here.

can anyone suggest a simple way to proceed?
:-)

I would like the option of making the class fully trivial. This would be a breaking change, as an uninitialized object would have a random value (just like int).

The advantage of this is that it can easily be used by templates that require trivial objects.

I suggest using a new #define, but this will add to the complexity of the class.

#ifdef DEC_TRIVIAL
    decimal() = default;
#else
    decimal() noexcept : m_value(0) {}
#endif

Hey congrats for this work! I am using decimal_for_cpp for checking the results of some other algorithm (fpga) when I came across to a few test cases that are failing when apparently they should not. I want to check if this is expected behavior. For example:

BOOST_CHECK_EQUAL( dec::decimal<0>::buildWithExponent(1,-23), dec::decimal<0>("0"));

This test should not fail but it is right now. This can be seen as an underflow, right?

see past builds on github

    decimal &pack(int64 beforeValue, int64 afterValue) {
      if (Prec > 0) {
        m_value = beforeValue * DecimalFactor<Prec>::value;
        m_value += (afterValue % DecimalFactor<Prec>::value);
       } else
        m_value = beforeValue * DecimalFactor<Prec>::value;
      return *this;
    }

Sorry, but are you sure that this works? I mean taking a modulo for afterValue?

Suppose you have pack(123, 456) with precision of 2. You will got 123.04 as a result.

And second question is about negative numbers, what if beforeValue < 0? Then when calling pack(-12, 34) with precision of 2, you will got -1200 + 34 == 1166.

in fromString and toString it would be nice to have the option of specifying decimal separator and thousand grouping directly as parameters.

Sometimes I want to parse with different settings than what my computer has.

I don't like to change my locale settings just to parse a few numbers with a different separator.

hello,

I need to extract the root of a DEC_NAMESPACE,
the standard sqrt operates on double.
I was able to result = std::sqrt(Input.getAsDouble());
but i guess i'm losing precision here somewhere...

please advise,
thanks,
Omer.

please try to evaluate the following small change

define DEC_MAX_INT32 ((std::numeric_limits::max)())

to make the header file compatible with includes which defines min and max macros

Hi

Can you please share the method to extract/convert to basic types?

for example :
int myInt;
dec<2> myDec("1");
myInt = myDec ;
currently this returns a "cannot convert error".
i've also tried dec<2,null_round_policy>... to no avail.

furthermore,
what I actually need right now is to perform a conversion on a "temporary"(implicitly defined) variable , for example :
int result = (decA - DecB) / DecC;
(in this case I precheck that the result of this calculation is in fact an integer)

Please advise,
Omer.

There can be an overflow condition that isn't caught right now.
Currently line 709 has:
if ((abs(value1) <= DEC_MAX_INT32) || (abs(value2) <= DEC_MAX_INT32))

I encountered an overflow when using dec::decimal6.
I changed my downloaded version and changed the line to:

if ((llabs(value1) <= DEC_MAX_INT32) && (llabs(value2) <= DEC_MAX_INT32))

The overflow occurred on the abs() call to one of the values.
I thought it safer to make it an AND condition, not and OR.

Hello,

Firstly, thank you very much for creating and publishing this wonderful library!

When adding to my project, i got a bunch of compiler errors similar to the one below.

../MehProject/./LIBS/decimal_for_cpp-master/include/decimal.h:403:29: error: member reference base type 'decimal<Prec, RoundPolicy> *' is not a structure or union
                multDiv(this.m_value, 1, rhs);
                        ~~~~^~~~~~~~

The method is defined using this.m_value to access the classes m_value dec_storage_t value when it should be a ->. Changing this allows the project to compile and now the arguments to the functions being called make sense.

Linux seems to not use INT32_MAX, I have added

#ifdef __linux__
    #define INT32_MAX INT_MAX
#endif

To the top of the header and this lets it compile.

Compile failure with that code:

int main() {
    dec::decimal<2> vol = 1.002;
    vol = 100.015;
    std::cout<<vol<<std::endl;
    return 0;
}

./try_decimal.cpp:5:21: error: no viable conversion from 'double' to 'dec::decimal<2>'
    dec::decimal<2> vol = 1.002;
./decimal_for_cpp/include/decimal.h:667:5: note: candidate constructor not viable: no known conversion from 'double' to 'const dec::decimal<2, dec::def_round_policy> &' for 1st argument
    decimal(const decimal &src) = default;

The stackoverflow said that: https://stackoverflow.com/questions/21822438/in-copy-initialization-is-the-call-to-the-copy-constructor-explicit-or-implicit