Is there a simple way to traverse a multi-dimensional array and transform each element in Swift? - ios

Question

If I have an multi-dimensional array of latitudes and longitudes like:
let inputLatLongArray = [[[
["-100.7777777775", "99.2222222"],
["-100.777777777", "87.2222222"],
["-100.777777777", "34.2222222"],
["-100.777777777", "99.2222222"],
["-100.777777777", "99.2222222"]
]]]
How can I traverse & transform the elements so each nested lat/long only has 2 decimal places?
Expected output:
let expectedLatLongArray = [[[
["-100.77", "99.22"],
["-100.77", "87.22"],
["-100.77", "34.22"],
["-100.77", "99.22"],
["-100.77", "99.22"]
]]]
Code:
Here's what I have so far below. My thought was to use a flatMap and then map down into the nested arrays but this doesn't seem correct either. Is there a simple way to do this?
func roundLatAndLong(with latLongArray: [[[[String, String]]]]) -> [[[[String, String]]]] {
let coordinates = latLongArray.flatMap { $0 }.map({ $0 }).map({ //Rounded both array positions down to 2 decimal places })
return coordinates
}
func rounded(toDecimalPlaces n: Int) -> String {
return String(format: "%.\(n)f", self)
}

Answer 1

If your data type is Double, there is no such thing as having a number of decimal places. If you try to round a value to a given number of decimal places, you'll get a value close to, but not exactly, that value. That's because binary floating point can't represent most decimal values exactly. If you really want to convert your values to values with an exact number of decimal places, you should use the Decimal type.
You COULD convert your array of lat/long Double values to Strings with a given number of decimal places pretty easily.
If you had an array of structs containing lat/longs, or an array of tuples, it would be a lot cleaner. Or even an array of dictionaries with keys of "lat" and "long"

Answer 2

You could do something like this:
func nestedTransform<InElement, OutElement>(nested: [[[[InElement]]]], transform: (InElement) -> OutElement) -> [[[[OutElement]]]]
{
return nested.map {$0.map { $0.map { $0.map(transform) }}}
}
I think in your attempt you just had your nesting a little off, that is you were chaining instead of nesting the map calls.
You would use this like this:
let roundedResult = nestedTransform(nested: inputLatLongArray) { $0.rounded(toDecimalPlaces: 8) }
Assuming the existence to a suitable extension on InElement. You edited the question to remove the original Double array. So this answer serves to solve the mapping of nested arrays. The implementation of the transform is left up to you!
I also strongly encourage you to read the answer by #DuncanC and the comments by #LeoDaubus about why your original transform is ill-advised.

Answer 3

You can gradually extend Array to allow transformations on multi-dimensional ones:
extension Array {
func map2<T, U>(_ transform: (T) -> U) -> [[U]] where Element == [T] {
map { $0.map(transform) }
}
func map3<T,U>(_ transform: (T) -> U) -> [[[U]]] where Element == [[T]] {
map { $0.map2(transform) }
}
func map4<T,U>(_ transform: (T) -> U) -> [[[[U]]]] where Element == [[[T]]] {
map { $0.map3(transform) }
}
}
You can then use the extension like this:
let inputLatLongArray = [[[
["-98.73264361706984", "38.5447223260328"],
["-98.73255257987707", "38.543630550793544"],
["-98.7302159585956", "38.54506646913993"],
["-98.73200635672036", "38.54556488037536"],
["-98.73264361706984", "38.5447223260328"]
]]]
let transform: (String) -> String = {
return String(format: "%.\(8)f", Double($0) ?? 0.0)
}
let transformedArray = inputLatLongArray.map4(transform)
print(transformedArray)