c++ উনল ভাসা এবং ডবল তুলনা জন্য সবচেয়ে কার্যকর উপায় কি?




সি++ বই (22)

একটি epsilon মান সঙ্গে তুলনা অধিকাংশ মানুষ কি (এমনকি গেম প্রোগ্রামিং)।

আপনি আপনার বাস্তবায়ন একটু পরিবর্তন করা উচিত যদিও:

bool AreSame(double a, double b)
{
    return fabs(a - b) < EPSILON;
}

সম্পাদনা: Christer একটি সাম্প্রতিক ব্লগ পোস্টে এই বিষয়ে দুর্দান্ত তথ্যের একটি স্ট্যাক যোগ করেছেন। উপভোগ করুন।

দুটি double বা দুটি float মান তুলনা করার সবচেয়ে কার্যকর উপায় কি হবে?

শুধু এই কাজ সঠিক নয়:

bool CompareDoubles1 (double A, double B)
{
   return A == B;
}

কিন্তু কিছু ভালো:

bool CompareDoubles2 (double A, double B) 
{
   diff = A - B;
   return (diff < EPSILON) && (-diff < EPSILON);
}

প্রক্রিয়াজাতকরণ বর্জ্য মনে হয়।

কেউ কি একটি স্মার্ট ফ্লাট তুলনাকারী জানেন?


`ফেরত fabs (একটি - বি) <EPSILON;

এটা ঠিক আছে যদি:

  • আপনার ইনপুট এর মাত্রা ক্রম অনেক পরিবর্তন না
  • বিপরীত লক্ষণগুলির খুব ছোট সংখ্যা সমান হিসাবে গণ্য করা যেতে পারে

কিন্তু অন্যথায় এটা আপনি কষ্ট মধ্যে নেতৃত্ব দেব। ডাবল স্পষ্টতা সংখ্যা প্রায় 16 দশমিক স্থান একটি রেজল্যুশন আছে। যদি আপনার তুলনা করা দুটি সংখ্যা EPSILON * 1.0E16 এর চেয়ে তত্পরতার মধ্যে বড় হয় তবে আপনিও বলছেন:

return a==b;

আমি একটি ভিন্ন পদ্ধতির পরীক্ষা করব যা আপনাকে প্রথম সমস্যাটির বিষয়ে চিন্তা করতে হবে এবং দ্বিতীয়টি অনুধাবন করুন আপনার আবেদনটি জরিমানা। একটি সমাধান মত কিছু হতে হবে:

#define VERYSMALL  (1.0E-150)
#define EPSILON    (1.0E-8)
bool AreSame(double a, double b)
{
    double absDiff = fabs(a - b);
    if (absDiff < VERYSMALL)
    {
        return true;
    }

    double maxAbs  = max(fabs(a) - fabs(b));
    return (absDiff/maxAbs) < EPSILON;
}

এটি ব্যয়বহুলভাবে ব্যয়বহুল, কিন্তু এটি কখনও কখনও বলা হয়। আমাদের কোম্পানিতে আমাদের যা করতে হবে, কারণ আমরা একটি ইঞ্জিনিয়ারিং লাইব্রেরির সাথে মোকাবিলা করি এবং ইনপুটগুলি মাত্র কয়েক ডজন আদেশ দ্বারা পরিবর্তিত হতে পারে।

যাইহোক, বিন্দুটি হল (এবং কার্যকরীভাবে প্রতি প্রোগ্রামিং সমস্যাটির ক্ষেত্রে প্রযোজ্য): আপনার প্রয়োজনীয়তাগুলি মূল্যায়ন করুন, তারপরে আপনার প্রয়োজনগুলির সমাধান করার একটি সমাধান নিয়ে আসুন - সহজ উত্তরটি অনুগ্রহ করে আপনার চাহিদাগুলি সমাধান করবে না। আপনার মূল্যায়ন পরে যদি আপনি যে fabs(ab) < EPSILON যথেষ্ট হবে, নিখুঁত - এটি ব্যবহার করুন! কিন্তু তার ক্ষয়ক্ষতি এবং অন্যান্য সম্ভাব্য সমাধান সম্পর্কে সচেতন থাকুন।


আপনি doubleএকটি নির্দিষ্ট সঙ্গে দুই তুলনা করতে পারবেন না EPSILON। মান উপর নির্ভর করে double, EPSILONপরিবর্তিত হয়।

একটি ভাল ডবল তুলনা হবে:

bool same(double a, double b)
{
  return std::nextafter(a, std::numeric_limits<double>::lowest()) <= b
    && std::nextafter(a, std::numeric_limits<double>::max()) >= b;
}

গভীরতার পদ্ধতিতে আরও একটি জন্য cygnus-software.com/papers/comparingfloats/comparingfloats.htm । এখানে যে লিঙ্ক থেকে কোড স্নিপেট হয়:

// Usable AlmostEqual function    
bool AlmostEqual2sComplement(float A, float B, int maxUlps)    
{    
    // Make sure maxUlps is non-negative and small enough that the    
    // default NAN won't compare as equal to anything.    
    assert(maxUlps > 0 && maxUlps < 4 * 1024 * 1024);    
    int aInt = *(int*)&A;    
    // Make aInt lexicographically ordered as a twos-complement int    
    if (aInt < 0)    
        aInt = 0x80000000 - aInt;    
    // Make bInt lexicographically ordered as a twos-complement int    
    int bInt = *(int*)&B;    
    if (bInt < 0)    
        bInt = 0x80000000 - bInt;    
    int intDiff = abs(aInt - bInt);    
    if (intDiff <= maxUlps)    
        return true;    
    return false;    
}

অন্যরা যেমন উল্লেখ করেছে, নির্দিষ্ট সংখ্যার ইপিসিলন (যেমন 0.0000001) ব্যবহার করে অ্যাপসিলন মান থেকে দূরে থাকা মূল্যের জন্য নিরর্থক হবে । উদাহরণস্বরূপ, যদি আপনার দুইটি মান 10000.000977 এবং 10000 হয়, তাহলে এই দুটি সংখ্যাগুলির মধ্যে কোন 32-বিট ভাসমান-বিন্দু মান নেই - 10000 এবং 10000.000977 আপনি যতটা সম্ভব বিট-বিট অভিন্ন ছাড়াও পেতে পারেন। এখানে, 0.0009 এর চেয়ে কম একটি epsilon অর্থহীন; আপনি ভাল সমানতা অপারেটর ব্যবহার করতে পারে।

একইভাবে, দুটি মান আকারে ইপিসিলন পদ্ধতির সাথে সম্পর্কিত, আপেক্ষিক ত্রুটি 100% বৃদ্ধি পায়।

সুতরাং, 0.00001 হিসাবে একটি নির্দিষ্ট বিন্দু সংখ্যা ভাসমান করার চেষ্টা করছে ভাসমান-বিন্দু মানগুলির সাথে (যেখানে সূচকটি নির্বিচারে হয়) একটি বিন্দুহীন ব্যায়াম। এটি কেবল তখনই কাজ করবে যদি আপনি আশ্বস্ত হতে পারেন যে অপারেড মানগুলি একটি সংকীর্ণ ডোমেনে (অর্থাৎ, কিছু নির্দিষ্ট এক্সপোনের কাছে) মধ্যে থাকে এবং আপনি যদি সেই নির্দিষ্ট পরীক্ষার জন্য সঠিকভাবে একটি অ্যাপসিলন মান নির্বাচন করেন। যদি আপনি বায়ু থেকে একটি নম্বর টেনে আনেন ("আরে! 0.00001 ছোট, তাই এটি ভাল হতে হবে!"), আপনি সংখ্যাসূচক ত্রুটিগুলির জন্য নষ্ট হয়েছেন। আমি খারাপ সংখ্যাসূচক কোড ডিবাগ করার সময় অতিবাহিত করেছি যেখানে কিছু দরিদ্র schmuck এখনও অন্য পরীক্ষা ক্ষেত্রে কাজ করতে র্যান্ডম অ্যাপসিলন মানের মধ্যে টসে।

যদি আপনি কোন ধরনের সংখ্যাসূচক প্রোগ্রামিং করেন এবং বিশ্বাস করেন যে আপনি নির্দিষ্ট বিন্দু অ্যাপসিলনগুলির জন্য পৌঁছাতে চান তবে ফ্লোটিং পয়েন্ট সংখ্যা তুলনায় ব্রুসের নিবন্ধটি পড়ুন

ভাসমান পয়েন্ট সংখ্যা তুলনা


আমার পোস্ট পূর্বে পোস্ট উত্তর উপর ভিত্তি করে। গুগলের কোড খুব অনুরূপ কিন্তু আমি একটি পক্ষপাত ব্যবহার করি যা 0xFF000000 এর উপরে সমস্ত NaN মানকে ধাক্কা দেয়। যে NaN জন্য একটি দ্রুত চেক করতে পারবেন।

এই কোড ধারণা প্রদর্শন করা হয়, একটি সাধারণ সমাধান না। Google এর কোড ইতিমধ্যে সমস্ত প্ল্যাটফর্মের নির্দিষ্ট মান গণনা করে দেখায় এবং আমি সেগুলি অনুলিপি করতে চাইনি। আমি এই কোড সীমিত পরীক্ষায় করেছি।

typedef unsigned int   U32;
//  Float           Memory          Bias (unsigned)
//  -----           ------          ---------------
//   NaN            0xFFFFFFFF      0xFF800001
//   NaN            0xFF800001      0xFFFFFFFF
//  -Infinity       0xFF800000      0x00000000 ---
//  -3.40282e+038   0xFF7FFFFF      0x00000001    |
//  -1.40130e-045   0x80000001      0x7F7FFFFF    |
//  -0.0            0x80000000      0x7F800000    |--- Valid <= 0xFF000000.
//   0.0            0x00000000      0x7F800000    |    NaN > 0xFF000000
//   1.40130e-045   0x00000001      0x7F800001    |
//   3.40282e+038   0x7F7FFFFF      0xFEFFFFFF    |
//   Infinity       0x7F800000      0xFF000000 ---
//   NaN            0x7F800001      0xFF000001
//   NaN            0x7FFFFFFF      0xFF7FFFFF
//
//   Either value of NaN returns false.
//   -Infinity and +Infinity are not "close".
//   -0 and +0 are equal.
//
class CompareFloat{
public:
    union{
        float     m_f32;
        U32       m_u32;
    };
    static bool   CompareFloat::IsClose( float A, float B, U32 unitsDelta = 4 )
                  {
                      U32    a = CompareFloat::GetBiased( A );
                      U32    b = CompareFloat::GetBiased( B );

                      if ( (a > 0xFF000000) || (b > 0xFF000000) )
                      {
                          return( false );
                      }
                      return( (static_cast<U32>(abs( a - b ))) < unitsDelta );
                  }
    protected:
    static U32    CompareFloat::GetBiased( float f )
                  {
                      U32    r = ((CompareFloat*)&f)->m_u32;

                      if ( r & 0x80000000 )
                      {
                          return( ~r - 0x007FFFFF );
                      }
                      return( r + 0x7F800000 );
                  }
};

আপনার লেখা কোডটি বাগ হয়েছে:

return (diff < EPSILON) && (-diff > EPSILON);

সঠিক কোড হবে:

return (diff < EPSILON) && (diff > -EPSILON);

(... এবং হ্যাঁ এই ভিন্ন)

Fabs আপনি কিছু ক্ষেত্রে অলস মূল্যায়ন হারাতে হবে না যদি আমি আশ্চর্য। আমি এটা কম্পাইলার উপর নির্ভর করবে বলে। আপনি উভয় চেষ্টা করতে পারেন। তারা গড় সমতুল্য, fabs সঙ্গে বাস্তবায়ন নিতে।

যদি আপনার দুটি তথ্য কোনটি দুটি ফ্ল্যাটের চেয়ে বড় হতে পারে তার কিছু তথ্য থাকে তবে অলস মূল্যায়নে আরও ভাল সুবিধা নেওয়ার তুলনায় আপনি তুলনা করতে পারেন।

অবশেষে আপনি এই ফাংশন inlining দ্বারা ভাল ফলাফল পেতে পারে। যদিও অনেক উন্নত করার সম্ভাবনা নেই ...

সম্পাদনা করুন: ওজে, আপনার কোড সংশোধন করার জন্য ধন্যবাদ। আমি সেই অনুযায়ী আমার মন্তব্য মুছে ফেলা


C ++ এ epsilon পেতে পোর্টেবল উপায়

#include <limits>
std::numeric_limits<double>::epsilon()

তারপর তুলনা ফাংশন হয়ে যায়

#include <cmath>
#include <limits>

bool AreSame(double a, double b) {
    return std::fabs(a - b) < std::numeric_limits<double>::epsilon();
}

আমি এই কোড ব্যবহার করি:

bool AlmostEqual(double v1, double v2)
    {
        return (std::fabs(v1 - v2) < std::fabs(std::min(v1, v2)) * std::numeric_limits<double>::epsilon());
    }

অন্যান্য পরামর্শ ব্যবহার করে অত্যন্ত সতর্ক থাকুন। এটা সব প্রসঙ্গ উপর নির্ভর করে।

আমি একটি সিস্টেমে একটি বাগ ট্রেস করার জন্য অনেক সময় ব্যয় করেছি যা a==b যদি বলে |ab|<epsilon । অন্তর্নিহিত সমস্যা ছিল:

  1. একটি অ্যালগরিদম মধ্যে অন্তর্নিহিত অনুমান যে a==b এবং b==c তারপর a==c

  2. মিলস (.001 ইঞ্চি) পরিমাপ ইঞ্চি এবং লাইন পরিমাপ লাইন জন্য একই epsilon ব্যবহার করে। যে a==b কিন্তু 1000a!=1000b । (এই কারণে AlmostEqual2sComplement ইপিসিলন বা সর্বোচ্চ ULPS এর জন্য অনুরোধ করে)।

  3. কোণের কোসাইন এবং লাইনের দৈর্ঘ্যের জন্য একই ইপ্সিলন ব্যবহার!

  4. একটি সংগ্রহে আইটেম সাজানোর যেমন একটি তুলনা ফাংশন ব্যবহার করে। (এই ক্ষেত্রে বিল্টিন সি ++ অপারেটর == ব্যবহার করে ডাবলসের জন্য সঠিক ফলাফল তৈরি করা হয়েছে।)

যেমন আমি বলেছি: এটি সব প্রসঙ্গ এবং a এবং b এর প্রত্যাশিত আকারের উপর নির্ভর করে।

BTW, std::numeric_limits<double>::epsilon() "মেশিন epsilon" হয়। এটি 1.0 এবং পরবর্তী মানের মধ্যে পার্থক্য দ্বিগুণ। আমি অনুমান করি যে এটি তুলনামূলক ফাংশনে ব্যবহার করা যেতে পারে তবে শুধুমাত্র প্রত্যাশিত মানগুলি 1 এর কম হলেই হয়। (এটি @ সিডিভির উত্তরের প্রতিক্রিয়া হিসাবে ...)

এছাড়াও, যদি আপনি মূলত doubles int গাণিতিক (যদি আমরা নির্দিষ্ট ক্ষেত্রে int-values ​​ধরে রাখতে ডাবলস ব্যবহার করি) আপনার গাণিতিকটি সঠিক হবে। উদাহরণস্বরূপ 4.0 / 2.0 1.0 + 1.0 হিসাবে একই হবে। যতক্ষণ আপনি এমন কিছু করবেন না যা ভগ্নাংশের ফলাফল (4.0 / 3.0) বা কোন int এর আকারের বাইরে না যান।


কেন বিটিভির XOR সঞ্চালন না? দুইটি ভাসমান বিন্দু সংখ্যা সমান হলে তাদের সংশ্লিষ্ট বিট সমান। আমি মনে করি, মন্তিসার সামনে ঘোষক বিট বসানোর সিদ্ধান্ত দুইটি ফ্ল্যাটের তুলনায় দ্রুত গতিতে তৈরি করা হয়েছিল। আমি মনে করি, এখানে অনেক উত্তর epsilon তুলনা বিন্দু অনুপস্থিত। Epsilon মান শুধুমাত্র স্পষ্টতা ভাসমান বিন্দু সংখ্যা তুলনা করা হয় কি উপর নির্ভর করে। উদাহরণস্বরূপ, floats সহ কিছু গাণিতিক কাজ করার পরে আপনি দুটি সংখ্যা পেতে: 2.5642943554342 এবং 2.5642943554345। তারা সমান নয়, তবে সমাধানটির জন্য কেবলমাত্র 3 দশমিক সংখ্যা সংখ্যা তাই তারা সমান: 2.564 এবং 2.564। এই ক্ষেত্রে আপনি 0.001 সমান epsilon নির্বাচন করুন। Epsilon তুলনা bitwise XOR সঙ্গে সম্ভব। আমি ভুল হলে আমাকে সংশোধন করুন।


এখানে প্রমাণটি ব্যবহার std::numeric_limits::epsilon()করা উত্তর নয় - এটি একের চেয়ে বেশি মানগুলির জন্য ব্যর্থ হয়:

উপরে আমার মন্তব্য প্রমাণ:

#include <stdio.h>
#include <limits>

double ItoD (__int64 x) {
    // Return double from 64-bit hexadecimal representation.
    return *(reinterpret_cast<double*>(&x));
}

void test (__int64 ai, __int64 bi) {
    double a = ItoD(ai), b = ItoD(bi);
    bool close = std::fabs(a-b) < std::numeric_limits<double>::epsilon();
    printf ("%.16f and %.16f %s close.\n", a, b, close ? "are " : "are not");
}

int main()
{
    test (0x3fe0000000000000L,
          0x3fe0000000000001L);

    test (0x3ff0000000000000L,
          0x3ff0000000000001L);
}

চলমান এই আউটপুট ফলন:

0.5000000000000000 and 0.5000000000000001 are  close.
1.0000000000000000 and 1.0000000000000002 are not close.

নোট করুন যে দ্বিতীয় ক্ষেত্রে (এক এবং একের চেয়ে বড়), দুটি ইনপুট মানগুলি সম্ভবত যতটা সম্ভব সেগুলির কাছাকাছি, এবং এখনও ঘনিষ্ঠ হিসাবে তুলনা করে। সুতরাং, 1.0 এর চেয়েও বেশি মানগুলির জন্য, আপনি কেবলমাত্র সমতা পরীক্ষাটি ব্যবহার করতে পারেন। ভাসমান-বিন্দু মান তুলনা করার সময় স্থায়ী epsilons আপনাকে সংরক্ষণ করবে না।


Qt দুটি ফাংশন প্রয়োগ করে, আপনি তাদের কাছ থেকে শিখতে পারেন:

static inline bool qFuzzyCompare(double p1, double p2)
{
    return (qAbs(p1 - p2) <= 0.000000000001 * qMin(qAbs(p1), qAbs(p2)));
}

static inline bool qFuzzyCompare(float p1, float p2)
{
    return (qAbs(p1 - p2) <= 0.00001f * qMin(qAbs(p1), qAbs(p2)));
}

এবং আপনি নিম্নলিখিত ফাংশন প্রয়োজন হতে পারে, যেহেতু

উল্লেখ্য যে মানগুলি তুলনা করা যেখানে প1 বা পি 2 হয় 0.0 কাজ করবে না, না মূল্যগুলির তুলনা করবে যেখানে মানগুলির মধ্যে একটি মান NaN বা অনন্ত। মানগুলির মধ্যে একটিতে সর্বদা 0.0 থাকলে, পরিবর্তে qFuzzyIsNull ব্যবহার করুন। যদি মানের মধ্যে একটি 0.0 হতে পারে, একটি সমাধান উভয় মান 1.0 যোগ করতে হয়।

static inline bool qFuzzyIsNull(double d)
{
    return qAbs(d) <= 0.000000000001;
}

static inline bool qFuzzyIsNull(float f)
{
    return qAbs(f) <= 0.00001f;
}

আমি দেখেছি যে গুগল সি ++ টেস্টিং ফ্রেমওয়ার্কটিতে একটি চমৎকার ক্রস-প্ল্যাটফর্ম টেমপ্লেট-ভিত্তিক বাস্তবায়ন রয়েছে যা AlmostEqual2sComplement যা উভয় ডাবল এবং ফ্ল্যাটে কাজ করে। এটি আপনার BSD লাইসেন্সের অধীনে প্রকাশ করা হয়েছে, এটি আপনার নিজের কোডে ব্যবহার করে কোনও সমস্যা হওয়া উচিত নয়, যতক্ষণ আপনি লাইসেন্সটি ধরে রাখবেন। আমি নীচের কোডটি http://code.google.com/p/googletest/source/browse/trunk/include/gtest/internal/gtest-internal.h https://github.com/google/googletest/blob/master/googletest/include/gtest/internal/gtest-internal.h থেকে বের করেছি। https://github.com/google/googletest/blob/master/googletest/include/gtest/internal/gtest-internal.h এবং উপরে লাইসেন্সটি যোগ করেছেন।

কিছু মানতে GTEST_OS_WINDOWS নির্ধারণ করুন (অথবা কোডটি পরিবর্তন করার জন্য যে কোডটি ব্যবহার করা হয়েছে তা কোডটি পরিবর্তন করতে - এটি সর্বদা BSD লাইসেন্সযুক্ত)।

ব্যবহার উদাহরণ:

double left  = // something
double right = // something
const FloatingPoint<double> lhs(left), rhs(right);

if (lhs.AlmostEquals(rhs)) {
  //they're equal!
}

এখানে কোডটি রয়েছে:

// Copyright 2005, Google Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
//     * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
//     * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// Authors: [email protected] (Zhanyong Wan), [email protected] (Sean Mcafee)
//
// The Google C++ Testing Framework (Google Test)


// This template class serves as a compile-time function from size to
// type.  It maps a size in bytes to a primitive type with that
// size. e.g.
//
//   TypeWithSize<4>::UInt
//
// is typedef-ed to be unsigned int (unsigned integer made up of 4
// bytes).
//
// Such functionality should belong to STL, but I cannot find it
// there.
//
// Google Test uses this class in the implementation of floating-point
// comparison.
//
// For now it only handles UInt (unsigned int) as that's all Google Test
// needs.  Other types can be easily added in the future if need
// arises.
template <size_t size>
class TypeWithSize {
 public:
  // This prevents the user from using TypeWithSize<N> with incorrect
  // values of N.
  typedef void UInt;
};

// The specialization for size 4.
template <>
class TypeWithSize<4> {
 public:
  // unsigned int has size 4 in both gcc and MSVC.
  //
  // As base/basictypes.h doesn't compile on Windows, we cannot use
  // uint32, uint64, and etc here.
  typedef int Int;
  typedef unsigned int UInt;
};

// The specialization for size 8.
template <>
class TypeWithSize<8> {
 public:
#if GTEST_OS_WINDOWS
  typedef __int64 Int;
  typedef unsigned __int64 UInt;
#else
  typedef long long Int;  // NOLINT
  typedef unsigned long long UInt;  // NOLINT
#endif  // GTEST_OS_WINDOWS
};


// This template class represents an IEEE floating-point number
// (either single-precision or double-precision, depending on the
// template parameters).
//
// The purpose of this class is to do more sophisticated number
// comparison.  (Due to round-off error, etc, it's very unlikely that
// two floating-points will be equal exactly.  Hence a naive
// comparison by the == operation often doesn't work.)
//
// Format of IEEE floating-point:
//
//   The most-significant bit being the leftmost, an IEEE
//   floating-point looks like
//
//     sign_bit exponent_bits fraction_bits
//
//   Here, sign_bit is a single bit that designates the sign of the
//   number.
//
//   For float, there are 8 exponent bits and 23 fraction bits.
//
//   For double, there are 11 exponent bits and 52 fraction bits.
//
//   More details can be found at
//   http://en.wikipedia.org/wiki/IEEE_floating-point_standard.
//
// Template parameter:
//
//   RawType: the raw floating-point type (either float or double)
template <typename RawType>
class FloatingPoint {
 public:
  // Defines the unsigned integer type that has the same size as the
  // floating point number.
  typedef typename TypeWithSize<sizeof(RawType)>::UInt Bits;

  // Constants.

  // # of bits in a number.
  static const size_t kBitCount = 8*sizeof(RawType);

  // # of fraction bits in a number.
  static const size_t kFractionBitCount =
    std::numeric_limits<RawType>::digits - 1;

  // # of exponent bits in a number.
  static const size_t kExponentBitCount = kBitCount - 1 - kFractionBitCount;

  // The mask for the sign bit.
  static const Bits kSignBitMask = static_cast<Bits>(1) << (kBitCount - 1);

  // The mask for the fraction bits.
  static const Bits kFractionBitMask =
    ~static_cast<Bits>(0) >> (kExponentBitCount + 1);

  // The mask for the exponent bits.
  static const Bits kExponentBitMask = ~(kSignBitMask | kFractionBitMask);

  // How many ULP's (Units in the Last Place) we want to tolerate when
  // comparing two numbers.  The larger the value, the more error we
  // allow.  A 0 value means that two numbers must be exactly the same
  // to be considered equal.
  //
  // The maximum error of a single floating-point operation is 0.5
  // units in the last place.  On Intel CPU's, all floating-point
  // calculations are done with 80-bit precision, while double has 64
  // bits.  Therefore, 4 should be enough for ordinary use.
  //
  // See the following article for more details on ULP:
  // http://www.cygnus-software.com/papers/comparingfloats/comparingfloats.htm.
  static const size_t kMaxUlps = 4;

  // Constructs a FloatingPoint from a raw floating-point number.
  //
  // On an Intel CPU, passing a non-normalized NAN (Not a Number)
  // around may change its bits, although the new value is guaranteed
  // to be also a NAN.  Therefore, don't expect this constructor to
  // preserve the bits in x when x is a NAN.
  explicit FloatingPoint(const RawType& x) { u_.value_ = x; }

  // Static methods

  // Reinterprets a bit pattern as a floating-point number.
  //
  // This function is needed to test the AlmostEquals() method.
  static RawType ReinterpretBits(const Bits bits) {
    FloatingPoint fp(0);
    fp.u_.bits_ = bits;
    return fp.u_.value_;
  }

  // Returns the floating-point number that represent positive infinity.
  static RawType Infinity() {
    return ReinterpretBits(kExponentBitMask);
  }

  // Non-static methods

  // Returns the bits that represents this number.
  const Bits &bits() const { return u_.bits_; }

  // Returns the exponent bits of this number.
  Bits exponent_bits() const { return kExponentBitMask & u_.bits_; }

  // Returns the fraction bits of this number.
  Bits fraction_bits() const { return kFractionBitMask & u_.bits_; }

  // Returns the sign bit of this number.
  Bits sign_bit() const { return kSignBitMask & u_.bits_; }

  // Returns true iff this is NAN (not a number).
  bool is_nan() const {
    // It's a NAN if the exponent bits are all ones and the fraction
    // bits are not entirely zeros.
    return (exponent_bits() == kExponentBitMask) && (fraction_bits() != 0);
  }

  // Returns true iff this number is at most kMaxUlps ULP's away from
  // rhs.  In particular, this function:
  //
  //   - returns false if either number is (or both are) NAN.
  //   - treats really large numbers as almost equal to infinity.
  //   - thinks +0.0 and -0.0 are 0 DLP's apart.
  bool AlmostEquals(const FloatingPoint& rhs) const {
    // The IEEE standard says that any comparison operation involving
    // a NAN must return false.
    if (is_nan() || rhs.is_nan()) return false;

    return DistanceBetweenSignAndMagnitudeNumbers(u_.bits_, rhs.u_.bits_)
        <= kMaxUlps;
  }

 private:
  // The data type used to store the actual floating-point number.
  union FloatingPointUnion {
    RawType value_;  // The raw floating-point number.
    Bits bits_;      // The bits that represent the number.
  };

  // Converts an integer from the sign-and-magnitude representation to
  // the biased representation.  More precisely, let N be 2 to the
  // power of (kBitCount - 1), an integer x is represented by the
  // unsigned number x + N.
  //
  // For instance,
  //
  //   -N + 1 (the most negative number representable using
  //          sign-and-magnitude) is represented by 1;
  //   0      is represented by N; and
  //   N - 1  (the biggest number representable using
  //          sign-and-magnitude) is represented by 2N - 1.
  //
  // Read http://en.wikipedia.org/wiki/Signed_number_representations
  // for more details on signed number representations.
  static Bits SignAndMagnitudeToBiased(const Bits &sam) {
    if (kSignBitMask & sam) {
      // sam represents a negative number.
      return ~sam + 1;
    } else {
      // sam represents a positive number.
      return kSignBitMask | sam;
    }
  }

  // Given two numbers in the sign-and-magnitude representation,
  // returns the distance between them as an unsigned number.
  static Bits DistanceBetweenSignAndMagnitudeNumbers(const Bits &sam1,
                                                     const Bits &sam2) {
    const Bits biased1 = SignAndMagnitudeToBiased(sam1);
    const Bits biased2 = SignAndMagnitudeToBiased(sam2);
    return (biased1 >= biased2) ? (biased1 - biased2) : (biased2 - biased1);
  }

  FloatingPointUnion u_;
};

সম্পাদনা করুন: এই পোস্টটি 4 বছর বয়সী। এটি সম্ভবত এখনও বৈধ, এবং কোডটি সুন্দর, তবে কিছু লোকের উন্নতি হয়েছে। গুগল টেস্ট সোর্স কোড থেকে সেরা AlmostEquals এর সর্বশেষ সংস্করণটি পান, এবং আমি AlmostEquals


আমি জাভা জন্য এই লিখুন, কিন্তু আপনি এটি দরকারী খুঁজে পেতে পারেন। এটি দ্বিগুণের পরিবর্তে লম্বা ব্যবহার করে, তবে NaNs, subnormals ইত্যাদি যত্ন নেয়।

public static boolean equal(double a, double b) {
    final long fm = 0xFFFFFFFFFFFFFL;       // fraction mask
    final long sm = 0x8000000000000000L;    // sign mask
    final long cm = 0x8000000000000L;       // most significant decimal bit mask
    long c = Double.doubleToLongBits(a), d = Double.doubleToLongBits(b);        
    int ea = (int) (c >> 52 & 2047), eb = (int) (d >> 52 & 2047);
    if (ea == 2047 && (c & fm) != 0 || eb == 2047 && (d & fm) != 0) return false;   // NaN 
    if (c == d) return true;                            // identical - fast check
    if (ea == 0 && eb == 0) return true;                // ±0 or subnormals
    if ((c & sm) != (d & sm)) return false;             // different signs
    if (abs(ea - eb) > 1) return false;                 // b > 2*a or a > 2*b
    d <<= 12; c <<= 12;
    if (ea < eb) c = c >> 1 | sm;
    else if (ea > eb) d = d >> 1 | sm;
    c -= d;
    return c < 65536 && c > -65536;     // don't use abs(), because:
    // There is a posibility c=0x8000000000000000 which cannot be converted to positive
}
public static boolean zero(double a) { return (Double.doubleToLongBits(a) >> 52 & 2047) < 3; }

মনে রাখবেন যে বেশিরভাগ ভাসমান-বিন্দু ক্রিয়াকলাপের পরে, আমরা যা আশা করি তার থেকে সংখ্যাটি ভিন্ন হতে পারে। যে ঠিক করার জন্য কোন কোড আছে।


ভাসমান বিন্দু সংখ্যার সাধারণ উদ্দেশ্য তুলনা সাধারণত অর্থহীন। তুলনা কিভাবে সত্যিই হাতে একটি সমস্যা উপর নির্ভর করে। অনেক সমস্যার মধ্যে, সংখ্যাগুলি প্রদত্ত সহনশীলতার মধ্যে তাদের তুলনা করার জন্য পর্যাপ্তরূপে বিযুক্ত করা হয়। দুর্ভাগ্যবশত, অনেক সমস্যা আছে, যেখানে এমন কৌশল সত্যিই কাজ করে না। এক উদাহরণের জন্য, আপনার পর্যবেক্ষণগুলি বাধাটির খুব কাছাকাছি হলে প্রশ্নগুলির একটি সংখ্যা (ডিজিটাল স্টক বিকল্পগুলি মনে রাখবেন) একটি হেভিসাইড (ধাপ) ফাংশনের সাথে কাজ করার কথা বিবেচনা করুন। সহনশীলতার উপর ভিত্তি করে তুলনা করা তুলনামূলকভাবে ভাল কাজ করবে না, কারণ এটি কার্যকরভাবে মূল বাধা থেকে দুটি নতুন অবস্থানে স্থানান্তরিত করবে। আবার, এ ধরনের সমস্যার জন্য কোনও সাধারণ উদ্দেশ্য সমাধান নেই এবং স্থিরতা অর্জনের জন্য নির্দিষ্ট সমাধানটির সংখ্যাসূচক পদ্ধতি পরিবর্তন করার প্রয়োজন হতে পারে।


আরও সাধারণ ভাবে:

template <typename T>
bool compareNumber(const T& a, const T& b) {
    return std::abs(a - b) < std::numeric_limits<T>::epsilon();
}

এটি বুঝতে একটি পুরানো থ্রেড তবে এই প্রবন্ধটি আমি ভাসমান বিন্দু সংখ্যার তুলনায় সর্বাধিক সোজা অগ্রগতিগুলির মধ্যে একটি এবং যদি আপনি আরো অন্বেষণ করতে চান তবে এটিতে আরও বিশদ উল্লেখ রয়েছে এবং এটি মূল বিষয়গুলির সম্পূর্ণ পরিসরকে অন্তর্ভুক্ত করে ভাসমান বিন্দু সংখ্যা সঙ্গে ডিল Floating- পয়েন্ট গাইড: তুলনা

আমরা পর্যায়ক্রমে ভাসমান-বিন্দু সহনশীলতাগুলির মধ্যে কিছুটা আরও বেশি ব্যবহারিক নিবন্ধ খুঁজে পেতে পারি এবং নিখরচায় সহনশীলতা পরীক্ষাটি রয়েছে যা সি ++ এ এটিকে উড়ে যায়:

bool absoluteToleranceCompare(double x, double y)
{
    return std::fabs(x - y) <= std::numeric_limits<double>::epsilon() ;
}

এবং আপেক্ষিক সহনশীলতা পরীক্ষা:

bool relativeToleranceCompare(double x, double y)
{
    double maxXY = std::max( std::fabs(x) , std::fabs(y) ) ;
    return std::fabs(x - y) <= std::numeric_limits<double>::epsilon()*maxXY ;
}

নিবন্ধটি উল্লেখ করে যে x এবং y বড় হলে পরম পরীক্ষা ব্যর্থ হয় এবং ছোট হলে আপেক্ষিক ক্ষেত্রে ব্যর্থ হয়। তিনি পরম এবং আপেক্ষিক সহনশীলতা একই মিলিত পরীক্ষা অনুমান করা হবে এই মত:

bool combinedToleranceCompare(double x, double y)
{
    double maxXYOne = std::max( { 1.0, std::fabs(x) , std::fabs(y) } ) ;

    return std::fabs(x - y) <= std::numeric_limits<double>::epsilon()*maxXYOne ;
}

এটা আপনি তুলনা করতে চান কিভাবে সুনির্দিষ্ট উপর নির্ভর করে। আপনি যদি ঠিক একই নম্বরের জন্য তুলনা করতে চান, তবে শুধু == দিয়ে যান। (যদি আপনি প্রকৃতপক্ষে একই নম্বরটি না চান তবে আপনি প্রায় এটি করতে চান না।) কোনও উপযুক্ত প্ল্যাটফর্মে আপনি নিম্নলিখিতগুলিও করতে পারেন:

diff= a - b; return fabs(diff)<EPSILON;

হিসাবে fabsবেশ দ্রুত হতে থাকে। বেশ দ্রুত দ্বারা আমি বলতে চাচ্ছি এটি মূলত একটি বিটwise এবং তাই এটি দ্রুততর হবে।

এবং দ্বিগুণ এবং ভাসমান তুলনা করার জন্য পূর্ণসংখ্যা কৌশলগুলি চমৎকার তবে বিভিন্ন CPU পাইপলাইনগুলিকে কার্যকরীভাবে পরিচালনা করার জন্য এটি আরও কঠিন করে তোলে। এবং স্থিরভাবে ব্যবহৃত মানগুলির জন্য একটি অস্থায়ী সঞ্চয়স্থান হিসাবে স্ট্যাকগুলি ব্যবহার করার কারণে আজকাল নির্দিষ্ট কিছু ইন আর্কিটেকচারগুলিতে এটি দ্রুততর নয়। (যারা যত্ন জন্য লোড হিট দোকান।)


পরিমানের পরিমাপের পরিপ্রেক্ষিতে:

যদি epsilonকিছু নির্দিষ্ট শারীরিক অর্থে পরিমাণ মাত্রার ছোট ভগ্নাংশ (অর্থাত আপেক্ষিক মান) এবং Aএবং Bধরনের একই অর্থে তুলনা করা যায় চেয়ে আমি মনে করি, নিম্নলিখিত বেশ ঠিক কিনা:

#include <limits>
#include <iomanip>
#include <iostream>

#include <cmath>
#include <cstdlib>
#include <cassert>

template< typename A, typename B >
inline
bool close_enough(A const & a, B const & b,
                  typename std::common_type< A, B >::type const & epsilon)
{
    using std::isless;
    assert(isless(0, epsilon)); // epsilon is a part of the whole quantity
    assert(isless(epsilon, 1));
    using std::abs;
    auto const delta = abs(a - b);
    auto const x = abs(a);
    auto const y = abs(b);
    // comparable generally and |a - b| < eps * (|a| + |b|) / 2
    return isless(epsilon * y, x) && isless(epsilon * x, y) && isless((delta + delta) / (x + y), epsilon);
}

int main()
{
    std::cout << std::boolalpha << close_enough(0.9, 1.0, 0.1) << std::endl;
    std::cout << std::boolalpha << close_enough(1.0, 1.1, 0.1) << std::endl;
    std::cout << std::boolalpha << close_enough(1.1,    1.2,    0.01) << std::endl;
    std::cout << std::boolalpha << close_enough(1.0001, 1.0002, 0.01) << std::endl;
    std::cout << std::boolalpha << close_enough(1.0, 0.01, 0.1) << std::endl;
    return EXIT_SUCCESS;
}

আসলে সংখ্যাসূচক সফ্টওয়্যারগুলিতে আপনি যেখানে দুটি ভাসমান বিন্দু সংখ্যা ঠিক সমান কিনা তা যাচাই করতে চান । আমি একটি অনুরূপ প্রশ্ন পোস্ট

https://.com/a/10973098/1447411

সুতরাং আপনি বলতে পারেন না যে "CompareDoubles1" সাধারণভাবে ভুল।


প্রস্থ উপর নির্ভর করে ভাসমান বিন্দু সংখ্যা তুলনা। যেহেতু অপারেশনগুলির ক্রম পরিবর্তন করার ফলে বিভিন্ন ফলাফল উত্পন্ন হতে পারে, তা জানতে হবে যে সংখ্যাগুলি কত "সমান" আপনি চান।

ভাসমান বিন্দু তুলনা করার সময় ব্রুস ডসন দ্বারা ভাসমান বিন্দু সংখ্যা তুলনা একটি ভাল জায়গা।

নিম্নলিখিত সংজ্ঞাগুলি নুথের কম্পিউটার প্রোগ্রামিং শিল্প থেকে এসেছে:

bool approximatelyEqual(float a, float b, float epsilon)
{
    return fabs(a - b) <= ( (fabs(a) < fabs(b) ? fabs(b) : fabs(a)) * epsilon);
}

bool essentiallyEqual(float a, float b, float epsilon)
{
    return fabs(a - b) <= ( (fabs(a) > fabs(b) ? fabs(b) : fabs(a)) * epsilon);
}

bool definitelyGreaterThan(float a, float b, float epsilon)
{
    return (a - b) > ( (fabs(a) < fabs(b) ? fabs(b) : fabs(a)) * epsilon);
}

bool definitelyLessThan(float a, float b, float epsilon)
{
    return (b - a) > ( (fabs(a) < fabs(b) ? fabs(b) : fabs(a)) * epsilon);
}

অবশ্যই, epsilon নির্বাচন প্রসঙ্গে নির্ভর করে, এবং সংখ্যার কতগুলি সমান হতে চান তা নির্ধারণ করে।

ভলিউটিং পয়েন্ট সংখ্যা তুলনা করার আরেকটি পদ্ধতি হল নম্বরগুলির ইউএলপি (শেষ স্থানে ইউনিট) দেখতে। যদিও তুলনামূলকভাবে বিশেষভাবে আচরণ না করে , কাগজটি কীভাবে ভলিউটিং পয়েন্ট সংখ্যাগুলি সম্পর্কে জানার উচিত তা হল কীভাবে ভলিউটিং বিন্দু কাজ করে এবং কী সমস্যাগুলি বোঝার জন্য একটি ভাল সম্পদ, যা ULP এর অন্তর্ভুক্ত।





floating-point