Date post: | 21-Dec-2015 |
Category: |
Documents |
View: | 215 times |
Download: | 0 times |
TeachingTeaching Geometric Algorithms Geometric Algorithms to Gracefully to Gracefully “Walk”“Walk” and and “Jump”“Jump”
Kanat TangwongsanALADDIN 2005
Joint work with Umut Acar, Joint work with Umut Acar, Guy Blelloch, and Jorge Vittes.Guy Blelloch, and Jorge Vittes.
A “Simple” Problem
• The Convex Hull Problem– Given: a set S µ R 3
– Maintain: smallest convex set containing S
Input:Input: S S
Output: Output: CHCH((S)S)
A “Simple” Problem (cont.)
• The Kinetic Convex Hull Problem– points continuously moving
• Imagine making a movie!
Facts…
• Trivial solution: calculate the CH for every frame.
• Better solution? Unfortunately, no known efficient solution.
• To support only insertion/deletion is super complicated already.
• Implication: Kinetic algorithm for CH in 3D is rather HOPELESS!
...To Conserve Our Brain Cells,
we chose a different approach…
In this Talk…• Recap of the self-adjusting framework.• Our design/implementation of a kinetic
framework.– Generated the movie we see previously.
• Discuss a few applications of the framework.– Jumping ahead in time and its beneficial
consequences. – Analysis of two algorithms.
• New problems for future work.
Self-Adjusting Computation
main
f gh
k m
main
f g
h
k m
Memory
Some parts of the input changeSome parts of the input change
IdeaIdea: Record who reads what and when : Record who reads what and when
Note: Some part of the computation can be re-used by applying the memoization technique.
The Kinetic Framework
• Static Geometric Algorithm:– Input: a set S µ Rd Output: A(S)
• Goal: enable straight-forward methodical transformation of a static geometric algorithm:– to handle continuous motioncontinuous motion.– to allow insertion/deletion of pointsinsertion/deletion of points.– to allow motion parameters updatemotion parameters update at any
time.– to support compositioncomposition of algorithms.
The Kinetic Framework (cont.)
• Idea: insert a tracking code into an existing code.
• Builds on the self-adjusting computation framework.– immediate dynamization
• Introduce certificate– test/comparison– expires when the current value is
invalid.– Illustration (next slide).
Self-Adjusting Computation
Our Kinetic Library
The Kinetic Framework (cont.) [An Example]
• Given: a list of moving points in R2.• Calculate: the right-most point (assuming
no tie at all time)• Trivial algorithm: maintain the max so far and
scan the list
p0 <L p1 p1 <L p2
Y
p0 <L p2
N
p2
p1
p2
p0
Y
Y
N
N
The Kinetic Framework (cont.)
• In theory: – able to kinetize every algorithm
whose certificate’s expiration time can be computed.
• Efficiency? not always!
p0 <L p1 p1 <L p2
Y
p0 <L p2
N
p2
p1
p2
Y
Y
N
N
p0
certificate = comparsion result + expiration time
Our Kinetic Library• SML library (compatible with SML/NJ and
MLton) ~ 700 lines of SML code• Builds atop the self-adjusting library
– A Library for Self-Adjusting Computation (to appear in ML 2005)
• Priority queue of certificate failure times. Self-adjusting computation to reflect the changes.
• We were able to kinetize – 2d: Graham-scan, Merge Hull, QuickHull,
Randomized QuickHull– 3d: Incremental Hull
• Benchmark: Pending
Training QuickHull to “Walk”
fun split (p1,p2, pts, hull) = let val l = List.filter (fn p => lineSideTest((p1,p2),p)) pts in case l of nil => bp1::hull | h::t => let
fun selectMin (a,b) = if (distCmp(a, b, (p1,p2)) then a else b
val max = List.foldr selectMin h t val rest = split (max,bp2,l,hull) in split (bp1,max,l,rest) end end
fun splitM (p1, p2, pts, hull) = let val l = filter (fn p => K.mkCert(lineSideTest((p1,p2),p)) pts in l ==> (fn cl => case cl of
ML.NIL => ML.write (ML.CONS(p1,hull)) | ML.CONS(h,t) => hull ==> (fn chull =>
let fun select (a,b) = K.mkCert(distCmp(a,b,(vp1,vp2)))
val rmax = minimum select l val rest = C.modref (rmax ==> (fn max => splitM (max,p2,l,hull)))
in rmax ==> (fn max => splitM (p1,max,l,rest))
end)) end
Static
Kinetic
Jumping Time• An Open Problem [Guibas’98]: How can one
skip ahead in time?• Fact: The set of “certificates” is a correctness
proof wrt. running it from scratch.• Theorem: By advancing the time to t + and
updating the certificates corresponding to events in the queue up to the time t + , the resulting set of certificates after propagation agrees with running it from scratch.
• Efficiency: no worse than processing each event one by one.
Timet t +
Jumping Time (cont.)
• Benefits– Interested in events up to precision? ( can
be chosen to suit one’s need/machine)– Make video more efficiently– Dealing with less floating-point round-off
error
• New Problems– Suppose float precision up to , what should
be to avoid round-off error?– Jumping so far ahead in time? When is it
faster to simply re-run it form scratch?
Introducing the Communist Model
• Coined by Mulmuley’91• Dynamic setting
– Operations: insert/delete– Finite set U, and active set S.– Each element has an equal probability of
being inserted or deleted from the active set.
insert
delete
Stable Randomized QuickHull
• QuickHull (for computing 2d convex hull) – Very Fast in practice– Worst-case: O(n2) – Unstable (in self-adjusting framework)
• Randomize it to stabilize.
Stable Randomized QuickHull (cont.)
Std-Qhull(p1,p2, s)– Eliminate points under
p1p2 to get s’– Pick max from p1p2– Qhull (p1, max, s’)– Qhull (max, p2, s’)
• Idea: Randomly pair up points, and ensure that at least a fraction of points are eliminated with certain probability.
• Build on idea in Wenger’97 and B. Bhattacharya et al ’97, and T. Chan ’95.
Stable Randomized QuickHull (cont.)
• Replace the step marked in red by– Pair up points above the line p1p2
– Pick a random pair, define a line and find the maximizer above that line.
– Apply elimination (as extending from Chan’s)
• There are n/4 pairs on expectation, and max {subproblem L, subproblem R} · 13/16 with probability ¸ 1/2
0 1 0 0 0 1 1
Stable Randomized QuickHull (cont.)
• Extended Chan’s Elimination
• Initial Runtime: O(nlog n) is obvious.• Theorem: Randomized QuickHull
supports insertion/deletion in O(log2 n) • Also perform well practically in kinetic
setting, but QuickHull still outperforms it.
max
Convex Hull in 3D
• Incremental Hull– Simple and efficient – Generalizeable to arbitrary dimension
• Idea: insert points one by one. remove visible faces, and tent new faces.
Incremental Hull in 3D
• Key Requirements– Given a point p, find a
face f that p sees.– Given a face f, find
adjacent faces.
• Solutions– For each face, keep a list of points that
“belongs to” it.– Keep a mapping from points to faces.– Purely functional dictionary: treap
Incremental Hull in 3D (cont.)
DynamizedTreap
IncrementalConvex Hull
in 3D
KineticConvex Hull
in 3D
Incremental Hull in 3D (cont.)
• Fact: In a dynamized treap with uniform distribution of keys, an insertion/deletion takes O(log n)
• Theorem:– O(nlog2 n) for initial run– O(log2 n) for each insert/delete (assuming
the communist model).
• Also experimentally verified.
TimeTime
Experimental Evaluation
Summary
• Implemented a kinetic framework– Generated the movie we see previously.– Capable of skipping ahead in time.
• Analyzed a few Kinetized/Dynamized examples– Graham-scan, Merge Hull, QuickHull,
Randomized QuickHull, IHull3D• In progress
– Trying to formalize the notion of “when an algorithm performs efficiently in this framework” a.k.a kinetic stability
– Per event?
Questions ?
Thank You