Можно ли заставить экспоненты и мантиссы числа с плавающей точкой, чтобы соответствовать другой поплавок (питон)?

TL; DR

использовать

f2 = f2*np.max(f1)-np.min(f1)*(f2-1)  # f2 is now between min(f1) and max(f1)

и убедитесь, что вы используете двойную точность, сравните числа с плавающей запятой, глядя на абсолютные или относительные различия, избегайте округления для регулировки (или сравнения) чисел с плавающей запятой и не устанавливайте базовые компоненты чисел с плавающей запятой вручную.

подробности

это не очень простая ошибка для воспроизведения, как вы обнаружили. Однако, работа с плавающими числами подвержена ошибкам. Е. Г., сложения 1 000 000 000 + 0 . 000 000 000 1 дает 1 000 000 000 . 000 000 000 1, но это слишком много значащих цифр даже для двойной точности (которая поддерживает вокруг 15 значащих цифр), поэтому конечная десятичная дробь отбрасывается. Более того, некоторые "короткие" числа не могут быть представлены точно, как отмечено в @Kevin's ответ. См., например, здесь, для более. (Поиск чего-то вроде "ошибки округления с плавающей запятой" для еще больше.)

вот пример, который демонстрирует проблему:

import numpy as np

numpy.set_printoptions(precision=16)

dtype=np.float32                     
f1 = np.linspace(-1000, 0.001, 3, dtype=dtype)
f2 = np.linspace(0, 1, 3, dtype=dtype)

f2 = (f2-np.min(f2))/(np.max(f2)-np.min(f2)) # f2 is now between 0.0 and 1.0
f2 = f2*(np.max(f1)-np.min(f1)) + np.min(f1)  # f2 is now between min(f1) and max(f1)

print (f1)
print (f2)

выход

[ -1.0000000000000000e+03  -4.9999951171875000e+02   1.0000000474974513e-03]
[ -1.0000000000000000e+03  -4.9999951171875000e+02   9.7656250000000000e-04]

после @Mark Dickinson's комментарий, я использовал 32-битную плавающую точку. Это согласуется с сообщенной вами ошибкой, относительной ошибкой около 10^-7, около 7-й значимой цифры

In: (5.0230602 - 5.0230593) / 5.0230593
Out: 1.791736760621852e-07

собирается dtype=np.float64 делает вещи лучше, но это все еще не идеально. Программа выше, то дает

[ -1.0000000000000000e+03  -4.9999950000000001e+02   1.0000000000000000e-03]
[ -1.0000000000000000e+03  -4.9999950000000001e+02   9.9999999997635314e-04]

это не идеально, но, как правило, достаточно близко. При сравнении чисел с плавающей запятой вы почти никогда не захотите использовать строгое равенство из-за возможности небольших ошибок, как указано выше. Вместо этого вычитайте одно число из другого и проверьте, что абсолютная разница меньше некоторого допуска, и/или посмотрите на относительную ошибку. См., например, numpy.isclose.

возвращаясь к вашей проблеме, кажется, что это должно быть возможно сделать лучше. Ведь f2 имеет диапазон от 0 до 1, поэтому вы должны иметь возможность реплицировать максимум в f1. Проблема возникает в строке

f2 = f2*(np.max(f1)-np.min(f1)) + np.min(f1)  # f2 is now between min(f1) and max(f1)

потому что, когда элемент f2 это 1 Вы делаете намного больше, чем просто умножение 1 на максимум f1, что приводит к возможности возникновения арифметических ошибок с плавающей запятой. Обратите внимание, что вы можете умножить скобки f2*(np.max(f1)-np.min(f1)) to f2*np.max(f1) - f2*np.min(f1), а затем разложим полученный - f2*np.min(f1) + np.min(f1) до np.min(f1)*(f2-1) давать

f2 = f2*np.max(f1)-np.min(f1)*(f2-1)  # f2 is now between min(f1) and max(f1)

Итак, когда элемент f2 это 1, у нас есть 1*np.max(f1) - np.min(f1)*0. И наоборот, когда элемент f2 равно 0, у нас есть 0*np.max(f1) - np.min(f1)*1. Числа 1 и 0 can быть точно представлены, так что не должно быть никаких ошибок.

измененная программа выводит

[ -1.0000000000000000e+03  -4.9999950000000001e+02   1.0000000000000000e-03]
[ -1.0000000000000000e+03  -4.9999950000000001e+02   1.0000000000000000e-03]

т. е. по желанию.

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

альтернативным подходом к приведенному выше, который может быть предпочтительнее, было бы масштабирование и массивы от 0 до 1. Это может быть наиболее подходящая форма для использования в программе. (И оба массива могут быть умножены на коэффициент масштабирования такой оригинальный выбор f1, если это необходимо.)

Re используя округление для решения вашей проблемы, я бы не рекомендую это. Проблема с округлением-помимо того, что это излишне уменьшает точность ваших данных - заключается в том, что числа, которые очень близки, могут округляться в разных направлениях. Е. Г.

f1 = np.array([1.000049])
f2 = np.array([1.000051])
print (f1)
print (f2)
scale = 10**(-np.floor(np.log10(np.max(f1))) + 4)
f2 = np.round(f2*scale)/scale
f1 = np.round(f1*scale)/scale
print (f1)
print (f2)

выход

[ 1.000049]
[ 1.000051]
[ 1.]
[ 1.0001]

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

Re мантиссы и экспоненты, см. math.frexp и math.ldexp, документирован здесь. Однако я бы не рекомендовал устанавливать их самостоятельно (рассмотрим два числа, которые очень близки, но имеют разные показатели, например-вы действительно хотите установить мантиссу). Гораздо лучше просто установить максимум f2 явно до максимума f1, если вы хотите, чтобы убедиться, цифры точно такие же (и аналогично для минимума).