มีฟังก์ชั่นสัญญาณมาตรฐาน (signum, sgn) ใน C / C ++ หรือไม่

ฉันต้องการฟังก์ชั่นที่คืนค่า -1 สำหรับจำนวนลบและ +1 สำหรับจำนวนบวก http://en.wikipedia.org/wiki/Sign_function มันง่ายพอที่จะเขียนของฉันเอง แต่ดูเหมือนว่าบางสิ่งที่ควรจะอยู่ในห้องสมุดมาตรฐานที่ไหนสักแห่ง

แก้ไข: โดยเฉพาะฉันกำลังมองหาฟังก์ชั่นที่ทำงานกับลอย

แปลกใจที่ไม่มีใครโพสต์รุ่น C ++ ที่ปลอดภัยประเภท:

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

ประโยชน์ที่ได้รับ:

• ใช้สัญลักษณ์จริง (-1, 0 หรือ 1) การนำไปใช้ที่นี่โดยใช้ copysign จะส่งคืนค่า -1 หรือ 1 เท่านั้นซึ่งไม่ใช่ signum นอกจากนี้การใช้งานบางอย่างที่นี่กลับมาลอย (หรือ T) มากกว่า int ซึ่งดูเหมือนว่าสิ้นเปลือง
• ใช้งานได้กับ ints ลอยคู่กางเกงขาสั้นที่ไม่ได้ลงชื่อหรือประเภทที่กำหนดเองใด ๆ ที่สร้างได้จากจำนวนเต็ม 0 และสามารถสั่งซื้อได้
• ด่วน! copysignช้าโดยเฉพาะถ้าคุณต้องการโปรโมตและ จำกัด ให้แคบลงอีกครั้ง นี่คือไม่มีสาขาและเพิ่มประสิทธิภาพอย่างยอดเยี่ยม
• มาตรฐาน! แฮ็ก bitshift นั้นเรียบร้อย แต่ใช้ได้กับการเป็นตัวแทนเพียงเล็กน้อยและจะไม่ทำงานเมื่อคุณมีประเภทที่ไม่ได้ลงนาม มันสามารถให้เป็นความเชี่ยวชาญคู่มือเมื่อเหมาะสม
• ถูกต้อง! การเปรียบเทียบแบบง่าย ๆ กับศูนย์สามารถรักษาการแสดงภายในที่มีความแม่นยำสูงของเครื่อง (เช่น 80 บิตบน x87) และหลีกเลี่ยงรอบก่อนกำหนดเป็นศูนย์

คำเตือน:

• มันเป็นเทมเพลตดังนั้นจึงอาจใช้เวลานานในการรวบรวมในบางสถานการณ์
• เห็นได้ชัดว่าบางคนคิดว่าการใช้ฟังก์ชั่นไลบรารี่มาตรฐานใหม่ที่ค่อนข้างลึกลับและช้ามากที่ไม่ได้ใช้ Signum จริงๆเป็นที่เข้าใจได้มากกว่า

• < 0ส่วนหนึ่งของการตรวจสอบเป็นต้นเหตุของ GCC -Wtype-limitsเตือนเมื่อ instantiated สำหรับประเภทที่ไม่ได้ลงชื่อ คุณสามารถหลีกเลี่ยงปัญหานี้ได้ด้วยการใช้งานเกินพิกัดบางอย่าง:

  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>());
  }

  (ซึ่งเป็นตัวอย่างที่ดีของข้อแม้แรก)

ฉันไม่รู้ฟังก์ชันมาตรฐานสำหรับมัน นี่เป็นวิธีที่น่าสนใจในการเขียน:

(x > 0) - (x < 0)

นี่เป็นวิธีที่อ่านได้มากขึ้น:

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

ถ้าคุณชอบผู้ประกอบการที่คุณสามารถทำสิ่งนี้:

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

มีฟังก์ชั่นห้องสมุดคณิตศาสตร์ C99 ที่เรียกว่า copysign () ซึ่งรับสัญญาณจากการโต้แย้งหนึ่งและค่าสัมบูรณ์จากที่อื่น:

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

จะให้ผลลัพธ์เป็น +/- 1.0 ขึ้นอยู่กับสัญลักษณ์ของมูลค่า โปรดทราบว่าเลขศูนย์ทศนิยมถูกเซ็นชื่อ: (+0) จะให้ผลเป็น +1 และ (-0) จะให้ผลเป็น -1

ดูเหมือนว่าคำตอบส่วนใหญ่ไม่ได้ตอบคำถามดั้งเดิม

มีฟังก์ชั่นสัญญาณมาตรฐาน (signum, sgn) ใน C / C ++ หรือไม่

ไม่ได้อยู่ในไลบรารีมาตรฐาน แต่มีวิธีการcopysignที่สามารถใช้ได้เกือบเหมือนกันผ่านทางcopysign(1.0, arg)และมีฟังก์ชั่นการลงชื่อเข้าใช้จริงboostซึ่งอาจเป็นส่วนหนึ่งของมาตรฐานด้วย

    #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_functions.html

เห็นได้ชัดว่าคำตอบของคำถามโปสเตอร์ต้นฉบับคือไม่มี ไม่มีฟังก์ชั่นC ++ มาตรฐานsgn

มีฟังก์ชั่นสัญญาณมาตรฐาน (signum, sgn) ใน C / C ++ หรือไม่

ใช่ขึ้นอยู่กับคำจำกัดความ

C99 และใหม่กว่ามีsignbit()มาโคร<math.h>

int signbit(ลอยจริงx); แมโครผลตอบแทนค่าไม่ใช่ศูนย์ถ้าหากสัญญาณของค่าอาร์กิวเมนต์เป็นลบ C11 §7.12.3.6
signbit

ทว่า OP ต้องการบางสิ่งที่แตกต่างออกไปเล็กน้อย

ฉันต้องการฟังก์ชั่นที่คืนค่า -1 สำหรับจำนวนลบและ +1 สำหรับจำนวนบวก ... ฟังก์ชั่นที่ทำงานกับโฟลต

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

ลึก:

x = 0.0, -0.0, +NaN, -NaNโพสต์ไม่ได้เฉพาะในกรณีต่อไปนี้:

คลาสสิกsignum()ผลตอบแทน+1บนx>0, -1บนx<0และบน0x==0

มีคำตอบมากมายที่ได้กล่าวไปแล้ว แต่ไม่ได้x = -0.0, +NaN, -NaNกล่าวถึง หลายคนกำลังมุ่งสำหรับจำนวนเต็มจุดของมุมมองที่มักจะขาดไม่-a-เบอร์ (เป็นน่าน ) และ-0.0

คำตอบทั่วไปทำงานเหมือนsignnum_typical() เมื่อวันที่พวกเขากลับ-0.0, +NaN, -NaN0.0, 0.0, 0.0

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

ฉันขอเสนอฟังก์ชั่นนี้: วันที่-0.0, +NaN, -NaNมันกลับ-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;
}

เร็วกว่าโซลูชันด้านบนซึ่งรวมถึงอันดับสูงสุด:

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

มีวิธีการทำโดยไม่แตกกิ่งก้านสาขา แต่ก็ไม่สวยมาก

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

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

อีกมากมายที่น่าสนใจและฉลาดเกินกว่าในหน้านั้นอีกด้วย ...

หากสิ่งที่คุณต้องการคือการทดสอบสัญญาณให้ใช้signbit (ส่งกลับจริงถ้าอาร์กิวเมนต์มีเครื่องหมายลบ) ไม่แน่ใจว่าทำไมคุณถึงต้องการส่งคืนค่าเป็น -1 หรือ +1; copysign นั้นสะดวกกว่า แต่ดูเหมือนว่าจะส่งคืน +1 สำหรับศูนย์ลบในบางแพลตฟอร์มที่สนับสนุนเฉพาะบางส่วนสำหรับศูนย์ลบ

โดยทั่วไปไม่มีฟังก์ชั่นเซ็นมาตรฐานใน C / C ++ และการขาดฟังก์ชั่นพื้นฐานดังกล่าวจะบอกคุณมากมายเกี่ยวกับภาษาเหล่านี้

นอกจากนั้นฉันเชื่อว่ามุมมองส่วนใหญ่ทั้งสองเกี่ยวกับวิธีการที่ถูกต้องในการกำหนดฟังก์ชั่นดังกล่าวนั้นถูกต้องและ "การโต้เถียง" เกี่ยวกับมันเป็นความจริงที่ไม่ใช่ข้อโต้แย้งเมื่อคุณคำนึงถึงสองประการสำคัญ:

• Signumฟังก์ชั่นควรกลับชนิดของตัวถูกดำเนินการของตนในทำนองเดียวกันไปยังabs()ฟังก์ชั่นเพราะSignumมักจะใช้สำหรับการคูณกับค่าแน่นอนหลังจากที่หลังได้รับการประมวลผลอย่างใด ดังนั้นกรณีการใช้งานที่สำคัญของsignumไม่ใช่การเปรียบเทียบ แต่เป็นเลขคณิตและกรณีหลังนั้นไม่ควรเกี่ยวข้องกับการแปลงจำนวนเต็มเป็นถึง / จากจุดลอยตัวที่มีราคาแพง

• ชนิดจุดลอยตัวไม่มีคุณลักษณะเป็นค่าศูนย์ที่แน่นอนเดียว: +0.0 สามารถตีความได้ว่า "อนันต์เหนือศูนย์" และ -0.0 เป็น "อนันต์ต่ำกว่าศูนย์" นั่นคือเหตุผลที่การเปรียบเทียบที่เกี่ยวข้องกับศูนย์ต้องตรวจสอบค่าทั้งสองและการแสดงออกเช่นx == 0.0นั้นอาจเป็นอันตรายได้

เกี่ยวกับ C ฉันคิดว่าวิธีที่ดีที่สุดที่มีประเภทอินทิกรัลคือการใช้(x > 0) - (x < 0)นิพจน์เนื่องจากมันควรจะแปลในแบบที่ไม่มีสาขาและต้องการการดำเนินงานพื้นฐานเพียงสามครั้งเท่านั้น ที่ดีที่สุดกำหนดฟังก์ชั่นแบบอินไลน์ที่บังคับใช้ประเภทผลตอบแทนที่ตรงกับประเภทอาร์กิวเมนต์และเพิ่ม C11 define _Genericเพื่อแมปฟังก์ชั่นเหล่านี้กับชื่อสามัญ

ที่มีค่าจุดลอยผมคิดว่าฟังก์ชั่นแบบอินไลน์บนพื้นฐาน C11 copysignf(1.0f, x), copysign(1.0, x)และcopysignl(1.0l, x)เป็นวิธีที่จะไปเพียงเพราะพวกเขายังมีแนวโน้มที่จะเป็นสาขาฟรีและยังไม่จำเป็นต้องหล่อเป็นผลมาจากจำนวนเต็มกลับเข้ามาในจุดลอย ราคา. คุณควรแสดงความคิดเห็นอย่างเด่นชัดว่าการใช้งานจุดลอยตัวของsignumของคุณจะไม่กลับมาเป็นศูนย์เพราะลักษณะของค่าศูนย์จุดลอยตัวการพิจารณาเวลาในการประมวลผลและเพราะมันมักจะมีประโยชน์มากในเลขคณิตจุดลอยตัวเพื่อรับ -1 / + 1 เครื่องหมายแม้เป็นค่าศูนย์

สำเนา C ของฉันในสั้นเผยให้เห็นการมีอยู่ของฟังก์ชั่นมาตรฐานที่เรียกว่า copysign ซึ่งอาจมีประโยชน์ ดูเหมือนว่า copysign (1.0, -2.0) จะคืนค่า -1.0 และ copysign (1.0, 2.0) จะคืนค่า +1.0

ใกล้ชิดเหรอ?

ไม่มันไม่มีอยู่ใน c ++ เหมือนใน matlab ฉันใช้มาโครในโปรแกรมของฉันสำหรับสิ่งนี้

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

ตอบรับกับการโอเวอร์โหลดด้านล่างไม่แน่นอนไม่เรียก-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>());
}

สำหรับ C ++ 11 ทางเลือกอาจเป็นได้

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));  
}

สำหรับฉันมันไม่เรียกใช้คำเตือนใด ๆ ใน GCC 5.3.1

บิตนอกหัวข้อ แต่ฉันใช้สิ่งนี้:

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));
}

และฉันพบฟังก์ชั่นแรก - อันที่มีสองข้อโต้แย้ง, จะมีประโยชน์มากขึ้นจาก "มาตรฐาน" sgn () เพราะมันมักจะใช้ในรหัสเช่นนี้:

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

เมื่อเทียบกับ

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

ไม่มีเพี้ยนสำหรับประเภทที่ไม่ได้ลงชื่อและไม่มีการลบเพิ่มเติม

อันที่จริงฉันมีรหัสชิ้นนี้ใช้ 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);
}

คำถามเก่า แต่ตอนนี้มีฟังก์ชั่นที่ต้องการเช่นนี้ ฉันเพิ่ม wrapper โดยไม่เหลือกะและธันวาคม

คุณสามารถใช้ฟังก์ชั่น wrapper ตามsignbit จาก C99เพื่อให้ได้พฤติกรรมตามที่ต้องการ (ดูรหัสเพิ่มเติมด้านล่าง)

ส่งคืนว่าเครื่องหมายของ x เป็นลบหรือไม่
นอกจากนี้ยังสามารถนำไปใช้กับ infinites, NaNs และ zeroes (ถ้าศูนย์ไม่ได้ลงนามก็ถือว่าเป็นบวก

#include <math.h>

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

หมายเหตุ: ฉันใช้ตัวถูกดำเนินการไม่ ("!") เพราะค่าตอบแทนของ signbit ไม่ได้ระบุว่าเป็น 1 (แม้ว่าตัวอย่างให้เราคิดว่ามันจะเป็นเช่นนี้เสมอ) แต่จริงสำหรับจำนวนลบ:

Return value ค่าที่
ไม่ใช่ศูนย์ (จริง) หากเครื่องหมายของ x เป็นลบ; และศูนย์ (เท็จ) มิฉะนั้น

จากนั้นฉันคูณสองด้วยการเลื่อนซ้าย ("<< 1") ซึ่งจะให้เรา 2 สำหรับจำนวนบวกและ 0 สำหรับหนึ่งลบหนึ่งและลดลงในที่สุด 1 เพื่อให้ได้ 1 และ -1 สำหรับตัวเลขบวกและลบตามลำดับตามที่ร้องขอโดย OP

ในขณะที่วิธีแก้ปัญหาจำนวนเต็มในคำตอบที่ยอมรับนั้นค่อนข้างหรูหรา แต่ก็รบกวนฉันว่ามันจะไม่สามารถคืน NAN สำหรับประเภทสองประเภทได้ดังนั้นฉันจึงปรับเปลี่ยนเล็กน้อย

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

โปรดทราบว่าการส่งคืนจุดลอย NAN ซึ่งตรงข้ามกับฮาร์ดโค้ดNANทำให้เกิดการตั้งค่าบิตในการใช้งานบางอย่างดังนั้นเอาต์พุตสำหรับval = -NANและval = NANจะเหมือนกันไม่ว่าจะเกิดอะไรขึ้น (ถ้าคุณชอบnanเอาต์พุต "" มากกว่าที่-nanคุณสามารถใส่ได้ " abs(val)ก่อนที่จะส่งกลับ ... )

คุณสามารถใช้boost::math::sign()วิธีการboost/math/special_functions/sign.hppถ้ามีการเพิ่ม

นี่คือการติดตั้งที่ใช้งานง่าย

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

เว้นแต่ว่าข้อมูลของคุณมีศูนย์เป็นครึ่งหนึ่งของตัวเลขนี่คือตัวพยากรณ์สาขาจะเลือกสาขาใดสาขาหนึ่งที่พบมากที่สุด สาขาทั้งสองเกี่ยวข้องกับการดำเนินการที่เรียบง่ายเท่านั้น

อีกทางหนึ่งในคอมไพเลอร์และซีพียูบางรุ่นอาจไม่มีสาขาที่สมบูรณ์เร็วกว่า:

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

งานนี้สำหรับIEEE 754 แม่นยำสองรูปแบบไบนารีจุดลอยตัว: binary64

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

ฟังก์ชั่นนี้ถือว่า:

• การแสดงเลขฐานสองของเลขฐาน 32
• คอมไพเลอร์ที่สร้างข้อยกเว้นเกี่ยวกับกฎนามแฝงที่เข้มงวดเมื่อใช้ยูเนี่ยนที่ตั้งชื่อแล้ว

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

เหตุใดจึงต้องใช้ตัวดำเนินการที่ประกอบไปด้วยและหากอื่นเมื่อคุณสามารถทำได้

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