This repository has been archived by the owner on Jun 1, 2023. It is now read-only.

use arith 'exact'/'fast' #21

Open

rurban opened this issue Sep 11, 2015 · 2 comments

Assignees

Labels

enhancement ready

Member

rurban commented Sep 11, 2015

New lexical pragma for exact or fast arith, promote to double or bigint? We probably need a PL_hints bit for this, more then for no magic or strict names.

Add a core pragma to select arithmetic overflow semantics.
Overflow to fast NV (double) as with perl5, or to exact bigint/num/rat as with perl6.

rurban added the enhancement label

rurban self-assigned this

Member Author

rurban commented Dec 9, 2015

See e.g. 2713d58
for pp_add with exactarith instead of promoting to NV. Note that NV overflow/precision loss is not done there yet.

rurban pushed a commit that referenced this issue


          exact_arith: implement it

a2e7e76

Promote on overflow to bigint, and not to NV.
This is a new lexical user-pragma to use exact
arithmetic without loosing precision on all builtin arithmetic ops.
As in perl6, just much faster. (only in the rare 1% overflow case)

It is of course a bit slower than without, but I could not
measure any difference.

See #21.

rurban pushed a commit that referenced this issue


          exact_arith: implement it

fb34414

Promote on overflow to bigint/num, and not to NV.
This is a new lexical user-pragma to use exact
arithmetic without loosing precision on all builtin arithmetic ops.
As in perl6.

It is of course a bit slower than without.

Closes #21.

rurban pushed a commit that referenced this issue


          exact_arith: implement it

5edf944

Promote on overflow to bigint, and not to NV.
This is a new lexical user-pragma to use exact
arithmetic without loosing precision on all builtin arithmetic ops.
As in perl6, just much faster. (only in the rare 1% overflow case)

It is of course a bit slower than without, but I could not
measure any difference.

See #21.

rurban pushed a commit that referenced this issue


          Rename PPPort_xs.PL to RealPPPort_xs.PL

0f14f67

Fixes Devel-PPPort GH #21

To avoid confusion rename the template for RealPPPort.xs
file as RealPPPort_xs.PL so it's now clear what file
it generates.

rurban pushed a commit that referenced this issue


          Rename PPPort_xs.PL to RealPPPort_xs.PL

3bfe1c6

Fixes Devel-PPPort GH #21

To avoid confusion rename the template for RealPPPort.xs
file as RealPPPort_xs.PL so it's now clear what file
it generates.

(cherry picked from commit 0f14f67)
Signed-off-by: Nicolas R <[email protected]>

rurban pushed a commit that referenced this issue


          exact_arith: implement it

5efa55f

Promote on overflow to bigint/num, and not to NV.
This is a new lexical user-pragma to use exact
arithmetic without loosing precision on all builtin arithmetic ops.
As in perl6.

It is of course a bit slower than without.

Closes #21.

rurban pushed a commit that referenced this issue


          exact_arith: implement it

b4c46f8

Promote on overflow to bigint, and not to NV.
This is a new lexical user-pragma to use exact
arithmetic without loosing precision on all builtin arithmetic ops.
As in perl6, just much faster. (only in the rare 1% overflow case)

It is of course a bit slower than without, but I could not
measure any difference.

See #21.

rurban pushed a commit that referenced this issue


          exact_arith: implement it

8b8af00

Promote on overflow to bigint, and not to NV.
This is a new lexical user-pragma to use exact
arithmetic without loosing precision on all builtin arithmetic ops.
As in perl6, just much faster. (only in the rare 1% overflow case)

It is of course a bit slower than without, but I could not
measure any difference.

See #21.

rurban pushed a commit that referenced this issue


          exact_arith: implement it

567535e

Promote on overflow to bigint/num, and not to NV.
This is a new lexical user-pragma to use exact
arithmetic without loosing precision on all builtin arithmetic ops.
As in perl6.

It is of course a bit slower than without.

Closes #21.

rurban pushed a commit that referenced this issue


          exact_arith: implement it

0376e5f

Promote on overflow to bigint/num, and not to NV.
This is a new lexical user-pragma to use exact
arithmetic without loosing precision on all builtin arithmetic ops.
As in perl6.

It is of course a bit slower than without.

Closes #21.

rurban pushed a commit that referenced this issue


          exact_arith: implement it

33e3cd0

Promote on overflow to bigint, and not to NV.
This is a new lexical user-pragma to use exact
arithmetic without loosing precision on all builtin arithmetic ops.
As in perl6, just much faster. (only in the rare 1% overflow case)

It is of course a bit slower than without, but I could not
measure any difference.

See #21.

rurban pushed a commit that referenced this issue


          exact_arith: implement it

f32233a

Promote on overflow to bigint/num, and not to NV.
This is a new lexical user-pragma to use exact
arithmetic without loosing precision on all builtin arithmetic ops.
As in perl6.

It is of course a bit slower than without.

Closes #21.

rurban pushed a commit that referenced this issue


          exact_arith: implement it

a0911f4

Promote on overflow to bigint, and not to NV.
This is a new lexical user-pragma to use exact
arithmetic without loosing precision on all builtin arithmetic ops.
As in perl6, just much faster. (only in the rare 1% overflow case)

It is of course a bit slower than without, but I could not
measure any difference.

See #21.

rurban pushed a commit that referenced this issue


          exact_arith: implement it

Promote on overflow to bigint/num, and not to NV.
This is a new lexical user-pragma to use exact
arithmetic without loosing precision on all builtin arithmetic ops.
As in perl6.

It is of course a bit slower than without.

Closes #21.

rurban pushed a commit that referenced this issue


          exact_arith: implement it

7befe9c

Promote on overflow to bigint, and not to NV.
This is a new lexical user-pragma to use exact
arithmetic without loosing precision on all builtin arithmetic ops.
As in perl6, just much faster. (only in the rare 1% overflow case)

It is of course a bit slower than without, but I could not
measure any difference.

See #21.

rurban pushed a commit that referenced this issue


          exact_arith: implement it

a4b09c9

Promote on overflow to bigint/num, and not to NV.
This is a new lexical user-pragma to use exact
arithmetic without loosing precision on all builtin arithmetic ops.
As in perl6.

It is of course a bit slower than without.

Closes #21.

rurban pushed a commit that referenced this issue


          exact_arith: implement it

d714f57

Promote on overflow to bigint, and not to NV.
This is a new lexical user-pragma to use exact
arithmetic without loosing precision on all builtin arithmetic ops.
As in perl6, just much faster. (only in the rare 1% overflow case)

It is of course a bit slower than without, but I could not
measure any difference.

See #21.

rurban pushed a commit that referenced this issue


          exact_arith: implement it

c620809

Promote on overflow to bigint/num, and not to NV.
This is a new lexical user-pragma to use exact
arithmetic without loosing precision on all builtin arithmetic ops.
As in perl6.

It is of course a bit slower than without.

Closes #21.

rurban pushed a commit that referenced this issue


          exact_arith: implement it

e0fcf78

Promote on overflow to bigint, and not to NV.
This is a new lexical user-pragma to use exact
arithmetic without loosing precision on all builtin arithmetic ops.
As in perl6, just much faster. (only in the rare 1% overflow case)

It is of course a bit slower than without, but I could not
measure any difference.

See #21.

rurban pushed a commit that referenced this issue


          exact_arith: implement it

e0c3676

Promote on overflow to bigint/num, and not to NV.
This is a new lexical user-pragma to use exact
arithmetic without loosing precision on all builtin arithmetic ops.
As in perl6.

It is of course a bit slower than without.

Closes #21.

rurban pushed a commit that referenced this issue


          exact_arith: implement it

0c5f4c0

Promote on overflow to bigint/num, and not to NV.
This is a new lexical user-pragma to use exact
arithmetic without loosing precision on all builtin arithmetic ops.
As in perl6.

It is of course a bit slower than without.

Closes #21.

rurban pushed a commit that referenced this issue


          exact_arith: implement it

5e5c026

Promote on overflow to bigint, and not to NV.
This is a new lexical user-pragma to use exact
arithmetic without loosing precision on all builtin arithmetic ops.
As in perl6, just much faster. (only in the rare 1% overflow case)

It is of course a bit slower than without, but I could not
measure any difference.

See #21.

rurban pushed a commit that referenced this issue


          exact_arith: implement it

a05b4db

Promote on overflow to bigint, and not to NV.
This is a new lexical user-pragma to use exact
arithmetic without loosing precision on all builtin arithmetic ops.
As in perl6, just much faster. (only in the rare 1% overflow case)

It is of course a bit slower than without, but I could not
measure any difference.

See #21.

rurban pushed a commit that referenced this issue


          exact_arith: implement it

c17797b

Promote on overflow to bigint/num, and not to NV.
This is a new lexical user-pragma to use exact
arithmetic without loosing precision on all builtin arithmetic ops.
As in perl6.

It is of course a bit slower than without.

Closes #21.

rurban pushed a commit that referenced this issue


          exact_arith: implement it

703c7ca

Promote on overflow to bigint/num, and not to NV.
This is a new lexical user-pragma to use exact
arithmetic without loosing precision on all builtin arithmetic ops.
As in perl6.

It is of course a bit slower than without.

Closes #21.

rurban pushed a commit that referenced this issue


          exact_arith: implement it

563464a

Promote on overflow to bigint, and not to NV.
This is a new lexical user-pragma to use exact
arithmetic without loosing precision on all builtin arithmetic ops.
As in perl6, just much faster. (only in the rare 1% overflow case)

It is of course a bit slower than without, but I could not
measure any difference.

See #21.

rurban pushed a commit that referenced this issue


          exact_arith: implement it

55f18be

Promote on overflow to bigint/num, and not to NV.
This is a new lexical user-pragma to use exact
arithmetic without loosing precision on all builtin arithmetic ops.
As in perl6.

It is of course a bit slower than without.

Closes #21.

rurban pushed a commit that referenced this issue


          exact_arith: implement it

1d6a394

Promote on overflow to bigint, and not to NV.
This is a new lexical user-pragma to use exact
arithmetic without loosing precision on all builtin arithmetic ops.
As in perl6, just much faster. (only in the rare 1% overflow case)

It is of course a bit slower than without, but I could not
measure any difference.

See #21.

rurban pushed a commit that referenced this issue


          exact_arith: implement it

22b61d6

Promote on overflow to bigint/num, and not to NV.
This is a new lexical user-pragma to use exact
arithmetic without loosing precision on all builtin arithmetic ops.
As in perl6.

It is of course a bit slower than without.

Closes #21.

rurban pushed a commit that referenced this issue


          exact_arith: implement it

ff96172

Promote on overflow to bigint, and not to NV.
This is a new lexical user-pragma to use exact
arithmetic without loosing precision on all builtin arithmetic ops.
As in perl6, just much faster. (only in the rare 1% overflow case)

It is of course a bit slower than without, but I could not
measure any difference.

See #21.

Sign up for free to subscribe to this conversation on GitHub. Already have an account? Sign in.