Bring your calculations to Scala!

@MSkarsaune#DV14 #ScalaCalculations

Bring Your Calculations to:[email protected]

Kantega – Norwegian software craftsmanship since 2003

高馬丁

mailto:[email protected]


1.The Situation


• Exact representation of values within range

• Interoperable through widening conversion

Integer

float double byte short int long

Java Number Types - Integer


• Approximate representation of numeric values

• NEVER use for monetary amounts

• Interoperable with integer types through widening

conversion

Floating point Integer


Java Number Types – Floating point


• Immutable

• Calculation possible via primitives

• Interoperability through widening conversion

Floating point Integer Number

Float Double Byte Short Integer Long BigInteger BigDecimal


boxingunboxin

g

Java Number Types - Boxed


• To represent large numbers

• Calculations with methods

• Cumbersome conversions

“Infinite”Floating point Integer Number

Float Double Byte Short Integer Long BigInteger BigDecimal


Java Object Number - Extended

Poor

interoperabilit

y


2. Inspiration


Smalltalk calculations

Numbers are objects

Binary message selectors (+, -, *, / , ….)

Built in decimals

Overflows handled

Precise division

Interoperable and extendable number types


The Hope


Main Scala language number types

AnyVal

Double Int Long

ScalaNumber

BigDecimal BigInt


1. Decimal Numbers


Decimal representation

• Integer value and scale

• 123456789

• Scale is important! Know your scale!

Scale = 3

1234567891000


Decimal notation

• Smalltalk: 2.5s2

• Java: new BigDecimal("2.50")

new BigDecimal(2.5).setScale(2)

• Scala: val dec : BigDecimal = 2.50

How is this possible?


Scala Implicit Type Conversion

• Implicit type conversion

• Compiler looks for implicit function to convert source type

to target type

• Object scala.math.BigDecimal:

/** Implicit conversion from `Double` to `BigDecimal`. */

implicit def double2bigDecimal(

d: Double): BigDecimal = decimal(d)


Decimal computation

• Task multiply decimal dec by 100:

• Smalltalk: dec * 100

• Java: dec.multiply(new BigDecimal(100));

• Scala: dec * 100

What does this mean?


Infix, symbols + implicit conversion

• Special characters as method identifiers (+ , - , ∙, √, ⊂, π

…)

• Infix notation: num.*(100) <==> num * 100

• Class scala.math.BigDecimal:

• Also works: 100 * num

/** Multiplication of BigDecimals */

def * (that: BigDecimal): BigDecimal

= new BigDecimal(

this.bigDecimal.multiply(that.bigDecimal, mc), mc)


Decimal calculation summary

• Natural syntax

• Operators and literals

• Interoperable with other number types

• Withouth having to change existing number types


Spire math

• Scala calculation library:

https://github.com/non/spire

• Generic algorithms

• Extended number types, such as

• Rational

• Real

• Complex

• Macros provide additional number literal syntax



4. Overflow1_000_000 * 1_000_000 = ?

1_000_000_000_000 ?

-727_379_968


Overflow management

• Smalltalk:

Automatically converts SmallInteger <=> LargeInteger

• Java:

Libraries such as guava or Apache commons-math can

detect


(Some) Spire number types

• SafeLong detects overflows and ensures optimal

representation

ScalaNumber

SafeLong Real Rational Complex


SafeLong example

val trillion : SafeLong = 1000000000000l //SafeLongLong

val product = trillion * trillion //SafeLongBigInt

val other = product / trillion //SafeLongLong


3. Division2 / 3 = ?

0 ?

0.6666666666666666 ?

0.6666666666666667 ?

2

3?


Precise division

• Smalltalk: 3 / 3 = 1

2 / 3 =2

3* 3 = 2


(Some) Spire number types

• Real ensures exact division and always chooses the

most precise representation

ScalaNumber

SafeLong Real Rational Complex


Real example

val numerator: Real = 2 //Real$Exact(2)

val fraction = numerator / 3 //Real$Exact(2/3)

fraction * 3 //Real$Exact(2)

fraction * Real.pi

//Real$Inexact(2.0943951023931954923084289221863352561314)


Some conversion code of our own

….final class DoubleSyntax(val value : Double) {

def scaled(scale : Int) = BigDecimal(value).setScale(scale)

def i = Complex(0.0, value)

}

object DoubleSyntax {

implicit def doubleToDoubleConverter(value : Double) =

new DoubleSyntax(value)

}


… that allows us to write

val dec : BigDecimal = 2.50

val dec = 2.5 scaled 2 // BigDecimal(2.50) “2.5s2”

val complex = -1.0 + 1.0.i // Complex(-1.0, 1.0)


Conclusion

• Scala brings

• Natural syntax: special characters + infix notation

• Extendability and interoperability: implicit type conversions

• Possible improvements (as demonstrated by spire math)

• New number types

• New calculations


References

http://www.scala-lang.org/

Spire:


Sample code:

https://github.com/skarsaune/devoxx.scala.calculations

http://www.scala-lang.org/


https://github.com/skarsaune/devoxx.scala.calculations


Thank you for your time

Software

Bring your calculations to Scala!