vDSP_zrvmul不返回任何结果（或全零） [英] vDSP_zrvmul not returning any results (or all zeros)
问题描述
根据其他用户的评论，我整理了代码并将其压缩以使其可读。我有一个complexFloatArray类，用于存储复杂向量的数组
I have tidied my code up and condensed it to make it readable, as per another users comments. I have a complexFloatArray class, to store arrays of Complex vectors
class complexFloatArray {
var reals: [Float]
var imaginaries: [Float]
init(reals: [Float], imaginaries: [Float]){
self.reals = reals
self.imaginaries = imaginaries
}
}
然后我在此类的扩展中定义了一些函数。一种是：
I then have some functions defined in extensions to this class. One being:
func useAsDSPSplitComplex<R>(_ closure: (inout DSPSplitComplex) -> R) -> R {
return reals.withUnsafeMutableBufferPointer { realBufferPointer in
return imaginaries.withUnsafeMutableBufferPointer { imaginaryBufferPointer in
var dspSplitComplex = DSPSplitComplex(realp: realBufferPointer.baseAddress!, imagp: imaginaryBufferPointer.baseAddress!)
return closure(&dspSplitComplex)
}
}
}
<这个想法是在complexFloatArray实例上调用时，它创建一个DSPSplitComplex指针以与Accelerate框架一起使用。
The idea is when called on an instance of complexFloatArray, it creates a DSPSplitComplex pointer for use with the Accelerate framework.
最后，我有一个想使用的加速函数（vDSP_zrvmul）将实向量乘以我的复数向量。
Finally I have an accelerate function I would like to use (vDSP_zrvmul) to multiply my complex vector by a real vector.
func floatMultiply(with other: [Float]) -> complexFloatArray {
assert(self.count == other.count, "Multiplied Vectors Must have the same size!")
var result = complexFloatArray.zeros(count: other.count)
self.useAsDSPSplitComplex { selfPointer in
result.useAsDSPSplitComplex { resultPointer in
vDSP_zrvmul(
&selfPointer, complexFloatArray.stride,
other, complexFloatArray.stride,
&resultPointer, complexFloatArray.stride,
vDSP_Length(result.count))
}
}
return result
}
我使用以下函数调用该函数：
I call the function using:
var kernel = sine.floatMultiply(with: gauss)
其中正弦是complexFloatArray，高斯是FloatArray，两者的长度相等，以创建morlet小波。但是，结果是一个用零填充的complexFloatArray。
where sine is a complexFloatArray, and gauss is a FloatArray, both of equal length to create a morlet wavelet. However the result is a complexFloatArray filled with zeros.
在调试时，我可以在floatMultiply函数的任意位置放置一个断点，并确认self和other（正弦和高斯）都填充有值。因此，在vDSP调用中的某处未返回正确的结果。
When debugging I can put a breakpoint at any point in the floatMultiply function and confirm that both self and other (sine and gauss) are filled with vales. So it is somewhere in the vDSP call that is not returning the correct results.
为了完整起见，complexFloatArray.stride = 1（此值在complexFloatArray类中声明）。
For completeness complexFloatArray.stride = 1 (this value is declared within the complexFloatArray class).
zeros是complexFloatArray中的一个函数，用于使用特定长度的零填充数组。 （数组（重复：0，计数：N）
And 'zeros' is a function within complexFloatArray to populate an Array with zeros of a certain length. (Array(repeating:0, count:N)
有人建议为什么我的通话结果为零？
Any suggestions why I am getting zero in my result to this call?
我现在包括了完整的代码，而不是包含不完整图片的摘录。
ComplexFloatArray类的完整代码如下：
I have now included the full code, rather than snippets which give an incomplete picture.
The full code for ComplexFloatArray Class is below:
class ComplexFloatArray {
var reals: [Float]
var imaginaries: [Float]
init(reals: [Float], imaginaries: [Float]){
self.reals = reals
self.imaginaries = imaginaries
}
}
extension ComplexFloatArray {
var count: Int {
assert(reals.count == imaginaries.count)
return reals.count
}
static let stride = 1
func append(real: Float, imaginary: Float) {
self.reals.append(real)
self.imaginaries.append(imaginary)
}
func removeAtIndex(index: Int) {
self.reals.remove(at: index)
self.imaginaries.remove(at: index)
}
func useAsDSPSplitComplex<R>(_ closure: (inout DSPSplitComplex) -> R) -> R {
return reals.withUnsafeMutableBufferPointer { realBufferPointer in
return imaginaries.withUnsafeMutableBufferPointer { imaginaryBufferPointer in
var dspSplitComplex = DSPSplitComplex(realp: realBufferPointer.baseAddress!, imagp: imaginaryBufferPointer.baseAddress!)
return closure(&dspSplitComplex)
}
}
}
}
extension ComplexFloatArray {
convenience init() {
self.init(reals:[], imaginaries:[])
}
static func zeros(count: Int) -> ComplexFloatArray {
return ComplexFloatArray(reals:Array(repeating: 0, count: count), imaginaries: Array(repeating:0, count:count))
}
}
extension ComplexFloatArray {
enum ComplexMultiplicationType: Int32 { case normal = 1, conjugate = -1}
func ComplexMultiply(
with other: ComplexFloatArray,
multiplicationType: ComplexMultiplicationType = .normal
) -> ComplexFloatArray {
assert(self.count == other.count, "Multiplied Vectors Must have the same size!")
var result = ComplexFloatArray.zeros(count: self.count)
self.useAsDSPSplitComplex { selfPointer in
other.useAsDSPSplitComplex { otherPointer in
result.useAsDSPSplitComplex { resultPointer in
vDSP_zvmul(
&selfPointer, ComplexFloatArray.stride,
&otherPointer, ComplexFloatArray.stride,
&resultPointer, ComplexFloatArray.stride,
vDSP_Length(result.count),
multiplicationType.rawValue)
}
}
}
return result
}
}
extension ComplexFloatArray {
func floatMultiply(
with other: [Float]
) -> ComplexFloatArray {
assert(self.count == other.count, "Multiplied Vectors Must have the same size!")
var result = ComplexFloatArray.zeros(count: other.count)
self.useAsDSPSplitComplex { selfPointer in
result.useAsDSPSplitComplex { resultPointer in
vDSP_zrvmul(
&selfPointer, ComplexFloatArray.stride,
other, ComplexFloatArray.stride,
&resultPointer, ComplexFloatArray.stride,
vDSP_Length(result.count))
}
}
return result
}
}
extension ComplexFloatArray {
enum FourierTransformDirection: Int32 { case forward = 1, inverse = -1 }
func outOfPlaceComplexFourierTransform(
setup: FFTSetup,
resultSize:Int,
logSize: UInt,
direction: FourierTransformDirection) -> ComplexFloatArray {
var result = ComplexFloatArray.zeros(count:resultSize)
self.useAsDSPSplitComplex { selfPointer in
result.useAsDSPSplitComplex { resultPointer in
vDSP_fft_zop(
setup,
&selfPointer,
ComplexFloatArray.stride,
&resultPointer,
ComplexFloatArray.stride,
logSize,
direction.rawValue)
}
}
return result
}
}
我的CWT类的完整代码如下：
The full code for my CWT class is below:
var nVoices = 96 //number of voices per octave
var kernelLength = 2048 //Length of N
var fs = globalSampleRate
class CWT{
var timeArray:[Float] = []
var sines: [ComplexFloatArray] = []
var gaussian:[[Float]] = []
var fftFilterBank:[ComplexFloatArray] = []
var filterBank:[ComplexFloatArray] = []
var convProduct:[ComplexFloatArray] = []
var centreFreqs:[Float]=[]
var phase:[Float] = []
var magnitude:[Float] = []
func synthesizeKernels(){
timeArray = makeArray(from: ((1.0/Float(fs))*((-0.5)*Float(kernelLength))), to: ((1.0/Float(fs))*((0.5)*Float(kernelLength))), increment: 1/fs)
centreFreqs = getCentreFreqs(N:timeArray.count)
for i in 0..<centreFreqs.count {
makeSine(freq: centreFreqs[i], N:timeArray.count, iteration: i)
makeGaus(freq: centreFreqs[i], N:timeArray.count, iteration: i)
makeMorlet(sine: sines[i], gauss: gaussian[i], count:timeArray.count, iteration: i)
fftKernel(kernel: filterBank[i], N:timeArray.count, iteration:i)
}
}
func convolveSignal(realSamples:[Float], imagSamples:[Float]) {
let logN = 11
let fft1Setup = vDSP_create_fftsetup(UInt(logN), FFTRadix(FFT_RADIX2))!
var product = ComplexFloatArray.zeros(count: filterBank.count)
var input = ComplexFloatArray(reals: realSamples, imaginaries: imagSamples)
var fftOfSamples = ComplexFloatArray.zeros(count: input.count)
fftOfSamples = input.outOfPlaceComplexFourierTransform(setup: fft1Setup, resultSize: input.count, logSize: UInt(logN), direction: ComplexFloatArray.FourierTransformDirection(rawValue: 1)!)
fftOfSamples.removeAtIndex(index: 0)
for i in 0..<self.filterBank.count {
var kernel = fftFilterBank[i]
var multiplyResult = kernel.ComplexMultiply(with: fftOfSamples)
convProduct.append(multiplyResult)
}
}
//HELPER FUNCTION FOR TIME ARRAY
func makeArray(from:Float, to:Float, increment:Float) ->[Float]{
var Array:[Float]=[]
for i in stride(from: from, to: to, by: increment) {
Array.append(i)
}
return Array
}
//MAKE COMPLEX SINE WAVE
func makeSine(freq:Float, N:Int, iteration:Int) {
var compSine = ComplexFloatArray.init()
for i in 0..<timeArray.count{
let x = 2 * Float.pi * freq * timeArray[i]
compSine.append(real: cos(x), imaginary: sin(x))
}
sines.append(compSine)
}
//MAKE GAUSSIAN WINDOW
func makeGaus(freq:Float, N:Int, iteration:Int) {
var gaus:[Float] = Array(repeating:0, count:N)
let s:Float = 7 / (2.0 * Float.pi * freq)
let interimCalc: Float = Float(2)*Float(pow(s,2))
for i in 0..<N{
var u = pow(timeArray[i],2)
u = (-u)
let v = u / interimCalc
gaus[i] = exp(v)
}
gaussian.append(gaus)
}
//CREATE CENTRE FREQUENCIES
func getCentreFreqs(N:Int) ->[Float]{
var CF:[Float] = []
var filteredCF:[Float] = []
var G:Float = pow(10,(3/10))
var x = makeArray(from: -1000, to: 1350, increment: 1)
for i in 0..<x.count {
var fraction:Float = (Float(2*Float(x[i]))-Float(59.0)) / Float(2*nVoices)
var fr:Float = Float(1000.0) * Float(powf(Float(G), Float(fraction)))
CF.append(fr)
}
for i in 0..<CF.count {
if (Float(20) < CF[i] && CF[i] < Float(20000)) {
filteredCF.append(CF[i])
}
}
return filteredCF
}
//MAKE COMPLEX MORLET WAVELET
func makeMorlet(sine:ComplexFloatArray, gauss:[Float], count:Int, iteration:Int) {
var kernel = sine.floatMultiply(with: gauss)
filterBank.append(kernel)
}
//PERFORM FFT ON KERNEL
func fftKernel(kernel: ComplexFloatArray, N:Int, iteration:Int) {
var size = kernel.count
var logSize = 11
var FFTSetup = vDSP_create_fftsetup(vDSP_Length(logSize), FFTRadix(FFT_RADIX2))
var output = kernel.outOfPlaceComplexFourierTransform(setup: FFTSetup!, resultSize: size, logSize: UInt(logSize), direction: ComplexFloatArray.FourierTransformDirection(rawValue: 1)!)
output.removeAtIndex(index:0)
fftFilterBank.append(output)
}
//Test Signal to Convolve - 1kHz Sine Wave
func testSine(){
var testTimeArray = makeArray(from: ((1.0/Float(fs))*((-0.5)*Float(kernelLength))), to: ((1.0/Float(fs))*((0.5)*Float(kernelLength))), increment: 1/fs)
var testSine = ComplexFloatArray.zeros(count: testTimeArray.count)
for i in 0..<testTimeArray.count{
var x = 2 * Float.pi * 1000 * testTimeArray[i]
testSine.reals[i] = cos(x)
testSine.imaginaries[i] = sin(x)
}
convolveSignal(realSamples: testSine.reals, imagSamples:testSine.imaginaries)
}
}
最后在我的ViewController类中，我有以下内容：
finally in my ViewController class I have the following:
class ViewController: UIViewController {
var wavelet = CWT()
func viewDidLoad(){
wavelet.synthesizeKernels()
wavelet.testSine()
}
}
如果我对此进行调试并在makeMorlet函数上暂停，则FloatMultiply的结果将全部为零，尽管等式的左侧和右侧的长度值相同。
If I debug this and pause on the makeMorlet function, the results of FloatMultiply are all zeros, despite having the same length values in both the left and right side of the equation.
推荐答案
不幸的是，您的代码无法在具有默认设置的Xcode 10.2上运行。
Unfortunately, your code does not run on Xcode 10.2 with default settings.
线程1：同时访问0x600001170550，但修改需要独占访问权限
Thread 1: Simultaneous accesses to 0x600001170550, but modification requires exclusive access
我是不确定是否将对内存的独占访问权限设置为关闭（仅编译时强制执行），或使用某些旧版本的Xcode，但是Swift编译器会在假定排他性强制完全有效的情况下优化并生成代码。 （因此，永远不要关闭对内存的独占访问权限。）
I'm not sure you are setting Exclusive Access to Memory to off (Compile time Enforcement Only), or using some older version of Xcode, but Swift compiler optimizes and generates code assuming Exclusivity Enforcement is fully valid. (So, you should never set Exclusive Access to Memory off.)
请仔细阅读本文：
您在 ComplexFloatArray 中实现的 count 违反了此强制措施。在执行传递到 reals.withUnsafeMutableBufferPointer 的闭包时，您不能访问 reals ，因为该数组被方法专用。
Your implementation of count in ComplexFloatArray is violating this enforcement. While executing the closure passed to reals.withUnsafeMutableBufferPointer, you cannot access reals as the array is exclusively occupied by the method.
违反此规则，Swift运行时可能会显示任何意外行为。
And with violating this rule, Swift runtime may show any sort of unexpected behavior.
尝试更改实现 count 的内容，如下所示，看看会发生什么：
Try changing the implementation of count like following, and see what happens:
class ComplexFloatArray {
var reals: [Float]
var imaginaries: [Float]
init(reals: [Float], imaginaries: [Float]){
self.reals = reals
self.imaginaries = imaginaries
assert(reals.count == imaginaries.count)
self.count = reals.count
}
//Make `count` a stored property.
var count: Int
}
extension ComplexFloatArray {
//Remove this computed property.
// var count: Int {
// assert(reals.count == imaginaries.count)
// return reals.count
// }
static let stride = 1
func append(real: Float, imaginary: Float) {
self.reals.append(real)
self.imaginaries.append(imaginary)
count += 1
}
func removeAtIndex(index: Int) {
self.reals.remove(at: index)
self.imaginaries.remove(at: index)
count -= 1
}
//...
}
再一次，您的代码会生成许多带有建议设置的警告，您最好不要忽略它们。
One more, your code generates many warnings with recommended settings, you should better not ignore them.
这篇关于vDSP_zrvmul不返回任何结果（或全零）的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！
