List [Int] => Int没有字符串转换？

Question

I came up with the following to convert a List[Int] => Try[BigDecimal] :

import scala.util.Try

def f(xs: List[Int]): Try[BigDecimal] =
  Try { xs.mkString.toInt }.map ( BigDecimal(_) )

Example:

scala> f(List(1,2,3,4))
res4: scala.util.Try[BigDecimal] = Success(1234)

scala> f(List(1,2,3,55555))
res5: scala.util.Try[BigDecimal] = Success(12355555)

Is there a way to write this function without resorting to a String conversion step?

Answer 1

Not very pretty, and I'm not convinced it's much more efficient. Here's the basic outline.

val pwrs:Stream[BigInt] = 10 #:: pwrs.map(_ * 10)
List(1,2,3,55555).foldLeft(0:BigInt)((p,i) => pwrs.find(_ > i).get * p + i)

Here it is a little more fleshed out with error handling.

import scala.util.Try
def f(xs: List[Int]): Try[BigDecimal] = Try {

  lazy val pwrs: Stream[BigDecimal] = 10 #:: pwrs.map(_ * 10)
  xs.foldLeft(0: BigDecimal) {
    case (acc, i) if i >= 0 => pwrs.find(_ > i).get * acc + i
    case _ => throw new Error("bad")
  }
}

---

UPDATE

Just for giggles, I thought I'd plug some code into Rex Kerr's handy benchmarking/profiling tool, Thyme .

the code

import scala.util.Try

def fString(xs: List[Int]): Try[BigInt] = Try { BigInt(xs.mkString) }

def fStream(xs: List[Int]): Try[BigInt] = Try {
  lazy val pwrs: Stream[BigInt] = 10 #:: pwrs.map(_ * 10)
  xs.foldLeft(0: BigInt) {
    case (acc, i) if i >= 0 => pwrs.find(_ > i).get * acc + i
    case _ => throw new Error("bad")
  }
}

def fLog10(xs: List[Int]): Try[BigInt] = Try {
  xs.foldLeft(0: BigInt) {
    case (acc, i) if i >= 0 =>
      math.pow(10, math.ceil(math.log10(i))).toInt * acc + i
    case _ => throw new Error("bad")
  }
}

fString() is a slight simplification of Kevin's original question. fStream() is my proposed non-string implementation. fLog10 is the same but with Alexey's suggested enhancement.

You'll note that I'm using BigInt instead of BigDecimal . I found that both non-string methods encountered a bug somewhere around the 37th digit of the result. Some kind of rounding error or something, but there was no problem with BigInt so that's what I used.

test setup

// create a List of 40 Ints and check its contents
val lst = List.fill(40)(util.Random.nextInt(20000))
lst.min              // 5
lst.max              // 19858
lst.mkString.length  // 170

val th = ichi.bench.Thyme.warmed(verbose = print)
th.pbenchWarm(th.Warm(fString(lst)), title="fString")
th.pbenchWarm(th.Warm(fStream(lst)), title="fStream")
th.pbenchWarm(th.Warm(fLog10(lst)),  title="fLog10")

results

Benchmark for fString (20 calls in 345.6 ms) Time: 4.015 us 95% CI 3.957 us - 4.073 us (n=19) Garbage: 109.9 ns (n=2 sweeps measured)

Benchmark for fStream (20 calls in 305.6 ms) Time: 7.118 us 95% CI 7.024 us - 7.213 us (n=19) Garbage: 293.0 ns (n=3 sweeps measured)

Benchmark for fLog10 (20 calls in 382.8 ms) Time: 9.205 us 95% CI 9.187 us - 9.222 us (n=17) Garbage: 73.24 ns (n=2 sweeps measured)

So I was right about the efficiency of the non-string algorithm. Oddly, using math._ to avoid Stream creation doesn't appear to be better. I didn't expect that.

takeaway

Number-to-string and string-to-number transitions are reasonably efficient.

Answer 2

import scala.util.{Try, Success}
import scala.annotation.tailrec

def findOrder(i: Int): Long = {
  @tailrec
  def _findOrder(i: Int, order: Long): Long = {
    if (i < order) order
    else _findOrder(i, order * 10)
  }
  _findOrder(i, 1)
}

def f(xs: List[Int]): Try[BigDecimal] = Try(
  xs.foldLeft(BigDecimal(0))((acc, i) => acc * findOrder(i) + i)
)

Answer 3

To find the correct power of 10 more efficiently (replace pwrs.find(_ > i).get with nextPowerOf10(i) in @jwvh's answer):

def nextPowerOf10(x: Int) = {
  val n = math.ceil(math.log10(x))
  BigDecimal(math.pow(10, n))
}

Since you start with an Int , there should be no rounding issues.