public   float  roundTo( float  number)
{
     if (number== 13 .5465f)
    {
         return   13 .547f;
    }
     if (number== 13 .5461f)
    {
         return   13 .546f;
    }
     return   0 .0f;
}

     public   static   void  main(String[] args)
    {
        test =  new  BigDecimal("13.5465");
        test = test.setScale( 3 , BigDecimal.ROUND_HALF_UP);
        System.out.println("TEST: "+test);
    }

 import  java.text.*;
 public   class  Decimal {
    public   static   void  main(String[] args) {
       double  d =  1 . 2345 ;
      NumberFormat nf = NumberFormat.getNumberInstance();
      nf.setMaximumFractionDigits( 3 );
      String s = nf.format(d);
      System.out.println(s);
   }
}
  

    /**
     * Translates a <code>double</code> into a BigDecimal.  The scale
     * of the BigDecimal is the smallest value such that
     * <tt>(10<sup>scale</sup> * val)</tt> is an integer.
     * <p>
     * Note: the results of this constructor can be somewhat unpredictable.
     * One might assume that <tt>new BigDecimal(.1)</tt> is exactly equal
     * to .1, but it is actually equal
     * to .1000000000000000055511151231257827021181583404541015625.
     * This is so because .1 cannot be represented exactly as a double
     * (or, for that matter, as a binary fraction of any finite length).
     * Thus, the long value that is being passed <i>in</i> to the constructor 
     * is not exactly equal to .1, appearances notwithstanding.
     * <p>
     * The (String) constructor, on the other hand, is perfectly predictable:
     * <tt>new BigDecimal(".1")</tt> is <i>exactly</i> equal to .1, as one
     * would expect.  Therefore, it is generally recommended that the (String)
     * constructor be used in preference to this one.
     *
     * @param val <code>double</code> value to be converted to BigDecimal.
     * @throws NumberFormatException <tt>val</tt> if <tt>val</tt> is
     *         infinite or NaN.
     */
     public  BigDecimal( double  val) {
	 if  ( Double .isInfinite(val) ||  Double .isNaN(val))
	     throw   new  NumberFormatException("Infinite or NaN");

	/*
	 * Translate the double into sign, exponent and mantissa, according
	 * to the formulae in JLS, Section 20.10.22.
	 */
	 long  valBits =  Double .doubleToLongBits(val);
	 int  sign = ((valBits >>  63 )== 0  ?  1  : - 1 );
	 int  exponent = ( int ) ((valBits >>  52 ) & 0x7ffL);
	 long  mantissa = (exponent== 0  ? (valBits & ((1L<< 52 ) -  1 )) <<  1 
				     : (valBits & ((1L<< 52 ) -  1 )) | (1L<< 52 ));
	exponent -=  1075 ;
	/* At this point, val == sign * mantissa * 2**exponent */

	/*
	 * Special case zero to to supress nonterminating normalization
	 * and bogus scale calculation.
	 */
	 if  (mantissa ==  0 ) {
	    intVal = BigInteger.ZERO;
	     return ;
	}

	/* Normalize */
	 while ((mantissa &  1 ) ==  0 ) {    /*  i.e., Mantissa is even */
	    mantissa >>=  1 ;
	    exponent++;
	}

	/* Calculate intVal and scale */
	intVal = BigInteger.valueOf(sign*mantissa);
	 if  (exponent <  0 ) {
	    intVal = intVal.multiply(BigInteger.valueOf( 5 ).pow(-exponent));
	    scale = -exponent;
	}  else   if  (exponent >  0 ) {
	    intVal = intVal.multiply(BigInteger.valueOf( 2 ).pow(exponent));
	}
    }

* The (String) constructor, on the other hand, is perfectly predictable:
* <tt>new BigDecimal(".1")</tt> is <i>exactly</i> equal to .1, as one
* would expect.  Therefore, it is generally recommended that the (String)
* constructor be used in preference to this one.

Так что, andy_h, могу посоветовать вам преобразовывать double-значения в String-значения.