Arduino.ru

Коллеги, сегодня мне захотелось поговорить о типе float и его использовании.

Как многие, наверное, знают, аппаратно восьмиразрядные AVR контроллеры плавающую арифметику не поддерживают, а потому, всё, что с нею связано, реализовано программно. Ну, а раз программно, то работает это не так быстро как хотелось бы, да ещё и отжирает приличную память в области программ на библиотеку с программной реализацией всех функций (как только используете float – порядка двух кило памяти «вынь, да положь»).

Поэтому, первый совет по использованию типа float – избегать такового использования без крайней нужды. Ну, вот, как пример, вот нафига библиотека DallasTemperature возвращает результат измерений именно как float (причём больше там float ни для чего не используется)? Руки бы поотрывал таким «писателям». Неужели датчику с паспортной погрешностью в 0,5 градуса нужна точность до семи знаков? Да, ну нафиг – вполне хватило бы возвращать целое число в десятых долях градуса. Так нет же … и два кило программной памяти псу под хвост!

Но иногда без float действительно не обойтись, так что давайте посмотрим, какие грабли там вокруг него разбросаны. Все приводимые примеры, исполнялись на Nano, а компилировались IDE 1.8.1 с опциями «из коробки».

1. Общие сведения о числах с плавающей запятой

В языке С++ определены три типа для работы с такими числами (стандарт ISO/IEC 14882:2014, п. 3.9.1.8):

float — тип с плавающей точкой одинарной точности;
double — тип с плавающей точкой двойной точности;
long double — тип с плавающей точкой повышенной точности.

В нашем случае, все три типа идентичны – все представляют собой 32-битное число одинарной тонности и разницы между ними нет никакой.

Первое важное замечание: в памяти плавающие числа представлены как отдельно мантисса, отдельно порядок и отдельно знак.

Прямым следствием из первого важного замечания является тот факт, что в плавающей арифметике существуют два нуля – положительный и отрицательный. В принципе, ничего страшного, операция == выдаёт для них равенство, но иногда это важно при некоторых видах умножения (см. ниже).

Точность представления чисел приблизительно семь знаков мантиссы, а наибольшее и наименьшее возможные значения приблизительно ±3,4х10^±38.

Из последнего абзаца прямо следует второе важное замечание: числа с плавающей запятой точно представлены быть не могут – почти всегда они представляются с некоторой погрешностью. Например, невозможно точно записать число 0,1 (или 0,2). То, что хранится в памяти, обязательно будет отличаться от точного значения в каком-нибудь далёком разряде.

Также существуют три специальных значения: NaN – «не число» и две бесконечности, положительная и отрицательная. Деление на 0 даёт бесконечность со знаком делимого. Деление на бесконечность даёт ноль с соответствующим знаком.

Вот, собственно всё, что нам важно знать для дальнейшего. Те, кого интересуют подробности, могут почитать стандарт представления плавающих чисел IEEE 754-2008 и/или многочисленные статьи и эссе на эту тему, коими забит Интернет.

Мы же перейдём непосредственно к граблям и вкусняшкам.

2. Неточность представления значений

Давайте запустим вот такую программу:

и полюбуемся на её результат:

Ну, что, вроде бы a и b честно равны 0,2 (строки 2 и 3 результата), но при этом почему-то a не равно b (строки 4 и 5 результата)!

Как такое может быть? Правильно - числа представленные в памяти на самом деле не равны друг друг другу, а строки 2 и 3 вводят нас в заблуждение исключительно из-за округления.

Давайте напечатаем наши a и b с большим количеством знаков после запятой.

Вот теперь всё стало на свои места. a > b, что мы и наблюдаем.

Таким образом, мы выяснили, что выражения «1.2 - 1.0» и «0.2» в плавающей арифметике вовсе не равны друг другу. И это не косяк конкретного компилятора и даже не следствие китайского происхождения Вашей ардуины – это факт, прямо следующий из особенностей реализации плавающей арифметики. Бороться с этим невозможно, остаётся только приспособиться. Вот давайте и начнём приспосабливаться.

Первый шаг в нашем приспособленчестве – это научиться таки сравнивать плавающие числа, чтобы «1.2 - 1.0» и «0.2» всё же получались равными друг другу, а не выносили нам мозг своей экзистенциальной сущностью.

3. Сравнение плавающих чисел

Зайти на форум по теоретическому программированию и сказать, что Вы придумали универсальный алгоритм сравнения плавающих чисел – это высшая форма троллинга! Всё равно, как на форуме зоозащитников заявить о необходимости санитарного отстрела бродячих животных. Многостраничный, плавно переходящий в срач, холивар, сопровождаемый невосполнимыми потерями форумного населения от банов и прочих ограничений области видимости – это меньшее на что Вы можете рассчитывать.

Но это касается «универсального», применимого везде и всегда метода, т.е. «сферического коня в вакууме». Мы же с Вами всегда решаем конкретную задачу, и исходя их это задачи, примерно представляем какая точность для нас приемлема и желательна, и потому всегда можем определить некую величину eps, о которой можем сказать, что если два числа различаются на величину меньшую, чем eps, то мы будем считать их равными. Тогда сравнения будут выглядеть так: 

Функция fabs, использованная в строке 4, возвращает свой аргумент, взятый «по модулю» и нужна здесь для того, чтобы результат сравнение не зависел то того, что больше (на величину меньшую, чем eps) a или b.

Ещё раз - eps Вы выбираете сами, исходя из сущности задачи. Например, если a и b - температуры. полученные с далласовского датчика, погрешность которого, как известно ±0,5 градуса, то eps можно взять 1 или, скажем, 0.75.

На самом деле, такой подход к сравнению, с точки зрения теоретиков, не выдерживает никакой критики, и может быть разнесён в хвост и в гриву. Однако, очень многие программисты его используют поскольку, если есть понимание задачи и величина eps выбирается разумно, то он вполне прилично работает, хотя, с точки зрения теоретиков, и не должен бы.

Нужно только помнить, что если то, что Вы считаете - не окончательный результат, а только данные для дальнейших рассчётов, то лучше считать точнее, т.к. погрешности накапливаются. Подробнее об этом я планирую написать в «Приложении для любопытного читателя» чуть позже в этом топике.

4. Как не накапливать погрешность

Как мы уже видели на примере вычитания единицы из 1,2, любая операция с плавающей точкой выполняется с некоторой погрешностью. Она небольшая, но проблема в том, что если операции выполнять много раз, то она имеет очень неприятную привычку накапливаться. А ведь многие программы для микроконтроллеров предназначены для работы в безостановочном режиме сутками, неделями и месяцами – за такое время можно такую погрешность накопить, что будь здоров.

Для примера, предположим, что нам нужно что-то делать с величинами 0.000002, 0.000004, 0.000006, 0.000008 и т.д. до 2.0 – т.е. в общей сложности с миллионом значений. Как получать эти значения? Можно завести переменную, равную 0, к ней прибавить 0.000002, сделать с результатом что нужно, прибавить ещё 0.000002, опять сделать с результатом что нужно и так миллион раз. Запишем это:

Что мы здесь имеем. Переменна fi получается последовательным прибавлением шага 0.000002 к старому значению. Значит, чем больше раз мы это сделаем, тем большую погрешность накопим. Окончательное (самое последнее) значение fi будет получено путём миллиона операций сложения!

Давайте попробуем другой подход. Теперь мы не будем прибавлять шаг миллион раз, а вместо этого, на каждом шаге будем брать величину, полученную умножением 0.000002 на номер текущего шага. Запишем это:

Здесь на любом шаге, наше значение fi всегда получается в результате одной операции умножения. Потому, никакая погрешность накапливаться не будет и погрешность значения fi на любом шаге буде равна погрешности одной операции умножения – независимо от количества шагов!

Давайте сравним погрешности в конечном значении переменной fi для первого и второго подходов.

Как видите, при первом подходе (где fi получалась накапливающим сложением) погрешность за миллион шагов составила почти 2%!!! А при втором подходе, погрешность оказалось пренебрежимо малой, такой, что при нашей печати и вовсе обратилась в 0.

Вывод: по возможности, старайтесь никогда не вычислять значение величины итеративным путём, т.к. при этом Вы накапливаете погрешность. Везде, где возможно, старайтесь свести количество операций для получения значения к минимуму.

Возможно, кому-то проблема накопления погрешности покажется искусственной и надуманной. Напрасно! Именно с этой ошибкой связаны наиболее эпичные техногенные катастрофы, вызванные ошибками в программном обеспечении. Например, именно накопление погрешности в системе управления американским ракетным комплексом Patriot стало причиной того, что древняя как Фортран советская ракета 8К14, выпущенная иракскими военными, сумела долететь до американской военной базы, охраняемой Patriot'ами и угробить почти 30 военнослужащих, прихватив ещё под сотню ранеными.

5. Знаковые нули, бесконечности и не числа

Как уже говорилось, ноль здесь может быть положительным и отрицательным. Само по себе это не страшно, но знак может повлиять на дальнейшие вычисления. Также, есть три специальных значения: положительная бесконечность, отрицательная бесконечность и «не число» - NaN.

Бесконечности получаются либо когда результат операции выходит за границы возможно, либо при делении на 0. С ними можно продолжать операции, например, число, разделённое на бесконечность, даст 0, сложение бесконечности с числом даст ту же бесконечность. Операции с двумя бесконечностями (например, деление их друг на друга) недопустимы, результат – NaN.

Вообще значение NaN получается в результате любой ошибки вычислений. С самим NaN также можно проделывать операции (сложение, умножение и т.п.), результат - всегда NaN. Забавным свойством значения NaN является то, что оно одновременно не больше и не меньше любого числа, а также NaN не равно ничему, включая самого себя.

Обычно появление в расчётах значений типа NaN и бесконечностей, является следствием ошибок. Для контроля таких ситуаций. Стандарт предоставляет специальные функции, позволяющий проверить является ли число бесконечность или NaN. Функции эти: isnan(f) и  isfinite(f). Первая возвращает истину, если аргумент является NaN, а вторая возвращает истину, если аргумент не является ни бесконечностью, ни NaN. Для использования этих функций требуется включить #include <math.h>

Если у Вас возникла проблема и Вам нужно искать ошибку, то для печати значений типа float в монитор порта лучше не использовать напрямую Serial.print, а делать это через dtostrf (как в моём примере ниже), т.к. Serial.print плохо печатает как раз такие специальные значения, например, он никогда не печатает знак перед нулём, даже, если ноль отрицательный.

Теперь посмотрите пример работы с этим хитрыми значениями. Пример достаточно самодокументирован, потому пояснять его отдельно я не буду.