NaN in Math

[Sibedir]

Блин, вы так рассуждаете, как будто первый раз меня на форуме видите. Вылез мол чайник какой-то.

NaN - это просто запись, обозначающая бесконечность и ей соответствует вполне определенный битовый набор в представлении чисел...

Да ежу пьяному это понятно . Вы вопросы внимательней почитайте.

Вопрос №1:

Сообщение от Sibedir

Вроде понятно, но хотелось бы услышать еще мнения.

Сообщение от Sibedir

Стал гадать, как этим воспользоватся на полную катушку.

Да ладно, сам уже ответил. (Пост #6)
Вопрос №2:

Сообщение от Sibedir

Но вот вопрос, это что такое получается? Перед любой арифметической операцией сначала идет проверка: А не с NaN'ом ли мы работаем? Не влияет ли это на скорость вычислений?

Вопрос в силе.

[B_N]

Сообщение от Sibedir

Блин, вы так рассуждаете, как будто первый раз меня на форуме видите. Вылез мол чайник какой-то.

Нет. Просто Вы сами задаете взаимоисключающие вопросы: с одной стороны Вам понятно, что это просто "битовый набор", а с другой:

Но вот вопрос, это что такое получается? Перед любой арифметической операцией сначала идет проверка: А не с NaN'ом ли мы работаем? Не влияет ли это на скорость вычислений?

И что значит, как пользоваться? Нужна Вам бесконечность в расчётах - пользуйтесь. Смотрите мой пост №10. Не понимаю, что Вы хотите...

[Sibedir]

Да где же взаимоисключени. Я в посте #6 как раз и воспользовался этим битовым набором иным способом, нежели описано в Math.

{ The following constants should not be used for comparison, only  
    assignments. For comparison please use the IsNan and IsInfinity functions  
    provided below. }

Не понимаю, что Вы хотите...

Услышать ответ на вопрос

Сообщение от Sibedir

Но вот вопрос, это что такое получается? Перед любой арифметической операцией сначала идет проверка: А не с NaN'ом ли мы работаем? Не влияет ли это на скорость вычислений?

Так это или нет.

[B_N]

Вот еще:

	double d = 1;
00411D1E  fld         qword ptr [__real@3ff0000000000000 (42B030h)] 
00411D24  fstp        qword ptr [d] 
	d /= 0;			// 00 00 00 00 00 00 f0 7f
00411D27  fld         qword ptr [d] 
00411D2A  fdiv        qword ptr [__real@0000000000000000 (42B528h)] 
00411D30  fstp        qword ptr [d] 
	d -= 1;
00411D33  fld         qword ptr [d] 
00411D36  fsub        qword ptr [__real@3ff0000000000000 (42B030h)] 
00411D3C  fstp        qword ptr [d] 
// после этого - опять бесконечность

Какая проверка? Если число стало бесконечным, так бесконечным и останется, на уровне аппаратуры, при чем здесь скорость вычислений?

[B_N]

Ответ простой - операции над
"нормальными" числами если и замедлены сравнением с бесконечностями, то это мы вряд ли узнаем и наверняка не сможем поменять, остается доверять инженерам Intel'а. Но операции над самими бесконечностями заметно медленнее (подчеркиваю - именно, если один из операндов - бесконечность).

С:

#include <stdlib.h>
#include <stdio.h>
#include <windows.h>

int main()
{
	const unsigned long Iterations = 10000000;

	unsigned long i;
	double X;
	DWORD dw1, dw2;

	double f = 1; f /= 0;			// 00 00 00 00 00 00 f0 7f - Infinity
	unsigned long NotANumber[2]={0xffffffff, 0x7fffffff};
	double NaN = *( double* )NotANumber;
	double Infinity = f;
	

	f = Infinity;
	printf("Counting %d of operations on: %f\n", Iterations, f);
	dw1 = GetTickCount();
	for(i = 0; i < Iterations; i++)
	{
		X = f - 1e1;
	}
	dw2 = GetTickCount();
	printf("Time elapsed: %d ticks, X=%f\n\n", dw2 - dw1, X);

	f = 1e10;
	
	printf("Counting %d of operations on: %f\n", Iterations, f);
	dw1 = GetTickCount();
	for(i = 0; i < Iterations; i++)
	{
		X = f - 1e1;
	}
	dw2 = GetTickCount();
	printf("Time elapsed: %d ticks, X=%f\n\n", dw2 - dw1, X);


	f = NaN;
	printf("Counting %d of operations on: %f\n", Iterations, f);
	dw1 = GetTickCount();
	for(i = 0; i < Iterations; i++)
	{
		X = f - 1e1;
	}
	dw2 = GetTickCount();
	printf("Time elapsed: %d ticks, X=%f\n\n", dw2 - dw1, X);

	return 0;
}

Результат

Counting 100000000 of operations on: 1.#INF00
Time elapsed: 24615 ticks, X=1.#INF00

Counting 100000000 of operations on: 10000000000.000000
Time elapsed: 1562 ticks, X=9999999990.000000

Counting 100000000 of operations on: 1.#QNAN0
Time elapsed: 23735 ticks, X=1.#QNAN0

Фортран:

		IMPLICIT NONE 

		INTEGER*8 :: I, ITERATIONS = 100000000
		REAL*10 :: F = 1, X
		INTEGER*4 TIMER1, TIMER2

		F = F / 0										! Так - МОЖНО! - F - вещественное


		PRINT *, "COUNTING ", ITERATIONS, " OF OPERATIONS ON ", F

		CALL SYSTEM_CLOCK(TIMER1)
		DO I = 1, ITERATIONS
			X = F - 1
		END DO 
		CALL SYSTEM_CLOCK(TIMER2)

		PRINT *,"TIME ELAPSED:", TIMER2 - TIMER1, " TICKS, X=", X
		PRINT *, ''

		F = 1E10

		PRINT *, "COUNTING ", ITERATIONS, " OF OPERATIONS ON ", F

		CALL SYSTEM_CLOCK(TIMER1)
		DO I = 1, ITERATIONS
			X = F - 1E1
		END DO 
		CALL SYSTEM_CLOCK(TIMER2)

		PRINT *,"TIME ELAPSED:", TIMER2 - TIMER1, " TICKS, X=", X
		PRINT *, ""

		END

Результат:

COUNTING 100000000 OF OPERATIONS ON +Infinity
TIME ELAPSED: 25096 TICKS, X= +Infinity

COUNTING 100000000 OF OPERATIONS ON 10000000000.0000000000
TIME ELAPSED: 3225 TICKS, X= 9999999990.0000000000

Ну а Дельфи нету.

А операции над целыми числами разумеется быстрее, чем над вещественными. Примерно раз в 8-10.
------------------
Не совсем удачно выразился - работа с вещественными числами медленнее "напрямую". При аппартной поддержке FPU скорости обработки целых (в процессоре) и вещественных (в FPU) примерно одинаковы.

[Sibedir]

Спасибо, B_N. Исчерпывающий ответ.

Ответ простой - операции над "нормальными" числами если и замедлены сравнением с бесконечностями, то это мы вряд ли узнаем и наверняка не сможем поменять, остается доверять инженерам Intel'а. Но операции над самими бесконечностями заметно медленнее (подчеркиваю - именно, если один из операндов - бесконечность).

В точку