Dicas - Arredondando números de modos diferentes

Você precisa estar logado para dar um feedback. Clique aqui para efetuar o login
Para efetuar o download você precisa estar logado. Clique aqui para efetuar o login
Confirmar voto
0
 (0)  (2)

Veja nesta dica, algumas funções para arredondamento em vários modos diferentes.

Arredondando números de modos diferentes

 

Alternativas para a função Round, inclusive arredondamento de valores não inteiros e de centenas, milhares, milhões, etc. Como poderia arredondar um número "normalmente"? Poderia arredondar as casas de milhares? Poderia arredondar o terceiro dígito depois da vírgula decimal?

Arredondamento de inteiro

A função Round que vem com Delphi executa o que é chamado "arredondamento de banqueiro", significando que um número com uma parte fracionária de valor 0,5, às vezes é arredondada “para cima” e às vezes “para abaixo”, sempre para o valor par mais próximo.

Isso quer dizer que, por exemplo, Round(3,5) resultará em um valor 4, enquanto que Round(2,5) resultará em um valor 2. A seguir, apresentamos um conjunto de funções para arredondamento de valores, inclusive a função RoundN, a qual arredonda um valor "normalmente" (i.e. RoundN(3,5) resulta em um valor 4 e RoundN(2,5) resulta em um valor 3).

 

function Sgn(X: Extended): Integer;

{ Retorna -1, 0 or 1 de acordo com o sinal do argumento }

begin
  if X < 0 then

    Result := -1

  else

    if X = 0 then

      Result := 0

    else
      Result := 1;

end;

function RoundUp(X: Extended): Extended;

{ Retorna o primeiro inteiro maior que ou igual a um

  dado número em valor absoluto (o sinal e preservado).

  RoundUp(3,3) = 4    RoundUp(-3,3) = -4 }

begin
  Result := Int(X) + Sgn(Frac(X));

end;

function RoundDn(X: Extended): Extended;

{ Retorna o primeiro inteiro menor que ou

  igual a um dado número em  valor absoluto (o sinal é preservado).

  RoundDn(3,7) = 3    RoundDn(-3,7) = -3

begin
  Result := Int(X);

end;

function RoundN(X: Extended): Extended;

{ Arredonda um número "normalmente": caso a parte de fração
  seja >= 0,5 o número será arredondado “para cima” (ver RoundUp)
  caso contrário, se a parte de fração for < 0,5, o
  número será arredondado “para baixo” (ver RoundDn).
  
RoundN(3,5) = 4     RoundN(-3,5) = -4

  RoundN(3,1) = 3     RoundN(-3,1) = -3 }

begin
  (*
  if Abs(Frac(X)) >= 0.5 then

    Result := RoundUp(X)

  else
    Result := RoundDn(X);

  *)
    Result := Int(X) + Int(Frac(X) * 2);

end;

function Fix(X: Extended): Extended;

{ Retorna o primeiro inteiro menor que ou

  igual a um dado número.

  Int(3,7) = 3          Int(-3,7) = -3

  Fix(3,7) = 3          Fix(-3,1) = -4 }

begin
  if (X >= 0) or (Frac(X) = 0) then

    Result := Int(X)

  else
    Result := Int(X) - 1;

end;

function RoundDnX(X: Extended): Extended;

{ Retorna o primeiro inteiro menor que ou

  igual a um dado número.

  RoundDnX(3,7) = 3     RoundDnX(-3,7) = -3

  RoundDnX(3,7) = 3     RoundDnX(-3,1) = -4 }

begin
  Result := Fix(X);

end;

function RoundUpX(X: Extended): Extended;

{ Retorna o primeiro inteiro maior que ou

  igual a um dado número.

  RoundUpX(3,1) = 4     RoundUpX(-3,7) = -3 }

begin
  Result := Fix(X) + Abs(Sgn(Frac(X)))

end;

function RoundX(X: Extended): Extended;

{ Arredonda o número "normalmente", porém levando em conta o sinal:
  se a parte de fração for >= 0,5, o número

  será arredondado “para cima” (ver RoundUpX)

  caso contrario, se a parte de fração for < 0,5,  

  o número será arredondado “para baixo” (ver RoundDnX).

  RoundX(3,5) = 4     RoundX(-3,5) = -3 }

begin
  (*
  if Abs(Frac(X)) >= 0,5 then

    Result := RoundUpX(X)

  else
    Result := RoundDnX(X);

  *)
    Result := Fix(X + 0.5);

end;

Arredondando para um dígito decimal

As funções acima apresentadas, sempre arredondam “para acima” até o último dígito inteiro, porém, às vezes precisamos, por exemplo, arredondar para a segunda casa decimal ou para a casa dos milhares, milhões ou bilhões. Podemos sobrecarregar a função RoundN para funcionar com essa versão, adicionando um parâmetro extra, para indicar o dígito a ser arredondado:

 

function RoundNExtend(x: Extended; d: Integer): Extended;

{ RoundN(123,456, 0) = 123,00

  RoundN(123,456, 2) = 123,46

  RoundN(123456, -3) = 123000 }

const
  t: array [0..12] of int64 = (1, 10, 100, 1000, 10000, 100000,
    1000000, 10000000, 100000000, 1000000000, 10000000000,
    100000000000, 1000000000000);

begin
  if Abs(d) > 12 then

    raise ERangeError.Create('RoundN: Value must be in -12..12');

  if d = 0 then

    Result := Int(x) + Int(Frac(x) * 2)

  else

    if d > 0 then

    begin

      x := x * t[d];

      Result := (Int(x) + Int(Frac(x) * 2)) / t[d];

    end

    else

    begin  // d < 0

      x := x / t[-d];

      Result := (Int(x) + Int(Frac(x) * 2)) * t[-d];

    end;
end;

 

 
Você precisa estar logado para dar um feedback. Clique aqui para efetuar o login
Receba nossas novidades
Ficou com alguma dúvida?