8 replies to this topic

[escafandra]

Para saber el signo de un double y obtener un entero +1 ó -1, podemos usar una función como esta, usando las utilidades matemáticas:
 

cpp

#include <math.h>
int Sign(double d)
{
  if(d==0) return 0;
  if(fabs(d)+d == 0) return - 1;
  return 1;
}

Pero si no queremos o no podemos usar math.h, tenemos esta otra forma a bajo nivel:
 

cpp

int Sign(double d)
{
  if(d==0) return 0;
  DWORD* R = (DWORD*)&d + 1;
  if(*R >> 31 & 1) return -1;
  return 1;
}

Saludos.

[BDWONG]

Hola escanfandra no es lo mismo hacer esto o no entendi bien tu idea

cpp

int sign2(double d){
   if(d==0)return 0;
   else if(d<0) return -1;
   else return 1;
}

[escafandra]

Hola escanfandra no es lo mismo hacer esto o no entendi bien tu idea

cpp

int sign2(double d){
   if(d==0)return 0;
   else if(d<0) return -1;
   else return 1;
}

Si, entendiste bien la idea. Delphi tiene una función Sign de la que carece C, pero no Builder.
La verdadera idea del tema era usar la representación en bits a bajo nivel de un double para encontrar el bit que representa el signo desde una perspectiva de compilación a 32 bits pues en 64 hubiera sido más sencillo, a nivel bits.

Saludos.

[Delphius]

No recuerdo si la función Sign() en Delphi tiene una implementación a bajo nivel como la que describes. Lazarus tiene la implementación "tradicional" a base de ifs como la que expone BDWONG:

delphi

function Sign(const AValue: Double): TValueSign;inline;
begin
  If Avalue<0.0 then
    Result:=NegativeValue
  else If Avalue>0.0 then
    Result:=PositiveValue
  else
    Result:=ZeroValue;
end;

Es curioso que lo implementen así. Creería que es muchísimo más rápido y apropiado ir por bajo nivel y leer el bit en cuestión.

 

Saludos,

[escafandra]

Esta rutina va a perder poco tiempo de cálculo. Podría pensarse que los saltos condicionales de ASM pueden sustituir la localización del bit de signo, eso sería cierto enteros pero no en double en un programa compliado para 32bits. En un programa compilado para 64 bits es más directo, puesto que el signo está en el bit más significativo y double es de longitud 64.

Hay que tener en cuenta el orden de significación de bits de un procesador, Intel los tiene invertidos y mi código está basado en eso. Si queremos que el código funcione para otro tipo de procesador, quizás la opción de Lazarus es lo mejor.

Considero que la forma más rápida de encontrar el signo en los procesadores que usamos Windows, es el bajo nivel descrito.


Saludos.

[Delphius]

Ummm. Yo que sepa el tipo double ya está definido para un tamaño de bits y formato particular y éste es independiente de la arquitectura es 32 o 64 bits. Es decir el signo estará en el mismo lugar... el problema pasa que en 32bits debe cuidarse de leer "la mitad" correcta.
 
Al menos Lazarus, para funciones como IsNan mediante cláusulas de compilación evalúa si es Big-endian y procede de una forma u otra:

pascal

{$ifdef FPC_HAS_TYPE_DOUBLE}
function IsNan(const d : Double): Boolean;
  var
    fraczero, expMaximal: boolean;
  begin
{$if defined(FPC_BIG_ENDIAN) or defined(FPC_DOUBLE_HILO_SWAPPED)}
    expMaximal := ((TSplitDouble(d).cards[0] shr 20) and $7ff) = 2047;
    fraczero:= (TSplitDouble(d).cards[0] and $fffff = 0) and
                (TSplitDouble(d).cards[1] = 0);
{$else FPC_BIG_ENDIAN}
    expMaximal := ((TSplitDouble(d).cards[1] shr 20) and $7ff) = 2047;
    fraczero := (TSplitDouble(d).cards[1] and $fffff = 0) and
                (TSplitDouble(d).cards[0] = 0);
{$endif FPC_BIG_ENDIAN}
    Result:=expMaximal and not(fraczero);
  end;
{$endif FPC_HAS_TYPE_DOUBLE}

Saludos,

[escafandra]

Ummm. Yo que sepa el tipo double ya está definido para un tamaño de bits y formato particular y éste es independiente de la arquitectura es 32 o 64 bits. Es decir el signo estará en el mismo lugar... el problema pasa que en 32bits debe cuidarse de leer "la mitad" correcta.

Ese es el tema, su estructura está bien definida pero sabes que los microprocesadores no interpretan el mismo orden de bits a bajo nivel. Es por eso, y dices bien, que debes encontrar la mitad correcta.

 

 

Saludos.

[cram]

Para saber el signo de un double y obtener un entero +1 ó -1, podemos usar una función como esta, usando las utilidades matemáticas:
 

cpp

#include <math.h>
int Sign(double d)
{
  if(d==0) return 0;
  if(fabs(d)+d == 0) return - 1;
  return 1;
}

Pero si no queremos o no podemos usar math.h, tenemos esta otra forma a bajo nivel:
 

cpp

int Sign(double d)
{
  if(d==0) return 0;
  DWORD* R = (DWORD*)&d + 1;
  if(*R >> 31 & 1) return -1;
  return 1;
}

Saludos.

 

 

Solo por curiosidad,

Luego de la pregunta sobre si es cero hay una salida del procedimiento.

¿cómo se maneja el bit de signo para el cero?. ¿es impredecible y por eso la consulta por si es cero va al principio?

[Delphius]

Solo por curiosidad,

Luego de la pregunta sobre si es cero hay una salida del procedimiento.

¿cómo se maneja el bit de signo para el cero?. ¿es impredecible y por eso la consulta por si es cero va al principio?

 

Según la norme IEEE el cero es un caso especial. Y tiene dos posibles valores: +0.0 y -0.0, que para la norma tiene un valor a nivel de bits conocido. Y como dice el compañero Escafandra, hay que tener cuidado si hay que leerlo según si es 32bits o 64bits.

Si tienes activada la palabra de control para detectar el caso puedes capturar e identificar que zero se ha dado. Por lo general los compiladores por defecto detectan el cero indistintamente y lo asumen como positivo y en la mayoría de los casos no hace falta evaluar esto. En la mayoría de los casos basta con emplear la función IsZero() que viene en la unidad Math que se encarga de aplicar un valor Absoluto y de esa forma el -0.0 se transforma en 0.0. Opcionalmente IsZero() puede recibir el valor de tolerancia en error absoluto para considerar cuando un número sea cero. Por defecto es 1E-12 para el tipo double, 1E-4 para single y para extended 1E-16:

delphi

function IsZero(const A: Double; Epsilon: Double): Boolean;
begin
  if (Epsilon=0) then
    Epsilon:=DZeroResolution;
  Result:=Abs(A)<=Epsilon;
end;

Como puedes ver en el código no hace las cosas a bajo nivel. De esta forma evita lidiar con los problemas de arquitectura y deja que la magia del compilador haga el trabajo de interpretar el valor.

 

El sitio de Efg tiene un buen material para entender todo sobre los números especiales en Delphi. No tiene desperdicio.

 

Saludos,