f2cf74c7
 yangbin
1.0.20(4)
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
|
# Surge [](https://travis-ci.org/mattt/Surge) [](https://github.com/mattt/Surge/blob/master/LICENSE) [](https://github.com/Carthage/Carthage)
Surge is a Swift library that uses the Accelerate framework to provide high-performance functions for matrix math, digital signal processing, and image manipulation.
Accelerate exposes [SIMD](http://en.wikipedia.org/wiki/SIMD) instructions available in modern CPUs to significantly improve performance of certain calculations. Because of its relative obscurity and inconvenient APIs, Accelerate is not commonly used by developers, which is a shame, since many applications could benefit from these performance optimizations.
**Surge aims to bring Accelerate to the mainstream, making it as easy (and nearly as fast, in most cases) to perform computation over a set of numbers as for a single member.**
Though, keep in mind: _Accelerate is not a silver bullet_. Under certain conditions, such as performing simple calculations over a small data set, Accelerate can be out-performed by conventional algorithms. Always benchmark to determine the performance characteristics of each potential approach.
---
> Curious about the name _Surge_? Back in the mid 90's, Apple, IBM, and Motorola teamed up to create [AltiVec](http://en.wikipedia.org/wiki/AltiVec) (a.k.a the Velocity Engine), which provided a SIMD instruction set for the PowerPC architecture. When Apple made the switch to Intel CPUs, AltiVec was ported to the x86 architecture and rechristened [Accelerate](https://developer.apple.com/library/mac/documentation/Accelerate/Reference/AccelerateFWRef/_index.html). The derivative of Accelerate (and second derivative of Velocity) is known as either [jerk, jolt, surge, or lurch](http://en.wikipedia.org/wiki/Jerk_%28physics%29), hence the name of this library.
---
## Performance
Initial benchmarks on iOS devices and the iOS simulator indicate significant performance improvements over a conventional Swift implementation.
```swift
import Surge
let numbers: [Double] = ...
var sum: Double = 0.0
// Naïve Swift Implementation
sum = reduce(numbers, 0.0, +)
// Surge Implementation
sum = Surge.sum(numbers)
```
_(Time in milliseconds, Optimization Level `-Ofast`)_
| _n_ | Swift | Surge | Δ |
|------------|------------------|---------------|-----------|
| 100 | 0.269081 | 0.004453 | ~60x |
| 100000 | 251.037254 | 0.028687 | ~9000x |
| 100000000 | 239474.689326 | 57.009841 | ~4000x |
> Surge's performance characteristics have not yet been thoroughly evaluated, though initial benchmarks show incredible promise. Further investigation is definitely warranted.
## Installation
_The infrastructure and best practices for distributing Swift libraries are currently in flux during this beta period of Swift & Xcode. In the meantime, you can add Surge as a git submodule, drag the `Surge.xcodeproj` file into your Xcode project, and add `Surge.framework` as a dependency for your target._
### Installation with Carthage
To use [Carthage](https://github.com/Carthage/Carthage) (a more lightweight but more hands on package manager) just create a `Cartfile` with
```ruby
github "mattt/Surge"
```
Then follow the [steps in the Carthage guide](https://github.com/Carthage/Carthage#getting-started) basically (for iOS):
* run `carthage update`
* drag the framework from Carthage/Build into Linked Frameworks on the General tab
* add `carthage copy-frameworks` to a `Run Scripts` phase
and you're done. The [steps for Mac are very similar](https://github.com/Carthage/Carthage#getting-started).
---
## Inventory
> Surge functions are named according to their corresponding "Math.h" functions, where applicable (omitting `f` and `d` affixes, since type information is communicated and enforced by the language's type system).
### Arithmetic
- `sum`
- `asum`
- `max`
- `min`
- `mean`
- `meamg`
- `measq`
- `add`
- `sub`
- `mul`
- `div`
- `mod`
- `remainder`
- `sqrt`
### Auxiliary
- `abs`
- `ceil`
- `copysign`
- `floor`
- `rec`
- `round`
- `trunc`
### Convolution
- `conv`
- `xcorr`
### Exponential
- `exp`
- `exp2`
- `log`
- `log2`
- `log10`
- `logb`
### FFT
- `fft`
### Hyperbolic
- `sinh`
- `cosh`
- `tanh`
- `asinh`
- `acosh`
- `atanh`
### Matrix
- `add`
- `mul`
- `inv`
- `transpose`
### Power
- `pow`
### Trigonometric
- `sincos`
- `sin`
- `cos`
- `tan`
- `asin`
- `acos`
- `atan`
- `rad2deg`
- `deg2rad`
## Usage
### Computing Sum of `[Double]`
```swift
import Surge
let n = [1.0, 2.0, 3.0, 4.0, 5.0]
let sum = Surge.sum(n) // 15.0
```
### Computing Product of Two `[Double]`s
```swift
import Surge
let a = [1.0, 3.0, 5.0, 7.0]
let b = [2.0, 4.0, 6.0, 8.0]
let product = Surge.mul(a, b) // [2.0, 12.0, 30.0, 56.0]
```
---
## License
Surge is available under the MIT license. See the LICENSE file for more info.
|
