Cara terbaik untuk membuat modulus Java berperilaku seperti seharusnya dengan angka negatif?

Di java saat Anda melakukannya

a % b

Jika a negatif, itu akan mengembalikan hasil negatif, alih-alih membungkusnya menjadi b seperti seharusnya. Apa cara terbaik untuk memperbaikinya? Satu-satunya cara saya bisa berpikir adalah

a < 0 ? b + a : a % b

Ini berperilaku sebagaimana mestinya a% b = a - a / b * b; yaitu sisanya.

Anda dapat melakukan (a% b + b)% b

Ekspresi ini bekerja karena hasil dari (a % b)harus lebih rendah dari b, tidak peduli apakah apositif atau negatif. Penjumlahan bmenangani nilai negatif dari a, karena (a % b)merupakan nilai negatif antara -bdan 0, (a % b + b)harus lebih rendah dari bdan positif. Modulo terakhir ada jika apositif untuk memulai, karena jika apositif (a % b + b)akan menjadi lebih besar dari b. Oleh karena itu, (a % b + b) % bubah menjadi lebih kecil dari blagi (dan tidak mempengaruhi anilai negatif ).

Pada Java 8, Anda dapat menggunakan Math.floorMod (int x, int y) dan Math.floorMod (long x, long y) . Kedua metode ini memberikan hasil yang sama dengan jawaban Petrus.

Math.floorMod( 2,  3) =  2
Math.floorMod(-2,  3) =  1
Math.floorMod( 2, -3) = -1
Math.floorMod(-2, -3) = -2

Bagi mereka yang belum menggunakan (atau belum bisa menggunakan) Java 8, Guava datang untuk menyelamatkan dengan IntMath.mod () , tersedia sejak Guava 11.0.

IntMath.mod( 2, 3) = 2
IntMath.mod(-2, 3) = 1

Satu peringatan: tidak seperti Math.floorMod () Java 8, pembagi (parameter kedua) tidak boleh negatif.

Dalam teori bilangan, hasilnya selalu positif. Saya kira hal ini tidak selalu terjadi dalam bahasa komputer karena tidak semua programmer adalah ahli matematika. Dua sen saya, saya akan menganggapnya sebagai cacat desain bahasa, tetapi Anda tidak dapat mengubahnya sekarang.

= MOD (-4.180) = 176 = MOD (176, 180) = 176

karena 180 * (-1) + 176 = -4 sama dengan 180 * 0 + 176 = 176

Menggunakan contoh jam di sini, http://mathworld.wolfram.com/Congruence.html Anda tidak akan mengatakan durasi_of_time mod cycle_length adalah -45 menit, Anda akan mengatakan 15 menit, meskipun kedua jawaban memenuhi persamaan dasar.

Java 8 memiliki Math.floorMod, tetapi sangat lambat (implementasinya memiliki beberapa divisi, perkalian, dan bersyarat). Mungkin saja JVM memiliki rintisan yang dioptimalkan secara intrinsik untuknya, bagaimanapun, yang akan mempercepatnya secara signifikan.

Cara tercepat untuk melakukan ini tanpanya floorModadalah seperti beberapa jawaban lain di sini, tetapi tanpa cabang bersyarat dan hanya satu %operasi lambat .

Asumsi n positif, dan x bisa berupa apa saja:

int remainder = (x % n); // may be negative if x is negative
//if remainder is negative, adds n, otherwise adds 0
return ((remainder >> 31) & n) + remainder;

Hasil ketika n = 3:

x | result
----------
-4| 2
-3| 0
-2| 1
-1| 2
 0| 0
 1| 1
 2| 2
 3| 0
 4| 1

Jika Anda hanya memerlukan distribusi seragam antara 0dan n-1dan bukan operator mod yang tepat, dan Anda xtidak mengelompokkan dekat 0, berikut ini akan menjadi lebih cepat, karena ada lebih banyak paralelisme tingkat instruksi dan %komputasi lambat akan terjadi secara paralel dengan yang lain bagian karena tidak bergantung pada hasilnya.

return ((x >> 31) & (n - 1)) + (x % n)

Hasil diatas dengan n = 3:

x | result
----------
-5| 0
-4| 1
-3| 2
-2| 0
-1| 1
 0| 0
 1| 1
 2| 2
 3| 0
 4| 1
 5| 2

Jika masukan acak dalam rentang penuh int, distribusi kedua solusi akan sama. Jika cluster masukan mendekati nol, akan ada terlalu sedikit hasil di n - 1solusi terakhir.

Berikut ini alternatifnya:

a < 0 ? b-1 - (-a-1) % b : a % b

Ini mungkin atau mungkin tidak lebih cepat dari rumus lain [(a% b + b)% b]. Tidak seperti rumus lainnya, rumus ini berisi cabang, tetapi menggunakan satu operasi modulo yang lebih sedikit. Mungkin menang jika komputer dapat memprediksi <0 dengan benar.

(Edit: Memperbaiki rumus.)