# Compile Time Computation

Kronos produces runtime code that is both deterministic and simple. Therefore, most of the abstraction you can use to generate complex patches takes place at compile time.

## Sinusoid Approximation

As an example, we are going to write a sinusoidal oscillator that uses polynomial approximation. This technique is not as efficient as the various recursive methods of sinusoid generation, but it has the benefit of adjustable precision and inexpensive modulation. That is why it is a good choice for frequency modulation synthesis.

## MacLaurin Series

Our plan is to develop a polynomial approximation for a sinusoidal slope and utilize the symmetry properties to generate a full waveform period. The first step is the MacLaurin series.

```
Import Algorithm
Fact(n) {
When(n > #1
n * Fact(n - #1)
Otherwise
#1)
}
is = Algorithm:Expand(#10 (+ #1) #0)
Algorithm:Map(Fact is)
````#1x2 #2 #6 #24 #120 #720 #5040 #40320 #362880 nil
`
Sin-Coef(n) {
Math:Pow(#-1 n) / Fact(#2 * n + #1)
}
coefs = Algorithm:Map(Sin-Coef is)
coefs`#1 #-0.16666666666666666666666666666666666667 #0.008333333333333333333333333333333333333 #-0.0001984126984126984126984126984126984127 #0.000002755731922398589065255731922398589065 #-0.000000025052108385441718775052108385441718775 #0.00000000016059043836821614599392377170154947933 #-0.0000000000007647163731819816475901131985788070444 #0.000000000000002811457254345520763198945583010320016 #-8.220635246624329716955981236872280749e-18 nil
`

Please note that as we are using invariant numbers (`#10`

), the entire computation happens at compile time during the specialization pass.

## Horner-form polynomial

Armed with polynomial coefficients, we can use Horner's scheme to evaluate the polynomial efficiently. Since our series only has coefficients for odd powers, we use `x^2`

as the polynomial variable.

```
Horner(x coefs...) {
Algorithm:Fold((c p) => c + x * p coefs...)
}
SinA(w) {
w * Horner(w * w coefs)
}
Import Math
Algorithm:Map(SinA
Math:Pi / 4
Math:Pi / 3
Math:Pi / 2)
````0.70710677 0.86602545 0.99999988
`

## Periodicity

Approximating `sin`

makes sense, because zero is in the middle of the slope. We can further shift the phase angle by `-Pi/2`

to translate sine into cosine, which is beneficial because cosine is symmetrical around zero.

```
CosA(w) {
SinA(Abs(w) - Math:Pi / #2)
}
Algorithm:Map(CosA
Math:Pi
Math:Pi / -2
0
Math:Pi / 2
Math:Pi )
````#0.9999999999999998484472428494967738426 0 -0.99999988 0 #0.9999999999999998484472428494967738426
`

We now have an approximation that's decent in the interval [-Pi, Pi]. We can plug in a phasor:

```
Import Gen
snd = CosA((Gen:Phasor(440) * 2 - 1) * Math:Pi) * 0.2
```

## Cleaning Up

For completeness, we may want to warp the whole thing in a function.

```
SinOsc(freq) {
; Refer to Map, Expand and Fold from Algorithm
; with implicit package prefix
Use Algorithm[Map Expand Fold]
N = #10 ; approximation order
; compute polynomial coefficients
coefs = Map(Sin-Coef Expand(N (+ #1) #0))
; phasor
phase = Gen:Phasor(freq)
; map phasor to [-Pi, Pi]
x = ( Abs(phase * 2 - 1) - 0.5 ) * Math:Pi
x * Horner(x * x coefs)
}
snd = SinOsc(440 + 10 * SinOsc(5.5)) * 0.2
; Frequency Modulation Synthesis
f0 = 110
mod = SinOsc(0.1) * 32
op1 = SinOsc(f0 * 3)
op2 = SinOsc((1 + op1 * mod) * f0)
snd = op2 * 0.2
```

## Compile Time Power

To recap, we have an oscillator definition that relies on a MacLaurin series that looks pretty close to that from a mathematical textbook. However, the generated code avoids all the tricky stuff. If we take a peek at the inner loop of our signal processor, this is what we see in LLVMish:

```
%15 = fmul float %10, 2.000000e+00
%16 = fadd float %15, -1.000000e+00
%17 = fmul float %16, 0x400921FB60000000
%abs.i.i = tail call float @llvm.fabs.f32(float %17) #1
%18 = fadd float %abs.i.i, 0xBFF921FB60000000
%19 = fmul float %18, %18
%20 = fmul float %19, 0x3C62F49B40000000
%21 = fsub float 0x3CE952C780000000, %20
%22 = fmul float %19, %21
%23 = fadd float %22, 0xBD6AE7F3E0000000
%24 = fmul float %19, %23
%25 = fadd float %24, 0x3DE6124620000000
%26 = fmul float %19, %25
%27 = fadd float %26, 0xBE5AE64560000000
%28 = fmul float %19, %27
%29 = fadd float %28, 0x3EC71DE3A0000000
%30 = fmul float %19, %29
%31 = fadd float %30, 0xBF2A01A020000000
%32 = fmul float %19, %31
%33 = fadd float %32, 0x3F81111120000000
%34 = fmul float %19, %33
%35 = fadd float %34, 0xBFC5555560000000
%36 = fmul float %19, %35
%37 = fadd float %36, 1.000000e+00
%38 = fmul float %18, %37
%39 = bitcast i8* %2 to float*
store float %38, float* %39, align 4, !alias.scope !9, !noalias !10
```

In other words, the compiler has generated an inlined Horner form polynomial with constant multipliers: pretty much what we would write by hand in C. Second-order code generation has some additional benefits - this oscillator could easily have parametric precision. `SinOsc`

could simply receive the approximation order, `N`

as a compile time constant argument.

To look at Kronos code output, please take a look at the command line workflow and `kc`

, the static compiler.