Obtener un número positivo o negativo.
 

En una tabla guardo abonos y cargos los abonos tienen que ser negativos y los cargos positivos. El objeto es que al facturar cargue o abone dichas cantidades.

El propósito es, independientemente de la buena voluntad del usuario que los bultos y unidades sean positivas o negativas dependiendo de lo explicado anteriormente.

Código Delphi [-]
//Empece así:
procedure TDmAbon.IBDtsAbonBeforePost(DataSet: TDataSet);
begin
 if Es_Abono = True then
 begin
 DmAbon.IBDtsAbonBULTOS.AsFloat  :=Sqr(Power(DmAbon.IBDtsAbonBULTOS.Value,2))*-1;
 DmAbon.IBDtsAbonUNIDADES.AsFloat:=Sqr(Power(DmAbon.IBDtsAbonUNIDADES.Value,2))*-1;
 end
 else
 begin
 DmAbon.IBDtsAbonBULTOS.AsFloat  :=Sqr(Power(DmAbon.IBDtsAbonBULTOS.Value,2));
 DmAbon.IBDtsAbonUNIDADES.AsFloat:=Sqr(Power(DmAbon.IBDtsAbonUNIDADES.Value,2));
 end;

end;


//Lo remedé así:

procedure TDmAbon.IBDtsAbonBeforePost(DataSet: TDataSet);
begin
 if Es_Abono = True then
 begin
 DmAbon.IBDtsAbonBULTOS.AsInteger  :=ABS(DmAbon.IBDtsAbonBULTOS.Value)*-1;
 DmAbon.IBDtsAbonUNIDADES.AsInteger:=ABS(DmAbon.IBDtsAbonUNIDADES.Value)*-1;
 end
 else
 begin
 DmAbon.IBDtsAbonBULTOS.AsInteger  :=ABS(DmAbon.IBDtsAbonBULTOS.Value);
 DmAbon.IBDtsAbonUNIDADES.AsInteger:=ABS(DmAbon.IBDtsAbonUNIDADES.Value);
 end;

end;

Alguna otra idea?

Un Saludo.

La solución de calcular el valor absoluto y luego multiplicar o no por -1 me parece la más cómoda. No sé si sería más eficiente comprobar los valores:

Código Delphi [-]
  IF ValorPositivo < 0 THEN
    ValorPositivo := ValorPositivo * (-1);
  IF ValorNegativo > 0 THEN
    ValorNegativo := ValorNegativo * (-1);

Vamos, que no sé cómo está implementado "ABS", porque si el compilador la expande como hace, por ejemplo, con INC y DEC entonces creo que da lo mismo, casi.

Gracias Ñuño, creo que lo dejaré tal como está. Que conste que antes de hacer cosas como está pronuncio internamente "la polvora la inventaron los chinos...".

Un Saludo.

Hola,
Creo que lo más adecuado es irse por el valor absoluto. Supuestamente ya está optimizada esta función y debería hacer uso de la instrucción ABS y/o FABS en assembler que justamente lo único que hacen es alterar el campo de signo. ;)

La ventaja del uso del valor absoluto es que no interesa si se ingresa positivo o negativo... siempre se obtiene el "lado positivo" y lo que nos resta por hacer es multiplicarlo por -1 en caso de ser necesario (que es más que evidente que solo aplica para cuando se requiere de los negativos) y no se necesita de hacer evaluaciones previas, como la que sugiere Nuño. Añadir un IF equivale a añadir un V(G) = 2. Dos IFs, son V(G) = 4. A mi humilde ver, me parece algo exagerado contar con una V(G) de 4 sólo para generar positivos y/o negativos.

Cuanto mucho me podría preguntar si da lo mismo hacer:

Código Delphi [-]
Negativo := - Abs(Valor);

Que:

Código Delphi [-]
Negativo := Abs(Valor) * -1;

Saludos,

También podrías evitar el condicional:

Código Delphi [-]
DmAbon.IBDtsAbonBULTOS.AsInteger   := (2*Integer(EsAbono) - 1)*ABS(DmAbon.IBDtsAbonBULTOS.Value);
DmAbon.IBDtsAbonUNIDADES.AsInteger := (2*Integer(EsAbono) - 1)*ABS(DmAbon.IBDtsAbonUNIDADES.Value);

// Saludos

Hola,
tambien podrias asignar directamente el bit de paridad con un or (no recuerdo cual es) aunque supongo que es lo que debe hacer abs o algo bastante parecido.
Saludos.

Yo también optaría por una solución como la de Román, dándole simetría aritmética al condicionante Boolean. Pero a esa variable le daría un significado positivo, es decir, la llamaría EsCargo (que de hecho es el sentido que adquiere el código de Román). :)

Saludos.

Je, je. Me equivoqué. Sería así:

Código Delphi [-]
DmAbon.IBDtsAbonBULTOS.AsInteger   := (-2*Integer(EsAbono) + 1)*ABS(DmAbon.IBDtsAbonBULTOS.Value);
DmAbon.IBDtsAbonUNIDADES.AsInteger := (-2*Integer(EsAbono) + 1)*ABS(DmAbon.IBDtsAbonUNIDADES.Value);

Por otro lado, también podría optarse por crear disparadores before insert y before update para asegurar las signaturas correctas en la base.

// Saludos

Me gusta la solución de Román, gracias también al resto que me habeis dado pautas interesantes.

Decir que Es_Cargo es una variable de tipo Boolean que le paso desde el menú y que se analiza en el evento de apertura del formulario para saber cual de las dos opciones se está ejecutando.


Por otra parte como veis el código va en el evento:

Código Delphi [-]
procedure TDmAbon.IBDtsAbonBeforePost(DataSet: TDataSet);
begin

Para que cada vez que se ejecute algún cambio en los datos se actualice el valor.

Un Saludo.

No exactamente. En las computadoras binarias modernas, para obtener el negativo de un entero hay calcular el su complemento binario, de esta forma:

Código Delphi [-]
FUNCTION Complemento (Valor: INTEGER): INTEGER;
BEGIN
  RESULT := (NOT Valor) + 1;
END;

Por ejemplo, para el -3:
Esto mantiene la coherencia matemática:
Incluso con el cero:

Hola,
A ver Nuño, la verdad es que me matas con tu explicación. Entiendo lo que dices, y pareciera ser bastante coherente. Pero que yo sepa hay un estándar en como se guardan los números. Este estándar establece un formato adecuado, y casualmente se destina un campo para indicar si el número es positivo o negativo, parecido al formato que se ha definido para los números flotantes. La diferencia respecto a éste es que no posee campos para exponentes sino un campo para el número en si:

EDITO:
El estándar indica que los números negativos están expresados en complemento-2. Y resulta ser estos complementos SIEMPRE tienen un 1 en el campo destinado al signo. Las rutinas INVIERTEN este campo, y naturalmente deberá complementar el resto.

En donde si me corrijo es en haber dicho que ABS y FABS únicamente alterar el campo de signo. Pero vamos, que realizar el complemento-2 del número es una rutina más que normal para la máquina por lo que no deberíamos preocuparnos demasiado en bajarnos a estos niveles.

No nos deberíamos complicar demasiado... ya Abs() nos hace fácil la cosa.

Saludos,

Cierto, confundi el bit de paridad con el de signo, y no se bien bien si existe. Gracias por la aclaracion, Ñuño.

Pues eso: el complemente binario o "complemento a dos" es la norma más usada en la representación de números binarios con signo. Para punto flotante se usa otro método cuya base matemática es algo más obscura.