Implement RFC #2169 (Euclidean modulo). #49389

fanzier · 2018-03-26T18:35:03Z

Tracking issue: #49048

rust-highfive · 2018-03-26T18:35:09Z

Thanks for the pull request, and welcome! The Rust team is excited to review your changes, and you should hear from @KodrAus (or someone else) soon.

If any changes to this PR are deemed necessary, please add them as extra commits. This ensures that the reviewer can see what has changed since they last reviewed the code. Due to the way GitHub handles out-of-date commits, this should also make it reasonably obvious what issues have or haven't been addressed. Large or tricky changes may require several passes of review and changes.

Please see the contribution instructions for more information.

varkor

This is looking good! I've left a few very minor comments, but apart from that and fixing the tidy errors, I can't see any problems!

varkor · 2018-03-26T20:38:17Z

src/libcore/num/mod.rs

@@ -1318,6 +1460,40 @@ $EndFeature, "
            }
        }

+
+        doc_comment! {
+            concat!("Calculates the modulo of Euclidean divsion `self.mod_euc(rhs)`.


Nit: I would call this "the remainder" or "the modulus", as "modulo" is the operation, rather than the result.

Changing to "remainder" since "modulus" is another word for "divisor".

varkor · 2018-03-26T20:41:19Z

src/libcore/num/mod.rs

+
+
+        doc_comment! {
+            concat!("Calculates the modulo `self mod rhs` by Euclidean division.


varkor · 2018-03-26T20:42:20Z

src/libcore/num/mod.rs

+        doc_comment! {
+            concat!("Calculates the quotient of Euclidean division of `self` by `rhs`.
+
+This computes the integer n such that `self = n * rhs + self.mod_euc(rhs)`.


Nit: backticks around n for consistency (and in f32/f64).

varkor · 2018-03-26T20:54:27Z

src/libcore/num/mod.rs

+            #[unstable(feature = "euclidean_division", issue = "49048")]
+            #[inline]
+            pub fn wrapping_div_euc(self, rhs: Self) -> Self {
+                self.div_euc(rhs)


This can be the standard self / rhs to avoid the extra branch (like with wrapping_mod_euc).

Good catch, thanks.

varkor

Looks good to me 👍

fanzier · 2018-03-27T23:50:53Z

I was just wondering whether the f32/f64 code should live in libstd or in libcore. Since it doesn't depend on anything special, I think it should be in core, not std. On the other hand, there is a lot of stuff in libstd/f32.rs that I would have guessed should be in libcore/num/f32.rs. What is the policy regarding this?

varkor · 2018-03-28T00:10:33Z

As far as I'm aware, the libstd methods are limited to those that rely on platform libraries / intrinsics (e.g. most of the mathematical methods). Pure-Rust methods tend to reside in libcore (which also makes them available for no_std). I wouldn't be surprised if the situation isn't entirely consistent at the moment.

~~I think libcore was the correct choice here.~~

Edit: just realised the floating-point methods are not in libcore right now. See later comment.

fanzier · 2018-03-28T00:14:42Z

@varkor That makes sense. So I should move the float methods to libcore?

Edit: Apparently, to move it there, I would have to add the div_euc and mod_euc methods to the num::Float trait, which seems like overkill. Let's keep it as is?

varkor · 2018-03-28T22:37:30Z

I got a little confused before, sorry! I think it would be better to move the methods to libcore and delegate to them in libstd, yes (see, for example, the relatively recent to_bits, which does the same). You will have to extend the Float trait, but this should also allow the methods to be used on no_std, which is useful and expected. (It's not like the Float trait is being kept deliberately minimal as far as I can tell.)

fanzier · 2018-03-28T22:56:54Z

Fair enough, I'll move it into libcore. But since div_euc uses f32::trunc, should I move trunc from libstd into num::Float as well, or use intrinsics::truncf32 directly instead?

varkor · 2018-03-28T23:07:35Z

But since div_euc uses f32::trunc, should I move trunc from libstd into num::Float as well, or use intrinsics::truncf32 directly instead?

Ah, I didn't spot that. In that case, let's just leave it in libstd for now. If anyone needs it in libcore later on, it can be moved then (unless anyone else has some strong opinions now?). I think the integer methods are the most important ones, anyway.

shepmaster · 2018-04-07T19:48:59Z

Ping from triage, @KodrAus ! Will you have time to review soon?

KodrAus

Sorry for the late review! This is looking good, thanks @fanzier. I've just left a few nitpicky comments about the docs. Once we're happy with those I think we can push this through.

KodrAus · 2018-04-12T05:22:54Z

src/libcore/num/mod.rs

+            concat!("Wrapping Euclidean division. Computes `self.div_euc(rhs)`,
+wrapping around at the boundary of the type.
+
+The only case where such wrapping can occur is when one divides `MIN / -1` on a signed type (where


The wording here feels a little wonky. How about:

Wrapping will occur in MIN / -1 on a signed type (where MIN is the negative minimal value for the type). This is equivalent to -MIN, a positive value that is too large to represent in the type. In this case, this method returns MIN itself.

I almost copy-pasted that documentation from wrapping_div. Should I update the documentation there as well or should that be a separate PR?

KodrAus · 2018-04-12T05:31:32Z

src/libcore/num/mod.rs

+            concat!("Wrapping Euclidean modulo. Computes `self.mod_euc(rhs)`, wrapping around at the
+boundary of the type.
+
+Such wrap-around never actually occurs mathematically; implementation artifacts make `x % y`


Same as above. How about:

Wrapping will occur in MIN % -1 on a signed type (where MIN is the negative minimal value for the type). In this case, this method return 0.

KodrAus · 2018-04-12T05:35:06Z

src/libcore/num/mod.rs

+            concat!("Calculates the quotient of Euclidean division `self.div_euc(rhs)`.
+
+Returns a tuple of the divisor along with a boolean indicating whether an arithmetic overflow would
+occur. If an overflow would occur then self is returned.


We should put self in backticks here.

KodrAus · 2018-04-13T00:14:13Z

Thanks @fanzier this looks good to me! I'll leave a note on the tracking issue about libcore vs libstd.

@bors r+

bors · 2018-04-13T00:14:14Z

📌 Commit ca4e458 has been approved by KodrAus

bors · 2018-04-13T07:34:45Z

⌛ Testing commit ca4e458 with merge f9f9050...

Implement RFC #2169 (Euclidean modulo). Tracking issue: #49048

bors · 2018-04-13T10:33:46Z

☀️ Test successful - status-appveyor, status-travis
Approved by: KodrAus
Pushing f9f9050 to master...

vigna · 2023-02-27T19:35:24Z

Is the compiler able to specialize to Euclidean modulus for powers of two?

One of the reasons the Euclidean definition is the right one (unfortunately, Rust committed already to the weird C definition) is that a % (1 << k) can be computed with a mask both for signed and unsigned values. With the wrong definition and signed variables, you need to do a number of checks (that's why in Java you have to write all strength-reduction optimizations manually—the compiler will never be allowed to replace a % 8 with a & 7).

It would be nice to know I can compute remainders modulo a power of two in all cases and be sure they will be reduced to a logical bit operation.

Implement RFC rust-lang#2169 (Euclidean division).

9255bbd

Tracking issue: rust-lang#49048

rust-highfive assigned KodrAus Mar 26, 2018

rust-highfive added the S-waiting-on-review Status: Awaiting review from the assignee but also interested parties. label Mar 26, 2018

varkor suggested changes Mar 26, 2018

View reviewed changes

Address nits and tidy errors.

ece87c3

varkor approved these changes Mar 27, 2018

View reviewed changes

Fix #![feature]s.

1b5db85

Fix doctest (typo).

c0870e2

KodrAus reviewed Apr 12, 2018

View reviewed changes

Address more nits.

ca4e458

bors added S-waiting-on-bors Status: Waiting on bors to run and complete tests. Bors will change the label on completion. and removed S-waiting-on-review Status: Awaiting review from the assignee but also interested parties. labels Apr 13, 2018

KodrAus mentioned this pull request Apr 13, 2018

Tracking issue for RFC 2169: Euclidean Modulo #49048

Closed

2 tasks

bors added a commit that referenced this pull request Apr 13, 2018

Auto merge of #49389 - fanzier:euclidean-division, r=KodrAus

f9f9050

Implement RFC #2169 (Euclidean modulo). Tracking issue: #49048

bors merged commit ca4e458 into rust-lang:master Apr 13, 2018

bors mentioned this pull request Apr 13, 2018

Add inherent methods in libcore for [T], [u8], str, f32, and f64 #49896

Merged

scottmcm mentioned this pull request Apr 18, 2018

Tracking issue for integer methods for Wrapping #32463

Open

23 tasks

petoknm mentioned this pull request Oct 6, 2018

libcore and f32::{abs, mod_euc} #54876

Closed

dtolnay mentioned this pull request Jul 12, 2019

Stablize Euclidean Modulo (feature euclidean_division) #61884

Merged

traviscross mentioned this pull request Dec 3, 2024

Fix {f16,f32,f64,f128}::div_euclid #133755

Closed

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Implement RFC #2169 (Euclidean modulo). #49389

Implement RFC #2169 (Euclidean modulo). #49389

fanzier commented Mar 26, 2018

rust-highfive commented Mar 26, 2018

varkor left a comment

varkor Mar 26, 2018

fanzier Mar 27, 2018

varkor Mar 26, 2018

varkor Mar 26, 2018

varkor Mar 26, 2018

fanzier Mar 27, 2018

varkor left a comment

fanzier commented Mar 27, 2018

varkor commented Mar 28, 2018 •

edited

Loading

fanzier commented Mar 28, 2018 •

edited

Loading

varkor commented Mar 28, 2018

fanzier commented Mar 28, 2018

varkor commented Mar 28, 2018

shepmaster commented Apr 7, 2018

KodrAus left a comment

KodrAus Apr 12, 2018

fanzier Apr 12, 2018

KodrAus Apr 12, 2018

KodrAus Apr 12, 2018

KodrAus commented Apr 13, 2018

bors commented Apr 13, 2018

bors commented Apr 13, 2018

bors commented Apr 13, 2018

vigna commented Feb 27, 2023



		doc_comment! {
		concat!("Calculates the modulo `self mod rhs` by Euclidean division.

Implement RFC #2169 (Euclidean modulo). #49389

Implement RFC #2169 (Euclidean modulo). #49389

Conversation

fanzier commented Mar 26, 2018

rust-highfive commented Mar 26, 2018

varkor left a comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

varkor left a comment

Choose a reason for hiding this comment

fanzier commented Mar 27, 2018

varkor commented Mar 28, 2018 • edited Loading

fanzier commented Mar 28, 2018 • edited Loading

varkor commented Mar 28, 2018

fanzier commented Mar 28, 2018

varkor commented Mar 28, 2018

shepmaster commented Apr 7, 2018

KodrAus left a comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

KodrAus commented Apr 13, 2018

bors commented Apr 13, 2018

bors commented Apr 13, 2018

bors commented Apr 13, 2018

vigna commented Feb 27, 2023

varkor commented Mar 28, 2018 •

edited

Loading

fanzier commented Mar 28, 2018 •

edited

Loading