Apakah ada fungsi tanda standar (signum, sgn) di C / C ++?

Saya ingin fungsi yang mengembalikan -1 untuk angka negatif dan +1 untuk angka positif. http://en.wikipedia.org/wiki/Sign_function Cukup mudah untuk menulis sendiri, tetapi sepertinya sesuatu yang seharusnya ada di perpustakaan standar di suatu tempat.

Sunting: Secara khusus, saya sedang mencari fungsi yang bekerja pada floats.

Terkejut belum ada yang diposting versi C ++ tipe-safe:

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

Manfaat:

• Sebenarnya mengimplementasikan signum (-1, 0, atau 1). Implementasi di sini menggunakan copysign hanya mengembalikan -1 atau 1, yang tidak masuk. Juga, beberapa implementasi di sini mengembalikan float (atau T) daripada sebuah int, yang tampaknya boros.
• Dapat digunakan untuk int, float, dobel, celana pendek yang tidak ditandatangani, atau jenis kustom apa pun yang dapat dibangun dari integer 0 dan dapat dipesan.
• Cepat! copysignlambat, terutama jika Anda perlu mempromosikan dan kemudian mempersempit lagi. Ini tanpa cabang dan mengoptimalkan dengan sangat baik
• Sesuai standar! Retasan bithift rapi, tetapi hanya berfungsi untuk beberapa representasi bit, dan tidak berfungsi ketika Anda memiliki tipe yang tidak ditandai. Ini dapat diberikan sebagai spesialisasi manual bila perlu.
• Tepat! Perbandingan sederhana dengan nol dapat mempertahankan representasi presisi tinggi internal mesin (mis. 80 bit pada x87), dan menghindari putaran prematur ke nol.

Peringatan:

• Ini templat sehingga mungkin perlu waktu lebih lama untuk dikompilasi dalam beberapa keadaan.
• Rupanya beberapa orang berpikir penggunaan fungsi perpustakaan standar baru, agak esoterik, dan sangat lambat yang bahkan tidak benar-benar menerapkan signum lebih dapat dimengerti.

• Bagian < 0dari cek memicu -Wtype-limitsperingatan GCC ketika dipakai untuk tipe yang tidak ditandatangani. Anda dapat menghindari ini dengan menggunakan beberapa kelebihan:

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

  (Yang merupakan contoh yang baik dari peringatan pertama.)

Saya tidak tahu fungsi standar untuk itu. Inilah cara yang menarik untuk menulisnya:

(x > 0) - (x < 0)

Berikut cara yang lebih mudah dibaca untuk melakukannya:

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

Jika Anda menyukai operator ternary, Anda dapat melakukan ini:

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

Ada fungsi perpustakaan matematika C99 yang disebut copysign (), yang mengambil tanda dari satu argumen dan nilai absolut dari yang lain:

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

akan memberi Anda hasil +/- 1.0, tergantung pada tanda nilai. Perhatikan bahwa nol floating point ditandatangani: (+0) akan menghasilkan +1, dan (-0) akan menghasilkan -1.

Tampaknya sebagian besar jawaban tidak menjawab pertanyaan awal.

Apakah ada fungsi tanda standar (signum, sgn) di C / C ++?

Tidak di perpustakaan standar, namun ada copysignyang dapat digunakan dengan cara yang hampir sama copysign(1.0, arg)dan ada fungsi tanda yang benar boost, yang mungkin juga menjadi bagian dari standar.

    #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

Rupanya, jawaban untuk pertanyaan poster asli adalah tidak. Tidak ada fungsi standar C ++ sgn.

Apakah ada fungsi tanda standar (signum, sgn) di C / C ++?

Ya, tergantung definisi.

C99 dan yang lebih baru memiliki signbit()makro di<math.h>

int signbit(mengambang nyata x);
The signbitpengembalian makro nilai nol jika dan hanya jika tanda nilai argumen negatif. C11 §7.12.3.6

Namun OP menginginkan sesuatu yang sedikit berbeda.

Saya ingin fungsi yang mengembalikan -1 untuk angka negatif dan +1 untuk angka positif. ... sebuah fungsi yang bekerja pada pelampung.

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

Lebih dalam:

Posting adalah tidak spesifik dalam kasus berikut: x = 0.0, -0.0, +NaN, -NaN.

Sebuah klasik signum()kembali +1pada x>0, -1pada x<0dan 0di x==0.

Banyak jawaban telah membahas hal itu, tetapi tidak membahasnya x = -0.0, +NaN, -NaN. Banyak diarahkan untuk sudut pandang bilangan bulat yang biasanya tidak memiliki Not-a-Numbers ( NaN ) dan -0.0 .

Fungsi jawaban umum seperti signnum_typical() Hidup -0.0, +NaN, -NaN, mereka kembali 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;
}

Sebagai gantinya, saya mengusulkan fungsi ini: Hidup -0.0, +NaN, -NaN, itu kembali -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;
}

Lebih cepat daripada solusi di atas, termasuk yang berperingkat tertinggi:

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

Ada cara untuk melakukannya tanpa bercabang, tapi itu tidak terlalu cantik.

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

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

Banyak hal menarik lainnya, terlalu pintar di halaman itu, juga ...

Jika semua yang Anda inginkan adalah menguji tanda, gunakan signbit (mengembalikan true jika argumennya memiliki tanda negatif). Tidak yakin mengapa Anda ingin -1 atau +1 dikembalikan; copysign lebih nyaman untuk itu, tetapi sepertinya itu akan mengembalikan +1 untuk nol negatif pada beberapa platform dengan hanya dukungan parsial untuk nol negatif, di mana signbit mungkin akan mengembalikan true.

Secara umum, tidak ada fungsi signum standar di C / C ++, dan kurangnya fungsi fundamental seperti itu memberi tahu Anda banyak tentang bahasa-bahasa ini.

Terlepas dari itu, saya percaya kedua sudut pandang mayoritas tentang pendekatan yang tepat untuk mendefinisikan fungsi seperti itu dengan cara yang benar, dan "kontroversi" tentang itu sebenarnya bukan argumen ketika Anda mempertimbangkan dua peringatan penting:

• Sebuah signum fungsi harus selalu kembali jenis operan nya, mirip dengan sebuah abs()fungsi, karena signum biasanya digunakan untuk perkalian dengan nilai absolut setelah yang terakhir telah diproses entah bagaimana. Oleh karena itu, kasus penggunaan utama signum bukan perbandingan tetapi aritmatika, dan yang terakhir tidak boleh melibatkan konversi bilangan bulat ke / dari-floating-point yang mahal.

• Tipe floating point tidak menampilkan nilai nol tepat tunggal: +0.0 dapat diartikan sebagai "jauh di atas nol", dan -0,0 sebagai "sangat jauh di bawah nol". Itulah alasan mengapa perbandingan yang melibatkan nol harus secara internal memeriksa kedua nilai, dan ekspresi seperti itu x == 0.0bisa berbahaya.

Mengenai C, saya pikir cara terbaik untuk maju dengan tipe integral adalah dengan menggunakan (x > 0) - (x < 0)ekspresi, karena harus diterjemahkan dalam mode bebas cabang, dan hanya membutuhkan tiga operasi dasar. Mendefinisikan fungsi inline terbaik yang memberlakukan tipe kembali yang cocok dengan tipe argumen, dan menambahkan C11 define _Genericuntuk memetakan fungsi-fungsi ini ke nama umum.

Dengan nilai floating point, saya pikir fungsi inline berdasarkan C11 copysignf(1.0f, x),, copysign(1.0, x)dan copysignl(1.0l, x)adalah cara untuk pergi, hanya karena mereka juga sangat mungkin menjadi bebas cabang, dan juga tidak memerlukan casting hasil dari integer kembali ke floating point nilai. Anda mungkin harus berkomentar dengan jelas bahwa implementasi signum titik mengambang Anda tidak akan mengembalikan nol karena kekhasan nilai nol titik mengambang, pertimbangan waktu pemrosesan, dan juga karena sering sangat berguna dalam aritmatika titik apung untuk menerima -1 / + yang benar 1 tanda, bahkan untuk nilai nol.

Salinan C saya dalam Singkatnya mengungkapkan adanya fungsi standar yang disebut copysign yang mungkin berguna. Sepertinya copysign (1.0, -2.0) akan mengembalikan -1.0 dan copysign (1.0, 2.0) akan mengembalikan +1.0.

Cukup dekat ya?

Tidak, itu tidak ada di c ++, seperti di matlab. Saya menggunakan makro dalam program saya untuk ini.

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

Jawaban yang diterima dengan kelebihan di bawah ini memang tidak memicu -Wtype-limit .

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

Untuk C ++ 11 alternatif bisa jadi.

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

Bagi saya itu tidak memicu peringatan pada GCC 5.3.1.

Agak di luar topik, tapi saya menggunakan ini:

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

dan saya menemukan fungsi pertama - satu dengan dua argumen, untuk menjadi jauh lebih bermanfaat dari "standar" sgn (), karena paling sering digunakan dalam kode seperti ini:

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

vs.

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

tidak ada pemeran untuk tipe yang tidak ditandatangani dan tidak ada minus tambahan.

sebenarnya saya memiliki potongan kode ini menggunakan 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);
}

Pertanyaannya sudah tua tetapi sekarang ada fungsi yang diinginkan. Saya menambahkan pembungkus dengan tidak, shift kiri dan Desember.

Anda dapat menggunakan fungsi pembungkus berdasarkan signbit dari C99 untuk mendapatkan perilaku yang diinginkan yang tepat (lihat kode lebih lanjut di bawah).

Mengembalikan apakah tanda x negatif.
Ini dapat juga diterapkan pada infinites, NaNs dan nol (jika nol tidak ditandatangani, itu dianggap positif

#include <math.h>

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

NB: Saya menggunakan operand not ("!") Karena nilai kembalian dari signbit tidak ditentukan menjadi 1 (meskipun contohnya mari kita berpikir akan selalu seperti ini) tetapi berlaku untuk angka negatif:

Nilai kembali Nilai
bukan nol (benar) jika tanda x negatif; dan nol (salah) jika tidak.

Lalu saya kalikan dua dengan shift kiri ("<< 1") yang akan memberi kita 2 untuk angka positif dan 0 untuk yang negatif dan akhirnya dikurangi dengan 1 untuk mendapatkan 1 dan -1 untuk masing-masing angka positif dan negatif seperti yang diminta oleh OP.

Sementara solusi integer dalam jawaban yang diterima cukup elegan, itu mengganggu saya bahwa itu tidak akan dapat mengembalikan NAN untuk tipe ganda, jadi saya memodifikasinya sedikit.

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

Perhatikan bahwa mengembalikan floating point NAN sebagai lawan dari kode keras NANmenyebabkan bit tanda diatur dalam beberapa implementasi , sehingga output untuk val = -NANdan val = NANakan identik tidak peduli apa (jika Anda lebih memilih nanoutput " " daripada -nanAnda dapat menempatkan sebuah abs(val)sebelum kembalinya ...)

Anda dapat menggunakan boost::math::sign()metode dari boost/math/special_functions/sign.hppjika dorongan tersedia.

Berikut ini adalah implementasi yang ramah cabang:

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

Kecuali jika data Anda memiliki nol sebagai setengah dari angka, di sini prediktor cabang akan memilih salah satu cabang sebagai yang paling umum. Kedua cabang hanya melibatkan operasi sederhana.

Atau, pada beberapa kompiler dan arsitektur CPU versi yang benar-benar tanpa cabang mungkin lebih cepat:

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

Ini berfungsi untuk format floating-point biner IEEE 754 presisi ganda: binary64 .

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

Fungsi ini mengasumsikan:

• binary32 representasi angka floating point
• kompiler yang membuat pengecualian tentang aturan aliasing yang ketat saat menggunakan serikat bernama

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

Mengapa menggunakan operator ternary dan jika-lain saat Anda bisa melakukan ini

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