When joining two signals of different frequencies how do I find the phase shift that makes the join smooth?

Question

I'm generating a sine wave and I want the second half of the signal to be in a different frequency. How do I find the phase shift I can apply to the second half so that the joining between the halves at a certain point in time is smooth?

More specifically, I'm generating sound and want to avoid the clicking sound when frequency changes.

Desired result joins smoothly (please ignore the poor image editing):

time:
t0                                              t1                  

The result I currently has a gap at t1:

And that happens because the 2nd part of the wave, when generated with the same phase (see it starts at 0° at t0), had a different Y axis value at t1:

If you look back at the 1st image, the 2nd part had to be shifted a bit to the left (i.e. it's phase starts at something > 0°) in order to smoothly connect with the 1st part (i.e. to have the same Y axis value at the time of frequency change)

Answer 1

Generate the second sine wave as

$$x(t) = sin(\omega_2 t + \omega_1t_0)$$

where $t_0$ is the time when the frequency changes from $\omega_1$ to $\omega_2$ .

Answer 2

To ensure smooth continuity we generate

$$ x_0 = \cos(\omega_0 t), \ t_0 \leq t < t_1 \\ x_1 = \cos(\omega_1 t + t_1 \cdot (\omega_0 / \omega_1)), \ t_1 \leq t < t_2 \\ $$

where $\omega_0 t$ is input phase for $x_0$.

Example

It cannot be perfectly smooth for any arbitrary $t_1$ per discretization limitations (but $t_1$ can be chosen to maximize smoothness; use e.g. derivative criteria).

Explanation

For double the frequency, the "same" point will occur at half the input phase, so to generate $f=2$ as continuous with $f=1$, we generate $f=1$ up to some cutoff point, and then $f=2$ starting from half the cutoff point. Generalize "double" and "half" via $f_0 / f_1$.

Code

import numpy as np
import matplotlib.pyplot as plt
N = 128
cut = 19
f0, f1 = 4, 8
t = np.linspace(0, 1, 128, 0)
x0 = np.cos(2np.pi  f0 * t)[:cut]
x1 = np.cos(2np.pi  f1 * (t + t[cut]*(f0/f1)))[:-cut]
x = np.hstack([x0, x1])
plt.plot(x)
plt.title("f0, f1 = %s, %s | transition at sample=%s" % (f0, f1, cut),
          weight='bold', loc='left', fontsize=16)

Answer 3

Here is my picture.

You don't need to shift the sinusoid since in a programming context you just need the values to append in a buffer (or file).

We have a first sinusoid (orange) and let's just say it stopped at the cyan point (just a little before the full cycle). We need to pick up from there with the second sinusoid (red). The points where the value (height/vertical direction) of the second is the same as that last point of the first are the pink/magenta ones (there are two but we will just use one - if you need to dive into the fine details of which is better, you can).

Now the two sinusoids will be equal means

$$ \sin \left(2 \pi f_{1} t_{1} \right) = \sin \left(2 \pi f_{2} t_{2} \right) \tag{1} $$

By taking the $\arcsin$ we get

$$ 2 \pi f_{1} t_{1} = 2 \pi f_{2} t_{2} \tag{2} $$

(there is also $2 \pi f_{1} t_{1} = 2 \pi f_{2} t_{2} + \theta$ for the other point).

And so

$$ t_{2} = \frac{f_{1}}{f_{2}} t_{1} \tag{3} $$

$t_{1}$ is the time when the first sinusoid ended (cyan point). $t_{2}$ is the time when we need to start taking the values of the second sinusoid (magenta point).

So you just let the second sinusoid run until it reaches $t_{2}$; then you start taking its values and append to your buffer $\implies$ no click.

All these times are counted from $0$ - no need to do the math shifting of the sinusoid.

(The green sinusoid is just for illustration purposes - the red-shifted)