Neil Sarnek, Robert Tarjan, “Planar Point Location using persistent trees”

and

James Driscoll, Daniel Sleator, Robert Tarjan “Making data structures persistent”

… hopefully with some insight.

A higher branching factor (such as is used in Vector) might be interesting to explore, but I don’t think it would help too much. In fact, I think it would hinder performance. For one thing, you would *have* to use a tree structure rather than a trie (otherwise range matches are still linear time). Also, bumping up the branching factor makes it much more complicated to just select out your sub-tree. You would have to trim nodes as well as trees, and that gets to be quite inefficient.

// for N=50000
t2-t1 = 1226 ms
t5-t3 = 6 ms
t8-t6 = 159 ms

// for N=100000
t2-t1 = 2688 m
t5-t3 = 12 ms
t8-t6 = 317 ms

// for N=200000
t2-t1 = 6155 ms
t5-t3 = 20 ms
t8-t6 = 603 ms

case class Span( start: Long, stop: Long );
case class Lala( name: String, span: Span );

var t_start = new scala.collection.immutable.TreeMap[ Long, Lala ]()
var t_stop = new scala.collection.immutable.TreeMap[ Long, Lala ]()

val rand = new java.util.Random

(1 to 1000).foreach { i =>
val start = rand.nextInt( 400000 )
val stop = start + rand.nextInt( 400000 )
val span = Span( start, stop )
val lala = Lala( String.valueOf( i ), span )
t_start = t_start.update( span.start, lala )
t_stop = t_stop.update( span.stop, lala )
}

val search = Span( 100000, 200000 )

val coll1 = t_start from search.start
val coll2 = t_stop until search.stop

val c1vals = coll1.values
val c1valSet = new scala.collection.mutable.HashSet[ Lala ]
c1valSet ++= c1vals

val result = coll2.filter { e => c1valSet.contains( e._2 )}

i understand i can use tuples as keys. but they won’t solve the two problems
- duplicate keys
- range searches for boundaries

while i can imagine solving the first problem by using a Map[ Span, Seq[ Object ]], the second problem seems impossible to do with the normal tree / vector: if any object is defined by its Span( , ), how would i query for example

“give me all objects that intersect with Span( 10000, 40000 )” ?

if i’m not wrong this requires a two-dimensional tree… or do you see another solution? thanks again!

Map[(A, B), C]

thanks for the fast reply, and thanks for the hint to TreeMap. in fact, i only understand the conception of scala.collection.immutable after reading your article – coming from the java world, i had always thought that that package is just creating read-only objects like java.util.Collections.unmodifiable(List|Map|…) !

TreeMap however doesn’t work in my case due to two things:
- all range operations are 1-dimensional, where i need two-dimensional keys
(like a (start, stop) tuple)
- i cannot insert two elements at the same key

i just realize the second issue is also true for the Vector class ;-( and i guess it’s a lot of work to modify it so that it accepts duplicate keys. (there is a trick however i read in a paper – you can store a proxy value for a key that points to more than one value, the proxy value contains a list of all objects stored under that key). however that introduces a new problem for the generics. i guess i will need to have a wrapper class to handle that.

TreeMap uses Tree to implement an essentially Red-Black tree structure.

Hmm, I’m not sure I understand completely what you’re trying to do, but I can definately help you with a log(n) efficient Map! What you want is a functional, balanced binary search tree. Traditionally, most languages use an immutable Red-Black tree for this case, but Scala actually has an even faster implementation: scala.collection.immutable.Tree. This structure guarantees O(log(n)) for all operations.

It’s actually possible to do a little better though. Clojure has a persistent hash map based on Bagwell’s ideal hash tries which is able to claim O(log32(n)) for all operations. This is actually even a little better than conventional mutable bucket hashing which has an absolute worse-case O(log(n)) (when everything hashes to the same bucket). I haven’t had the chance to port Clojure’s hash map to Scala yet, but I’m working on it! This persistent hash map is very similar in design to the persistent vector (they’re both based on the same structural concept).