Cách viết mã toán tử modulo (%) trong C / C ++ / Obj-C xử lý số âm

Một trong những thú cưng của tôi ghét các ngôn ngữ có nguồn gốc từ C (với tư cách là một nhà toán học) là

(-1) % 8 // comes out as -1, and not 7

fmodf(-1,8) // fails similarly

Giải pháp tốt nhất là gì?

C ++ cho phép khả năng tạo khuôn mẫu và nạp chồng toán tử, nhưng cả hai điều này đều là vùng nước âm u đối với tôi. những ví dụ đã nhận được một cách biết ơn.

Trước hết, tôi muốn lưu ý rằng bạn thậm chí không thể dựa vào thực tế rằng (-1) % 8 == -1. điều duy nhất bạn có thể dựa vào đó là (x / y) * y + ( x % y) == x. Tuy nhiên, phần còn lại có âm hay không là do việc thực hiện xác định .

Bây giờ tại sao sử dụng các mẫu ở đây? Quá tải cho int và longs sẽ xảy ra.

int mod (int a, int b)
{
   int ret = a % b;
   if(ret < 0)
     ret+=b;
   return ret;
}

và bây giờ bạn có thể gọi nó như mod (-1,8) và nó sẽ có vẻ là 7.

Chỉnh sửa: Tôi tìm thấy một lỗi trong mã của mình. Nó sẽ không hoạt động nếu b là âm. Vì vậy, tôi nghĩ điều này tốt hơn:

int mod (int a, int b)
{
   if(b < 0) //you can check for b == 0 separately and do what you want
     return -mod(-a, -b);   
   int ret = a % b;
   if(ret < 0)
     ret+=b;
   return ret;
}

Tham khảo: C ++ 03 đoạn 5.6 khoản 4:

Toán tử nhị phân / sinh ra thương số và toán tử nhị phân% sinh ra phần còn lại từ phép chia biểu thức đầu tiên cho biểu thức thứ hai. Nếu toán hạng thứ hai của / hoặc% bằng 0 thì hành vi không được xác định; ngược lại (a / b) * b + a% b bằng a. Nếu cả hai toán hạng đều không âm thì phần còn lại là không âm; nếu không, dấu hiệu của phần còn lại được xác định thực thi .

Đây là một hàm C xử lý số nguyên dương HOẶC số nguyên âm HOẶC giá trị phân số cho cả hai hàm thao tác

#include <math.h>
float mod(float a, float N) {return a - N*floor(a/N);} //return in range [0, N)

Đây chắc chắn là giải pháp thanh lịch nhất từ ​​quan điểm toán học. Tuy nhiên, tôi không chắc liệu nó có mạnh mẽ trong việc xử lý số nguyên hay không. Đôi khi lỗi dấu phẩy động xuất hiện khi chuyển đổi int -> fp -> int.

Tôi đang sử dụng mã này cho các không phải int và một hàm riêng cho int.

LƯU Ý: cần bẫy N = 0!

Mã người kiểm tra:

#include <math.h>
#include <stdio.h>

float mod(float a, float N)
{
    float ret = a - N * floor (a / N);

    printf("%f.1 mod %f.1 = %f.1 \n", a, N, ret);

    return ret;
}

int main (char* argc, char** argv)
{
    printf ("fmodf(-10.2, 2.0) = %f.1  == FAIL! \n\n", fmodf(-10.2, 2.0));

    float x;
    x = mod(10.2f, 2.0f);
    x = mod(10.2f, -2.0f);
    x = mod(-10.2f, 2.0f);
    x = mod(-10.2f, -2.0f);

    return 0;
}

(Lưu ý: Bạn có thể biên dịch và chạy nó ngay từ CodePad: http://codepad.org/UOgEqAMA )

Đầu ra:

fmodf (-10.2, 2.0) = -0.20 == FAIL!

10,2 mod 2.0 = 0,2
10,2 mod -2,0 = -1,8
-10,2 mod 2.0 = 1,8
-10,2 mod -2.0 = -0,2

Tôi vừa nhận thấy rằng Bjarne Stroustrup gắn nhãn %là toán tử phần dư , không phải toán tử mô đun.

Tôi dám cá rằng đây là tên chính thức của nó trong thông số kỹ thuật ANSI C & C ++ và việc lạm dụng thuật ngữ đã len lỏi vào. Có ai biết điều này cho sự thật không?

Nhưng nếu trường hợp này xảy ra thì hàm fmodf () của C (và có thể là những hàm khác) rất sai lầm. chúng phải được gắn nhãn fremf (), v.v.

Hàm tổng quát đơn giản nhất để tìm modulo dương sẽ là hàm này- Nó sẽ hoạt động trên cả giá trị âm và dương của x.

int modulo(int x,int N){
    return (x % N + N) %N;
}

Đối với số nguyên, điều này là đơn giản. Cứ làm đi

(((x < 0) ? ((x % N) + N) : x) % N)

trong đó tôi cho rằng điều đó Nlà tích cực và có thể đại diện trong loại x. Trình biên dịch yêu thích của bạn sẽ có thể tối ưu hóa điều này, sao cho nó kết thúc chỉ trong một thao tác mod trong trình lắp ráp.

Giải pháp tốt nhất ¹ cho một nhà toán học là sử dụng Python.

Việc nạp chồng toán tử C ++ ít liên quan đến nó. Bạn không thể nạp chồng các toán tử cho các kiểu cài sẵn. Những gì bạn muốn chỉ đơn giản là một chức năng. Tất nhiên, bạn có thể sử dụng C ++ templating để triển khai hàm đó cho tất cả các kiểu liên quan chỉ với 1 đoạn mã.

Thư viện C tiêu chuẩn cung cấp fmod, nếu tôi nhớ lại tên một cách chính xác, cho các loại dấu phẩy động.

Đối với số nguyên, bạn có thể xác định một mẫu hàm C ++ luôn trả về phần dư không âm (tương ứng với phép chia Euclidian) là ...

#include <stdlib.h>  // abs

template< class Integer >
auto mod( Integer a, Integer b )
    -> Integer
{
    Integer const r = a%b;
    return (r < 0? r + abs( b ) : r);
}

... và chỉ viết mod(a, b)thay vì a%b.

Ở đây kiểu Integercần phải là kiểu số nguyên có dấu.

Nếu bạn muốn hành vi toán học phổ biến trong đó dấu của phần dư giống với dấu của số chia, thì bạn có thể làm ví dụ:

template< class Integer >
auto floor_div( Integer const a, Integer const b )
    -> Integer
{
    bool const a_is_negative = (a < 0);
    bool const b_is_negative = (b < 0);
    bool const change_sign  = (a_is_negative != b_is_negative);

    Integer const abs_b         = abs( b );
    Integer const abs_a_plus    = abs( a ) + (change_sign? abs_b - 1 : 0);

    Integer const quot = abs_a_plus / abs_b;
    return (change_sign? -quot : quot);
}

template< class Integer >
auto floor_mod( Integer const a, Integer const b )
    -> Integer
{ return a - b*floor_div( a, b ); }

… Với cùng một ràng buộc Integer, rằng đó là kiểu có chữ ký.

^{¹ Vì phép chia số nguyên của Python làm tròn về phía âm vô cùng.}

Ồ, tôi cũng ghét thiết kế% cho cái này ....

Bạn có thể chuyển đổi cổ tức thành không dấu theo cách như:

unsigned int offset = (-INT_MIN) - (-INT_MIN)%divider

result = (offset + dividend) % divider

nơi bù đắp gần nhất với (-INT_MIN) bội số của mô-đun, vì vậy việc cộng và trừ nó sẽ không thay đổi mô-đun. Lưu ý rằng nó có kiểu không dấu và kết quả sẽ là số nguyên. Thật không may, nó không thể chuyển đổi chính xác các giá trị INT_MIN ... (- offset-1) vì chúng gây ra tràn arifmetic. Nhưng phương pháp này chỉ có một số học bổ sung duy nhất cho mỗi phép toán (và không có điều kiện) khi làm việc với bộ chia không đổi, vì vậy nó có thể sử dụng được trong các ứng dụng giống như DSP.

Có trường hợp đặc biệt, trong đó bộ chia là 2 ^N (lũy thừa nguyên của hai), mà modulo có thể được tính bằng cách sử dụng logic số học và bitwise đơn giản như

dividend&(divider-1)

ví dụ

x mod 2 = x & 1
x mod 4 = x & 3
x mod 8 = x & 7
x mod 16 = x & 15

Cách phổ biến hơn và ít phức tạp hơn là lấy modulo bằng hàm này (chỉ hoạt động với bộ chia dương):

int mod(int x, int y) {
    int r = x%y;
    return r<0?r+y:r;
}

Kết quả này chỉ chính xác nếu nó là âm tính.

Ngoài ra, bạn có thể lừa:

(p% q + q)% q

Nó rất ngắn nhưng sử dụng hai% -s thường chậm.

Tôi tin rằng một giải pháp khác cho vấn đề này sẽ là sử dụng các biến kiểu long thay vì int.

Tôi chỉ đang làm việc trên một số mã trong đó toán tử% trả về giá trị âm, điều này gây ra một số vấn đề (để tạo các biến ngẫu nhiên đồng nhất trên [0,1], bạn không thực sự muốn số âm :)), nhưng sau khi chuyển các biến thành gõ dài, mọi thứ đều chạy trơn tru và kết quả khớp với kết quả mà tôi nhận được khi chạy cùng một mã trong python (điều quan trọng đối với tôi là tôi muốn có thể tạo cùng một số "ngẫu nhiên" trên một số nền tảng.

Đây là câu trả lời mới cho một câu hỏi cũ, dựa trên bài báo Nghiên cứu của Microsoft này và các tài liệu tham khảo trong đó.

Lưu ý rằng từ C11 và C ++ 11 trở đi, ngữ nghĩa của divđã bị cắt bớt về phía không (xem [expr.mul]/4). Hơn nữa, đối với phép Dchia cho d, C ++ 11 đảm bảo những điều sau về thương qTvà phần dưrT

auto const qT = D / d;
auto const rT = D % d;
assert(D == d * qT + rT);
assert(abs(rT) < abs(d));
assert(signum(rT) == signum(D));

trong đó signumánh xạ tới -1, 0, +1, tùy thuộc vào việc đối số của nó có <, ==,> hơn 0 hay không (xem phần Hỏi & Đáp này để biết mã nguồn).

Với phép chia cắt ngắn, dấu của phần dư bằng dấu của số bị chiaD , tức là -1 % 8 == -1. C ++ 11 cũng cung cấp một std::divhàm trả về một cấu trúc với các thành viên quotvàrem theo phép chia cắt ngắn.

Có thể có các định nghĩa khác, ví dụ: cái gọi là phép phân chia có cấu trúc phân lớp có thể được định nghĩa theo cách phân chia được cắt bớt nội dung

auto const I = signum(rT) == -signum(d) ? 1 : 0;
auto const qF = qT - I;
auto const rF = rT + I * d;
assert(D == d * qF + rF);
assert(abs(rF) < abs(d));
assert(signum(rF) == signum(d));

Với phép chia có lớp, dấu của phần dư bằng dấu của số chiad . Trong các ngôn ngữ như Haskell và Oberon, có các toán tử nội trang cho phép phân chia tầng. Trong C ++, bạn cần viết một hàm bằng các định nghĩa trên.

Tuy nhiên, một cách khác là phép phân chia Euclide , cũng có thể được định nghĩa theo cách phân chia cắt ngắn nội tại

auto const I = rT >= 0 ? 0 : (d > 0 ? 1 : -1);
auto const qE = qT - I;
auto const rE = rT + I * d;
assert(D == d * qE + rE);
assert(abs(rE) < abs(d));
assert(signum(rE) != -1);

Với phép chia Euclide, dấu của phần dư luôn là số dương .

Đối với giải pháp không sử dụng nhánh và chỉ 1 mod, bạn có thể làm như sau

// Works for other sizes too,
// assuming you change 63 to the appropriate value
int64_t mod(int64_t x, int64_t div) {
  return (x % div) + (((x >> 63) ^ (div >> 63)) & div);
}

/ * Cảnh báo: macro mod đánh giá tác dụng phụ của đối số nhiều lần. * /
#define mod (r, m) (((r)% (m)) + ((r) <0)? (m): 0)

... hoặc chỉ quen với việc lấy bất kỳ đại diện nào cho lớp tương đương.

Mẫu ví dụ cho C ++

template< class T >
T mod( T a, T b )
{
    T const r = a%b;
    return ((r!=0)&&((r^b)<0) ? r + b : r);
}

Với mẫu này, phần còn lại được trả về sẽ bằng 0 hoặc có cùng dấu với số chia (mẫu số) (tương đương với việc làm tròn về phía âm vô cùng), thay vì hành vi C ++ của phần còn lại là 0 hoặc có cùng dấu với số bị chia ( tử số) (tương đương với làm tròn về 0).

define  MOD(a, b)       ((((a)%(b))+(b))%(b))

unsigned mod(int a, unsigned b) {
    return (a >= 0 ? a % b : b - (-a) % b);
}

Giải pháp này (để sử dụng khi modlà số dương) tránh thực hiện các phép toán chia hoặc dư âm cùng nhau:

int core_modulus(int val, int mod)
{
    if(val>=0)
        return val % mod;
    else
        return val + mod * ((mod - val - 1)/mod);
}

Tôi sẽ làm:

((-1)+8) % 8 

Điều này thêm số thứ hai vào số đầu tiên trước khi thực hiện modulo cho 7 như mong muốn. Điều này sẽ hoạt động đối với bất kỳ số nào xuống -8. Đối với -9, thêm 2 * 8.