int ideal_filter_coef(int ntaps, int f_in, int f_c, int *coef) {
  int i, isum_coef;
  float bw, tau, scale, pi;
  float fcoef[63] = {0}, sum_coef;
  pi = acos((double)(-1.));
  bw = (float)f_c / (float)f_in;
  fcoef[0] = .50;
  sum_coef = fcoef[0];
  for (i = 1; i < ntaps + 1; i++) {
    fcoef[i] = 0.5 * exp(-(double)((i) * (i)) * bw);
    sum_coef += fcoef[i];
  }
  scale = (32768. / (float)sum_coef);
  isum_coef = 0;
  for (i = 0; i < ntaps; i++) {
    *(coef + i) = (int)(scale * fcoef[i]);
    isum_coef += *(coef + i);
  }
  return (isum_coef);
}


x86 assembly (clang, -O0):
<ideal_filter_coef>:
push   %rbp
mov    %rsp,%rbp
sub    $0x140,%rsp
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %edx,-0xc(%rbp)
mov    %rcx,-0x18(%rbp)
lea    -0x130(%rbp),%rdi
xor    %esi,%esi
mov    $0xfc,%edx
call   1040 <memset@plt>
movsd  0xea5(%rip),%xmm0
call   1030 <acos@plt>
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x30(%rbp)
cvtsi2ssl -0xc(%rbp),%xmm0
cvtsi2ssl -0x8(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x24(%rbp)
movss  0xe74(%rip),%xmm0
movss  %xmm0,-0x130(%rbp)
ff
movss  -0x130(%rbp),%xmm0
ff
movss  %xmm0,-0x134(%rbp)
ff
movl   $0x1,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
mov    -0x4(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    123b <ideal_filter_coef+0x10b>
mov    -0x1c(%rbp),%eax
imul   -0x1c(%rbp),%eax
cvtsi2sd %eax,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movss  -0x24(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm1,%xmm0
call   1050 <exp@plt>
movaps %xmm0,%xmm1
movsd  0xe1d(%rip),%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movslq -0x1c(%rbp),%rax
movss  %xmm0,-0x130(%rbp,%rax,4)
ff ff
movslq -0x1c(%rbp),%rax
movss  -0x130(%rbp,%rax,4),%xmm0
ff ff
addss  -0x134(%rbp),%xmm0
ff
movss  %xmm0,-0x134(%rbp)
ff
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    11ab <ideal_filter_coef+0x7b>
movss  -0x134(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm1
movsd  0xdc1(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x2c(%rbp)
movl   $0x0,-0x20(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    12b6 <ideal_filter_coef+0x186>
movss  -0x2c(%rbp),%xmm0
movslq -0x1c(%rbp),%rax
mulss  -0x130(%rbp,%rax,4),%xmm0
ff ff
cvttss2si %xmm0,%edx
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    126a <ideal_filter_coef+0x13a>
mov    -0x20(%rbp),%eax
add    $0x140,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<ideal_filter_coef>:
push   %rbp
push   %r15
push   %r14
push   %r12
push   %rbx
sub    $0x110,%rsp
xorps  %xmm0,%xmm0
movaps %xmm0,0x10(%rsp)
movups %xmm0,0xfc(%rsp)
movaps %xmm0,0xf0(%rsp)
movaps %xmm0,0xe0(%rsp)
movaps %xmm0,0xd0(%rsp)
movaps %xmm0,0xc0(%rsp)
movaps %xmm0,0xb0(%rsp)
movaps %xmm0,0xa0(%rsp)
movaps %xmm0,0x90(%rsp)
movaps %xmm0,0x80(%rsp)
movaps %xmm0,0x70(%rsp)
movaps %xmm0,0x60(%rsp)
movaps %xmm0,0x50(%rsp)
movaps %xmm0,0x40(%rsp)
movaps %xmm0,0x30(%rsp)
movaps %xmm0,0x20(%rsp)
movl   $0x3f000000,0x10(%rsp)
3f
xor    %r12d,%r12d
test   %edi,%edi
jle    137e <ideal_filter_coef+0x26e>
mov    %rcx,%r15
mov    %edi,%r14d
xorps  %xmm0,%xmm0
cvtsi2ss %edx,%xmm0
cvtsi2ss %esi,%xmm1
divss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,0x8(%rsp)
lea    0x1(%r14),%ebx
movss  0xe35(%rip),%xmm1
mov    $0x1,%ebp
movss  %xmm1,0x4(%rsp)
mov    %ebp,%eax
imul   %ebp,%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
xorpd  0xe26(%rip),%xmm0
mulsd  0x8(%rsp),%xmm0
call   1030 <exp@plt>
movss  0x4(%rsp),%xmm1
mulsd  0xe1d(%rip),%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0x10(%rsp,%rbp,4)
addss  %xmm0,%xmm1
add    $0x1,%rbp
cmp    %rbp,%rbx
jne    11d0 <ideal_filter_coef+0xc0>
test   %r14d,%r14d
jle    137e <ideal_filter_coef+0x26e>
movss  0xdd9(%rip),%xmm0
divss  %xmm1,%xmm0
movss  0xdc9(%rip),%xmm1
mulss  %xmm0,%xmm1
cvttss2si %xmm1,%r12d
mov    %r12d,(%r15)
cmp    $0x1,%r14d
je     137e <ideal_filter_coef+0x26e>
mov    %r14d,%eax
lea    -0x1(%rax),%rdx
mov    $0x1,%ecx
cmp    $0x8,%rdx
jb     1360 <ideal_filter_coef+0x250>
mov    %rdx,%rcx
and    $0xfffffffffffffff8,%rcx
movd   %r12d,%xmm1
movaps %xmm0,%xmm3
shufps $0x0,%xmm0,%xmm3
lea    -0x8(%rcx),%rsi
mov    %rsi,%rbp
shr    $0x3,%rbp
add    $0x1,%rbp
test   %rsi,%rsi
je     1391 <ideal_filter_coef+0x281>
mov    %rbp,%rdi
and    $0xfffffffffffffffe,%rdi
pxor   %xmm2,%xmm2
mov    $0x1,%esi
xchg   %ax,%ax
movups 0x10(%rsp,%rsi,4),%xmm4
movups 0x20(%rsp,%rsi,4),%xmm5
mulps  %xmm3,%xmm4
mulps  %xmm3,%xmm5
cvttps2dq %xmm4,%xmm4
cvttps2dq %xmm5,%xmm5
movdqu %xmm4,(%r15,%rsi,4)
movdqu %xmm5,0x10(%r15,%rsi,4)
paddd  %xmm4,%xmm1
paddd  %xmm5,%xmm2
movups 0x30(%rsp,%rsi,4),%xmm4
movups 0x40(%rsp,%rsi,4),%xmm5
mulps  %xmm3,%xmm4
mulps  %xmm3,%xmm5
cvttps2dq %xmm4,%xmm4
cvttps2dq %xmm5,%xmm5
movdqu %xmm4,0x20(%r15,%rsi,4)
movdqu %xmm5,0x30(%r15,%rsi,4)
paddd  %xmm4,%xmm1
paddd  %xmm5,%xmm2
add    $0x10,%rsi
add    $0xfffffffffffffffe,%rdi
jne    12a0 <ideal_filter_coef+0x190>
test   $0x1,%bpl
je     1338 <ideal_filter_coef+0x228>
movups 0x10(%rsp,%rsi,4),%xmm4
movups 0x20(%rsp,%rsi,4),%xmm5
mulps  %xmm3,%xmm4
mulps  %xmm3,%xmm5
cvttps2dq %xmm4,%xmm3
cvttps2dq %xmm5,%xmm4
movdqu %xmm3,(%r15,%rsi,4)
movdqu %xmm4,0x10(%r15,%rsi,4)
paddd  %xmm3,%xmm1
paddd  %xmm4,%xmm2
paddd  %xmm2,%xmm1
pshufd $0xee,%xmm1,%xmm2
paddd  %xmm1,%xmm2
pshufd $0x55,%xmm2,%xmm1
paddd  %xmm2,%xmm1
movd   %xmm1,%r12d
cmp    %rcx,%rdx
je     137e <ideal_filter_coef+0x26e>
or     $0x1,%rcx
nopl   0x0(%rax)
movss  0x10(%rsp,%rcx,4),%xmm1
mulss  %xmm0,%xmm1
cvttss2si %xmm1,%edx
mov    %edx,(%r15,%rcx,4)
add    %edx,%r12d
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1360 <ideal_filter_coef+0x250>
mov    %r12d,%eax
add    $0x110,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
ret
pxor   %xmm2,%xmm2
mov    $0x1,%esi
test   $0x1,%bpl
jne    130b <ideal_filter_coef+0x1fb>
jmp    1338 <ideal_filter_coef+0x228>

LLVM IR (-O0):
define i32 @ideal_filter_coef(i32 %0, i32 %1, i32 %2, i32* %3) {
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32*
%9 = alloca i32
%10 = alloca i32
%11 = alloca float
%12 = alloca float
%13 = alloca float
%14 = alloca float
%15 = alloca [63 x float]
%16 = alloca float
store i32 %0, i32* %5
store i32 %1, i32* %6
store i32 %2, i32* %7
store i32* %3, i32** %8
%17 = bitcast [63 x float]* %15 to i8*
%18 = call double @acos(double -1.000000e+00)
%19 = fptrunc double %18 to float
store float %19, float* %14
%20 = load i32, i32* %7
%21 = sitofp i32 %20 to float
%22 = load i32, i32* %6
%23 = sitofp i32 %22 to float
%24 = fdiv float %21, %23
store float %24, float* %11
%25 = getelementptr inbounds [63 x float], [63 x float]* %15, i64 0, i64 0
store float 5.000000e-01, float* %25
%26 = getelementptr inbounds [63 x float], [63 x float]* %15, i64 0, i64 0
%27 = load float, float* %26
store float %27, float* %16
store i32 1, i32* %9
br label %28
28: ; preds = %54, %4
%29 = load i32, i32* %9
%30 = load i32, i32* %5
%31 = add nsw i32 %30, 1
%32 = icmp slt i32 %29, %31
br i1 %32, label %33, label %57
33: ; preds = %28
%34 = load i32, i32* %9
%35 = load i32, i32* %9
%36 = mul nsw i32 %34, %35
%37 = sitofp i32 %36 to double
%38 = fneg double %37
%39 = load float, float* %11
%40 = fpext float %39 to double
%41 = fmul double %38, %40
%42 = call double @exp(double %41)
%43 = fmul double 5.000000e-01, %42
%44 = fptrunc double %43 to float
%45 = load i32, i32* %9
%46 = sext i32 %45 to i64
%47 = getelementptr inbounds [63 x float], [63 x float]* %15, i64 0, i64 %46
store float %44, float* %47
%48 = load i32, i32* %9
%49 = sext i32 %48 to i64
%50 = getelementptr inbounds [63 x float], [63 x float]* %15, i64 0, i64 %49
%51 = load float, float* %50
%52 = load float, float* %16
%53 = fadd float %52, %51
store float %53, float* %16
br label %54
54: ; preds = %33
%55 = load i32, i32* %9
%56 = add nsw i32 %55, 1
store i32 %56, i32* %9
br label %28
57: ; preds = %28
%58 = load float, float* %16
%59 = fpext float %58 to double
%60 = fdiv double 3.276800e+04, %59
%61 = fptrunc double %60 to float
store float %61, float* %13
store i32 0, i32* %10
store i32 0, i32* %9
br label %62
62: ; preds = %85, %57
%63 = load i32, i32* %9
%64 = load i32, i32* %5
%65 = icmp slt i32 %63, %64
br i1 %65, label %66, label %88
66: ; preds = %62
%67 = load float, float* %13
%68 = load i32, i32* %9
%69 = sext i32 %68 to i64
%70 = getelementptr inbounds [63 x float], [63 x float]* %15, i64 0, i64 %69
%71 = load float, float* %70
%72 = fmul float %67, %71
%73 = fptosi float %72 to i32
%74 = load i32*, i32** %8
%75 = load i32, i32* %9
%76 = sext i32 %75 to i64
%77 = getelementptr inbounds i32, i32* %74, i64 %76
store i32 %73, i32* %77
%78 = load i32*, i32** %8
%79 = load i32, i32* %9
%80 = sext i32 %79 to i64
%81 = getelementptr inbounds i32, i32* %78, i64 %80
%82 = load i32, i32* %81
%83 = load i32, i32* %10
%84 = add nsw i32 %83, %82
store i32 %84, i32* %10
br label %85
85: ; preds = %66
%86 = load i32, i32* %9
%87 = add nsw i32 %86, 1
store i32 %87, i32* %9
br label %62
88: ; preds = %62
%89 = load i32, i32* %10
ret i32 %89
}

LLVM IR (-O2):
define i32 @ideal_filter_coef(i32 %0, i32 %1, i32 %2, i32* nocapture writeonly %3) {
%5 = alloca [63 x float]
%6 = bitcast [63 x float]* %5 to i8*
%7 = getelementptr inbounds [63 x float], [63 x float]* %5, i64 0, i64 0
store float 5.000000e-01, float* %7
%8 = icmp slt i32 %0, 1
br i1 %8, label %145, label %9
9: ; preds = %4
%10 = sitofp i32 %2 to float
%11 = sitofp i32 %1 to float
%12 = fdiv float %10, %11
%13 = fpext float %12 to double
%14 = add nuw i32 %0, 1
%15 = zext i32 %14 to i64
br label %16
16: ; preds = %9, %16
%17 = phi i64 [ 1, %9 ], [ %29, %16 ]
%18 = phi float [ 5.000000e-01, %9 ], [ %28, %16 ]
%19 = trunc i64 %17 to i32
%20 = mul nsw i32 %19, %19
%21 = sitofp i32 %20 to double
%22 = fneg double %21
%23 = fmul double %13, %22
%24 = tail call double @exp(double %23)
%25 = fmul double %24, 5.000000e-01
%26 = fptrunc double %25 to float
%27 = getelementptr inbounds [63 x float], [63 x float]* %5, i64 0, i64 %17
store float %26, float* %27
%28 = fadd float %18, %26
%29 = add nuw nsw i64 %17, 1
%30 = icmp eq i64 %29, %15
br i1 %30, label %31, label %16
31: ; preds = %16
%32 = fdiv float 3.276800e+04, %28
%33 = icmp sgt i32 %0, 0
br i1 %33, label %34, label %145
34: ; preds = %31
%35 = zext i32 %0 to i64
%36 = fmul float %32, 5.000000e-01
%37 = fptosi float %36 to i32
store i32 %37, i32* %3
%38 = icmp eq i32 %0, 1
br i1 %38, label %145, label %39
39: ; preds = %34
%40 = add nsw i64 %35, -1
%41 = icmp ult i64 %40, 8
br i1 %41, label %131, label %42
42: ; preds = %39
%43 = and i64 %40, -8
%44 = or i64 %43, 1
%45 = insertelement <4 x i32> <i32 poison, i32 0, i32 0, i32 0>, i32 %37, i64 0
%46 = insertelement <4 x float> poison, float %32, i64 0
%47 = shufflevector <4 x float> %46, <4 x float> poison, <4 x i32> zeroinitializer
%48 = insertelement <4 x float> poison, float %32, i64 0
%49 = shufflevector <4 x float> %48, <4 x float> poison, <4 x i32> zeroinitializer
%50 = add nsw i64 %43, -8
%51 = lshr exact i64 %50, 3
%52 = add nuw nsw i64 %51, 1
%53 = and i64 %52, 1
%54 = icmp eq i64 %50, 0
br i1 %54, label %101, label %55
55: ; preds = %42
%56 = and i64 %52, 4611686018427387902
br label %57
57: ; preds = %57, %55
%58 = phi i64 [ 0, %55 ], [ %96, %57 ]
%59 = phi <4 x i32> [ %45, %55 ], [ %94, %57 ]
%60 = phi <4 x i32> [ zeroinitializer, %55 ], [ %95, %57 ]
%61 = phi i64 [ 0, %55 ], [ %97, %57 ]
%62 = or i64 %58, 1
%63 = getelementptr inbounds [63 x float], [63 x float]* %5, i64 0, i64 %62
%64 = bitcast float* %63 to <4 x float>*
%65 = load <4 x float>, <4 x float>* %64
%66 = getelementptr inbounds float, float* %63, i64 4
%67 = bitcast float* %66 to <4 x float>*
%68 = load <4 x float>, <4 x float>* %67
%69 = fmul <4 x float> %47, %65
%70 = fmul <4 x float> %49, %68
%71 = fptosi <4 x float> %69 to <4 x i32>
%72 = fptosi <4 x float> %70 to <4 x i32>
%73 = getelementptr inbounds i32, i32* %3, i64 %62
%74 = bitcast i32* %73 to <4 x i32>*
store <4 x i32> %71, <4 x i32>* %74
%75 = getelementptr inbounds i32, i32* %73, i64 4
%76 = bitcast i32* %75 to <4 x i32>*
store <4 x i32> %72, <4 x i32>* %76
%77 = add <4 x i32> %59, %71
%78 = add <4 x i32> %60, %72
%79 = or i64 %58, 9
%80 = getelementptr inbounds [63 x float], [63 x float]* %5, i64 0, i64 %79
%81 = bitcast float* %80 to <4 x float>*
%82 = load <4 x float>, <4 x float>* %81
%83 = getelementptr inbounds float, float* %80, i64 4
%84 = bitcast float* %83 to <4 x float>*
%85 = load <4 x float>, <4 x float>* %84
%86 = fmul <4 x float> %47, %82
%87 = fmul <4 x float> %49, %85
%88 = fptosi <4 x float> %86 to <4 x i32>
%89 = fptosi <4 x float> %87 to <4 x i32>
%90 = getelementptr inbounds i32, i32* %3, i64 %79
%91 = bitcast i32* %90 to <4 x i32>*
store <4 x i32> %88, <4 x i32>* %91
%92 = getelementptr inbounds i32, i32* %90, i64 4
%93 = bitcast i32* %92 to <4 x i32>*
store <4 x i32> %89, <4 x i32>* %93
%94 = add <4 x i32> %77, %88
%95 = add <4 x i32> %78, %89
%96 = add nuw i64 %58, 16
%97 = add i64 %61, 2
%98 = icmp eq i64 %97, %56
br i1 %98, label %99, label %57
99: ; preds = %57
%100 = or i64 %96, 1
br label %101
101: ; preds = %99, %42
%102 = phi <4 x i32> [ undef, %42 ], [ %94, %99 ]
%103 = phi <4 x i32> [ undef, %42 ], [ %95, %99 ]
%104 = phi i64 [ 1, %42 ], [ %100, %99 ]
%105 = phi <4 x i32> [ %45, %42 ], [ %94, %99 ]
%106 = phi <4 x i32> [ zeroinitializer, %42 ], [ %95, %99 ]
%107 = icmp eq i64 %53, 0
br i1 %107, label %125, label %108
108: ; preds = %101
%109 = getelementptr inbounds [63 x float], [63 x float]* %5, i64 0, i64 %104
%110 = bitcast float* %109 to <4 x float>*
%111 = load <4 x float>, <4 x float>* %110
%112 = getelementptr inbounds float, float* %109, i64 4
%113 = bitcast float* %112 to <4 x float>*
%114 = load <4 x float>, <4 x float>* %113
%115 = fmul <4 x float> %47, %111
%116 = fmul <4 x float> %49, %114
%117 = fptosi <4 x float> %115 to <4 x i32>
%118 = fptosi <4 x float> %116 to <4 x i32>
%119 = getelementptr inbounds i32, i32* %3, i64 %104
%120 = bitcast i32* %119 to <4 x i32>*
store <4 x i32> %117, <4 x i32>* %120
%121 = getelementptr inbounds i32, i32* %119, i64 4
%122 = bitcast i32* %121 to <4 x i32>*
store <4 x i32> %118, <4 x i32>* %122
%123 = add <4 x i32> %105, %117
%124 = add <4 x i32> %106, %118
br label %125
125: ; preds = %101, %108
%126 = phi <4 x i32> [ %102, %101 ], [ %123, %108 ]
%127 = phi <4 x i32> [ %103, %101 ], [ %124, %108 ]
%128 = add <4 x i32> %127, %126
%129 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %128)
%130 = icmp eq i64 %40, %43
br i1 %130, label %145, label %131
131: ; preds = %39, %125
%132 = phi i64 [ 1, %39 ], [ %44, %125 ]
%133 = phi i32 [ %37, %39 ], [ %129, %125 ]
br label %134
134: ; preds = %131, %134
%135 = phi i64 [ %143, %134 ], [ %132, %131 ]
%136 = phi i32 [ %142, %134 ], [ %133, %131 ]
%137 = getelementptr inbounds [63 x float], [63 x float]* %5, i64 0, i64 %135
%138 = load float, float* %137
%139 = fmul float %32, %138
%140 = fptosi float %139 to i32
%141 = getelementptr inbounds i32, i32* %3, i64 %135
store i32 %140, i32* %141
%142 = add nsw i32 %136, %140
%143 = add nuw nsw i64 %135, 1
%144 = icmp eq i64 %143, %35
br i1 %144, label %145, label %134
145: ; preds = %134, %34, %125, %4, %31
%146 = phi i32 [ 0, %31 ], [ 0, %4 ], [ %37, %34 ], [ %129, %125 ], [ %142, %134 ]
ret i32 %146
}