http://nbviewer.jupyter.org/gist/leftaroundabout/725e015c9ea7a2f61cd8f2eec4028dff
As G Cab said, a synthesizer generates such a waveform by low-pass filtering a sawtooth signal.
To describe that mathematically: we start out with a sawtooth
$$
s(t) = \operatorname{round} (t) - t.
$$

The low-pass filter is typically a kind of state variable filter. These are named so because there is a “state variable” that's governed by an ordinary differential equation dependent on the incoming signal. The simplest form, that can be build with just a resistor and a capacitor, can be written (I'm using PDE-convention notation for derivatives, i.e. $r_t = \frac{\partial r}{\partial t}$)
$$
r_t(r,t) = \eta \cdot (s(t) - r(t))
$$
Because $r_t$ depends Lipschitz-continuously on $r$, the Picard-Lindelöf theorem tells us that the solution $r : \mathbb{R}\to\mathbb{R}$ is uniquely determined by this differential equation, in other words, the above equation for $r_t$ also defines $r(t)$.
But how does it actually look? Well, we can use numerical techniques to calculate an arbitrarily good approximation to the exact solution. A common method is the fourth-order† Runge-Kutta solver. Implemented in Haskell:
rk₄ :: (Time -> ℝ -> ℝ) -- the function r_t(t,r)
-> Time -- time-step for the solver
-> [(Time, ℝ)] -- sequence of solution snapshots [r(t)]
rk₄ f h = go 0 0
where go t y = (t,y) : go (t+h) (y + h/6*(k₁ + 2*k₂ + 2*k₃ + k₄))
where k₁ = f t y
k₂ = f (t + h/2) (y + h/2*k₁)
k₃ = f (t + h/2) (y + h/2*k₂)
k₄ = f (t + h) (y + h*k₃)
If we evaluate this for the above filter $r$ with a couple of different values for $\eta$, we get this result:
toRenderable $ forM [0 .. 8] $ \η -> signalPlot ("η = "++show η)
$ rk₄ (\t r -> η * (s t - r)) 0.01

Well, this does appear to behave broadly related to the function you've described, but it's hardly the same thing. In particular, the result you get for low $\eta$ doesn't actually look much like a sine, it's still pretty spiky on the negative side, but already has a strongly attenuated amplitude.
And indeed that's also the case for a real analogue synthesizer: those never generate exact sine signals, only approximations‡. Im my example the deviation is extreme because I've used a very simple filter, which has only order 1. I.e., when I make $\eta$ small enough to get rid of the transient high-frequency components (the “edges”), then I must also sacrifice a lot of the base sinusoidial part.
With a suitable second-order filter, we can get a better result. That requires an additional variable $u$ to be solved:
toRenderable $ forM [0, 5 .. 30] $ \η -> signalPlot ("η = "++show η) $ second fst
<$> rk₄ (\t (r,u) -> (u, η^2 * (s t - r) - η*u)) 0.01

Still not perfect, but a really well-designed filter can get you very close to a real sine. Filter design used to be a big research topic. Nowadays it tends to be more practical to use digitally sampled signals, then you can just perform a Fourier transform, take whichever frequency components you want, and zero out or attenuate the rest to any amplitude you like.
†RK4 is arguably a bit overkill here. Because this filter is linear, a discretised form can actually be calculated much more efficiently and accurately as an IIR, using linear filter theory.
‡If the goal is really only to generate a sine, then you can actually get much more out of a simple 2nd-order filter than in my example, by using high resonance peak: you start out with only a very weak rectangular signal that's feeding a resonant LC circuit at the right frequency so the the output has a much higher amplitude. But this requires that the filter and oscillator are exactly in tune – in practice, they're generally back-coupled to a phase-locked loop, i.e. the oscillator is actually part of the filter resonance.