middl | A generic middleware library , inspired by Express | Runtime Evironment library

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.

Well.. this seems to be an iOS bug.

I have cerated a sample project here that shows the bug... https://github.com/oliverfoggin/BrokenImagePickers

And a replica project here written with UIKit that does not... https://github.com/oliverfoggin/UIKit-Image-Pickers

I tried to take a screen recording of this happening but it appears that if any screen recording is happening (whether on device or via QuickTime on the Mac) this suppresses the bug from happening.

I have filed a radar with Apple and sent them both projects to have a look at and LOTS of detail around what's happening. I'll keep this updated with any progress on that.

After a bit of further investigation I found that you can start with SwiftUI and then present a PHPickerViewController without this crash happening.

From SwiftUI if you present a UIViewControllerRepresentable... and then from there if you present the PHPickerViewController it will not crash.

So I came up with a (very tacky) workaround that avoids this crash.

I first create a UIViewController subclass that I use like a wrapper.

Great question. I have often thought about this. I don't know of any packages that allow it natively, but it's not terribly difficult to do it yourself, since geom_text accepts angle as an aesthetic mapping.

Say we have the following plot:

Since C++17 the order of evaluation is specified such that the operands of = are evaluated right-to-left and those of << are evaluated left-to-right, matching the associativity of these operators. (But this doesn't apply to all operators, e.g. + and other arithmetic operators.)

So in

For the example setup, I would recommend splitting up the operations to easily fit them side-by-side using pandoc syntax for multiple columns. In this way, we can just call the specifics we want.

One potential solution is to specify the values manually for each scale, e.g.

OpenGL gives a lot of leeway for how implementations rasterize lines. It requires some desirable properties, but those do not prevent gaps when mixing x-major ('horizontal') and y-major ('vertical') lines.

• First thing, the "spirit of the spec" is to rasterize half-open lines; i.e. include the first vertex and exclude the final one. For that reason you should ensure that each vertex appears exactly once as a source and once as destination:

I have such a solution. And I'm surprised myself that I used two loops for!! Incredibly, I did it. First things first.

My proposal is based on a simplification. However, the mistake you will make at short distances will be relatively small. But the time gain is huge!

Well, I propose to count the distance in Cartesian coordinates, not spherical.

So we're going to need a simple function that computes the Cartesian coordinates based on the two arguments latitude and longitude. Here is our LatLong2Cart feature.

You need to create a secondary thread where you run your async code. You initialize the secondary thread with its own event loop, which runs forever. Execute each async function by calling run_coroutine_threadsafe(), and calling result() on the returned object. That's an instance of concurrent.futures.Future, and its result() method doesn't return until the coroutine's result is ready from the secondary thread.

Your main thread is then, in effect, calling each async function as if it were a sync function. The main thread doesn't proceed until each function call is finished. BTW it doesn't matter if your sync function is actually running in an event loop context or not.

The calls to result() will, of course, block the main thread's event loop. That can't be avoided if you want to get the effect of running an async function from sync code.

Needless to say, this is an ugly thing to do and it's suggestive of the wrong program structure. But you're trying to convert a legacy program, and it may help with that.