Initializing an Array of Alternating Values
On my computer (a 1.2 GHz Intel Core m5 MacBook) I measured 

Array(repeating:count:)        663μs 995ns
Array(repeatingValues:count:)  13ms 105μs


with the code compiled in the Release configuration, i.e. with
optimizations. This is approximately a factor of 20 between those methods.

It seems that one “culprit” is the remainder calculation in 

        newArr.append(arr[i % arr.count])


If we replace that by an addition with wrap-around test

public init(repeatingValues arr: Array, count: Int) {
    precondition(!arr.isEmpty, "Initialization values cannot be empty")
    precondition(count &gt; 0, "Count cannot be less than 1")

    var newArr = Array&lt;Element&gt;()
    var srcIndex = 0
    for _ in 0..&lt;count {
        newArr.append(arr[srcIndex])
        srcIndex += 1
        if srcIndex == arr.count { srcIndex = 0 }
    }
    self = newArr
}


then the performance improves to

Array(repeatingValues:count:)   3ms 315μs


which is “only” by a factor of 5 slower than Array(repeating:count).

Another possible bottleneck is the array bounds check on each access.
This can be bypassed  by accessing the element storage directly:

init (repeatingValues2 arr: Array, count: Int) {
    precondition(!arr.isEmpty, "Initialization values cannot be empty")
    precondition(count &gt; 0, "Count cannot be less than 1")
    var newArr = Array(repeating: arr.first!, count: count)
    newArr.withUnsafeMutableBufferPointer { src in
        arr.withUnsafeBufferPointer { dest in
            var j = 0
            for i in 0..&lt;count {
                src[i] = dest[j]
                j += 1
                if j == arr.count { j = 0 }
            }
        }
    }
    self = newArr
}


This reduces the execution time to

Array(repeatingValues:count:)   1ms 889μs


which is now slower roughly by a factor of 3 than Array(repeating:count).

Other possibly useful technique is to avoid reallocations of the
array element storage by calling

    newArr.reserveCapacity(count)


However, this did not make a significant difference in my tests.

One further remark: Requiring the destination count to be strictly
positive seems unnecessary restrictive to me. I would change that to

init (repeatingValues arr: Array, count: Int) {
    precondition(!arr.isEmpty, "Initialization values cannot be empty")
    precondition(count &gt;= 0, "Count cannot be negative")
    if count == 0 {
        self = []
        return
    }

    // ...
}