double precision mandel что это

Одинарная или двойная точность?

Введение

Статья также написана для тех из вас, у кого много данных. Если вам требуется несколько чисел тут или там, просто используйте double и не забивайте себе голову!

Точность данных

У 32-битных чисел с плавающей запятой точность примерно 24 бита, то есть около 7 десятичных знаков, а у чисел с двойной точностью — 53 бита, то есть примерно 16 десятичных знаков. Насколько это много? Вот некоторые грубые оценки того, какую точность вы получаете в худшем случае при использовании float и double для измерения объектов в разных диапазонах:

Почему всегда не хранить всё с двойной точностью?

Влияние на производительность вычислений с одинарной и двойной точностью

Когда производить вычисления с увеличенной точностью

Даже если вы храните данные с одинарной точностью, в некоторых случаях уместно использовать двойную точность при вычислениях. Вот простой пример на С:

Если вы запустите этот код на десяти числах одинарной точности, то не заметите каких-либо проблем с точностью. Но если запустите на миллионе чисел, то определённо заметите. Причина в том, что точность теряется при сложении больших и маленьких чисел, а после сложения миллиона чисел, вероятно, такая ситуация встретится. Практическое правило такое: если вы складываете 10^N значений, то теряете N десятичных знаков точности. Так что при сложении тысячи (10^3) чисел теряются три десятичных знака точности. Если складывать миллион (10^6) чисел, то теряются шесть десятичных знаков (а у float их всего семь!). Решение простое: вместо этого выполнять вычисления в формате double :

Пример

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

Чтобы увеличить точность, вы решаете сложить результаты измерений и вычислить среднее значение. В этом примере используется число с плавающей запятой в base-10, у которого точность составляет точно семь десятичных знаков (похоже на 32-битный float ). С тремя значимыми разрядами это даёт нам четыре дополнительных десятичных знака точности:

В сумме уже четыре значимых разряда, с тремя свободными. Что если сложить сотню таких значений? Тогда мы получим нечто вроде такого:

Всё ещё остались два неиспользованных разряда. Если суммировать тысячу чисел?

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

Заметьте, как мы сдвигаем меньшее число, чтобы выровнять десятичный разделитель. У нас больше нет запасных разрядов, и мы опасно приблизились к потере точности. Что если сложить сто тысяч значений? Тогда добавление новых значений будет выглядеть так:

Обратите внимание, что последний значимый разряд данных (2 в 3.12) теряется. Вот теперь потеря точности действительно происходит, поскольку мы непрерывно будем игнорировать последний разряд точности наших данных. Мы видим, что проблема возникает после сложения десяти тысяч чисел, но до ста тысяч. У нас есть семь десятичных знаков точности, а в измерениях имеются три значимых разряда. Оставшиеся четыре разряда — это четыре порядка величины, которые выполняют роль своеобразного «числового буфера». Поэтому мы можем безопасно складывать четыре порядка величины = 10000 значений без потери точности, но дальше возникнут проблемы. Поэтому правило следующее:

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

Выводы

Приложение: Что такое число с плавающей запятой?

Я обнаружил, что многие на самом деле не вникают, что такое числа с плавающей запятой, поэтому есть смысл вкратце объяснить. Я пропущу здесь мельчайшие детали о битах, INF, NaN и поднормалях, а вместо этого покажу несколько примеров чисел с плавающей запятой в base-10. Всё то же самое применимо к двоичным числам.

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

1.875545 · 10^-18 = 0.000 000 000 000 000 001 875 545
3.141593 · 10^0 = 3.141593
2.997925 · 10^8 = 299 792 500
6.022141 · 10^23 = 602 214 100 000 000 000 000 000

Выделенная жирным часть называется мантиссой, а выделенная курсивом — экспонентой. Вкратце, точность хранится в мантиссе, а величина в экспоненте. Так как с ними работать? Ну, умножение производится просто: перемножаем мантисссы и складываем экспоненты:

Сложение немного хитрее: чтобы сложить два числа разной величины, сначала нужно сдвинуть меньшее из двух чисел таким образом, чтобы запятая находилась в одном и том же месте.

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

Источник

Помогите расшифровать результаты теста

Тестировал программой AIDA64 Extreme

Прошу сильно не пинать, прост не силен в этом)

Benchmark Result Run Time Build Time

Memory Read 3249 MB/s 1156 ms

— Pinned 3249 MB/s 9 ms

— Pageable 1926 MB/s 16 ms

Memory Write 3035 MB/s 1015 ms

— Pinned 3035 MB/s 10 ms

— Pageable 2207 MB/s 14 ms

Memory Copy 11653 MB/s 7688 ms

— 15 MB Block 10886 MB/s 3 ms

— 32 MB Block 11300 MB/s 6 ms

— 64 MB Block 11530 MB/s 11 ms

— 128 MB Block 11585 MB/s 22 ms

— 256 MB Block 11653 MB/s 44 ms

— 512 MB Block 788 MB/s 1299 ms

— 761 MB Block 4199 MB/s 363 ms

Single-Precision FLOPS 473.9 GFLOPS 12750 ms

— float1 473.9 GFLOPS 580 ms 1282 ms

— float2 470.5 GFLOPS 584 ms 281 ms

— float4 469.6 GFLOPS 585 ms 265 ms

— float8 467.2 GFLOPS 588 ms 266 ms

— float16 458.9 GFLOPS 599 ms 250 ms

Double-Precision FLOPS 32.60 GFLOPS 7812 ms

— double1 32.60 GFLOPS 527 ms 437 ms

— double2 32.60 GFLOPS 527 ms 344 ms

— double4 32.44 GFLOPS 530 ms 328 ms

— double8 32.13 GFLOPS 535 ms 313 ms

— double16 32.13 GFLOPS 535 ms 328 ms

24-bit Integer IOPS 470.6 GIOPS 11094 ms

— int1 470.6 GIOPS 584 ms 141 ms

— int2 470.4 GIOPS 584 ms 109 ms

— int4 469.1 GIOPS 586 ms 125 ms

— int8 452.4 GIOPS 608 ms 157 ms

— int16 425.1 GIOPS 647 ms 297 ms

32-bit Integer IOPS 103.2 GIOPS 24219 ms

— int1 103.2 GIOPS 666 ms 2000 ms

— int2 98.2 GIOPS 700 ms 156 ms

— int4 98.3 GIOPS 699 ms 172 ms

— int8 96.5 GIOPS 712 ms 234 ms

— int16 93.8 GIOPS 733 ms 391 ms

64-bit Integer IOPS 26.10 GIOPS 34985 ms

— long1 26.10 GIOPS 658 ms 2078 ms

— long2 26.08 GIOPS 659 ms 187 ms

— long4 25.96 GIOPS 662 ms 328 ms

— long8 25.48 GIOPS 674 ms 547 ms

— long16 14.82 GIOPS 580 ms 1156 ms

AES-256 2787 MB/s 55438 ms

— inline loop / 4 MB 2784 MB/s 736 ms 281 ms

— inline loop / 8 MB 2786 MB/s 735 ms

— inline loop / 16 MB 2786 MB/s 735 ms

— inline loop / 256 MB 2772 MB/s 739 ms

— inline unroll / 4 MB 2784 MB/s 736 ms 297 ms

— inline unroll / 8 MB 2785 MB/s 735 ms

— inline unroll / 16 MB 2786 MB/s 735 ms

— inline unroll / 32 MB 2787 MB/s 735 ms

— inline unroll / 64 MB 2768 MB/s 740 ms

— inline unroll / 128 MB 2787 MB/s 735 ms

— inline unroll / 256 MB 2786 MB/s 735 ms

— define loop / 4 MB 2784 MB/s 736 ms 141 ms

— define loop / 8 MB 2784 MB/s 736 ms

— define loop / 16 MB 2742 MB/s 747 ms

— define loop / 32 MB 2651 MB/s 773 ms

— define loop / 64 MB 2653 MB/s 772 ms

— define loop / 128 MB 2648 MB/s 774 ms

— define loop / 256 MB 2733 MB/s 749 ms

— define unroll / 4 MB 2784 MB/s 736 ms 297 ms

— define unroll / 8 MB 2785 MB/s 735 ms

— define unroll / 16 MB 2655 MB/s 771 ms

— define unroll / 32 MB 2658 MB/s 770 ms

— define unroll / 64 MB 2659 MB/s 770 ms

— define unroll / 128 MB 2656 MB/s 771 ms

— define unroll / 256 MB 2666 MB/s 768 ms

SHA-1 Hash 5461 MB/s 14844 ms

— 512 blocks 2226 MB/s 899 ms 906 ms

— 1024 blocks 4446 MB/s 900 ms

— 2048 blocks 4443 MB/s 900 ms

— 4096 blocks 4442 MB/s 901 ms

— 8192 blocks 5072 MB/s 789 ms

— 16384 blocks 5461 MB/s 732 ms

— 32768 blocks 5460 MB/s 733 ms

— 65536 blocks 5459 MB/s 733 ms

Single-Precision Julia 102.7 FPS 8906 ms

— float1 break 65.1 FPS 984 ms 187 ms

— float1 stay / unroll 3 99.1 FPS 646 ms 94 ms

— float2 stay / unroll 3 78.8 FPS 812 ms 109 ms

— float1 stay / unroll 9 102.7 FPS 623 ms 109 ms

— float2 stay / unroll 9 78.1 FPS 819 ms 125 ms

Double-Precision Mandel 10.66 FPS 7735 ms

— double1 break 9.41 FPS 850 ms 125 ms

— double1 stay / unroll 3 10.66 FPS 750 ms 109 ms

— double2 stay / unroll 3 6.87 FPS 582 ms 109 ms

— double1 stay / unroll 9 10.16 FPS 788 ms 109 ms

— double2 stay / unroll 9 6.00 FPS 666 ms 125 ms

Benchmark Result Run Time Build Time

Memory Read 3228 MB/s 1422 ms

— Pinned 2744 MB/s 11 ms

— Pageable 3228 MB/s 9 ms

Memory Write 2903 MB/s 1344 ms

— Pinned 2903 MB/s 10 ms

— Pageable 2749 MB/s 11 ms

Memory Copy 9233 MB/s 4047 ms

— 15 MB Block 8879 MB/s 3 ms

— 32 MB Block 9180 MB/s 7 ms

— 64 MB Block 9044 MB/s 14 ms

— 128 MB Block 9116 MB/s 28 ms

— 256 MB Block 9233 MB/s 55 ms

— 350 MB Block 8622 MB/s 81 ms

Single-Precision FLOPS 43.67 GFLOPS 13141 ms

— float1 39.90 GFLOPS 861 ms 3391 ms

— float2 43.67 GFLOPS 787 ms 219 ms

— float4 22.72 GFLOPS 756 ms 187 ms

— float8 43.44 GFLOPS 791 ms 219 ms

— float16 43.33 GFLOPS 793 ms 219 ms

24-bit Integer IOPS 15.01 GIOPS 8063 ms

— int1 14.98 GIOPS 573 ms 109 ms

— int2 15.01 GIOPS 572 ms 422 ms

— int4 15.01 GIOPS 572 ms 3672 ms

32-bit Integer IOPS 11.68 GIOPS 20594 ms

— int1 11.61 GIOPS 740 ms 11735 ms

— int2 11.68 GIOPS 736 ms 453 ms

— int4 11.65 GIOPS 737 ms 3641 ms

64-bit Integer IOPS 3.39 GIOPS 28891 ms

— long1 3.39 GIOPS 633 ms 13078 ms

— long2 3.37 GIOPS 638 ms 12937 ms

AES-256 363.7 MB/s 11328 ms

— define unroll / 4 MB 352.0 MB/s 727 ms 219 ms

— define unroll / 8 MB 352.5 MB/s 726 ms

— define unroll / 16 MB 352.1 MB/s 727 ms

— define unroll / 32 MB 352.4 MB/s 726 ms

— define unroll / 64 MB 355.4 MB/s 720 ms

— define unroll / 128 MB 363.7 MB/s 704 ms

SHA-1 Hash 681.7 MB/s 13015 ms

— 512 blocks 571.4 MB/s 875 ms 1140 ms

— 1024 blocks 608.5 MB/s 822 ms

— 2048 blocks 647.6 MB/s 772 ms

— 4096 blocks 663.1 MB/s 754 ms

— 8192 blocks 674.6 MB/s 741 ms

— 16384 blocks 678.5 MB/s 737 ms

— 32768 blocks 681.7 MB/s 733 ms

Single-Precision Julia 19.90 FPS 12781 ms

— float1 break 19.90 FPS 804 ms 156 ms

— float1 stay / unroll 3 14.62 FPS 547 ms 63 ms

— float2 stay / unroll 3 16.96 FPS 943 ms 78 ms

— float4 stay / unroll 3 15.93 FPS 502 ms 93 ms

— float1 stay / unroll 9 17.49 FPS 915 ms 78 ms

— float2 stay / unroll 9 18.84 FPS 849 ms 78 ms

— float4 stay / unroll 9 17.81 FPS 899 ms 94 ms

Будьте терпимее

Опять «умная» лента на пикабу

В стопицотый раз про умную ленту

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

ЗЫ: и отключение этого дурацкого фона постов тоже.

«Елена, алё!» Продолжение

Некто padillion наложил эти дикие вопли на современный бит, и получился такой трек, который неплохо так разошелся по интернету:

Самое смешное, что эта резкая мадам нашла его в инстаграме и пригрозила судом, попутно наговорив на новый трек. Там глядишь и до альбома недалеко. Ребята, это заслуженная слава!

Дисклеймер: никакого отношения к упомянутым персонажам не имею, никого не раскручиваю и не рекламирую. Форсю мем.

Полезный совет, если прорвало стояк с водой

Хочу поделиться своим горьким опытом. Вчера перекрывал воду в квартире, повернул барашек шарового крана на стояке с холодной водой и. кран остался у меня в руках. Ситуация примерно такая:

Дом высотный, давление хорошее, на пол лилось примерно по ведру за 2 секунды. Сначала пытался выливать воду ведрами в унитаз, но они наполнялись мновенно.

Решение пришло неожиданно от супруги: взять шланг от пылесоса и отвести воду в унитаз.

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

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

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

Я тоже душнила

У жены во время беременности был жёсткий токсикоз. Да такой, что два раза приходилось ложиться в перинатальный центр. Речь пойдет про первый раз. В четверг жена с направлением от врача на госпитализацию приезжает в перинатальный центр, а там говорят «мест нет». На вопрос «что делать и как быть» отвечают «идите к главврачу на второй этаж». Главврач говорит жене «мест нет, может быть завтра кого-то выпишут и будет место, но скорее всего до понедельника ничего не будет». Перинатальный центр новый и большой, странно, что там нет мест. Да и создалась впечатление, что человек финансовой благодарности захотел. Жена в слезах звонит мне, меня же такой поворот конкретно взбесил, ибо есть направление на госпитализацию, беременной девушке реально очень плохо, а они тут на денежки намекают и отфутболивают. Приезжаю я в перинаталку и начинаю просто звонить в министерство здравоохранения. С третьего раза дозваниваюсь куда надо (два первых раза меня переадресовывали на министерства по другим областям) и минут через 15 с небес на землю (с какого-то этажа выше на первый этаж к нам) спускается какая-то баба и ведёт нас в абсолютно пустую палату ставить капельницы жене, попутно приговаривая «ой ну что вы сразу письма писать, это всё решается на местном уровне, надо было к главврачу зайти». Потом ещё мне звонили из министерства, спрашивали решился ли мой вопрос и главврач сам звонил мне и рассказывал сказки как он сейчас будет нам место искать. По итогу в четверг капельницы прокапали, отправили домой. На следующий день в пятницу жену положили одну в палату (палаты на двоих) и при этом на этаже было очень много пустых палат.

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

Всем здоровья! Не бойтесь и не стесняйтесь предпринимать какие-то действия в экстренных ситуациях.

Источник

CPU vs GPU догоняет потихоньку

Просто результаты сравнительного теста Ryzen 9 3900X и Radeon RX580

AIDA64 GPGPU Benchmark (скромно потупясь, да-да, под оффтопиком запускал, но это непринципиально)

Radeon RX580	Ryzen 9 3900X
Memory Read	13063 MB/s	41410 MB/s
Memory Write	12827 MB/s	39449 MB/s
Memory Copy	186053 MB/s	43695 MB/s
Single-Precision FLOPS	6264 GFLOPS	1579 GFLOPS
Double-Precision FLOPS	391.5 GFLOPS	789.1 GFLOPS
24-bit integer IOPS	6260 GIOPS	393.4 GIOPS
32-bit integer IOPS	1253 GIOPS	393.7 GIOPS
64-bit integer IOPS	313.2 GIOPS	98.59 GIOPS
AES-256	33429 MB/s	109151 MB/s
SHA-1 Hash	73763 MB/s	37069 MB/s
Single-Precision Julia	947.4 FPS	583.6 FPS
Doble-Precision Mandel	74.36 FPS	308.1 FPS

Как сказано, на CPU использовался не OpenCL, а специально оптимизированные программы для вычислений, да и карточка уже далеко не топовая, но тем не менее. Видно, что в некоторых случаях CPU даже быстрее, а почти во многих не принципиально отстает.

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

Топовые процессоры типа TR 3990x наверное и вообще быстрее будут. История развивается по спирали? С CPU начали массивно-параллельные задачи переносить на GPU, но по мере нарастания гонки ядер обычных CPU преимущества вычислений на видеокарте слабеют.

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

Источник

Число двойной точности

Число́ двойно́й то́чности (Double precision, Double) — компьютерный формат представления чисел, занимающий в памяти две последовательных ячейки (компьютерных слова; в случае 32-битного компьютера — 64 бита или 8 байт). Как правило, обозначает формат числа с плавающей запятой стандарта IEEE 754. Числа с плавающей запятой (двойной/одинарной/четверной точности) поддерживаются сопроцессором (в 80386 выполнен как отдельный модуль, начиная с 80486 является встроенным в главный процессор. Сопроцессор, хотя он сейчас и является частью главного процессора, принято называть FPU — Floating Point Unit, буквально Модуль Плавающей Запятой).

Одним из первых языков программирования, позволявшим использовать числа одинарной и двойной точности с плавающей запятой, был Фортран.

Знак
(11 битов) Экспонента											(52 бита) Мантисса
63				56				55				48				47				40				39				32				31				24				23				16				15				8				7				0

Для вычисления экспоненты из 11-ти битного числа вычитается 10-ти битное смещение экспоненты, равное . Для вычисления мантиссы к 1,0 добавляется поле мантиссы в виде дробной части. Число равно произведению мантиссы со знаком на двойку в степени экспоненты.

Примеры чисел двойной точности

См. также

Ссылки

Полезное

Смотреть что такое «Число двойной точности» в других словарях:

Число одинарной точности — (англ. Single precision, Single) широко распространенный компьютерный формат представления вещественных чисел, занимающий в памяти 32 бита (4 байта). Как правило, под ним понимают формат числа с плавающей запятой стандарта IEEE 754.… … Википедия

Число четверной точности — (англ. Quadruple precision) компьютерный формат представления чисел с плавающей запятой, занимающий в памяти четыре последовательных ячейки (компьютерных слова; в случае 32 битного компьютера 128 бит или 16 байт). Как правило, обозначает… … Википедия

Число половинной точности — (англ. half precision) компьютерный формат представления чисел, занимающий в памяти половину компьютерного слова (в случае 32 битного компьютера 16 бит или 2 байта). Диапазон значений ± 2−24(5.96E 8) 65504. Приблизительная… … Википедия

Число с плавающей запятой — Число с плавающей запятой форма представления действительных чисел, в которой число хранится в форме мантиссы и показателя степени. При этом число с плавающей запятой имеет фиксированную относительную точность и изменяющуюся абсолютную.… … Википедия

Strtod — (сокр. от string to double, строку в число двойной точности ) функция языка Си, конвертирующая символ строки в число с плавающей запятой двойной точности. Определение функции имеет вид: double strtod ( const char * str, char ** endptr );[1]… … Википедия

strtod — (сокр. от string to double, «строку в число двойной точности») функция языка Си, конвертирующая символ строки в число с плавающей запятой двойной точности. Определение функции имеет вид: double strtod ( const char * str, char ** endptr… … Википедия

stdlib.h — Стандартная библиотека языка программирования С assert.h complex.h ctype.h errno.h fenv.h float.h inttypes.h iso646.h limits.h locale.h math.h setjmp.h signal.h stdarg.h stdbool.h stddef.h stdint.h … Википедия

Числа с плавающей запятой — Плавающая запятая форма представления действительных чисел, в которой число хранится в форме мантиссы и показателя степени. При этом число с плавающей запятой имеет фиксированную относительную точность и изменяющуюся абсолютную. Наиболее… … Википедия

Запятая плавающая — Плавающая запятая форма представления дробных чисел, в которой число хранится в форме мантиссы и показателя степени. При этом число с плавающей запятой имеет фиксированную относительную точность и изменяющуюся абсолютную. Наиболее часто… … Википедия

Машинный эпсилон — Плавающая запятая форма представления дробных чисел, в которой число хранится в форме мантиссы и показателя степени. При этом число с плавающей запятой имеет фиксированную относительную точность и изменяющуюся абсолютную. Наиболее часто… … Википедия

Источник