intersection | drag images between social sites | Application Framework library

1) If box sizes are not equal:

• Sort boxes on X-axis
• Generate 1D adjacency list for each box, by comparing only within range (since it is 1D and sorted, you only compare the boxes within range) like [(1,2),(1,3),(1,5),....] for first box and [(2,1),(2,6),..] for second box, etc. (instead of starting from index=0, start from index=current and go both directions until it is out of box range)
• Iterate over 1D adjacency list and remove duplicates or just don't do the last step on backwards (only compare to greater indexed boxes to evade duplication)
• Group the adjacencies per box index like [(1,a),(1,b),..(2,c),(2,d)...]
• Sort the adjacencies within each group, on Y-axis of the second box per pair
• Within each group, create 2D adjacency list like [(1,f),(1,g),..]
• Remove duplicates
• Group by first box index again
• Sort (Z) of second box per pair in each group
• create 3D adjacency list
• remove duplicates
• group by first index in pairs
• result=current adjacency list (its a sparse matrix so not a full O(N*N) memory consumption unless all the boxes touch all others)

So in total, there are:

• 1 full sort (O(N*logN))
• 2 partial sorts with length depending on number of collisions
• 3 lumping pairs together (O(N) each)
• removing duplicates (or just not comparing against smaller index): O(N)

this should be faster than O(N^2).

2) If rectangles are equal sized, then you can do this:

• scatter: put box index values in virtual cells of a grid (i.e. divide the computational volume into imaginary static cells & put your boxes into a cell that contains the center of selected box. O(N)

• gather: Only once per box, using the grid cells around the selected box, check collisions using the index lists inside the cells. O(N) x average neighbor boxes within collision range

3) If rectangles are not equal sized, then you can still "build" them by multiple smaller square boxes and apply the second (2) method. This increases total computation time complexity by multiplication of k=number of square boxes per original box. This only requires an extra "parent" box pointer in each smaller square box to update original box condition.

This method and the (2) method are easily parallizable to get even more performance but I guess first(1) method should use less and less memory after each axis-scanning so you can go 4-dimension 5-dimension easily while the 2-3 methods need more data to scan due to increased number of cell-collisions. Both algorithms can become too slow if all boxes touch all boxes.

4) If there is "teapot in stadium" problem (all boxes in single cell of grid and still not touching or just few cells close to each other)

• build octree from box centers (or any nested structure)
• compute collisions on octree traversal, visiting only closest nodes by going up/down on the tree

1-revisited) If boxes are moving slowly (so you need to rebuild the adjacency list again in each new frame), then the method (1) gets a bit more tricky. With too small buffer zone, it needs re-computing on each frame, heavy computation. With too big buffer zone, it needs to maintain bigger collision lists with extra filtering to get real collisions.

2-revisited) If environment is infinitely periodic (like simulating Neo trapped in train station in the Matrix), then you can use grid of cells again, but this time using the wrapped-around borders as extra checking for collisions.

For all of methods (except first) above, you can accelerate the collision checking by first doing a spherical collision check (broad-collision-checking) to evade unnecessary box-collision-checks. (Spherical collision doesn't need square root since both sides have same computation, just squared sum of differences enough). This should give only linear speedup.

For method (2) with capped number of boxes per cell, you can use vectorization (SIMD) to further accelerate the checking. Again, this should give a linear speedup.

For all methods again, you can use multiple threads to accelerate some of their steps, for another a linear speedup.

Even without any methods above, the two for loops in the question could be modified to do tiled-computing, to stay in L1 cache for extra linear performance, then a second tiling but in registers (SSE/AVX) to have peak computing performance during the brute force time complexity. For low number of boxes, this can run faster than those acceleration structures and its simple:

This wouldn't be easy to implement but could be sublinear for many cases, and at most linear. Consider representing the perimeter of each tree as four corners (they mark a square rotated 45 degrees). For each tree compute it's perimeter intersection with the current intersection. The difficulty comes with managing the corners of the intersection, which could include more than one point because of the diagonal alignments. Run inside the final intersection to count how many empty spots are within it.

At first glance, I see three possibilities:

• It's hard to see where the issue is without showing how you're using the createCamera() method. You could be swapping pitch with heading or something like that. In Three.js, heading is rotation around the Y-axis, pitch around X-axis, and roll around Z-axis.

• Secondly, do you know in what order the heading, pitch, roll measurements were taken by your sensor? That will affect the way in which you initiate your THREE.Euler(xRad, yRad, zRad, 'XYZ'), since the order in which to apply rotations could also be 'YZX', 'ZXY', 'XZY', 'YXZ' or 'ZYX'.

• Finally, you have to think "What does heading: 0 mean to the sensor?" It could mean different things between real-world and Three.js coordinate system. A camera with no rotation in Three.js is looking straight down towards -Z axis, but your sensor might have it pointing towards +Z, or +X, etc.

I added a demo below, I think this is what you needed from the screenshots. Notice I multiplied pitch * -1 so the cameras "Look down", and added +180 to the heading so they're pointing in the right... heading.

Before TypeScript 3.9, both intersections would behave like your first example and be equivalent to {name: string, age: never}. TypeScript 3.9 introduced functionality to reduce intersections by discriminant properties. Discriminant properties are, roughly, those whose values are of single literal types (like string literal types, numeric literal types, boolean literal types, null, and undefined) or unions of such types. These are used in discriminated unions. If an intersection type causes a discriminant property to reduce to never, the compiler will reduce the whole intersection to never. See microsoft/TypeScript#36696 for details and motivation.

Anyway, the type boolean is represented as the union true | false of boolean literals, and therefore the age property in your second example is considered to be a discriminant property. On the other hand, number is a non-literal type and so the age property in your first example is not considered to be a discriminant property. This accounts for the difference in behavior you are seeing.

The intersection method requires an iterable as a parameter.

You are passing a string(word) which is an iterable, hence it works successfully.

The problem is that handler (ignoring the undefined, i.e. within the if block), is either a map EventA => Void or a map EventB => Void, whereas the input ev is either of type EventA or EventB. So from the compiler's perspective, it could be, for example, that handler is of type EventA => Promise, while ev is of type EventB, which then are not compatible. The type FindByTag does not reify an AnyEvent to an actual EventA or an EventB based on what K is.

I have done exactly this (but vertical line only) in a previous version of one of my projects. Unfortunately this feature has been removed but the older source code file can still be accessed via my github.

The key is this section of the code:

Once you know the items shared between the two lists, you can iterate over each list separately to sum up the items in between the shared items, thus constructing a list of partial sums. These lists will have the same length for both input lists, because the number of shared items is the same.

The maximum path sum can then be found by taking the maximum between the two lists for each stretch between shared values:

In order to achieve this goal we need to create permutation of all allowed paths. For example: