Scala Doubles, et Précision

Question

Existe-t-il une fonction permettant de tronquer ou d'arrondir un double ? À un moment donné dans mon code, je voudrais un nombre comme : 1.23456789 à arrondir à 1.23

Answer 1

Vous pouvez utiliser scala.math.BigDecimal :

BigDecimal(1.23456789).setScale(2, BigDecimal.RoundingMode.HALF_UP).toDouble

Il existe un certain nombre d'autres modes d'arrondi qui ne sont malheureusement pas très bien documentés à l'heure actuelle (bien que leurs équivalents Java sont ).

Answer 2

Voici une autre solution sans BigDecimals

Coupé :

(math floor 1.23456789 * 100) / 100

Ronde :

(math rint 1.23456789 * 100) / 100

Ou pour tout double n et toute précision p :

def truncateAt(n: Double, p: Int): Double = { val s = math pow (10, p); (math floor n * s) / s }

On peut faire de même pour la fonction d'arrondi, en utilisant cette fois-ci la curée :

def roundAt(p: Int)(n: Double): Double = { val s = math pow (10, p); (math round n * s) / s }

qui est plus réutilisable, par exemple, pour arrondir des montants d'argent, on peut utiliser ce qui suit :

def roundAt2(n: Double) = roundAt(2)(n)

Answer 3

Puisque personne n'a mentionné le % opérateur pourtant, voilà. Il ne fait que tronquer, et vous ne pouvez pas compter sur la valeur de retour pour ne pas avoir d'imprécisions en virgule flottante, mais parfois c'est pratique :

scala> 1.23456789 - (1.23456789 % 0.01)
res4: Double = 1.23

Answer 4

Edit : corrigé le problème que @ryryguy a signalé. (Merci !)

Si vous voulez que ce soit rapide, Kaito a la bonne idée. math.pow est lent, cependant. Pour toute utilisation standard, il est préférable d'utiliser une fonction récursive :

def trunc(x: Double, n: Int) = {
  def p10(n: Int, pow: Long = 10): Long = if (n==0) pow else p10(n-1,pow*10)
  if (n < 0) {
    val m = p10(-n).toDouble
    math.round(x/m) * m
  }
  else {
    val m = p10(n).toDouble
    math.round(x*m) / m
  }
}

C'est environ 10x plus rapide si vous êtes dans la gamme de Long (c'est-à-dire 18 chiffres), vous pouvez donc arrondir à n'importe quel chiffre entre 10^18 et 10^-18.

Answer 5

Récemment, j'ai rencontré un problème similaire et je l'ai résolu en utilisant l'approche suivante

def round(value: Either[Double, Float], places: Int) = {
  if (places < 0) 0
  else {
    val factor = Math.pow(10, places)
    value match {
      case Left(d) => (Math.round(d * factor) / factor)
      case Right(f) => (Math.round(f * factor) / factor)
    }
  }
}

def round(value: Double): Double = round(Left(value), 0)
def round(value: Double, places: Int): Double = round(Left(value), places)
def round(value: Float): Double = round(Right(value), 0)
def round(value: Float, places: Int): Double = round(Right(value), places)

J'ai utilisé ce Un problème. J'ai quelques fonctions surchargées pour les deux Float \Double \explicit options. Notez que, vous devez mentionner explicitement le type de retour en cas de fonctions surchargées.