xy array in Swift performance - arrays

Question

I have two large (several thousand values) arrays with floats, and would like to combine them in an xy point array for further processing, eg to plot.
So right now in Xcode playground I am doing this:
let xArray = // read from datafile, fast
let yArray = // read from another datafile, fast
struct xyPoint {
let x: Float
let y: Float
}
var spectrum: [xyPoint] = []
for i in 0..<xArray.count {
let xy = xyPoint(x: xArray[i], y: yArray[i])
spectrum.append(xy)
}
Now when I run the playground, this takes a really long time to do.
Any ideas how I can speed this up?

Answer 1

I checked the performance for various solutions to your problem. You can download my tests from this link to github
A) Your code
var spectrum: [XYPoint] = []
for i in 0..<xArray.count {
let xy = XYPoint(x: xArray[i], y: yArray[i])
spectrum.append(xy)
}
B) Zip + map (Martin R's answer)
let spectrumB = zip(xArray, yArray).map(XYPoint.init)
C) Range + map (My solution)
let spectrum = (0 ..< xArray.count).map { i in
return XYPoint(x: xArray[i], y: yArray[i])
}
D) ReserveCapacity + append (Duncan C's answer)
var spectrum: [XYPoint] = []
spectrum.reserveCapacity(xArray.count)
for (index, value) in xArray.enumerated() {
spectrum.append(XYPoint(x: xArray[index], y: yArray[index]))
}
My results (in seconds)
╭──────────────┬──────────────┬──────────────┬──────────────╮
│ A │ B │ C │ D │
╭───────────╬══════════════╪══════════════╪══════════════╪══════════════╡
│ 100 ║ 0.000009426 │ 0.000002401 │ 0.000000571 │ 0.000000550 │
│ 200 ║ 0.000003356 │ 0.000002629 │ 0.000000911 │ 0.000000866 │
│ 500 ║ 0.000005610 │ 0.000007288 │ 0.000002236 │ 0.000002012 │
│ 1000 ║ 0.000010638 │ 0.000009181 │ 0.000003905 │ 0.000005030 │
│ 2000 ║ 0.000019377 │ 0.000013316 │ 0.000007116 │ 0.000008732 │
│ 5000 ║ 0.000023430 │ 0.000019304 │ 0.000019809 │ 0.000019092 │
│ 10000 ║ 0.000050463 │ 0.000031669 │ 0.000035121 │ 0.000035420 │
│ 20000 ║ 0.000087040 │ 0.000058664 │ 0.000069300 │ 0.000069456 │
│ 50000 ║ 0.000272357 │ 0.000204213 │ 0.000176962 │ 0.000192996 │
│ 100000 ║ 0.000721436 │ 0.000459551 │ 0.000415024 │ 0.000437604 │
│ 200000 ║ 0.001114534 │ 0.000924621 │ 0.000816374 │ 0.000896202 │
│ 500000 ║ 0.002576687 │ 0.002094998 │ 0.001860833 │ 0.002060462 │
│ 1000000 ║ 0.007063596 │ 0.005924892 │ 0.004319181 │ 0.004869024 │
│ 2000000 ║ 0.014474969 │ 0.013594134 │ 0.008568550 │ 0.009388957 │
│ 5000000 ║ 0.038348767 │ 0.035136008 │ 0.021276415 │ 0.023855382 │
│ 10000000 ║ 0.081750925 │ 0.078742713 │ 0.043578664 │ 0.047700495 │
│ 20000000 ║ 0.202616669 │ 0.199960563 │ 0.148141266 │ 0.145360923 │
│ 50000000 ║ 0.567078563 │ 0.552158644 │ 0.370327555 │ 0.397115294 │
│ 100000000 ║ 1.136993625 │ 1.101725386 │ 0.713406642 │ 0.740150322 │
└───────────╨──────────────┴──────────────┴──────────────┴──────────────┘

Answer 2

The easiest way to create the array of points would be
let spectrum = zip(xArray, yArray).map(XYPoint.init)
(I have taken the liberty to call the struct XYPoint, as Swift types
should start with uppercase letters.) This also allows to define
the result array as a constant.
However, it is not the fastest with respect to execution time.
Reasons may be
zip() operates on general sequences and does not take advantage
of the input being arrays.
zip() returns a Sequence and therefore map()
does not know the number of elements which are to be created.
As a consequence, the destination array will be reallocated several
times.
Therefore an explicit loop is faster if you reserve the needed
capacity in advance:
var spectrum: [XYPoint] = []
spectrum.reserveCapacity(xArray.count)
for i in 0..<xArray.count {
let xy = XYPoint(x: xArray[i], y: yArray[i])
spectrum.append(xy)
}
In my test (on a 1.2 GHz Intel Core m5 MacBook, compiled in Release
mode) with two arrays of 10,000 elements, the first method took
about 0.65 milliseconds and the second method about 0.42 milliseconds.
For 1,000,000 elements I measured 12 milliseconds vs 6 milliseconds.

Answer 3

Once you have 2 separate arrays, combining them is a little awkward, and there isn't a neat "Swifty" way to do it. If you had an array of structs, where each struct contained an x an y value, you could use a map statement to transform that array into an array of CGPoint objects (which is actually another Struct type).
You start out by telling us:
let xArray = // read from datafile, fast
let yArray = // read from another datafile, fast
It might be better to rework that code you don't show, so that instead of reading all of the x points data file, then reading all of the y points data file, you:
read an x point
read a y point
create a CGPoint for that X/Y pair
Add the new CGPoint to your output array of CGPoint values
Or even, restructure your code that creates the data files so that it writes a file containing an array of X/Y pairs rather than 2 separate files.
If you have 2 separate arrays, you might use a variant of for... in that gives you both an index and a value for each array entry:
let xArray: [CGFloat] = [0.1, 0.2, 0.3, 0.4]
let yArray: [CGFloat] = [0.4, 0.3, 0.2, 0.1]
var output = [CGPoint]()
output.reserveCapacity(xArray.count)
for (index, value) in xArray.enumerated() {
let yValue = yArray[index]
let aPoint = CGPoint (x: value, y: yValue)
output.append(aPoint)
}
The code above will crash if yArray has less values than xArray, and will miss the last values in yArray if it contains more values than xArray. A complete implementation should really do error checking first and handle the cases were the arrays have different numbers of values.

Answer 4

When you run code in the main playground file, you will likely have logging enabled. This adds a huge performance hit to the code.
I tried out your code in the question as a function. Putting the function in the main swift file for arrays of size 10000 took over 10 minutes!
I moved the function to a separate swift file in the sources folder of the playground with the same size arrays, and it finished instantly.
The code I used was from your question (within a func) rather than the optimized versions.