Subversion Repositories Integrator Subversion

package br.com.sl.domain.util;

import java.math.BigDecimal;
import java.math.RoundingMode;

public final class BigDecimalUtils {

    private static final BigDecimal ZERO = BigDecimal.ZERO;
   
    /**
     * Valor sentinela para representar NaN em BigDecimal.
     * (Você pode ajustar para outro número se quiser)
     */
    public static final BigDecimal BD_NAN = new BigDecimal("-999999999");

    private BigDecimalUtils() {}

    /* ============================================================
       CONVERSÕES SEGURAS
       ============================================================ */

    /**
     * Converte double em BigDecimal de forma segura.
     */
    public static BigDecimal converterDoubleEmBigDecimal(Double value) {
        return BigDecimal.valueOf(value);
    }

    /**
     * Converte String em BigDecimal de forma segura.
     * Aceita vírgula ou ponto.
     */
    public static BigDecimal converterStringEmBigDecimal(String value) {
        if (value == null || value.trim().isEmpty()) {
            return ZERO;
        }
        value = value.trim().replace(",", ".");
        return new BigDecimal(value);
    }
   
    public static BigDecimal converterIntEmBigDecimal(int valor) {
        return BigDecimal.valueOf(valor);
    }

    /**
     * Normaliza null → ZERO
     */
    public static BigDecimal n(BigDecimal value) {
        return value == null ? ZERO : value;
    }

    /* ============================================================
       OPERAÇÕES MATEMÁTICAS
       ============================================================ */

    public static BigDecimal soma(BigDecimal a, BigDecimal b) {
        return n(a).add(n(b));
    }

    public static BigDecimal subtracao(BigDecimal a, BigDecimal b) {
        return n(a).subtract(n(b));
    }

    public static BigDecimal multiplicacao(BigDecimal a, BigDecimal b) {
        return n(a).multiply(n(b));
    }

    public static BigDecimal divisao(BigDecimal a, BigDecimal b) {
        if (b == null || b.compareTo(BigDecimal.ZERO) == 0) {
            throw new ArithmeticException("Divisão por zero");
        }
        return n(a).divide(n(b), 10, RoundingMode.HALF_UP);
    }

    /* ============================================================
       COMPARAÇÕES
       ============================================================ */

    public static boolean ehMaiorQue(BigDecimal a, BigDecimal b) { // a > b
        return n(a).compareTo(n(b)) > 0;
    }

    public static boolean ehMenorQue(BigDecimal a, BigDecimal b) { // a < b
        return n(a).compareTo(n(b)) < 0;
    }

    public static boolean ehMaiorOuIgualQue(BigDecimal a, BigDecimal b) { // a >= b
        return n(a).compareTo(n(b)) >= 0;
    }

    public static boolean ehMenorOuIgualQue(BigDecimal a, BigDecimal b) { // a <= b
        return n(a).compareTo(n(b)) <= 0;
    }

    public static boolean ehIgual(BigDecimal a, BigDecimal b) { // a == b
        return n(a).compareTo(n(b)) == 0;
    }

    public static boolean ehDiferente(BigDecimal a, BigDecimal b) { // a != b
        return n(a).compareTo(n(b)) != 0;
    }

    /* ============================================================
       EXTENSÕES
       ============================================================ */

    /**
     * Valor absoluto.
     */
    public static BigDecimal retornarValorAbsoluto(BigDecimal a) {
        return n(a).abs();
    }

    /**
     * Arredonda com casas decimais.
     */
    public static BigDecimal arredondar(BigDecimal a, int casasDecimais) {
        return n(a).setScale(casasDecimais, RoundingMode.HALF_UP);
    }

    /**
     * Verifica se 'a' está entre min e max, inclusive.
     */
    public static boolean estaEntre(BigDecimal valor, BigDecimal minimo, BigDecimal maximo) {
        BigDecimal val = n(valor);
        return val.compareTo(n(minimo)) >= 0 && val.compareTo(n(maximo)) <= 0;
    }

    /* ============================================================
       MÉTODOS ESPECIALIZADOS PARA O ROBÔ
       ============================================================ */

    /**
     * Diferença absoluta (amplitude).
     */
    public static BigDecimal amplitude(BigDecimal abertura, BigDecimal fechamento) {
        return retornarValorAbsoluto(subtracao(fechamento, abertura));
    }

    /**
     * Retorna true se valor for maior que zero.
     */
    public static boolean positivo(BigDecimal a) {
        return ehMaiorQue(a, ZERO);
    }

    /**
     * Retorna true se valor for menor que zero.
     */
    public static boolean negativo(BigDecimal a) {
        return ehMenorQue(a, ZERO);
    }
   
    /**
     * Retorna o maior dos dois valores (equivalente ao Math.max).
     */
    public static BigDecimal maximo(BigDecimal a, BigDecimal b) {
        BigDecimal na = n(a);
        BigDecimal nb = n(b);
        return na.compareTo(nb) >= 0 ? na : nb;
    }

    /**
     * Retorna o menor dos dois valores (equivalente ao Math.min).
     */
    public static BigDecimal minimo(BigDecimal a, BigDecimal b) {
        BigDecimal na = n(a);
        BigDecimal nb = n(b);
        return na.compareTo(nb) <= 0 ? na : nb;
    }
       
         /* ============================================================
            SUPORTE A NaN / INFINITY
            ============================================================ */
       
         /**
          * Converte double em BigDecimal de forma segura
          * evitando NaN, -Infinity e +Infinity.
          */
         public static BigDecimal fromDouble(double value) {
             if (Double.isNaN(value) || Double.isInfinite(value)) {
                 return BD_NAN; // Valor sentinela
             }
             return BigDecimal.valueOf(value);
         }
       
         /**
          * Verifica se um BigDecimal representa um NaN lógico.
          */
         public static boolean isNaN(BigDecimal v) {
             return v != null && v.compareTo(BD_NAN) == 0;
         }
         
         
   
}