Scala Doubles und Präzision

Gibt es eine Funktion, die ein Double abschneiden oder runden kann? An einer Stelle in meinem Code möchte ich eine Zahl wie: 1.23456789gerundet werden1.23

Sie können verwenden scala.math.BigDecimal:

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

Es gibt eine Reihe anderer Rundungsmodi , die derzeit leider nicht sehr gut dokumentiert sind (obwohl dies ihre Java-Entsprechungen sind ).

Hier ist eine andere Lösung ohne BigDecimals

Kürzen:

(math floor 1.23456789 * 100) / 100

Runden:

(math rint 1.23456789 * 100) / 100

Oder für jedes doppelte n und jede Genauigkeit p:

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

Ähnliches gilt für die Rundungsfunktion, diesmal mit Currying:

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

Das ist wiederverwendbarer, z. B. wenn Geldbeträge gerundet werden, könnte Folgendes verwendet werden:

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

Da noch niemand den %Betreiber erwähnt hat, kommt hier. Es wird nur abgeschnitten, und Sie können sich nicht darauf verlassen, dass der Rückgabewert keine Gleitkomma-Ungenauigkeiten aufweist, aber manchmal ist es praktisch:

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

Wie wäre es mit :

 val value = 1.4142135623730951

//3 decimal places
println((value * 1000).round / 1000.toDouble)

//4 decimal places
println((value * 10000).round / 10000.toDouble)

Bearbeiten: Das Problem, auf das @ryryguy hingewiesen hat, wurde behoben. (Vielen Dank!)

Wenn Sie möchten, dass es schnell geht, hat Kaito die richtige Idee. math.powist jedoch langsam. Für jede Standardanwendung sind Sie mit einer rekursiven Funktion besser dran:

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
  }
}

Dies ist ungefähr 10x schneller, wenn Sie sich im Bereich von Long(dh 18 Stellen) befinden, sodass Sie zwischen 10 ^ 18 und 10 ^ -18 runden können.

Sie können implizite Klassen verwenden:

import scala.math._

object ExtNumber extends App {
  implicit class ExtendedDouble(n: Double) {
    def rounded(x: Int) = {
      val w = pow(10, x)
      (n * w).toLong.toDouble / w
    }
  }

  // usage
  val a = 1.23456789
  println(a.rounded(2))
}

Für diejenigen, die interessiert sind, hier einige Zeiten für die vorgeschlagenen Lösungen ...

Rounding
Java Formatter: Elapsed Time: 105
Scala Formatter: Elapsed Time: 167
BigDecimal Formatter: Elapsed Time: 27

Truncation
Scala custom Formatter: Elapsed Time: 3 

Das Abschneiden ist am schnellsten, gefolgt von BigDecimal. Beachten Sie, dass diese Tests mit der Ausführung von Norma Scala ohne Verwendung von Benchmarking-Tools durchgeführt wurden.

object TestFormatters {

  val r = scala.util.Random

  def textFormatter(x: Double) = new java.text.DecimalFormat("0.##").format(x)

  def scalaFormatter(x: Double) = "$pi%1.2f".format(x)

  def bigDecimalFormatter(x: Double) = BigDecimal(x).setScale(2, BigDecimal.RoundingMode.HALF_UP).toDouble

  def scalaCustom(x: Double) = {
    val roundBy = 2
    val w = math.pow(10, roundBy)
    (x * w).toLong.toDouble / w
  }

  def timed(f: => Unit) = {
    val start = System.currentTimeMillis()
    f
    val end = System.currentTimeMillis()
    println("Elapsed Time: " + (end - start))
  }

  def main(args: Array[String]): Unit = {

    print("Java Formatter: ")
    val iters = 10000
    timed {
      (0 until iters) foreach { _ =>
        textFormatter(r.nextDouble())
      }
    }

    print("Scala Formatter: ")
    timed {
      (0 until iters) foreach { _ =>
        scalaFormatter(r.nextDouble())
      }
    }

    print("BigDecimal Formatter: ")
    timed {
      (0 until iters) foreach { _ =>
        bigDecimalFormatter(r.nextDouble())
      }
    }

    print("Scala custom Formatter (truncation): ")
    timed {
      (0 until iters) foreach { _ =>
        scalaCustom(r.nextDouble())
      }
    }
  }

}

Vor kurzem hatte ich ein ähnliches Problem und habe es mit dem folgenden Ansatz gelöst

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)

Ich habe dieses SO-Problem verwendet. Ich habe einige überladene Funktionen für Float \ Double und implizite \ explizite Optionen. Beachten Sie, dass Sie bei überladenen Funktionen den Rückgabetyp explizit angeben müssen.

Die Verwendung des Scala- fInterpolators ist sehr einfach - https://docs.scala-lang.org/overviews/core/string-interpolation.html

Angenommen, wir möchten auf 2 Dezimalstellen runden:

scala> val sum = 1 + 1/4D + 1/7D + 1/10D + 1/13D
sum: Double = 1.5697802197802198

scala> println(f"$sum%1.2f")
1.57

Ich würde BigDecimal nicht verwenden, wenn Sie Wert auf Leistung legen. BigDecimal konvertiert Zahlen in Zeichenfolgen und analysiert sie dann erneut:

  /** Constructs a `BigDecimal` using the decimal text representation of `Double` value `d`, rounding if necessary. */
  def decimal(d: Double, mc: MathContext): BigDecimal = new BigDecimal(new BigDec(java.lang.Double.toString(d), mc), mc)

Ich werde mich an mathematische Manipulationen halten, wie Kaito vorgeschlagen hat.

Ein bisschen seltsam, aber nett. Ich benutze String und nicht BigDecimal

def round(x: Double)(p: Int): Double = {
    var A = x.toString().split('.')
    (A(0) + "." + A(1).substring(0, if (p > A(1).length()) A(1).length() else p)).toDouble
}

Sie können Math.round(<double precision value> * 100.0) / 100.0 Folgendes tun: Aber Math.round ist am schnellsten, bricht jedoch in Eckfällen mit einer sehr hohen Anzahl von Dezimalstellen (z. B. rund (1000.0d, 17)) oder einem großen ganzzahligen Teil (z. B. rund (90080070060.1d, 9) schlecht zusammen. ).

Verwenden Sie Bigdecimal, es ist etwas ineffizient, da es die Werte in Zeichenfolgen konvertiert, aber mehr Erleichterung: BigDecimal(<value>).setScale(<places>, RoundingMode.HALF_UP).doubleValue() Verwenden Sie den Rundungsmodus.

Wenn Sie neugierig sind und mehr darüber erfahren möchten, warum dies geschieht, können Sie Folgendes lesen: