source: ether_megapoli/trunk/service/implementation/com/medias/integration/utils/Nombre.java @ 488

/**
 * Created on 24 Jan. 2007
 * @author 
 */
package com.medias.integration.utils;

import java.math.BigDecimal;

/**
 *
 * Fournit des opérations sur les nombres.
 */

public class Nombre {
    /**
     * Vérifie qu'une donnée est un entier.
     * @param nb Nombre é vérifier.
     * @return Vrai si la donnée est un entier.
     */
    public static boolean isInteger(String nb) {
        try {
            Integer.parseInt(nb);
            return true;
        } catch(NumberFormatException e) {
            return false;
        }
    }

    public static boolean isIntegerPositif(String nb) {
        try {
                if (nb.endsWith(".0")) nb = nb.replaceAll("\\.0", "");
                int integer = Integer.parseInt(nb);
            if(integer < 0) {
                return false;
            }
            return true;
        } catch(NumberFormatException nfe) {
            return false;
        }
    }
    
    /**
     * Vérifie qu'une donnée est un entier long.
     * @param nb Nombre é vérifier.
     * @return Vrai si la donnée est un entier long.
     */
    public static boolean isLong(String nb) {
        try {
            Long.parseLong(nb);
            return true;
        } catch(NumberFormatException e) {
            return false;
        }
    }
    
    /**
     * Verifie qu'une donnée est un double.
     * @param nb Nombre é vérifier.
     * @return Vrai si la donnée est un double.
     */
    public static boolean isDouble(String nb) {
        try {
            Double.parseDouble(nb.replaceAll(",", "."));
            return true;
        } catch(NumberFormatException e) {
            return false;
        }
    }

    /**
     * Verifie qu'un double est positif
     * @param nb Nombre é vérifier.
     * @return Vrai si la donnée est dans l'intervalle.
     */
    public static boolean isDoublePositif(String nb) {
        try {
            double temp = new Double(nb.replaceAll(",", ".")).doubleValue();
            if(temp < 0) {
                return false;
            }
            return true;
        } catch(NumberFormatException nfe) {
            return false;
        }
    }
    
    /**
     * Verifie qu'un double est dans un intervalle.
     * @param nb Nombre é vérifier.
     * @param min Borne inférieure de l'intervalle.
     * @param max Borne supérieure de l'intervalle.
     * @return Vrai si la donnée est dans l'intervalle.
     */
    public static boolean isDoubleInInterval(String nb, double min, double max) {
        try {
            double temp = new Double(nb.replaceAll(",", ".")).doubleValue();
            if(temp > max || temp < min) {
                return false;
            }
            return true;
        } catch(NumberFormatException nfe) {
            return false;
        }
    }

    /**
     * Transforme un chaine en double.
     * @param str Chaine é transformer.
     * @return Double généré, null si ce n'est pas un double.
     */
    public static Double getDouble(String str) {
        if(str.length() == 0 || str == null) {
            return null;
        }
        try {
            return new Double(str.replaceAll(",", "."));
        } catch(NumberFormatException e) {
            return null;
        }
    }

    /**
     * Transforme un chaine en double et le met en valeur absolue.
     * @param str Chaine é transformer.
     * @return Double en valeur absolue généré, null si ce n'est pas un double.
     */
    public static Double getAbsDouble(String str) {
        if(str.length() == 0 || str == null) {
            return null;
        }
        try {
            Double db = new Double(str.replaceAll(",", "."));
            return new Double(Math.abs(db.doubleValue()));
        } catch(NumberFormatException e) {
            return null;
        }
    }

    /**
     * Transforme un chaine en integer.
     * @param str Chaine é transformer.
     * @return Integer généré, null si ce n'est pas un integer.
     */
    public static Integer getInteger(String str) {
        if(str.length() == 0 || str == null) {
            return null;
        }
        try {
            return new Integer(str);
        } catch(NumberFormatException e) {
            return null;
        }
    }
    
    /**
     * Convertit une latitude ou longitude de Double vers Integer.
     * @param val Double  convertir.
     * @return Valeur convertie en Integer.
     */
    public static Integer latDoubleToInt(Double val) {
        return new Integer((int)((val.doubleValue() + 0.0005) * 10000.0));
    }

    /**
     * Convertit une latitude ou longitude de Integer vers Float.
     * @param val Integer  convertir.
     * @return Valeur convertie en Float.
     */
    public static Float latIntToFloat(Integer val) {
        return new Float(((val.intValue() / 10000.0) - 0.0005));
    }

    /**
     * Convertit une altitude ou une hauteur sol de Double vers Integer.
     * @param val Double  convertir.
     * @return Valeur convertie en Integer.
     */
    public static Integer altDoubleToInt(Double val) {
        return new Integer((int)((val.doubleValue() + 0.05) * 100.0));
    }

    /**
     * Convertit une altitude de Integer vers Float.
     * @param val Integer  convertir.
     * @return Valeur convertie en Float.
     */
    public static Float altIntToFloat(Integer val) {
        return new Float(((val.intValue() / 100.0) - 0.05));
    }
    
    /**
     * Convertit une température exprimée en degrés Kelvin en degrés Celsius.
     * @param val Integer  convertir.
     * @return Valeur convertie en Float.
     */
    public static Double kelvinToCelsius(Double kelvin) {
        return new Double(kelvin.doubleValue() - 273.16);
    }

    /**
     * Divise par 1000 la valeur
     */
    public static Double divMille(Double val) {
        BigDecimal bd = new BigDecimal(val.doubleValue());
        bd = bd.divide(new BigDecimal(1000),10,BigDecimal.ROUND_HALF_EVEN);
        Double d = new Double(bd.toString());
        return d;
    }
    
    /**
     * Multiplie par multi la valeur
     */
    public static Double mult(Double val,int multi) {
        BigDecimal bd = new BigDecimal(val.doubleValue());
        bd = bd.multiply(new BigDecimal(multi));
        Double d = new Double(bd.toString());
        return d;
    }
  
    public static Double mult(Double val,double multi) {
        BigDecimal bd = new BigDecimal(val.doubleValue());
        bd = bd.multiply(new BigDecimal(multi));
        Double d = new Double(bd.toString());
        return d;
    }
    
    /**
     * Convertit une altitude géopotentielle en altitude en métres
     */
    public static Double geopToAltitude(Double geop) {
        return new Double(geop.doubleValue() / 9.8);
    }

    public static Double getAbDouble(String str) {
        if(str.length() == 0 || str == null) {
            return null;
        }
        try {
            Double db = new Double(str.replaceAll("--", "."));
            return new Double(Math.abs(db.doubleValue()));
        } catch(NumberFormatException e) {
            return null;
        }
    }
}