Trần nhanh của một phân chia số nguyên trong C / C ++

Cho các giá trị nguyên xvà y, cả C và C ++ đều trả về giá trị q = x/ysàn của điểm nổi tương đương. Thay vào đó, tôi quan tâm đến một phương pháp trả lại trần. Ví dụ, ceil(10/5)=2và ceil(11/5)=3.

Cách tiếp cận rõ ràng liên quan đến một cái gì đó như:

q = x / y;
if (q * y < x) ++q;

Điều này đòi hỏi một sự so sánh và nhân rộng thêm; và các phương pháp khác mà tôi đã thấy (thực tế được sử dụng) liên quan đến việc chọn như là một floathoặc double. Có một phương pháp trực tiếp hơn để tránh phép nhân bổ sung (hoặc một phân chia thứ hai) và nhánh, và điều đó cũng tránh việc đúc như một số dấu phẩy động?

Đối với số dương

unsigned int x, y, q;

Để làm tròn ...

q = (x + y - 1) / y;

hoặc (tránh tràn trong x + y)

q = 1 + ((x - 1) / y); // if x != 0

Đối với số dương:

    q = x/y + (x % y != 0);

Câu trả lời của Sparky là một cách tiêu chuẩn để giải quyết vấn đề này, nhưng như tôi cũng đã viết trong bình luận của mình, bạn có nguy cơ bị tràn. Điều này có thể được giải quyết bằng cách sử dụng loại rộng hơn, nhưng nếu bạn muốn chia long longs thì sao?

Câu trả lời của Nathan Ernst cung cấp một giải pháp, nhưng nó liên quan đến một lệnh gọi hàm, khai báo biến và điều kiện, làm cho nó không ngắn hơn mã OP và thậm chí có thể chậm hơn, vì khó tối ưu hóa hơn.

Giải pháp của tôi là thế này:

q = (x % y) ? x / y + 1 : x / y;

Nó sẽ nhanh hơn một chút so với mã OP, bởi vì modulo và phép chia được thực hiện bằng cách sử dụng cùng một lệnh trên bộ xử lý, bởi vì trình biên dịch có thể thấy rằng chúng tương đương nhau. Ít nhất gcc 4.4.1 thực hiện tối ưu hóa này với cờ -O2 trên x86.

Về lý thuyết, trình biên dịch có thể thực hiện lệnh gọi hàm trong mã của Ern Ernst và phát ra điều tương tự, nhưng gcc đã không làm điều đó khi tôi kiểm tra nó. Điều này có thể là do nó sẽ buộc mã được biên dịch thành một phiên bản duy nhất của thư viện chuẩn.

Như một lưu ý cuối cùng, không có gì trong số này quan trọng trên một máy hiện đại, ngoại trừ nếu bạn đang ở trong một vòng lặp cực kỳ chặt chẽ và tất cả dữ liệu của bạn nằm trong các thanh ghi hoặc bộ đệm L1. Mặt khác, tất cả các giải pháp này sẽ nhanh như nhau, ngoại trừ khả năng của Nathan Ernst, có thể chậm hơn đáng kể nếu chức năng phải được lấy từ bộ nhớ chính.

Bạn có thể sử dụng divchức năng trong cstdlib để lấy thương số & phần còn lại trong một cuộc gọi và sau đó xử lý trần riêng, như trong phần dưới đây

#include <cstdlib>
#include <iostream>

int div_ceil(int numerator, int denominator)
{
        std::div_t res = std::div(numerator, denominator);
        return res.rem ? (res.quot + 1) : res.quot;
}

int main(int, const char**)
{
        std::cout << "10 / 5 = " << div_ceil(10, 5) << std::endl;
        std::cout << "11 / 5 = " << div_ceil(11, 5) << std::endl;

        return 0;
}

Còn cái này thì sao? (yêu cầu y không âm, vì vậy đừng sử dụng điều này trong trường hợp hiếm hoi trong đó y là biến không có bảo đảm không âm)

q = (x > 0)? 1 + (x - 1)/y: (x / y);

Tôi giảm xuống còn y/ymột, loại bỏ thuật ngữ x + y - 1và với nó bất kỳ cơ hội nào để tràn.

Tôi tránh x - 1quấn quanh khi xlà một loại không dấu và chứa số không.

Đối với ký x, âm và không vẫn kết hợp thành một trường hợp duy nhất.

Có lẽ không phải là một lợi ích to lớn trên CPU đa năng hiện đại, nhưng điều này sẽ nhanh hơn nhiều trong một hệ thống nhúng so với bất kỳ câu trả lời đúng nào khác.

Có một giải pháp cho cả tích cực và tiêu cực xnhưng chỉ cho tích cực ychỉ với 1 bộ phận và không có chi nhánh:

int ceil(int x, int y) {
    return x / y + (x % y > 0);
}

Lưu ý, nếu xlà số dương thì phép chia là 0 và chúng ta nên thêm 1 nếu lời nhắc không bằng 0.

Nếu xlà âm thì phân chia là 0, đó là những gì chúng ta cần và chúng ta sẽ không thêm bất cứ điều gì vì x % ykhông tích cực

Điều này hoạt động cho các số dương hoặc âm:

q = x / y + ((x % y != 0) ? !((x > 0) ^ (y > 0)) : 0);

Nếu có phần còn lại, hãy kiểm tra xem xvày có cùng dấu và thêm vào không 1.

Tôi muốn có bình luận nhưng tôi không có một đại diện đủ cao.

Theo như tôi biết, đối với các đối số tích cực và ước số là lũy thừa của 2, đây là cách nhanh nhất (được thử nghiệm trong CUDA):

//example y=8
q = (x >> 3) + !!(x & 7);

Đối với chỉ các đối số tích cực chung, tôi có xu hướng làm như vậy:

q = x/y + !!(x % y);

hình thức chung đơn giản hóa,

int div_up(int n, int d) {
    return n / d + (((n < 0) ^ (d > 0)) && (n % d));
} //i.e. +1 iff (not exact int && positive result)

Để có câu trả lời chung chung hơn, các hàm C ++ để phân chia số nguyên với chiến lược làm tròn được xác định rõ

Biên dịch với O3, Trình biên dịch thực hiện tối ưu hóa tốt.

q = x / y;
if (x % y)  ++q;