Re: P1788.1/M001.01 Missing roundTiesToEven/roundTiesToAway
Hi Dmitry,
Thank you for your comments.
> On Oct 7, 2015, at 7:57 AM, Dmitry Nadezhin <dmitry.nadezhin@xxxxxxxxxx> wrote:
>
> Simplicity is the goal of the simplified standard.
> One aspect of simplicity is a simple and regular API - a user can easyly keep in
> his/her mind a set of available operations and their interaction.
> Another aspect is a simplicity of implementation.
I would add, another aspect is we want non-experts to find it reasonably easy to understand
and to have what they presumably need. I am thinking of say people in hybrid systems
using interval methods.
> For me the first aspect has priority over the second aspect.
>
> The main standard 1788 and the simplified standard 1788.1 are related
> and, I think, they should be consistent so that user can easy keep them in memory.
> The main standard has two parts - the all flavor part and the set-based part.
> The simplified standard doesn't mention flavors, but it almost satisfies requirements
> to the flavor of the main standard.
I agree.
> There are a few exemptions listed at the end of the simplified standard.
>
> The relation between the standards could be simpler if there were no these exemptions,
> though implemention would be a litlle larger.
The document would be “cleaner” without such exceptions. At the same time, “minimalistic”
is one of the goals.
> I suggest to remove these exemptions
> and include in the standard the missing operations that are required in all flavours of the main standard.
>
> There are currently three exemptions:
> - rounding operations;
> - cancellative operations;
> - syntax of argument of textToInterval(s) constructor.
>
> I will say a few words about rounding operations in this email.
> Five rounding operations in the main standard 1788 correspond one-to-one
> to 5 rounding directions of IEEE 754/2008:
> roundTiesToEven(x) roundTiesToEven;
> roundTiesToAway(x) roundTiesToAway;
> ceil(x) roundTowardPositive;
> floor(x) roundTowardNegative;
> trunc(x) roundTowardZero .
> So it is easy to remember them.
> Current draft of the simplified standard omits two of these functions:
> roundTiesToEven(x) and roundTiesToAway(x). This seems irregular.
> The implementation of this functions is not difficult.
I suggest that the working group decides, and we judge based on
how much the above functionality has been used.
From my practical experience, I could live without it.
I do not know if you should make a motion?
Best regards,
Ned
>
> Below you can look at implementation of roundTiesToEven from
> https://java.net/projects/jinterval/sources/svn/content/trunk/jinterval/p1788-launcher-java/src/main/resources/net/java/jinterval/p1788/integerFuns.c?rev=379
> I do not consider it difficult.
> So I suggest to keep regularity and do not omit roundTiesToEven and roundTiesToAway from the basic standard.
>
> Best Regards,
> -Dima
>
> =============== roundTiesToEven ==============
> int roundTiesToEvenBareInfsupB64(BARE_INFSUP_B64 *r, BARE_INFSUP_B64 *x) {
> assert(isValidBareInfsupB64(x));
> int d = COM;
>
> unsigned long long xi = infbits(x);
> int inf_e = ((int) ((xi & EXP_MASK_B64) >> (PRECISION_B64 - 1))) - EXP_BIAS_B64; // exponent of inf
> if (inf_e <= -1) {
> if ((xi & ~SIGN_MASK_B64) <= 0x3fe0000000000000ULL) // +-0.5
> {
> if ((xi & ~SIGN_MASK_B64) == 0x3fe0000000000000ULL) // +-0.5
> {
> d = DAC;
> }
> xi = SIGN_MASK_B64; // -0
> }
> else
> {
> xi = (xi & SIGN_MASK_B64) | 0x3ff0000000000000ULL; // +-1
> }
> } else if (inf_e < (PRECISION_B64 - 1)) {
> int sh = (PRECISION_B64 - 1) - inf_e; // bits to clear
> xi += (1ULL << (sh - 1)); // add 1/2
> if ((xi & ((1ULL << sh) - 1)) == 0) { // tie
> xi = (xi >> (sh + 1)) << (sh + 1); // round to even
> d = DAC;
> } else {
> xi = (xi >> sh) << sh;
> }
> }
>
> unsigned long long xs = supbits(x);
> int sup_e = ((int) ((xs & EXP_MASK_B64) >> (PRECISION_B64 - 1))) - EXP_BIAS_B64; // exponent of sup
> if (sup_e <= -1) {
> if ((xs & ~SIGN_MASK_B64) <= 0x3fe0000000000000ULL) // +-0.5
> {
> if ((xs & ~SIGN_MASK_B64) == 0x3fe0000000000000ULL) // +-0.5
> {
> d = DAC;
> }
> xs = 0; // +0
> }
> else
> {
> xs = (xs & SIGN_MASK_B64) | 0x3ff0000000000000ULL; // +-1
> }
> } else if (sup_e < (PRECISION_B64 - 1)) {
> int sh = (PRECISION_B64 - 1) - sup_e; // bits to clear
> xs += (1ULL << (sh - 1)); // add 1/2
> if ((xs & ((1ULL << sh) - 1)) == 0) { // tie
> xs = (xs >> (sh + 1)) << (sh + 1); // round to even
> d = DAC;
> } else {
> xs = (xs >> sh) << sh;
> }
> }
>
> if (xi != xs && (xi != SIGN_MASK_B64 || xs != 0)) {
> if (xs == NEG_INFINITY_B64) {
> setEmptyBareInfsupB64(r);
> return TRV;
> }
> d = DEF;
> }
> setbits(r, xi, xs);
> return d;
> }
> ===============