Використання функцій min та max у C ++

Від C ++, є minі maxкраще fminі fmax? Для порівняння двох цілих чисел вони забезпечують в основному однакову функціональність?

Чи схильні ви використовувати один із цих наборів функцій, чи віддаєте перевагу писати власні (можливо, для підвищення ефективності, портативності, гнучкості тощо)?

Примітки:

1. Стандартна бібліотека шаблонів C ++ (STL) оголошує minі maxфункції в стандартному заголовку алгоритму C ++ .

2. Стандарт C (C99) забезпечує функцію fminта fmaxфункцію у стандартному заголовку m math.h.

Спасибі заздалегідь!

fminі fmaxспеціально призначені для використання з числами з плаваючою комою (звідси "f"). Якщо ви використовуєте його для ints, ви можете зазнати втрат продуктивності або точності внаслідок перетворення, накладних витрат функцій тощо, залежно від вашого компілятора / платформи.

std::minі std::maxє функціями шаблону (визначеними в заголовку <algorithm>), які працюють на будь-якому типі з <оператором менше ніж ( ), тому вони можуть працювати з будь-яким типом даних, що дозволяє таке порівняння. Ви також можете надати власну функцію порівняння, якщо не хочете, щоб вона спрацювала <.

Це безпечніше, оскільки вам доведеться явно перетворити аргументи на відповідність, коли вони мають різні типи. Наприклад, компілятор не дозволяє випадково перетворити 64-розрядний int у 64-розрядний плаваючий. Вже лише ця причина повинна зробити шаблони вашим вибором за замовчуванням. (Кредит Matthieu M & bk1e)

Навіть при використанні з поплавцями шаблон може виграти у продуктивності. Компілятор завжди має можливість вбудовувати виклики до функцій шаблону, оскільки вихідний код є частиною модуля компіляції. Іноді неможливо вбудувати виклик функції бібліотеки, з іншого боку (спільні бібліотеки, відсутність оптимізації часу на зв’язок тощо).

Існує важлива різниця між std::min, std::maxі fminта fmax.

std::min(-0.0,0.0) = -0.0
std::max(-0.0,0.0) = -0.0

тоді як

fmin(-0.0, 0.0) = -0.0
fmax(-0.0, 0.0) =  0.0

Тож std::minне є заміною 1-1 fmin. Функції std::minі std::maxне є комутативними. Для того, щоб отримати той же результат з двійниками з fminі fmaxодин повинен поміняти місцями аргументи

fmin(-0.0, 0.0) = std::min(-0.0,  0.0)
fmax(-0.0, 0.0) = std::max( 0.0, -0.0)

Але, наскільки я можу зрозуміти, усі ці функції в даному випадку визначені в будь-якому випадку, щоб бути на 100% впевненим, що ви повинні перевірити, як вони реалізовані.

Є ще одна важлива різниця. Для x ! = NaN:

std::max(Nan,x) = NaN
std::max(x,NaN) = x
std::min(Nan,x) = NaN
std::min(x,NaN) = x

тоді як

fmax(Nan,x) = x
fmax(x,NaN) = x
fmin(Nan,x) = x
fmin(x,NaN) = x

fmax можна емулювати за допомогою наступного коду

double myfmax(double x, double y)
{
   // z > nan for z != nan is required by C the standard
   int xnan = isnan(x), ynan = isnan(y);
   if(xnan || ynan) {
        if(xnan && !ynan) return y;
        if(!xnan && ynan) return x;
        return x;
   }
   // +0 > -0 is preferred by C the standard 
   if(x==0 && y==0) {
       int xs = signbit(x), ys = signbit(y);
       if(xs && !ys) return y;
       if(!xs && ys) return x;
       return x;
   }
   return std::max(x,y);
}

Це показує, що std::maxце підмножина fmax.

Перегляд збірки показує, що Clang використовує вбудований код, fmaxа fminтоді як GCC викликає їх із математичної бібліотеки. Збірка для клакання для fmaxз -O3є

movapd  xmm2, xmm0
cmpunordsd      xmm2, xmm2
movapd  xmm3, xmm2
andpd   xmm3, xmm1
maxsd   xmm1, xmm0
andnpd  xmm2, xmm1
orpd    xmm2, xmm3
movapd  xmm0, xmm2

тоді як для std::max(double, double)цього просто

maxsd   xmm0, xmm1

Однак для GCC та Clang використання -Ofast fmaxстає просто

maxsd   xmm0, xmm1

Отже, це ще раз показує, що std::maxце підмножина, fmaxі що коли ви використовуєте більш вільну модель із плаваючою комою, яка тоді не має nanабо не підписана нулем, fmaxі std::maxвони однакові. Очевидно, той самий аргумент стосується fminі std::min.

Ви пропустили всю точку fmin та fmax. Він був включений у C99, щоб сучасні центральні процесори могли використовувати свої власні (читати SSE) інструкції для плаваючої точки min і max та уникати тестування та розгалуження (і, отже, можливого неправильного прогнозування гілки). Я переписав код, який використовував std :: min та std :: max для використання внутрішніх властивостей SSE для min та max у внутрішніх циклах, і прискорення було значним.

std :: min та std :: max - це шаблони. Отже, вони можуть використовуватися на різних типах, що забезпечують оператора меншого, ніж плаваючий, парний, довгий парний. Отже, якщо ви хочете написати загальний код C ++, ви зробите щось подібне:

template<typename T>
T const& max3(T const& a, T const& b, T const& c)
{
   using std::max;
   return max(max(a,b),c); // non-qualified max allows ADL
}

Що стосується продуктивності, то я не думаю fminі не fmaxвідрізняюся від аналогів на C ++.

Якщо ваша реалізація передбачає цілий 64-розрядний тип, ви можете отримати іншу (неправильну) відповідь, використовуючи fmin або fmax. Ваші 64-розрядні цілі числа будуть перетворені в подвійні, які (принаймні зазвичай) матимуть значення, яке менше 64-бітового. Коли ви перетворюєте таке число у подвійне, деякі найменш значущі біти можуть / будуть повністю втрачені.

Це означає, що два числа, які насправді були різними, можуть перетворитися на рівні при перетворенні на подвійні - і результатом буде те неправильне число, яке не обов'язково дорівнює жодному з вихідних входів.

Я б віддав перевагу функціям C ++ min / max, якщо ви використовуєте C ++, оскільки вони є типовими. fmin / fmax змусить все конвертувати в / з плаваючою комою.

Крім того, функції C ++ min / max працюватимуть із визначеними користувачем типами, якщо ви визначили оператор <для цих типів.

HTH

Як ви самі зазначили, fminі fmaxбули введені в C99. Стандартна бібліотека C ++ не має fminі fmaxфункцій. Поки стандартна бібліотека C99 не вбудовується в C ++ (якщо взагалі коли-небудь), області застосування цих функцій чітко розділяються. Немає ситуації, коли вам, можливо, доведеться «віддавати перевагу» одному над іншим.

Ви просто використовуєте templated std::min/ std::maxв C ++ і використовуєте те, що доступно в C.

Як зазначив Річард Корден, використовуйте функції C ++ min і max, визначені в просторі імен std. Вони забезпечують безпеку типу та допомагають уникнути порівняння змішаних типів (тобто з плаваючою комою проти цілого числа), що іноді може бути небажаним.

Якщо ви виявите, що використовувана вами бібліотека C ++ також визначає min / max як макроси, це може спричинити конфлікти, тоді ви можете запобігти небажаній підміні макросів, викликаючи функції min / max таким чином (зверніть увагу на додаткові дужки):

(std::min)(x, y)
(std::max)(x, y)

Пам’ятайте, що це ефективно вимкне залежний пошук аргументів (ADL, також званий пошуком Koenig), якщо ви хочете покластися на ADL.

fmin і fmax призначені лише для змінних із подвійною комою та подвійними.

min та max - це функції шаблону, які дозволяють порівнювати будь-які типи з урахуванням двійкового предиката. Вони також можуть використовуватися з іншими алгоритмами для забезпечення складної функціональності.

Використовуйте std::minта std::max.

Якщо інші версії швидші, тоді ваша реалізація може додати для них перевантаження, і ви отримаєте переваги продуктивності та портативності:

template <typename T>
T min (T, T) {
  // ... default
}

inline float min (float f1, float f2) {
 return fmin( f1, f2);
}    

До речі, cstdlibтам є __minі __maxможна використовувати.

Докладніше: http://msdn.microsoft.com/zh-cn/library/btkhtd8d.aspx

Чи не може реалізація C ++, орієнтована на процесори з інструкціями SSE, передбачити спеціалізації std :: min та std :: max для типів float , double та long double, які виконують еквівалент fminf , fmin та fminl відповідно?

Спеціалізації забезпечували б кращу продуктивність для типів з плаваючою крапкою, тоді як загальний шаблон обробляв би типи з плаваючою точкою, не намагаючись примусити типи з плаваючою точкою до типів з плаваючою комою, як це зробили б fmin s та fmax .

Я завжди використовую макроси min та max для ints. Я не впевнений, чому хтось би використовував fmin або fmax для цілочисельних значень.

Найважливіша проблема з min і max полягає в тому, що вони не функціонують, навіть якщо вони схожі на них. Якщо ви робите щось на зразок:

min (10, BigExpensiveFunctionCall())

Цей виклик функції може бути викликаний двічі залежно від реалізації макросу. Таким чином, найкраща практика в моїй організації ніколи не викликати min або max з речами, які не є буквальними чи змінними.

fminі fmax, fminlі fmaxlможе бути кращим при порівнянні цілих чисел із підписом і без підпису - ви можете скористатися тим, що весь діапазон підписаних і без підпису чисел, і вам не доведеться турбуватися про цілі діапазони чи промоакції.

unsigned int x = 4000000000;
int y = -1;

int z = min(x, y);
z = (int)fmin(x, y);