Có chức năng ký hiệu chuẩn (dấu hiệu, sgn) trong C / C ++ không?

Tôi muốn một hàm trả về -1 cho số âm và +1 cho số dương. http://en.wikipedia.org/wiki/Sign_function Thật dễ dàng để viết riêng của tôi, nhưng có vẻ như một cái gì đó phải có trong một thư viện tiêu chuẩn ở đâu đó.

Chỉnh sửa: Cụ thể, tôi đang tìm kiếm một chức năng làm việc trên phao.

Ngạc nhiên là chưa có ai đăng phiên bản C ++ an toàn kiểu:

template <typename T> int sgn(T val) {
    return (T(0) < val) - (val < T(0));
}

Những lợi ích:

• Trên thực tế thực hiện dấu hiệu (-1, 0 hoặc 1). Việc triển khai ở đây bằng copysign chỉ trả về -1 hoặc 1, không phải là dấu hiệu. Ngoài ra, một số triển khai ở đây đang trả về một float (hoặc T) thay vì int, điều này có vẻ lãng phí.
• Hoạt động cho ints, float, double, unsign hoặc bất kỳ loại tùy chỉnh nào có thể xây dựng từ số nguyên 0 và có thể đặt hàng.
• Nhanh! copysignlà chậm, đặc biệt là nếu bạn cần quảng bá và sau đó thu hẹp lại. Điều này là không chi nhánh và tối ưu hóa xuất sắc
• Tuân thủ tiêu chuẩn! Hack bithift gọn gàng, nhưng chỉ hoạt động đối với một số biểu diễn bit và không hoạt động khi bạn có loại không dấu. Nó có thể được cung cấp như một chuyên môn thủ công khi thích hợp.
• Chính xác! So sánh đơn giản với số không có thể duy trì biểu diễn độ chính xác cao bên trong của máy (ví dụ 80 bit trên x87) và tránh vòng sớm đến 0.

Hãy cẩn thận:

• Đó là một mẫu để có thể mất nhiều thời gian hơn để biên dịch trong một số trường hợp.
• Rõ ràng một số người nghĩ rằng việc sử dụng một chức năng thư viện tiêu chuẩn mới, hơi bí truyền và rất chậm mà thậm chí không thực sự thực hiện dấu hiệu là điều dễ hiểu hơn.

• Một < 0phần của kiểm tra kích hoạt -Wtype-limitscảnh báo của GCC khi được khởi tạo cho loại không dấu. Bạn có thể tránh điều này bằng cách sử dụng một số quá tải:

  template <typename T> inline constexpr
  int signum(T x, std::false_type is_signed) {
      return T(0) < x;
  }
  
  template <typename T> inline constexpr
  int signum(T x, std::true_type is_signed) {
      return (T(0) < x) - (x < T(0));
  }
  
  template <typename T> inline constexpr
  int signum(T x) {
      return signum(x, std::is_signed<T>());
  }
  

  (Đó là một ví dụ tốt về cảnh báo đầu tiên.)

Tôi không biết về một chức năng tiêu chuẩn cho nó. Đây là một cách thú vị để viết nó mặc dù:

(x > 0) - (x < 0)

Đây là một cách dễ đọc hơn để làm điều đó:

if (x > 0) return 1;
if (x < 0) return -1;
return 0;

Nếu bạn thích toán tử ternary, bạn có thể làm điều này:

(x > 0) ? 1 : ((x < 0) ? -1 : 0)

Có một hàm thư viện toán học C99 được gọi là copysign (), lấy dấu từ một đối số và giá trị tuyệt đối từ đối số khác:

result = copysign(1.0, value) // double
result = copysignf(1.0, value) // float
result = copysignl(1.0, value) // long double

sẽ cho bạn kết quả là +/- 1.0, tùy thuộc vào dấu hiệu của giá trị. Lưu ý rằng các số 0 dấu phẩy động được ký: (+0) sẽ mang lại +1 và (-0) sẽ mang lại -1.

Có vẻ như hầu hết các câu trả lời đã bỏ lỡ câu hỏi ban đầu.

Có chức năng ký hiệu chuẩn (dấu hiệu, sgn) trong C / C ++ không?

Không phải trong thư viện tiêu chuẩn, tuy nhiên copysign, có thể được sử dụng gần như cùng một cách thông qua copysign(1.0, arg)và có một chức năng ký hiệu thực sự boost, cũng có thể là một phần của tiêu chuẩn.

    #include <boost/math/special_functions/sign.hpp>

    //Returns 1 if x > 0, -1 if x < 0, and 0 if x is zero.
    template <class T>
    inline int sign (const T& z);

http://www.boost.org/doc/libs/1_47_0/libs/math/doc/sf_and_dist/html/math_toolkit/utils/sign_fifts.html

Rõ ràng, câu trả lời cho câu hỏi ban đầu của người đăng là không. Không có chức năng C ++ tiêu chuẩnsgn .

Có chức năng ký hiệu chuẩn (dấu hiệu, sgn) trong C / C ++ không?

Có, tùy thuộc vào định nghĩa.

C99 và sau này có signbit()macro trong<math.h>

int signbit(nổi thật x);
Các signbitlợi vĩ mô một giá trị khác khi và chỉ khi các dấu hiệu của giá trị đối số của nó là tiêu cực. C11 §7.12.3.6

Tuy nhiên, OP muốn một chút gì đó khác biệt.

Tôi muốn một hàm trả về -1 cho số âm và +1 cho số dương. ... một chức năng làm việc trên phao.

#define signbit_p1_or_n1(x)  ((signbit(x) ?  -1 : 1)

Sâu sắc hơn:

Bài viết không cụ thể trong các trường hợp sau : x = 0.0, -0.0, +NaN, -NaN.

Một signum()lợi nhuận cổ điển +1trên x>0, -1trên x<0và 0trên x==0.

Nhiều câu trả lời đã bao gồm điều đó, nhưng không giải quyết x = -0.0, +NaN, -NaN. Nhiều người đang hướng đến một quan điểm số nguyên thường thiếu Not-a-Numbers ( NaN ) và -0.0 .

Chức năng trả lời điển hình như signnum_typical() On -0.0, +NaN, -NaN, họ trở lại 0.0, 0.0, 0.0.

int signnum_typical(double x) {
  if (x > 0.0) return 1;
  if (x < 0.0) return -1;
  return 0;
}

Thay vào đó, tôi đề xuất chức năng này: Bật -0.0, +NaN, -NaN, nó trả về -0.0, +NaN, -NaN.

double signnum_c(double x) {
  if (x > 0.0) return 1.0;
  if (x < 0.0) return -1.0;
  return x;
}

Nhanh hơn các giải pháp trên, bao gồm giải pháp được đánh giá cao nhất:

(x < 0) ? -1 : (x > 0)

Có một cách để làm điều đó mà không cần phân nhánh, nhưng nó không đẹp lắm.

sign = -(int)((unsigned int)((int)v) >> (sizeof(int) * CHAR_BIT - 1));

http://graphics.stanford.edu/~seander/bithacks.html

Nhiều thứ thú vị, thông minh quá mức khác trên trang đó, quá ...

Nếu tất cả những gì bạn muốn là kiểm tra dấu hiệu, hãy sử dụng Signbit (trả về true nếu đối số của nó có dấu âm). Không chắc chắn lý do tại sao bạn đặc biệt muốn trả lại -1 hoặc +1; copysign thuận tiện hơn cho việc đó, nhưng có vẻ như nó sẽ trả về +1 cho số 0 âm trên một số nền tảng chỉ hỗ trợ một phần cho số 0 âm, trong đó ký hiệu có lẽ sẽ trở về đúng.

Nói chung, không có chức năng đăng nhập tiêu chuẩn trong C / C ++ và việc thiếu chức năng cơ bản như vậy cho bạn biết rất nhiều về các ngôn ngữ này.

Ngoài ra, tôi tin rằng cả hai quan điểm đa số về cách tiếp cận đúng để xác định hàm như vậy đều đúng và "tranh cãi" về nó thực sự là một cuộc tranh luận một khi bạn tính đến hai cảnh báo quan trọng:

• Hàm Signum phải luôn trả về loại toán hạng của nó, tương tự như abs()hàm, bởi vì dấu hiệu thường được sử dụng để nhân với một giá trị tuyệt đối sau khi cái sau được xử lý bằng cách nào đó. Do đó, trường hợp sử dụng chính của dấu hiệu không phải là so sánh mà là số học, và trường hợp sau không nên liên quan đến bất kỳ chuyển đổi số nguyên sang / từ dấu phẩy động đắt tiền nào.

• Các loại dấu phẩy động không có một giá trị 0 chính xác duy nhất: +0.0 có thể được hiểu là "infinitesimally trên zero" và -0.0 là "infinitesimally under zero". Đó là lý do tại sao các so sánh liên quan đến số 0 phải kiểm tra bên trong cả hai giá trị và một biểu thức như x == 0.0có thể nguy hiểm.

Về C, tôi nghĩ rằng cách tốt nhất để chuyển tiếp với các loại tích phân thực sự là sử dụng (x > 0) - (x < 0)biểu thức, vì nó nên được dịch theo kiểu không có chi nhánh và chỉ cần ba thao tác cơ bản. Xác định tốt nhất các hàm nội tuyến thực thi loại trả về khớp với loại đối số và thêm C11 define _Genericđể ánh xạ các hàm này thành một tên chung.

Với các giá trị dấu chấm động, tôi nghĩ rằng chức năng inline dựa trên C11 copysignf(1.0f, x), copysign(1.0, x)và copysignl(1.0l, x)là con đường để đi, đơn giản chỉ vì chúng cũng rất có khả năng là ngành miễn phí, và bổ sung không cần đúc kết quả từ nguyên trở thành một dấu chấm động giá trị. Có lẽ bạn nên bình luận nổi bật mà hiện thực dấu chấm động lại signum sẽ không trở lại không vì đặc thù của dấu chấm động không giá trị, chế biến cân nhắc thời gian, và cũng vì nó thường là rất hữu ích trong điểm số học nổi để thu đúng -1 / + 1 dấu, thậm chí cho các giá trị bằng không.

Bản sao C của tôi trong một Nutshell cho thấy sự tồn tại của một chức năng tiêu chuẩn được gọi là copysign có thể hữu ích. Có vẻ như copysign (1.0, -2.0) sẽ trả về -1.0 và copysign (1.0, 2.0) sẽ trả về +1.0.

Khá gần hả?

Không, nó không tồn tại trong c ++, như trong matlab. Tôi sử dụng một macro trong các chương trình của tôi cho việc này.

#define sign(a) ( ( (a) < 0 )  ?  -1   : ( (a) > 0 ) )

Câu trả lời được chấp nhận với tình trạng quá tải dưới đây thực sự không kích hoạt giới hạn -Wtype .

template <typename T> inline constexpr
  int signum(T x, std::false_type) {
  return T(0) < x;
}

template <typename T> inline constexpr
  int signum(T x, std::true_type) {
  return (T(0) < x) - (x < T(0));
}

template <typename T> inline constexpr
  int signum(T x) {
  return signum(x, std::is_signed<T>());
}

Đối với C ++ 11, một sự thay thế có thể là.

template <typename T>
typename std::enable_if<std::is_unsigned<T>::value, int>::type
inline constexpr signum(T const x) {
    return T(0) < x;  
}

template <typename T>
typename std::enable_if<std::is_signed<T>::value, int>::type
inline constexpr signum(T const x) {
    return (T(0) < x) - (x < T(0));  
}

Đối với tôi, nó không kích hoạt bất kỳ cảnh báo nào trên GCC 5.3.1.

Bit ngoài chủ đề, nhưng tôi sử dụng điều này:

template<typename T>
constexpr int sgn(const T &a, const T &b) noexcept{
    return (a > b) - (a < b);
}

template<typename T>
constexpr int sgn(const T &a) noexcept{
    return sgn(a, T(0));
}

và tôi đã tìm thấy hàm đầu tiên - hàm có hai đối số, sẽ hữu ích hơn nhiều từ sgn "tiêu chuẩn", bởi vì nó thường được sử dụng trong mã như thế này:

int comp(unsigned a, unsigned b){
   return sgn( int(a) - int(b) );
}

so với

int comp(unsigned a, unsigned b){
   return sgn(a, b);
}

không có diễn viên cho các loại không dấu và không có dấu trừ bổ sung.

thực tế tôi có đoạn mã này bằng sgn ()

template <class T>
int comp(const T &a, const T &b){
    log__("all");
    if (a < b)
        return -1;

    if (a > b)
        return +1;

    return 0;
}

inline int comp(int const a, int const b){
    log__("int");
    return a - b;
}

inline int comp(long int const a, long int const b){
    log__("long");
    return sgn(a, b);
}

Câu hỏi đã cũ nhưng bây giờ có loại chức năng mong muốn. Tôi đã thêm một trình bao bọc không, thay đổi trái và dec.

Bạn có thể sử dụng chức năng bao bọc dựa trên ký hiệu từ C99 để có được hành vi mong muốn chính xác (xem thêm mã bên dưới).

Trả về cho dù dấu của x là âm.
Điều này cũng có thể được áp dụng cho infinites, NaN và 0 (nếu số 0 không dấu, nó được coi là dương

#include <math.h>

int signValue(float a) {
    return ((!signbit(a)) << 1) - 1;
}

Lưu ý

Giá trị trả về
Một giá trị khác không (đúng) nếu dấu của x là âm; và không (sai) nếu không.

Sau đó, tôi nhân hai với dịch chuyển trái ("<< 1") sẽ cho chúng ta 2 cho số dương và 0 cho số âm và cuối cùng giảm 1 để lấy 1 và -1 cho các số dương và âm tương ứng theo yêu cầu của OP.

Mặc dù giải pháp số nguyên trong câu trả lời được chấp nhận khá thanh lịch, nhưng điều đó làm phiền tôi rằng nó sẽ không thể trả về NAN cho loại kép, vì vậy tôi đã sửa đổi nó một chút.

template <typename T> double sgn(T val) {
    return double((T(0) < val) - (val < T(0)))/(val == val);
}

Lưu ý rằng việc trả về một dấu phẩy động NAN trái ngược với mã hóa cứng NANkhiến bit dấu được đặt trong một số triển khai , do đó, đầu ra cho val = -NANvà val = NANsẽ giống hệt nhau cho dù bạn có thể đặt nanđầu ra "" so với đầu ra "" -nanmột abs(val)trước khi trở về ...)

Bạn có thể sử dụng boost::math::sign()phương pháp từ boost/math/special_functions/sign.hppnếu có sẵn boost.

Đây là một triển khai thân thiện với chi nhánh:

inline int signum(const double x) {
    if(x == 0) return 0;
    return (1 - (static_cast<int>((*reinterpret_cast<const uint64_t*>(&x)) >> 63) << 1));
}

Trừ khi dữ liệu của bạn có số không bằng một nửa số, ở đây, bộ dự đoán nhánh sẽ chọn một trong những nhánh là phổ biến nhất. Cả hai chi nhánh chỉ liên quan đến các hoạt động đơn giản.

Ngoài ra, trên một số trình biên dịch và kiến ​​trúc CPU, một phiên bản hoàn toàn không phân nhánh có thể nhanh hơn:

inline int signum(const double x) {
    return (x != 0) * 
        (1 - (static_cast<int>((*reinterpret_cast<const uint64_t*>(&x)) >> 63) << 1));
}

Điều này hoạt động cho định dạng dấu phẩy động nhị phân chính xác kép của IEEE 754: binary64 .

int sign(float n)
{     
  union { float f; std::uint32_t i; } u { n };
  return 1 - ((u.i >> 31) << 1);
}

Hàm này giả định:

• biểu diễn binary32 của số dấu phẩy động
• một trình biên dịch tạo một ngoại lệ về quy tắc bí danh nghiêm ngặt khi sử dụng một liên minh có tên

double signof(double a) { return (a == 0) ? 0 : (a<0 ? -1 : 1); }

Tại sao nên sử dụng toán tử ternary và if-other khi bạn có thể đơn giản làm điều này

#define sgn(x) x==0 ? 0 : x/abs(x)