Top Books

We collected top books from hacker news, stack overflow, Reddit, which are recommended by amazing people.

Top Books

We collected top books from hacker news, stack overflow, Reddit, which are recommended by amazing people.

Real-Time Collision Detection by Christer Ericson could be a good choice for you since it covers many basic geometry intersection tests. Take a look at its table of contents.

If you get the chance you should really check out the Collision Detection bible, "Real Time Collision Detection" if you plan on doing anything non-trivial. I'm not a professional game programmer and I understood and could apply the concepts in it with little trouble.

alt text http://msinilo.pl/blog/img/RealTimeCollisionDetection_13330/cover_rtcd.png

Amazon - Real Time Collision Detection

Basically, doing a set of line intersection tests is expensive no matter what. What you do is use things like Bounding Boxes (axis aligned or oriented) over your complex polygons. This will allow you to quickly do a worst case O(N^2) check of collision between each "object". You can then speed things up even further by using spatial trees (Binary Partitioning or QuadTrees) by only checking intersections of objects close to eachother.

This allows you to prune many, many collision tests. The best optimization is not doing something at all. Only once you have a collision between bounding boxes do you do your expensive line intersections to determine if the objects truly do intersect or not. This allows you to scale the number of objects up while still keeping the speed reasonable.

Not really a website, but this book Real-Time Collision Detection is well worth it for what you are looking for.

The concept of

interval notationcomes up inbothMathematics and Computer Science. The Mathematical notation`[`

,`]`

,`(`

,`)`

denotes thedomain(orrange) of an interval.The brackets

`[`

and`]`

means:included,closed,The parenthesis

`(`

and`)`

means:excluded,open.An interval with mixed states is called

"half-open".For example, the range of consecutive integers from 1 .. 10 (inclusive) would be

notatedas such:Notice how the word

`inclusive`

was used. If we want toexcludethe end point but "cover" the same range we need to move the end-point:For both left and right edges of the interval there are actually 4 permutations:

How does this relate to Mathematics and Computer Science?

Array indexes tend to use a

differentoffset depending on which field are you in:one-based.zero-based, such as C, C++, Javascript, Python, while other languages such as Mathematica, Fortran, Pascal are one-based.These differences can lead to subtle

fence post errors, aka, off-by-one bugs when implementing Mathematical algorithms such as for-loops.## Integers

If we have a set or array, say of the first few primes

`[ 2, 3, 5, 7, 11, 13, 17, 19, 23, 29 ]`

, Mathematicians would refer to the first element as the`1st`

absoluteelement. i.e. Using subscript notation to denote the index:Some programming languages, in contradistinction, would refer to the first element as the

`zero'th`

relativeelement.Since the array indexes are in the range [0,N-1] then for clarity purposes it would be "nice" to keep the same numerical value for the range 0 .. N instead of adding textual

noisesuch as a`-1`

bias.For example, in C or JavaScript, to iterate over an array of N elements a programmer would write the common idiom of

`i = 0, i < N`

with the interval [0,N) instead of the slightly more verbose [0,N-1]:Mathematicians, since they start counting at 1, would instead use the

`i = 1, i <= N`

nomenclature but now we need to correct the array offset in a zero-based language.e.g.

Aside:In programming languages that are 0-based you might need a

kludgeof a dummy zero'th element to use a Mathematical 1-based algorithm. e.g. Python Index Start## Floating-Point

Interval notation is also important for floating-point numbers to avoid subtle bugs.

When dealing with floating-point numbers especially in Computer Graphics (color conversion, computational geometry, animation easing/blending, etc.) often times normalized numbers are used. That is, numbers between 0.0 and 1.0.

It is important to know the edge cases if the endpoints are

inclusiveorexclusive:Where M is some machine epsilon. This is why you might sometimes see

`const float EPSILON = 1e-#`

idiom in C code (such as`1e-6`

) for a 32-bit floating point number. This SO question Does EPSILON guarantee anything? has some preliminary details. For a more comprehensive answer see`FLT_EPSILON`

and David Goldberg's What Every Computer Scientist Should Know About Floating-Point ArithmeticSome implementations of a random number generator,

`random()`

may produce values in the range 0.0 .. 0.999... instead of the more convenient 0.0 .. 1.0. Proper comments in the code will document this as [0.0,1.0) or [0.0,1.0] so there is no ambiguity as to the usage.Example:

`random()`

colors. You convert three floating-point values to unsigned 8-bit values to generate a 24-bit pixel with red, green, and blue channels respectively. Depending on the interval output by`random()`

you may end up with`near-white`

(254,254,254) or`white`

(255,255,255).`+--------+-----+ |random()|Byte | |--------|-----| |0.999...| 254 | <-- error introduced |1.0 | 255 | +--------+-----+`

For more details about floating-point precision and robustness with intervals see Christer Ericson's Real-Time Collision Detection, Chapter 11

Numerical Robustness, Section 11.3Robust Floating-Point Usage.12pm - I can't think of any immediately obvious, simple, way to do this in iOS. I'd look around for a package and if you're lucky there will be one! Otherwise it's just a case of plain hard programming.

You may possibly have to use beziers (Find the tangent of a point on a cubic bezier curve (on an iPhone)) to define the travel path. Or maybe, "simply" two half-circles.

From there use a "normal" slider concept to get the X position of the finger,

but just position the "y" value of the red ball, per your equations. That will work OK.For a better approach (

I doubt it will be necessary), the NEXT more complicated approach is: ALSO note the Y value of the finger. WHEN THE FINGER IS NEAR the "difficult" parts", THEN INSTEAD consider the Y value. Do you see what I mean?Finally the "ultimate solution" .. you need to get in to finding the "closest point on a curve" (i.e., give some point). This is classic game programming math. So follow something like

http://hal.archives-ouvertes.fr/docs/00/51/83/79/PDF/Xiao-DiaoChen2007c.pdf

Check out any of these classic books for that type of thing

http://www.amazon.com/Mathematics-Programming-Computer-Graphics-Edition/dp/1435458869

http://www.amazon.com/Real-Time-Collision-Detection-Interactive-Technology/dp/1558607323

However, IMO it would be "thoughtless engineering" .. .solution "A" or "B" is typically perfect!