NaN это не «не число»
При разработке программного обеспечения очень важно быть точным в использовании терминов: корректное использование необходимо для эффективной коммуникации между разработчиками. Очень важно быть на одной волне.
Один из терминов, который очень часто используют неправильно,— это NaN.
Его корни лежат в стандарте IEEE754, он определяет NaN как специальное значение (на самом деле,
как мы увидим далее, множество значений), которое используется если результат вычисления не может
или не должен быть представлен как конкретное число, или попросту неизвестен. Например: asin(2) или 0/0.
Это приводит нас к следующему открытию: NaN — на самом деле значение числового типа! Просто это
специальное число, которое представлено по-особенному.
Итак, NaN, согласно стандарту IEEE754, не какое-то значение не числового типа,
но в действительности — число. А это значит, что не совсем корректно говорить, что строка "foo" является
Подводя итог: если вы используете термин NaN как синоним, обозначающий «что угодно, что не является числом»
(строка, значение null, объект, и т.д.), пожалуйста, прекратите. А если вы уже знаете что к чему, то
расскажите об этом остальным, что бы они могли выражать свои мысли так же точно, как это делаете вы.
Материалы для дальнейшего изучения:
Что такое NaN (не число) в словах новичка?
Вы задали здесь ряд замечательных вопросов. Вот моя попытка обратиться к каждому из них.
Что такое значение NaN или NaN точно (по словам профессора, не являющегося математиком)?
Предположим, что вы работаете с вещественными числами, такими как 1, π, e, -137, 6.626 и т. д. В стране действительных чисел есть некоторые операции, которые обычно можно выполнить, но иногда не имеют определенного результата. Например, давайте рассмотрим логарифмы. Вы можете взять логарифм множества действительных чисел: ln e = 1, например, а ln 10-это около 2.3. Однако математически логарифм отрицательного числа не определен. То есть мы не можем взять ln (-4) и получить обратно реальное число.
Так что теперь, давайте перейдем к программированию землю. Представьте себе, что вы пишете программу, которая вычисляет логарифм числа, и каким-то образом пользователь хочет, чтобы вы разделили на логарифм отрицательного числа. Что должно произойти?
На этот вопрос есть много разумных ответов. Вы можете заставить операцию выдать исключение, что делается в некоторых языках, таких как Python.
Однако на уровне аппаратного обеспечения было принято решение (людьми, разработавшими стандарт IEEE-754) предоставить программисту второй вариант. Вместо того чтобы вызвать сбой программы, вы можете вместо этого заставить операцию выдать значение, которое означает: «вы хотели, чтобы я сделал что-то невозможное, поэтому я сообщаю об ошибке.» Это достигается тем, что операция производит специальное значение
В этом подходе есть свои преимущества. Во многих научных вычислительных системах код выполняет серию длинных вычислений, периодически генерируя промежуточные результаты, которые могут представлять интерес. Имея операции, которые не определены, производят NaN в результате, программист может написать код, который просто делает математику, как они хотят, чтобы это было сделано, а затем ввести определенные места в коде, где они будут проверять, была ли операция успешной или нет. Оттуда они могут решить, что делать. Сравните это с отключением исключения или прямым сбоем программы — это будет означать, что программисту либо нужно охранять каждую серию операций с плавающей запятой, которые могут потерпеть неудачу, либо ему придется вручную проверять вещи самостоятельно. Это вызов суждения о том, какой вариант лучше, и именно поэтому вы можете включить или отключить поведение NaN с плавающей запятой.
Каковы операции, вызывающие в результате значение NaN?
Есть много способов получить результат NaN от операции. Вот образец, хотя это не исчерпывающий список:
- Берем логарифм отрицательного числа.
- Берется квадратный корень из отрицательного числа.
- Вычитание бесконечности из бесконечности.
- Выполнение любой арифметической операции на
NaN.
Есть, однако, некоторые операции, которые не производят NaN , даже если они математически неопределенны. Например, деление положительного числа на ноль дает в результате положительную бесконечность, хотя это и не определено математически. Причина этого заключается в том, что если вы берете предел x / y для положительного x, когда y приближается к нулю с положительного направления, значение растет без ограничений.
Почему результат 0.0 / 0.0 объявлен как неопределенный? Разве это не должно быть 0?
Это скорее математический вопрос, чем что-либо еще. Это связано с тем, как работают ограничения. Давайте подумаем, как определить 0 / 0. Одним из вариантов было бы сказать следующее: если мы посмотрим на выражение 0 / x и возьмем предел, когда x приближается к нулю, то мы увидим 0 в каждой точке, поэтому предел должен быть равен нулю. С другой стороны, если мы посмотрим на выражение x / x и возьмем предел, когда x приближается к 0, мы увидим 1 в каждой точке, поэтому предел должен быть один. Это проблематично, так как мы хотели бы, чтобы значение 0 / 0 соответствовало тому, что вы найдете при вычислении любого из этих выражений, но мы не можем выбрать фиксированное значение, которое имеет смысл. В результате значение 0 / 0 оценивается как NaN, что указывает на то , что здесь нет четкого значения для назначения.
Почему результат любой математической операции не может быть выражен с плавающей точкой или целым числом? Как может быть, что ценность не может быть представлена?
Это связано с внутренними числами IEEE-754 с плавающей запятой. Интуитивно это сводится к тому простому факту, что
- существует бесконечно много действительных чисел, бесконечно много из которых имеют бесконечно длинные неповторяющиеся десятичные дроби, но
- ваш компьютер имеет ограниченную память.
В результате хранение произвольного действительного числа может повлечь за собой хранение бесконечно длинной последовательности цифр, чего мы не можем сделать с нашими компьютерами с конечной памятью. Поэтому у нас есть числа с плавающей запятой , хранящие приближения действительных чисел, которые не являются ошеломляюще огромными, и неспособность представить значения является результатом того, что мы просто храним приближения.
Подробнее о том, как на самом деле хранятся числа и что это означает на практике, читайте в легендарном руководстве «What Every Programmer Should Know About Floating-Point Arithmetic»
Почему квадратный корень из отрицательного числа не является действительным числом?
Возьмем, к примеру, √(-1),. Представьте себе, что это действительное число x; то есть представьте, что x = √(-1). идея квадратного корня состоит в том, что это число, которое, если умножить его на себя, возвращает вам число, из которого вы взяли квадратный корень.
Итак… какое число x? Мы знаем, что x ≠ 0, потому что 0 2 = 0-это не -1. Мы также знаем, что x не может быть положительным, потому что любое положительное число, умноженное само на себя, является положительным числом. И мы также знаем, что x не может быть отрицательным, потому что любое отрицательное число, умноженное само на себя, является положительным.
Теперь у нас есть проблема. Чем бы ни был этот х, он должен быть не положительным, не нулевым и не отрицательным. Это значит, что это ненастоящее число.
Вы можете обобщить действительные числа на комплексные числа, введя число i, где i 2 = -1. обратите внимание, что никакие действительные числа не делают этого по причине, приведенной выше.
Почему NaN не эквивалентно неопределенному?
Существует разница между «indefinite» и «whatever it is, it’s not a real number.», например, 0 / 0 можно назвать неопределенным, потому что в зависимости от того, как вы приближаетесь к 0 / 0, вы можете получить обратно 0, или 1, или, возможно, что-то еще. С другой стороны, √(-1) совершенно точно определяется как комплексное число (предполагая, что у нас есть √(-1), возвращающее i, а не-i), поэтому проблема заключается не столько в «this is indeterminate», сколько в том, что «у него есть значение, но это значение не является реальным числом.»
Надеюсь, это поможет!
Почему NaN это не «Not a Number»? — CSS-LIVE
Перевод статьи NaN is not a not a number с сайта https://zerkmsit.wordpress.com/, опубликовано на css-live.ru с разрешения автора — Ivan Kurnosov, переводчик — Друганов Яков (k0d)
При разработке ПО очень важно быть точным при использовании терминов, ведь если все разработчики понимают термины одинаково, то эффективность коммуникации между ними будет высокой. Это как быть с человеком «на одной волне» и «понимать с полуслова».
Один из таких терминов, который часто используется не к месту и без понимания — NaN (Not a Number). Дословно — «нечисло».
Все уходит корнями в «бородатый» стандарт IEEE754-1985 и его преемника IEEE754-2008, там NaN определяется как «особое значение» (множество значений, как мы покажем далее), представляющее собой результат некоторого вычисления, которое не может или не должно быть представлено как конкретное число или такое значение просто неопределено в математическом смысле. Например, arcsin(2) или 0/0. Это также приводит нас к другому открытию: NaN на самом деле числовой тип! Просто это число, которое используется и представляется в некой особоой форме.
Итак, еще раз, по стандарту, NaN это НЕ произвольное значение НЕчислового типа, а число! Это значит, нельзя сказать, что строка "строка" это NaN, так как NaN это на самом деле число.
Все становится еще интереснее, если проверить, а как же представлено NaN в памяти компьютера.
У чисел с плавающей точкой двойной (64 бита) точности (как тип Number в JS) для представления NaN‘ов используется специальный ДИАПАЗОН значений.
А именно: числа (мн.ч.), показатель степени которых равен 0x7FF (hex) или 11111111111
NaN значений.Рассмотрим рис. 1.
Сейчас все биты равны 0, cледовательно все число равно 0 или 0.0 * 100, это тот самый 0, который нам всем привычен.
А теперь покажем, что такое NaN. Для этого, как мы уже упоминали, поставим все биты показателя степени в 1 (рис. 2)
Теперь запишем это число в шестнадцатеричной системе — 0x_7FF_0000000000000. Дамы и господа, перед вами «нечисло» с точки зрения IEEE754.
Более того, остальные 64 - 11 = 53 бита могуть быть любыми, за исключением полностью нулевой мантиссы, которая зарезервирована для представления +Бесконечность при первом знаковом бите равном 0 и -Бесконечность при знаковом бите равным 1 — число будет NaN в любом случае.
Скажем, на рис. 3 по-прежнему NaN
Запишем это число в шестнадцатеричной системе — 0x_7FF_B000000000000.
Путем нехитрых комбинаторных расчетов получим, что у чисел с плавающей точкой двойной точности мы имеем (по IEEE754) 253 - 2 чисел, которые будут NaN по стандарту IEEE754. Многовато, не правда ли?
Таким образом, если вы используете NaN как замену для всего, что «нечисло» (строки, значение типа null, объекты и т.д.) — не делайте так. Если нет — поделитесь знанием и помогите остальным быть такими же точными как числа двойной точности как вы.
Материалы для дальнейшего изучения:
http://www.binaryconvert.com/convert_double.html — конвертер чисел двойной точности в десятичные и обратно
https://ru.wikipedia.org/wiki/IEEE_754-2008 — статья в Википедии
P.S. Это тоже может быть интересно:
В чем разница между NaN и None? Ru Python
NaN используется в качестве заполнителя для отсутствия данных последовательно в пандах , консистенция хороша. Обычно я читаю / перевод NaN как «отсутствующий» . Также см. Раздел «Работа с отсутствующими данными» в документах.
Уэс пишет в выборе документов NA-представления :
После многих лет использования использование [NaN] доказало, по крайней мере, на мой взгляд, лучшее решение, учитывая состояние дел в NumPy и Python в целом. Специальное значение NaN (Not-A-Number) используется везде как значение NA, и существуют функции API
isnullиnotnullкоторые могут использоваться в dtypes для обнаружения значений NA.
…
Таким образом, я выбрал подход Pythonic «практичность превосходит чистоту» и торговал целочисленными возможностями NA для гораздо более простого подхода к использованию специального значения в массивах float и object для обозначения NA и поощрения целочисленных массивов к плаванию, когда должны вводиться NA.
Примечание: «gotcha», что целая серия, содержащая отсутствующие данные, взлетает до плавающих .
На мой взгляд, основной причиной использования NaN (по сравнению с None) является то, что он может быть сохранен с помощью numty’s float64 dtype, а не менее эффективный dtype объекта, см. Промотирования типа NA .
# without forcing dtype it changes None to NaN! s_bad = pd.Series([1, None], dtype=object) s_good = pd.Series([1, np.nan]) In [13]: s_bad.dtype Out[13]: dtype('O') In [14]: s_good.dtype Out[14]: dtype('float64') Джефф комментирует (см. Ниже):
np.nanдопускает векторизованные операции; его значение float, аNone, по определению, заставляет тип объекта, который в основном отключает всю эффективность в numpy.Так повторите 3 раза быстро: объект == плохой, float == good
Говоря о том, что многие операции могут работать так же хорошо, как и «Нет против NaN» (но, возможно, они не поддерживаются, они иногда могут давать неожиданные результаты ):
In [15]: s_bad.sum() Out[15]: 1 In [16]: s_good.sum() Out[16]: 1.0 Чтобы ответить на второй вопрос:
Вы должны использовать pd.isnull и pd.notnull для проверки отсутствующих данных (NaN).
NaN может использоваться как численное значение для математических операций, а None не может (или, по крайней мере, не должно).
NaN – числовое значение, как определено в стандарте IEEE 754 с плавающей запятой . None них не является внутренним NoneType Python ( NoneType ) и будет более похож на «несуществующий» или «пустой», чем «числовое недостоверное» в этом контексте.
Основным «симптомом» этого является то, что если вы выполняете, скажем, среднее значение или сумму на массиве, содержащем NaN, даже в одном, вы получаете NaN в результате …
С другой стороны, вы не можете выполнять математические операции, используя None качестве операнда.
Таким образом, в зависимости от случая, вы можете использовать None как способ сообщить вашему алгоритму не рассматривать недопустимые или несуществующие значения при вычислениях. Это означало бы, что алгоритм должен проверять каждое значение, чтобы увидеть, является ли оно None .
У Numpy есть некоторые функции, чтобы избежать значений NaN, чтобы загрязнять ваши результаты, например nansum и nan_to_num .
Функция isnan() проверяет, есть ли что-то «Not A Number» и вернет ли переменная число, например isnan(2) вернет false
Условное значение myVar is not None независимо от того, определена ли переменная
В вашем массиве numpy используется isnan() поскольку он предназначен для массива чисел и инициализирует все элементы массива NaN эти элементы считаются «пустыми»,
NaN все еще может немного удивить / Хабр
Сначала, я подумал, что это очередной вопрос из тех, которые могут задаваться на собеседовании. Наверное, если как следует пораскинуть мозгами, то можно догадаться до того, каким будет результат. Откинувшись на спинку кресла, начал размышлять, включать логику, вспоминать что-нибудь, на что можно опереться в рассуждениях. Но тщетно! Вдруг стало совершенно очевидно, что найти ответ не удается. Но почему? В чем нужно разбираться, чтобы он был найден? В математике? В языке программирования?
Ответ должен быть NaN. Но почему я не уверен в этом? Всю дорогу была уверенность в том, что любые выражения, содержащие NaN, вернут NaN. Ну разве что только если поделить NaN на ноль — в этом случае будет вызвано исключение ZeroDivisionError. Сто процентов NaN!
Ввожу выражение в ячейку блокнота:
>>> 1**nan + 1**nan
2.0В самом деле? Постойте:
>>> arange(5)**nan
array([nan, 1., nan, nan, nan])То есть, по какой-то причине, единица в степени NaN — это единица, а вот ноль и все остальные числа в степени NaN — это NaN. Где логика? В чем дело?
Так, давайте еще раз:
>>> 0**nan, 1**nan
(nan, 1.0)Может быть я просто из-за отсутствия какой-то практической надобности в глубоких познаниях о NaN, просто о чем-то не подозревал? А может я знал, но забыл? А может еще хуже — я не знал и забыл?
Заходим на Википедию. Там данный вопрос тоже обозначен как проблема, но почему все именно так устроено, никак не объясняется. Зато узнал что:
>>> hypot(inf, nan)
infХотя, в то же время:
>>> sqrt(inf**2 + nan**2)
nanЧто, согласитесь, тоже немного странно.
Ладно, с Википедии отправляемся в C99 на 182 страницу и наконец-то получаем логическое объяснение, почему pow(x, 0) возвращает 1 для любых x, даже для x равного NaN:
>>> power(nan, 0)
1.0Если функция
возводится в степень
и при этом
стремится к 0, то в результате получится 1, вне зависимости от того, какое значение имеет
.
А если результат не зависит от числового значения функции , то 1 — является подходящим результатом, даже для NaN. Однако это по-прежнему не объясняет, почему 1 в степени NaN равна 1.
Отыскиваем еще один C99 и на 461 странице не видим никаких объяснений, просто требование того, что pow(+1, y) должно возвращать 1 для всех y, даже равных NaN. Все.
С другой стороны, объяснение, почему pow(NaN, 0)=1 является более предпочтительным, чем pow(NaN, 0)=NaN все-таки наталкивает на мысль о том, что NaN не стоит воспринимать буквально, как Not-a-Number. Допустим, в результате каких- то вычислений мы получили число, превышающее размер памяти, выделенный под данный тип чисел, например:
>>> a = pi*10e307
>>> a
infВ результате мы получили
inf, что именно это за число мы не знаем, но все же это какое-то число. Затем мы снова что-то вычислили и снова получили слишком большое число:
>>> b = e*10e307
>>> b
infРазность
aи
bвернет NaN:
>>> c = a - b
>>> c
nanЕдинственная причина, по которой мы можем считать
cне числом, заключается в том, что мы использовали недостаточно точные вычисления. Однако, в
cпод NaN все же скрывается какое-то значение. О том, что это за значение, мы не знаем. Но все же это число, а раз это число, то нет ничего удивительного в том, что
pow(1, NaN)=1.
Почему же тогда pow(0, NaN)=NaN? Дело в том, что если возвести 0 в любую степень, то мы действительно получим ноль. Кроме одного единственного случая — когда степень равна 0:
>>> 0**0
1Из-за чего в выражении
pow(0, NaN)появляется неопределенность с конкретным значением NaN. Конечно, вероятность того, что под NaN может скрываться 0 — исчезающе мала и можно было бы принять, что
pow(0, NaN)=0. Но все же лучше перестраховаться, мало ли к чему это может привести. Возможно, так и рассуждали, когда создавались стандарты.
Даже не знаю, что еще сказать… если вы заранее знали ответ, то скорее всего вам можно позавидовать, ведь сферы, где могут пригодиться такие познания, наверняка, переполнены интересными задачами. А может и наоборот. Напишите об этом в комментариях.
P.S. Поскольку NaN относится к числам с плавающей точкой, оно может быть ключом словаря:
>>> d = {0.1: 'a', nan: 'b'}
>>> d[nan]
'b'Имеет ли смысл использовать такое на практике? Думаю, что лучше не стоит.
Как работать с NaN в Pandas: количество, фильтрация, замена пропусков
В предыдущих разделах вы видели, как легко могут образовываться недостающие данные. В структурах они определяются как значения NaN (Not a Value). Такой тип довольно распространен в анализе данных.
Но pandas спроектирован так, чтобы лучше с ними работать. Дальше вы узнаете, как взаимодействовать с NaN, чтобы избегать возможных проблем. Например, в библиотеке pandas вычисление описательной статистики неявно исключает все значения NaN.
Присваивание значения NaN
Если нужно специально присвоить значение NaN элементу структуры данных, для этого используется np.NaN (или np.nan) из библиотеки NumPy.
>>> ser = pd.Series([0,1,2,np.NaN,9],
... index=['red','blue','yellow','white','green'])
>>> ser
red 0.0
blue 1.0
yellow 2.0
white NaN
green 9.0
dtype: float64
>>> ser['white'] = None
>>> ser
red 0.0
blue 1.0
yellow 2.0
white NaN
green 9.0
dtype: float64
Фильтрование значений NaN
Есть несколько способов, как можно избавиться от значений NaN во время анализа данных. Это можно делать вручную, удаляя каждый элемент, но такая операция сложная и опасная, к тому же не гарантирует, что вы действительно избавились от всех таких значений. Здесь на помощь приходит функция dropna().
>>> ser.dropna()
red 0.0
blue 1.0
yellow 2.0
green 9.0
dtype: float64
Функцию фильтрации можно выполнить и прямо с помощью notnull() при выборе элементов.
>>> ser[ser.notnull()]
red 0.0
blue 1.0
yellow 2.0
green 9.0
dtype: float64
В случае с Dataframe это чуть сложнее. Если использовать функцию pandas dropna() на таком типе объекта, который содержит всего одно значение NaN в колонке или строке, то оно будет удалено.
>>> frame3 = pd.DataFrame([[6,np.nan,6],[np.nan,np.nan,np.nan],[2,np.nan,5]],
... index = ['blue','green','red'],
... columns = ['ball','mug','pen'])
>>> frame3
| ball | mug | pen | |
|---|---|---|---|
| blue | 6.0 | NaN | 6.0 |
| green | NaN | NaN | NaN |
| red | 2.0 | NaN | 5.0 |
>>> frame3.dropna()
Empty DataFrame
Columns: [ball, mug, pen]
Index: []
Таким образом чтобы избежать удаления целых строк или колонок нужно использовать параметр how, присвоив ему значение all. Это сообщит функции, чтобы она удаляла только строки или колонки, где все элементы равны NaN.
>>> frame3.dropna(how='all')
| ball | mug | pen | |
|---|---|---|---|
| blue | 6.0 | NaN | 6.0 |
| red | 2.0 | NaN | 5.0 |
Заполнение NaN
Вместо того чтобы отфильтровывать значения NaN в структурах данных, рискуя удалить вместе с ними важные элементы, можно заменять их на другие числа. Для этих целей подойдет fillna(). Она принимает один аргумент — значение, которым нужно заменить NaN.
>>> frame3.fillna(0)
| ball | mug | pen | |
|---|---|---|---|
| blue | 6.0 | 0.0 | 6.0 |
| green | 0.0 | 0.0 | 0.0 |
| red | 2.0 | 0.0 | 5.0 |
Или же NaN можно заменить на разные значения в зависимости от колонки, указывая их и соответствующие значения.
>>> frame3.fillna({'ball':1,'mug':0,'pen':99})
| ball | mug | pen | |
|---|---|---|---|
| blue | 6.0 | 0.0 | 6.0 |
| green | 1.0 | 0.0 | 99.0 |
| red | 2.0 | 0.0 | 5.0 |
| Другие результаты | |
| Второй урок: родители действительно имеют значение. | |
| И вот что я узнала: Африка имеет огромное значение. | |
| Именно моё мнение имеет значение. | |
| Я отправился в суд, и судья сказал то, что судьи говорят постоянно, но в этот раз в этом было особое значение. | |
| Но несмотря на то, что федералисты, придя к власти, ввели законы, уголовно преследовавшие критику действий правительства, — это действительно произошло в США — тем не менее республиканцы сопротивлялись, и Мэдисон стал придавать большое значение свободе слова, которую он включил в Билль о правах, и потенциалу гражданского общества к организации. | |
| Это всё то, что я собирала для Nokia, что поступало ко мне мельчайшими крупицами, но несло в себе значение невероятной глубины. | |
| И это имеет значение, потому что если твоя работа — блокировать солнечный свет, ты будешь намного больше полезен в тропиках, под палящим тропическим солнцем, чем в высоких широтах. | |
| И это имеет значение, потому что если ваша работа состоит в том, чтобы блокировать поступающий солнечный свет, вы будете гораздо более эффективны в тропиках под этим интенсивным тропическим солнцем, чем в более высоких широтах. | |
| Эти процессы имеют огромное значение, особенно в этой дельте, где изменение русла Миссиссипи сформировало ландшафт суши и моря. | |
| Тогда я впервые осознала, какую огромная роль играет текстура волос в определении этнической принадлежности и то, насколько большое значение они имеют в том, как меня воспринимают другие. | |
| Я всегда считала себя сиделкой — многие врачи так думают — и забота о Поле углубила значение этого слова. | |
| Сложно понять само значение поведения, потому что, в зависимости от обстоятельств, спуск курка является либо ужасным поступком, либо героическим самопожертвованием. | |
| Твой тренер говорит, что возраст имеет значение всегда, а в теннисе тем более, но он не сомневается в том, что ты вернёшься. | |
| Гендер имеет значение. | |
| В результате этого процесса я узнала, что эти женщины, несмотря на крайнюю нищету, придают большое значение своему здоровью и благополучию. | |
| Таким образом и во многом другом она уменьшала значение своей компании в глазах клиентов и принижала собственную значимость. | |
| Но вот что действительно имеет значение, — и это очень просто, — это то, смотрите ли вы на мир через призму одной страны и её прошлого, или, как я, глобально и с упором на будущее. | |
| Есть ли способ заставить нас задуматься над тем, как защитить и быстро восстановить институты, имеющие первостепенное значение для жизни, такие как система здравоохранения? | |
| В нашем языке есть омонимы, слова, имеющие более, чем одно значение. | |
| С технической стороны, имеет значение то, как мы пишем код. | |
| Первая: ответ имеет значение. | |
| Из-за таких провокационных заявлений мы чувствуем себя некомфортно: разве мы ещё не прошли ту точку, где раса имеет значение? | |
| Мы также видим идею того, что чёрные люди либо вне границ времени, либо застряли в прошлом, в ситуации, когда, как я сейчас, чёрный человек встаёт и настаивает на том, что расизм всё ещё имеет значение, и человек, как правило белый, отвечает: Почему вы застряли в прошлом? | |
| Поэтому в следующий раз, когда вам будет не хватать времени, просто помните — это имеет значение только с вашей земной точки зрения. | |
| Значение 1, значение 2. | |
| Но это и не слишком вас ограничивало — можно по-прежнему вписать любое значение, любую формулу в любую ячейку. | |
| Мы вытерли слёзы с глаз, мы украсили гробы флагами, мы убежали с места преступления из клуба, мы надрывно орали на улице, мы падали на бетон, на очертания тел павших с криками: Наша жизнь имеет значение, — мы кричали во имя исчезнувших. | |
| У такой рискованной ситуации есть неожиданно положительный итог: с повышением надёжности любого звена цепи возрастает значение повышения качества других звеньев. | |
| Я не могла повлиять на отсутствие стабильности у них дома, на то, когда они будут есть в следующий раз, или на шумных соседей, которые не давали им спать, я могла сделать так, чтобы в классе была атмосфера, полная любви, чтобы они могли гордиться тем, кто они, чтобы они понимали, что жизнь каждого из них имеет значение. | |
| Когда врачи заметили, что ипрониазид улучшает настроение, они не осознали по-настоящему значение увиденного. | |
isNaN () — JavaScript | MDN
Функция isNaN () определяет, является ли значение NaN или нет. Поскольку принуждение внутри - это NaN функция может быть неожиданной, вы можете в качестве альтернативы
хотите использовать Number.isNaN () .
Параметры
-
значение Проверяемое значение.
Возвращаемое значение
true , если заданное значение NaN ; иначе, ложь .
Необходимость функции isNaN
В отличие от всех других возможных значений в JavaScript, невозможно использовать равенство
операторы (== и ===) для сравнения значения с NaN , чтобы определить,
значение равно NaN или нет, потому что и NaN == NaN , и NaN === NaN оценивается как false . Следовательно, необходимость isNaN функция.
Происхождение значений NaN
NaN значений генерируются, когда арифметические операции приводят к неопределенное или непредставимое значение .Такие значения не обязательно
представляют собой условия переполнения. NaN также является результатом попытки принуждения
к числовым значениям нечисловых значений, для которых нет примитивных числовых значений
имеется в наличии.
Например, деление нуля на ноль дает NaN , но деление других
цифр на ноль нет.
Непонятное поведение в особых случаях
Поскольку самые ранние версии - это функциональная спецификация NaN , его
поведение для нечисловых аргументов сбивает с толку.Когда аргумент isNaN функция не относится к типу Number, значение сначала приводится к
Номер. Полученное значение затем проверяется, чтобы определить, составляет ли оно NaN .
Таким образом, для нечисловых, которые при приведении к числовому типу приводят к действительному не-NaN числовому
значение (в частности, пустая строка и логические примитивы, которые при принуждении дают числовые
значения ноль или единица), возвращаемое значение «false» может быть неожиданным; пустая строка, для
пример, конечно, «не число.»Путаница проистекает из того факта, что термин» не
число «, имеет особое значение для чисел, представленных как числа с плавающей запятой IEEE-754.
значения. Функцию следует интерпретировать как ответ на вопрос: «Это значение,
при приведении к числовому значению, значение IEEE-754 «Not A Number»? »
ECMAScript 2015 содержит функцию Number.isNaN () . Number.isNaN (x) — надежный способ проверить, является ли x NaN или нет. Даже с номером .isNaN , однако значение NaN остается точным числовым значением, а не «не числом».
В качестве альтернативы, при отсутствии Number.isNaN выражение (x! = X) — более надежный способ проверить, является ли переменная x NaN или нет, так как результат не подвержен ложным срабатываниям, которые делают isNaN ненадежный.
Полифилл для isNaN будет (полифилл использует уникальные
никогда не равная себе характеристика NaN ):
const isNaN = функция (значение) {
const n = Число (значение);
вернуть n! == n;
};
isNaN (NaN);
isNaN (не определено);
isNaN ({});
isNaN (правда);
isNaN (ноль);
isNaN (37);
isNaN ('37 ');
isNaN ('37.37 ');
isNaN ("37,5");
isNaN ('123ABC');
isNaN ('');
isNaN ('');
isNaN (новая дата ());
isNaN (новая дата (). toString ());
isNaN ('блабла');
Полезное поведение в особых случаях
Есть более ориентированный на использование способ думать о isNaN () : Если isNaN (x) возвращает false , вы можете использовать x в
арифметическое выражение, не возвращающее выражение NaN .Если он вернется true , x вернет каждое арифметическое выражение NaN . Это означает, что в JavaScript isNaN (x) == true равно
эквивалент x - 0 , возвращающий NaN (хотя в JavaScript x - 0 == NaN всегда возвращает false, поэтому вы не можете проверить это). Фактически, isNaN (x) , isNaN (x - 0) , isNaN (Число (x)) , Number.isNaN (x - 0) и Number.isNaN (Number (x)) всегда возвращать
то же самое и в JavaScript isNaN (x) — это кратчайшая возможная форма для
выражать каждое из этих условий.
Вы можете использовать это, например, чтобы проверить, является ли аргумент функции арифметически обрабатываемый (можно использовать «как» число), или, если это не так, и вы должны укажите значение по умолчанию или что-то еще. Таким образом, у вас может быть функция, которая делает использование полной универсальности JavaScript за счет неявного преобразования значений в зависимости от контекста.
Таблицы BCD загружаются только в браузере
math — Что такое NaN (не число) в словах новичка?
Вы задали здесь несколько замечательных вопросов.Вот моя попытка обратиться к каждому из них.
Что такое NaN или NaN (по словам профессора, не занимающегося математикой)?
Предположим, вы работаете с действительными числами — числами, такими как 1, π, e, -137, 6,626 и т. Д. В стране реальных чисел есть некоторые операции, которые обычно можно выполнить с , но иногда нет. имеют определенный результат. Например, давайте посмотрим на логарифмы. Вы можете логарифмировать множество действительных чисел: например, ln e = 1, а ln 10 — это примерно 2.3. Однако математически логарифм отрицательного числа не определен. То есть мы не можем взять ln (-4) и вернуть действительное число.
А теперь перейдем к программированию. Представьте, что вы пишете программу, которая или вычисляет логарифм числа, и каким-то образом пользователь хочет, чтобы вы делили на логарифм отрицательного числа. Что должно произойти?
На этот вопрос есть много разумных ответов. Вы могли бы заставить операцию генерировать исключение, что делается в некоторых языках, таких как Python.
Однако на уровне оборудования решение, которое было принято (людьми, разработавшими стандарт IEEE-754), заключалось в том, чтобы предоставить программисту второй вариант. Вместо того, чтобы приводить к сбою программы, вы можете вместо этого заставить операцию выдать значение, которое означает «вы хотели, чтобы я сделал что-то невозможное, поэтому я сообщаю об ошибке». Это делается путем получения операцией специального значения NaN («Не число»), указывающего на то, что где-то в ваших вычислениях вы пытались выполнить операцию, которая математически не определена.
У этого подхода есть некоторые преимущества. Во многих условиях научных вычислений код выполняет серию длинных вычислений, периодически генерируя промежуточные результаты, которые могут представлять интерес. Если в результате операции, которые не определены, производят NaN , программист может написать код, который просто выполняет математические вычисления так, как они хотят, а затем вводить определенные места в коде, где они будут проверять успешность операции. или нет. Оттуда они могут решить, что им делать.Сравните это с отключением исключения или полным сбоем программы — это будет означать, что программисту нужно либо защищать каждую серию операций с плавающей запятой, которые могут дать сбой, либо самому вручную тестировать что-то. Это вопрос о том, какой вариант лучше, поэтому вы можете включить или отключить поведение NaN с плавающей запятой.
Какие операции приводят к значению NaN в качестве результата?
Есть много способов получить результат операции NaN .Вот сэмплер, но это не исчерпывающий список:
- Журнал отрицательного числа.
- Извлечение квадратного корня из отрицательного числа.
- Вычитание бесконечности из бесконечности.
- Выполнение любых арифметических операций над
NaN.
Однако есть некоторые операции, которые не производят NaN , даже если они математически не определены. Например, деление положительного числа на ноль дает в результате положительную бесконечность, даже если это не определено математически.Причина этого в том, что если вы возьмете предел x / y для положительного x, когда y приближается к нулю в положительном направлении, значение будет неограниченно расти.
Почему результат 0,0 / 0,0 объявлен как неопределенный? Разве это не должно быть 0?
Это скорее математический вопрос, чем что-либо еще. Это связано с тем, как работают ограничения. Давайте подумаем о том, как определить 0/0. Одним из вариантов было бы сказать следующее: если мы посмотрим на выражение 0 / x и возьмем предел, когда x приближается к нулю, тогда мы увидим 0 в каждой точке, поэтому предел должно быть равно нулю.С другой стороны, если мы посмотрим на выражение x / x и возьмем предел, когда x приближается к 0, мы увидим 1 в каждой точке, поэтому предел должен быть равен единице. Это проблематично, поскольку мы хотели бы, чтобы значение 0/0 согласовывалось с тем, что вы найдете при вычислении любого из этих выражений, но мы не можем выбрать фиксированное значение, которое имеет смысл. В результате значение 0/0 оценивается как NaN , что указывает на то, что здесь нет четкого значения для присвоения.
Почему результат какой-либо математической операции не может быть выражен числом с плавающей запятой или целым числом? Как может быть, что ценность непредставима?
Это связано с внутренним устройством чисел с плавающей запятой IEEE-754.Интуитивно все сводится к тому простому факту, что
- существует бесконечно много действительных чисел, бесконечно многие из которых имеют бесконечно длинные неповторяющиеся десятичные дроби, но
- у вашего компьютера ограниченный объем памяти.
В результате сохранение произвольного действительного числа может повлечь за собой сохранение бесконечно длинной последовательности цифр, чего мы не можем сделать с нашими компьютерами с конечной памятью. Поэтому у нас есть числа с плавающей запятой, в которых хранится приближений, действительных чисел, , которые не являются ошеломляюще огромными , и невозможность представления значений является результатом того факта, что мы просто сохраняем приближения.
Подробнее о том, как на самом деле хранятся числа и что это означает на практике, можно найти в легендарном руководстве «Что должен знать каждый программист об арифметике с плавающей запятой».
Почему квадратный корень отрицательного числа не является действительным числом?
Возьмем, к примеру, √ (-1). Представьте, что это действительное число x; то есть представьте, что x = √ (-1). Идея квадратного корня состоит в том, что это число, если умножить его само на себя, вернет вам число, из которого вы взяли квадратный корень.
Итак … какое число x? Мы знаем, что x ≠ 0, потому что 0 2 = 0 не равно -1. Мы также знаем, что x не может быть положительным, потому что любое положительное число, умноженное на само по себе, является положительным числом. И мы, , также знаем, что , что x не может быть отрицательным, потому что любое отрицательное число, умноженное на само, положительно.
Теперь у нас проблема. Какой бы ни была эта вещь x, она должна быть не положительной, не нулевой и не отрицательной. Значит, это ненастоящее число.
Вы можете обобщить действительные числа на комплексные, введя число i, где i 2 = -1.Обратите внимание, что настоящие числа этого не делают по указанной выше причине.
Почему NaN не эквивалентно неопределенному?
Есть разница между «неопределенным» и «что бы это ни было, это не действительное число». Например, 0/0 можно назвать неопределенным, потому что в зависимости от того, как вы приближаетесь к 0/0, вы можете вернуть 0, или 1, или, возможно, что-то еще. С другой стороны, √ (-1) прекрасно определяется как комплексное число (при условии, что √ (-1) возвращает i, а не -i), поэтому проблема не в том, что «это неопределенно», а как «у него есть значение, но это значение не является действительным числом.«
Надеюсь, это поможет!
с плавающей запятой — Почему NaN не равно NaN?
Мой первоначальный ответ (4 года назад) критикует решение с современной точки зрения без понимания контекста, в котором было принято решение. Таким образом, он не отвечает на вопрос.
Здесь дан правильный ответ:
NaN! =NaNвозникла из двух прагматических соображений:[…] В то время, когда NaN был формализован в арифметике 8087, не существовало предиката
isnan (); необходимо было предоставить программистам удобные и эффективные средства определения значений NaN, которые не зависели от языков программирования, предоставляя что-то вродеisnan (), что могло занять много лет
У этого подхода был один недостаток: он делал NaN менее полезным во многих ситуациях, не связанных с численными вычислениями.Например, намного позже, когда люди захотели использовать NaN для представления пропущенных значений и поместить их в контейнеры на основе хешей, они не смогли этого сделать.
Если бы комитет предвидел будущие варианты использования и считал их достаточно важными, они могли бы пойти на более подробный ! (X вместо x! = X в качестве теста на NaN . Однако их цель была более прагматичной и узкой: обеспечение наилучшего решения для числовых вычислений, и поэтому они не видели проблем в своем подходе.
===
Оригинальный ответ:
Прошу прощения, хотя я ценю мысль, которая вошла в получивший наибольшее количество голосов ответ, я не согласен с ней. NaN не означает «неопределенный» — см. Http://www.cs.berkeley.edu/~wkahan/ieee754status/IEEE754.PDF, стр. 7 (поиск по слову «undefined»). Как подтверждается в этом документе, NaN — это четко определенная концепция.
Более того, подход IEEE заключался в том, чтобы в максимальной степени следовать обычным правилам математики, а когда они не могли, следовать правилу «наименьшего удивления» — см. Https: // stackoverflow.com / a / 1573715/336527. Любой математический объект равен самому себе, поэтому правила математики подразумевают, что NaN == NaN должно быть True. Я не вижу какой-либо веской и веской причины для отклонения от такого главного математического принципа (не говоря уже о менее важных правилах трихотомии сравнения и т. Д.).
В итоге мой вывод такой.
Члены комитета IEEE не очень четко это продумали и допустили ошибку. Поскольку очень немногие люди понимали подход комитета IEEE или заботились о том, что именно стандарт говорит о NaN (а именно: обработка NaN большинством компиляторов в любом случае нарушает стандарт IEEE), никто не поднял тревогу.Следовательно, эта ошибка теперь встроена в стандарт. Маловероятно, что это будет исправлено, поскольку такое исправление нарушит большую часть существующего кода.
Edit: Вот один пост из очень информативного обсуждения. Примечание: чтобы получить непредвзятую точку зрения, вы должны прочитать всю ветку, поскольку Гвидо придерживается другого взгляда, чем некоторые другие основные разработчики. Однако Гвидо лично не интересуется этой темой и во многом следует рекомендациям Тима Петерса. Если у кого-то есть аргументы Тима Петерса в пользу NaN! = NaN , пожалуйста, добавьте их в комментарии; у них есть хороший шанс изменить мое мнение.
Навигация по аду NaN в Python | Джулия Ди Руссо
Недавно у меня много головных болей из-за NaN. Каждый программист знает, что это такое и почему они происходят, но в моем случае я не знал всех их характеристик или недостаточно хорошо знал, чтобы предотвратить мою борьбу. В надежде найти решения и избежать сильной головной боли я изучил поведение значений NaN в Python. После игры с несколькими операторами в Jupyter Notebook мои результаты были довольно неожиданными и очень запутанными.Вот что у меня было с помощью np.nan от Numpy.
np.nan in [np.nan] is True
Пока все хорошо, хорошо, но…
np.nan == np.nan is False
А? И…
np.nan is np.nan is True
Так что, черт возьми, происходит с NaN в Python?
NaN означает Not A Number и является распространенным отсутствующим представлением данных. Это специальное значение с плавающей запятой, и его нельзя преобразовать ни в какой другой тип, кроме float.Он был введен стандартом IEEE для двоичных чисел с плавающей запятой для арифметики (IEEE 754) до того, как появился Python, и используется во всех системах, следующих этому стандарту. NaN можно рассматривать как своего рода вирус данных, заражающий все операции, которых он касается.
None vs NaN
None и NaN звучат похоже, выглядят одинаково, но на самом деле совершенно разные. None — это внутренний тип Python, который можно рассматривать как эквивалент NULL. Ключевое слово None используется для определения нулевого значения или отсутствия значения вообще.None — это не то же самое, что 0, False или пустая строка. Это отдельный тип данных (NoneType), и только None может быть… None. В то время как отсутствующие значения — NaN в числовых массивах, они — None в массивах объектов. Лучше всего проверить None, используя foo is None вместо foo == None, что возвращает нас к нашей предыдущей проблеме с необычными результатами, которые я обнаружил в своих операциях NaN.
Сначала чтение, что np.nan == np.nan равно Ложь может вызвать реакцию замешательства и разочарования.Это выглядит странно, звучит действительно странно, но если немного подумать, логика начинает проявляться и даже становится понятной.
Хотя мы не знаем, что такое каждое NaN, не все NaN одинаковы.
Давайте представим, что вместо значений nan мы смотрим на группу людей, которых мы не знаем. Они нам совершенно незнакомые люди. Неизвестные люди могут казаться нам одинаковыми, что означает, что мы описываем их всех как неизвестных.Однако на самом деле это не означает, что один неизвестный человек равен другому неизвестному человеку.
Чтобы оставить эту странную метафору и вернуться к Python, NaN не может быть равным самому себе, потому что NaN является результатом сбоя , но этот сбой может произойти по-разному. Результат одного отказа не может быть равен результату любого другого отказа, а неизвестные значения не могут быть равны друг другу.
Теперь, чтобы понять, почему np.nan в [np.nan] равно True , мы должны посмотреть на разницу между равенством и идентификатором .
Равенство
Равенство относится к концепции, которую большинство программистов Python знают как «==». Это используется, чтобы спросить Python, совпадает ли содержимое переменной с содержимым другой переменной.
num = 1
num2 = 1num == num2
Последняя строка приведет к True . Содержание обеих переменных одинаково . Как я сказал ранее, содержимое NaN никогда не совпадает с содержимым другого NaN.
Identity
Identity — это когда вы спрашиваете Python, совпадает ли переменная с с другой переменной, то есть вы спрашиваете Python, имеют ли две переменные одинаковые идентификаторы .Python присваивает id каждой создаваемой переменной, и идентификаторы сравниваются, когда Python проверяет идентичность переменной в операции. Однако нп. nan — это отдельный объект, который всегда имеет один и тот же идентификатор, независимо от того, какой переменной вы его назначили.
import numpy as np
one = np.nan
two = np.nan
one is two
np.nan is np.nan is True and one is two is also True .
Если вы проверите идентификатор , один и , два , используя id (один) и id (два) , отобразится один и тот же идентификатор.
np.nan в [np.nan] равно True , потому что контейнер списка в Python проверяет идентичность до , проверяя на равенство . Однако существуют разные «вкусы» нансов в зависимости от того, как они созданы. float ('nan') создает разные объекты с разными идентификаторами, поэтому float ('nan') равно float ('nan') фактически дает False !! Мы еще раз упомянем об этих отличиях позже.
Концепция полной нанотехнологии может быть довольно трудной для понимания и очень раздражающей поначалу. К счастью, pandas и numpy являются фантастическими, когда дело доходит до значений nan и предоставляют несколько функций, которые легко выбирают, заменяют или удаляют значения nan в ваших переменных.
Проверка, является ли значение nan
Как я уже сказал, всякий раз, когда вы хотите узнать, является ли значение nan, вы не можете проверить, равно ли оно nan. Однако есть много других вариантов, и тот, который я предлагаю, не единственный из доступных.
import numpy as np
import pandas as pdvar = float ('nan') var is np.nan #results in True
#or
np.isnan (var) #results in True
#or
pd.isna (var ) # результаты в True
# или
pd.isnull (var) # результаты в True
pd.isnull и pd.isna () ведут себя идентично. Pandas предоставляет функцию .isnull (), поскольку это адаптация фреймов данных R в Python. В R null и na — это два разных типа с разным поведением.
Кроме numpy и начиная с Python 3.5, вы также можете использовать math. нан . Причина, по которой я написал в этой статье и nan, и NaN (помимо моей непоследовательности), заключается в том, что значение не чувствительно к регистру. Оба типа: с плавающей запятой (‘nan’) или float (‘NAN’) дадут одинаковый результат.
import math
var = float ('nan')
math.isnan (var) #results in True
Небольшое предупреждение:
import math
import numpy as np
math.nan is math.nan # приводит к математике True
.nan is np.nan #results in False
math.nan is float ('nan') #results in False
Операторы дают False, потому что math.nan , np.nan и float ('nan') имеют разные идентификаторы. У них разные идентичности.
import pandas as pddf = pd.DataFrame (some_data) df.dropna ()
# удалит все строки вашего набора данных со значениями nan.
# использовать параметр подмножества, чтобы отбрасывать строки со значениями nan в определенных столбцахdf.fillna ()
# заполнит значения nan значением вашего choicedf.isnull ()
# то же, что и pd.isnull () для dataframesdf.isna ()
# то же самое, что pd.isna () для dataframes
К сожалению, я не находите документацию pandas чрезвычайно полезной, когда дело касается документации по их недостающим данным. Тем не менее, мне очень нравится этот отрывок из Python Data Science Handbook , который дает отличный обзор того, как работать с отсутствующими данными в Pandas.
TypeError: объект «float» не повторяется
Хотя ошибки NoneType достаточно ясны, ошибки, вызванные значениями nan, могут немного сбивать с толку.Значения Nan часто могут вызывать ошибки (в частности, TypeErrors ), которые будут связаны с их типом « float ». Сообщение об ошибке может быть неожиданным, особенно если вы считаете, что ваши данные абсолютно не имеют плавающего значения. Может показаться, что ваш фрейм данных не содержит никаких поплавков, но на самом деле это действительно так. Вероятно, он имеет значения NaN, о которых вы не знали, и вам просто нужно избавиться от ваших значений nan, чтобы избавиться от этой ошибки!
Как работать со значениями NaN — datatest 0.11.1 документация
Равенство: NaN ≠ NaN
значений NaN нельзя сравнивать ни с чем, даже с самими собой:
>>> x = float ('нан')
>>> х == х
Ложь
Чтобы проверить, является ли значение NaN, обычно для модулей и пакетов
чтобы предоставить функцию для этой цели (например, math.isnan () , numpy.isnan () , pandas.isna () и т. Д.):
>>> импорт математики
>>> x = float ('нан')
>>> математика.иснан (х)
Истинный
Хотя значения NaN нельзя сравнивать напрямую, их можно сравнить с и как часть объекта различия. Фактически, сравнения различий относятся к все значения NaN равны, даже если базовый тип отличается:
>>> импорт десятичных, математических, числовых
>>> из импорта последних данных Недействительно
>>> Invalid (math.nan) == Invalid (float ('nan'))
Истинный
>>> Invalid (math.nan) == Invalid (complex ('nan'))
Истинный
>>> Invalid (math.nan) == Invalid (decimal.Десятичный ('нан'))
Истинный
>>> Invalid (math.nan) == Invalid (numpy.nan)
Истинный
>>> Invalid (math.nan) == Invalid (numpy.float32 ('nan'))
Истинный
>>> Invalid (math.nan) == Invalid (numpy.float64 ('nan'))
Истинный
Идентификатор: NaN — это NaN, кроме случаев, когда это не
Некоторые пакеты предоставляют константу NaN, на которую можно ссылаться в
код пользователя (например, math.nan и numpy.nan ).
Хотя может возникнуть соблазн использовать эти константы для проверки
сопоставление значений NaN, этот подход на практике ненадежен.
Для оптимизации производительности Numpy и Pandas должны строго управлять
схемы памяти содержащихся в них данных. Когда numpy.nan — это
вставляется в ndarray или Series , значение преобразуется в совместимый dtype когда необходимо. Когда используется тип NaN, отдельный экземпляр
создается и возможность сопоставления с использованием оператора is больше не работает, как вы могли ожидать:
>>> импортировать панд как pd >>> импортировать numpy как np >>> нп.Нан - это Н.П. Нан Истинный >>> s = pd.Series ([10, 11, np.nan]) >>> s [2] нан >>> s [2] - np.nan Ложь
Мы можем проверить, что типы теперь разные:
>>> тип (np.nan) плавать >>> тип (s [2]) float64
Вообще говоря, предполагать, что NaN равно NaN, небезопасно. Это означает, что для надежной проверки лучше всего удалить NaN записывает полностью или заменяет их другим значением.
Infinity и NaN :: типы данных (программирование)
Infinity и NaN :: типы данных (программирование)| Программирование |
Infinity и NaN
MATLAB использует специальные значения inf , -inf и NaN для представления значений, которые являются положительной и отрицательной бесконечностью, а не числами соответственно.
Infinity
MATLAB представляет бесконечность специальным значением inf . Бесконечность возникает в результате таких операций, как деление на ноль и переполнение, которые приводят к слишком большим результатам, чтобы их можно было представить как обычные значения с плавающей запятой. MATLAB также предоставляет функцию под названием inf , которая возвращает арифметическое представление IEEE для положительной бесконечности как скалярное значение double .
Здесь показаны несколько примеров операторов, которые возвращают положительную или отрицательную бесконечность в MATLAB.
x = 1/0 | x = 1.e1000 |
x = exp (1000) | x = журнал (0) |
Используйте функцию isinf , чтобы убедиться, что x является положительной или отрицательной бесконечностью:
NaN
MATLAB представляет значения, которые не являются действительными или комплексными числами, со специальным значением, называемым NaN , что означает Not a Number.Выражения вроде 0/0 и inf / inf приводят к NaN , как и любые арифметические операции с NaN .
Например, оператор n / 0 , где n является сложным, возвращает NaN :
Используйте функцию isnan , чтобы убедиться, что x — это NaN:
MATLAB также предоставляет функцию NaN , которая возвращает арифметическое представление IEEE для NaN как скалярное значение double :
Логические операции над NaN. Поскольку два NaN не равны друг другу, логические операции, включающие NaN , всегда возвращают ложь, за исключением проверки на неравенство, ( NaN ~ = NaN ):
Функции бесконечности и NaN
См. Функции бесконечности и NaN для получения списка функций, наиболее часто используемых с inf и NaN в MATLAB.
| Комплексные числа | Определение числовых типов |
© 1994-2005 The MathWorks, Inc.
NaN Определение
Домашняя страница: Технические термины: определение NaN
означает «Не число». NaN — это термин, используемый в математике и информатике для описания нечислового значения. Это также может быть заполнитель для ожидаемого числового результата, который нельзя определить как число с плавающей запятой.
Существует два основных типа генерирования NaN: 1) математическое вычисление и 2) нечисловой ввод. Следующие математические вычисления дают NaN, потому что результат не определен:
- 0 ÷ 0
- 0 х ∞
- ∞ ÷ ∞
Если в вычислении используется символ, строка или другое нечисловое значение, результатом также может быть NaN.Например, 20 x «лошадь» не дает числового результата, поскольку 20 — целое число, а «лошадь» — строка. Функция может вернуть NaN в результате неверного ввода, что является предпочтительной альтернативой сбоям программы.
Некоторые программы для работы с электронными таблицами и базами данных отображают NaN или #NaN в ячейке таблицы, если формула ячейки не получила действительный числовой ввод для вычисления.Различные языки программирования по-разному обрабатывают значения NaN. Например, в JavaScript NaN — это свойство глобального объекта (т.е.е. Number.NaN). JavaScript предоставляет функцию isNan () для проверки, является ли значение NaN. PHP использует функцию is_nan () с той же целью. Оба возвращают логическое значение true или false.
Обновлено: 28 июня 2018 г.
https://techterms.com/definition/nan
TechTerms — Компьютерный словарь технических терминов
Эта страница содержит техническое определение NaN. Он объясняет в компьютерной терминологии, что означает NaN, и является одним из многих технических терминов в словаре TechTerms.
Все определения на веб-сайте TechTerms составлены так, чтобы быть технически точными, но также простыми для понимания. Если вы сочтете это определение NaN полезным, вы можете сослаться на него, используя приведенные выше ссылки для цитирования. Если вы считаете, что термин следует обновить или добавить в словарь TechTerms, отправьте электронное письмо в TechTerms!
Подпишитесь на рассылку TechTerms, чтобы получать избранные термины и тесты прямо в свой почтовый ящик. Вы можете получать электронную почту ежедневно или еженедельно.
Подписаться
.