Tukukkk

I'm doing a very simple operation. I'm sorting through a bunch of locations in a map to create an enclosing circle, like so:

var maxLong: Double = -180

var maxLat: Double = -180

var minLong: Double = 180

var minLat: Double = 180



for coord in inCoordinates {

    maxLong = max(coord.longitude, maxLong)

    maxLat = max(coord.latitude, maxLat)

    minLong = min(coord.longitude, minLong)

    minLat = min(coord.latitude, minLat)

}



let nw: CLLocation = CLLocation(latitude: maxLat, longitude: minLong)

let se: CLLocation = CLLocation(latitude: minLat, longitude: maxLong)

let center = CLLocationCoordinate2D(latitude: (maxLat + minLat) / 2.0, longitude: (maxLong + minLong) / 2.0)

let radiusInMeters = abs(nw.distance(from: se)) / 2.0



return MKCircle(center: center, radius: radiusInMeters)

Pretty straightforward (Yeah, I know about the IDL issue, but I want to keep this simple).

What I'd like to know, is if there were some way I could boil the loop into a variant of reduce, where you would end up with something like this:

let enclosingRect: MKMapRect = inCoordinates.magikalReduce {

    // Magic Happens Here -Queue Doug Henning GIF

}

So the returned rect contains the distilled points.

Yeah, I know that I can simply extend Array (with maybe a type qualifier) to do this with a calculated property, but that sort of defeats the purpose of this. The above is fairly efficient, and I'd rather not add overhead, just to be fancy (Which means, even if I could do it, it might be too inefficient to use).

This is more of a curiosity exploration than a technical need. The above code does fine for me, and is relatively zippy.

Do you mean

// calculate the enclosing rect with `reduce` and `union`, you have to create an `MKMapRect` from each coordinate

let enclosingRect = inCoordinates.reduce(MKMapRect.null) { $0.union(MKMapRect(origin: MKMapPoint($1), size: MKMapSize())) }

You can create a struct for holding the min/max longitude and latitude values, then use reduce, where you use the initial values for these for creating an initial result, then creating an updated version of the struct with the necessary min/max calculations.

struct MinMaxCoordinates {

    let maxLong:Double

    let maxLat:Double

    let minLong:Double

    let minLat:Double

}





let minMaxCoordinates = inCoordinates.reduce(MinMaxCoordinates(maxLong: -180, maxLat: -180, minLong: 180, minLat: 180), {minMax, coord in

    return MinMaxCoordinates(maxLong: max(minMax.maxLong, coord.longitude), maxLat: max(minMax.maxLat, coord.latitude), minLong: min(minMax.minLong, coord.longitude), minLat: max(minMax.minLat, coord.latitude))

})



let nw: CLLocation = CLLocation(latitude: minMaxCoordinates.maxLat, longitude: minMaxCoordinates.minLong)

let se: CLLocation = CLLocation(latitude: minMaxCoordinates.minLat, longitude: minMaxCoordinates.maxLong)

let center = CLLocationCoordinate2D(latitude: (minMaxCoordinates.maxLat + minMaxCoordinates.minLat) / 2.0, longitude: (minMaxCoordinates.maxLong + minMaxCoordinates.minLong) / 2.0)

let radiusInMeters = abs(nw.distance(from: se)) / 2.0



return MKCircle(center: center, radius: radiusInMeters)