从公式到一首歌：用代码和数学合成音乐 From Formula to Song: Making Music with Code and Mathematics

Open a WAV file and there is no piano, drum, or voice inside. There is only a long column of numbers between −1 and 1. A player reads them at a fixed rate, the loudspeaker cone follows their movement, and sound appears.

That plain fact is the useful starting point for making music in code: the program does not have to imitate what an instrument looks like. It only has to calculate the pressure changes that instrument would make over time. Pitch is how quickly a pattern repeats. Timbre is the detail within one repetition. Performance lives in the attack, decay, and differences of a few milliseconds.

Hitone works this way. It contains no sample packs and calls no software instruments; every “instrument” is arithmetic on a NumPy array. The sections below start with one sine wave and build toward a complete arrangement that can be written to disk. The three demos calculate their audio in the browser too, and remain silent until Play is pressed.

Sound begins as samples

Digital audio cuts continuous time into evenly spaced cells. A sample rate of Fₛ = 44100 stores 44,100 numbers per second. Sample n occurs at t = n / Fₛ seconds; in the other direction, a sound lasting T seconds needs N = T · Fₛ samples.

A sine wave can be written directly:

import numpy as np

SR = 44_100

def sine(freq, seconds):
    n = int(seconds * SR)
    step = 2 * np.pi * freq / SR
    phase = np.cumsum(np.full(n, step))
    return np.sin(phase)

At a fixed frequency, 2πft and accumulated phase give the same answer. Accumulation matters as soon as the note bends or vibrato arrives. Frequency says how quickly phase is moving now; it is not a changing number to multiply by time. The latter makes phase jump when a parameter moves, and the ear hears the jump as a click.

More cycles inside the fixed window mean a higher pitch. Changing the shape changes the detail inside each cycle, so it changes the timbre too.

A note name is another way to write a frequency

Twelve-tone equal temperament divides an octave into twelve equal ratios. Frequency doubles over an octave, so each semitone multiplies it by 2^(1/12). With A4 = 440 Hz at MIDI note 69:

def frequency(midi_note):
    return 440.0 * 2 ** ((midi_note - 69) / 12)

frequency(69)  # A4  -> 440.0 Hz
frequency(72)  # C5  -> 523.25 Hz
frequency(81)  # A5  -> 880.0 Hz

Transposition therefore needs no new audio. Multiply every frequency by 2^(n/12) to move the entire part by n semitones. Scales and chords are just collections of semitone intervals: a major triad is [0, 4, 7], a minor triad [0, 3, 7]. The code keeps the relationship rather than a frequency table where a typo can hide.

Harmonics decide what the sound is

A pure sine contains one frequency. It sounds clean and a little empty. Real strings, reeds, and vocal folds vibrate at integer multiples of a fundamental at the same time. Add those components and a richer periodic shape appears:

def additive(freq, seconds, amplitudes):
    n = int(seconds * SR)
    t = np.arange(n) / SR
    out = np.zeros(n)

    for k, amp in enumerate(amplitudes, start=1):
        out += amp * np.sin(2 * np.pi * k * freq * t)

    return out / max(1, np.abs(out).max())

A sawtooth has harmonics that fall roughly as 1/k. A square keeps only odd harmonics. A triangle keeps the odd ones but lets them fall quickly as 1/k². The names are not mysterious; each is shorthand for a particular list of harmonic levels.

Click a harmonic column to change its strength. The fundamental stays fixed while the sound moves from soft to bright, sharp, or hollow.

An envelope turns a waveform into a performance

An unchanging waveform is a test tone. A piano, plucked string, and drum are easy to tell apart largely because of how their energy arrives, holds, and leaves. The smallest useful step is to multiply the waveform by an envelope:

def envelope(n, attack=0.005, decay=0.6, curve=2.2):
    e = np.ones(n)
    na = min(n, int(attack * SR))
    nd = min(n - na, int(decay * SR))

    e[:na] = np.linspace(0, 1, na) ** 1.3
    e[n - nd:] = np.linspace(1, 0, nd) ** curve
    return e

note = sine(220, 1.2)
note *= envelope(len(note), attack=0.004, decay=0.9)

The decay is deliberately not a straight line. A struck or plucked object gives up most of its energy early and then fades more slowly; a power curve is closer to that motion than a constant-rate fade. Karplus–Strong synthesis goes further by putting a lowpass inside a feedback loop, so high frequencies disappear before low ones. That gradual darkening is what a string does, and scaling all frequencies with one envelope cannot reproduce it.

A filter is convolution with another column of numbers

Filters are often drawn as knobs, but code needs their impulse response h[n]. Convolve the input x[n] with h[n] to produce the output:

A one-pole lowpass has a closed-form response. For cutoff frequency f:

def lowpass(x, hz):
    a = np.exp(-2 * np.pi * hz / SR)
    length = int(np.log(1e-4) / np.log(a))  # decay to −80 dB
    h = (1 - a) * a ** np.arange(length)
    return np.convolve(x, h)[:len(x)]

This implementation does not update filter state sample by sample. It writes the formula into an array once and hands it to convolution. Short responses use direct convolution; long responses move to an FFT. The two routes sound the same, but they decide whether a multi-minute track can be regenerated in seconds or minutes. Fast rendering is what makes parameters genuinely editable.

Rhythm converts musical time into sample positions

An arrangement should not be written directly in seconds. At 120 BPM, one beat lasts 0.5 seconds. Change the tempo to 96 and scattered values such as 1.0, 1.5, and 2.0 will not arrange themselves back into bars. A stable interface accepts bars and beats:

class Track:
    def __init__(self, bpm=120, swing=0.5):
        self.bpm = bpm
        self.beat = 60.0 / bpm
        self.bar_seconds = 4 * self.beat
        self.swing = swing

    def at(self, bar, beat=0.0):
        whole, fraction = divmod(float(beat), 1.0)
        if abs(fraction - 0.5) < 1e-9:
            fraction = self.swing
        return bar * self.bar_seconds + (whole + fraction) * self.beat

Swing belongs here too, exactly once. Push the off-eighth from 0.50 to 0.58 and every hi-hat, bass note, and sidechain envelope follows the same grid. The drums cannot swing while the rest of the arrangement continues in a straight line.

Toggle sixteenth notes, then change BPM and Swing. The circles use the same at() calculation as the generated playback buffer.

A song needs layers, not a pile of notes

Sound functions answer “how does one note speak?” Arrangement answers “when does it appear?” Keep those layers separate. This passage talks only about bars, chords, and level; it does not need to know that the electric piano uses FM internally:

t = Track(bpm=104, bars=32, swing=0.56)
t.bus('keys', send=0.18, chorus={'rate': 0.42}, width=13)

progression = ['Amaj7', 'F#m7', 'Dmaj7', 'Eadd9']
for bar in range(32):
    chord = progression[bar % len(progression)]
    for freq in ch(chord, octave=3):
        note = rhodes(freq, at(1.8)) * envelope(at(1.8))
        t.add('keys', note, t.at(bar, 0), gain=0.22)

Each part enters its own bus before panning, chorus, delay, reverb, and sidechain are applied consistently. Mixing is still addition: align the arrays in time and sum them. The remaining issue is headroom. Several parts that do not clip alone can exceed [-1, 1] together. Leaving space on the buses, then applying gentle soft clipping and peak normalisation at the master, is clearer than quietly turning down every note as it is placed.

The last step is not “it probably sounds fine”

Code-generated audio can be checked repeatedly. The same random seed should produce the same file. Tempo can be measured again from the rendered audio. RMS, peak, crest factor, and spectral balance can be calculated for each section. A spectrogram is especially useful because it compresses the whole structure into one image.

This is not decoration. Time runs across the page, logarithmic frequency rises vertically, and brightness shows energy. A crowded verse, a low end that disappears halfway through, or a crescendo that never happened becomes visible at once.

The finished piece is still a column of numbers, but every number now has a reason to be there. Frequency gives pitch, harmonics give timbre, envelopes and filters shape gestures, the time grid organises rhythm, and buses place everything in one space. The code preserves not only the final WAV, but why the piece sounds the way it does.

The complete synthesis, arrangement, and analysis code is available in the Hitone repository.