hand-corrected compiler output

compile.jl

function compile(code)
    f = tempname()
    write(f, code)
    run(pipeline(`faust -lang julia $f`, stdout=pipeline(`tee ex.jl`)))
end

compile("""
import("stdfaust.lib");

process = fi.resonbp(440.0, 1000.0, 0.5);
""")

ex.jl

# TODO: move UIGlue to architecture file
mutable struct UIGlue
end

function mydsp_faustpower2_f(value::T) where {T}
	return (value * value) 
end

mutable struct mydsp{T}
	fSampleRate::Int32 
	fConst3::T 
	fConst4::T 
	fConst5::T 
	fConst6::T 
	fRec0::AbstractVector{T}
	fConst7::T 
	mydsp{T}() where {T} = begin
		dsp = new{T}()
		dsp.fRec0 = zeros(T, 3)
		dsp
	end
end

function getSampleRatemydsp(dsp::mydsp{T}) where {T}
	return dsp.fSampleRate 
end

function getNumInputsmydsp(dsp::mydsp{T}) where {T}
	return 1 
end
function getNumOutputsmydsp(dsp::mydsp{T}) where {T}
	return 1 
end

function classInitmydsp(sample_rate::Int32)
end

function instanceResetUserInterfacemydsp(dsp::mydsp{T}) where {T}
end

function instanceClearmydsp(dsp::mydsp{T}) where {T}
	for l0::Int32 = 1:3
		dsp.fRec0[l0] = 0.0f0
	end
end

function instanceConstantsmydsp(dsp::mydsp{T}, sample_rate::Int32) where {T}
	dsp.fSampleRate = sample_rate 
	fConst0::T = tan((1382.30078f0 / min(192000.0f0, max(1.0f0, T(dsp.fSampleRate))))) 
	fConst1::T = (1.0f0 / fConst0) 
	fConst2::T = (((fConst1 + 0.00100000005f0) / fConst0) + 1.0f0) 
	dsp.fConst3 = (0.5f0 / (fConst0 * fConst2)) 
	dsp.fConst4 = (1.0f0 / fConst2) 
	dsp.fConst5 = (((fConst1 + -0.00100000005f0) / fConst0) + 1.0f0) 
	dsp.fConst6 = (2.0f0 * (1.0f0 - (1.0f0 / mydsp_faustpower2_f(fConst0)))) 
	dsp.fConst7 = (0.0f0 - dsp.fConst3) 
end

function instanceInitmydsp(dsp::mydsp{T}, sample_rate::Int32) where {T}
	instanceConstantsmydsp(dsp, sample_rate)
	instanceResetUserInterfacemydsp(dsp)
	instanceClearmydsp(dsp)
end

function initmydsp(dsp::mydsp{T}, sample_rate::Int32) where {T}
	classInitmydsp(sample_rate)
	instanceInitmydsp(dsp, sample_rate)
end

function buildUserInterfacemydsp(dsp::mydsp{T}, ui_interface::UIGlue) where {T}
end

function computemydsp(dsp::mydsp{T}, count::Int32, inputs, outputs) where {T}
	input0 = @view inputs[:, 1] 
	output0 = @view outputs[:, 1] 
	for i0::Int32 = 1:count
		dsp.fRec0[1] = ((input0[i0]) - (dsp.fConst4 * ((dsp.fConst5 * dsp.fRec0[3]) + (dsp.fConst6 * dsp.fRec0[2])))) 
		output0[i0] = (((dsp.fConst3 * dsp.fRec0[1]) + (dsp.fConst7 * dsp.fRec0[3]))) 
		dsp.fRec0[3] = dsp.fRec0[2] 
		dsp.fRec0[2] = dsp.fRec0[1] 
	end
end

runtests.jl

# import Pkg; Pkg.add(["BenchmarkTools", "FFTW", "ReverseDiff", "Plots", "Test"])
using BenchmarkTools
using FFTW
using ReverseDiff: JacobianConfig, JacobianTape, jacobian!, compile
using Plots
using Test

include("ex.jl")

samplerate = Int32(44100)
block_size = Int32(2048)
f!(outputs, inputs; block_size::Int32=block_size) = begin
    dsp = mydsp{eltype(outputs)}()
    initmydsp(dsp, samplerate)
    computemydsp(dsp, block_size, inputs, outputs)
end

inputs = 2 * rand(Float32, block_size, 1) .- 1
outputs = zeros(Float32, block_size, 1)
const cfg = JacobianConfig(outputs, inputs)
const f_tape = JacobianTape(f!, outputs, inputs, cfg)
const compiled_f_tape = compile(f_tape)

@benchmark f!($outputs, $inputs)
df = jacobian!(compiled_f_tape, inputs)
@test size(df) == (block_size, block_size)
heatmap(df)

spec = abs.(FFTW.rfft(outputs))
freqs = FFTW.rfftfreq(size(spec, 1), samplerate)
peak = argmax(spec)[1]
@test peak == 21 || peak == 22
@test outputs != zeros(Float32, size(outputs))