A wave is described completely by three numbers.

$A$

amplitude — how far the quantity swings from rest. The unit depends on what is oscillating: pascals for sound pressure, volts on a wire, or a number between $-1$ and $1$ in an audio buffer.

$f$

frequency — complete cycles per second, measured in hertz.

$\phi$

phase — where in the cycle the wave sits at $t=0$. Measured here in turns, where $0.25$ is a quarter of the way through a cycle.

package main

import (
	"fmt"
	"math"
)

const (
	amplitude = 1.0 // peak swing away from rest, in whatever unit the wave carries
	frequency = 2.0 // complete cycles per second, in hertz
	phase     = 0.0 // starting position within the cycle, in turns (1.0 = a full cycle)
)

// wave returns the value of the tone at time t, in seconds.
func wave(t float64) float64 {
	return amplitude * math.Sin(2*math.Pi*(frequency*t+phase))
}

func main() {
	period := 1 / frequency // seconds per cycle: the reciprocal of frequency

	fmt.Printf("amplitude %.2f, frequency %.2f Hz, period %.3f s\n",
		amplitude, frequency, period)

	// One full cycle, sampled at eight evenly spaced instants.
	for n := 0; n < 8; n++ {
		t := float64(n) * period / 8
		fmt.Printf("t = %.3f s   value = %+.3f\n", t, wave(t))
	}
}

package main

import (
	"fmt"
	"math"
)

const (
	frequency = 2.0  // both waves are 2 Hz; only their phase differs
	steps     = 2000 // how many instants to check when searching for the peak
	span      = 1.0  // seconds to search over: two full cycles at 2 Hz
)

// peakOfSum returns the largest absolute value reached by wave A plus wave B,
// where B is shifted by diff turns relative to A.
func peakOfSum(diff float64) float64 {
	peak := 0.0
	for i := 0; i <= steps; i++ {
		t := span * float64(i) / steps
		a := math.Sin(2 * math.Pi * frequency * t)
		b := math.Sin(2 * math.Pi * (frequency*t + diff))
		if s := math.Abs(a + b); s > peak {
			peak = s
		}
	}
	return peak
}

func main() {
	// Each wave alone peaks at 1.0. Their sum peaks anywhere from 2.0 to 0.0,
	// decided entirely by the phase difference.
	for _, diff := range []float64{0, 0.125, 0.25, 0.375, 0.5} {
		fmt.Printf("phase difference %.3f turns (%3.0f deg)   peak of sum %.3f\n",
			diff, diff*360, peakOfSum(diff))
	}
}

package main

import (
	"fmt"
	"math"
)

const (
	fundamental = 1.0  // frequency of the lowest component, in hertz
	steps       = 4000 // instants examined across one period
)

// square sums the first n odd harmonics of a square wave.
// Harmonic k has amplitude 4/(pi*k), and only odd k are present.
func square(t float64, n int) float64 {
	sum := 0.0
	for k := 1; k <= n; k += 2 {
		sum += 4 / (math.Pi * float64(k)) * math.Sin(2*math.Pi*fundamental*float64(k)*t)
	}
	return sum
}

func main() {
	// A true square wave steps from -1 to +1, a jump of 2.0, and holds at 1.0.
	// Each partial sum overshoots that level near the step. The overshoot narrows
	// as terms are added but settles at about 9% of the jump rather than vanishing.
	const step = 2.0 // height of the square wave's jump, from -1 to +1
	for _, n := range []int{1, 3, 9, 33, 129} {
		peak := 0.0
		for i := 0; i <= steps; i++ {
			t := float64(i) / steps / fundamental
			if v := square(t, n); v > peak {
				peak = v
			}
		}
		fmt.Printf("harmonics up to %3d   peak %.4f   overshoot %.2f%% of the jump\n",
			n, peak, (peak-1)/step*100)
	}
}

package main

import (
	"fmt"
	"math"
	"math/cmplx"
)

const (
	sampleRate = 64.0 // measurements per second
	n          = 64   // number of measurements; one full second of signal
)

// dft returns the magnitude of each frequency bin in x.
// Bin k corresponds to k*sampleRate/n hertz.
func dft(x []float64) []float64 {
	mag := make([]float64, len(x)/2)
	for k := range mag {
		sum := complex(0, 0)
		for t, v := range x {
			angle := -2 * math.Pi * float64(k) * float64(t) / float64(len(x))
			sum += complex(v, 0) * cmplx.Exp(complex(0, angle))
		}
		// Scale so a sine of amplitude A reports A in its bin.
		mag[k] = 2 * cmplx.Abs(sum) / float64(len(x))
	}
	return mag
}

func main() {
	// A signal built from two known ingredients, so the answer is checkable.
	signal := make([]float64, n)
	for i := range signal {
		t := float64(i) / sampleRate
		signal[i] = 1.0*math.Sin(2*math.Pi*4*t) + 0.5*math.Sin(2*math.Pi*11*t)
	}

	binWidth := sampleRate / n // hertz covered by each bin
	fmt.Printf("bin width %.2f Hz\n\n", binWidth)

	for k, m := range dft(signal) {
		if m < 0.01 { // skip bins holding no meaningful energy
			continue
		}
		fmt.Printf("%5.1f Hz   magnitude %.3f\n", float64(k)*binWidth, m)
	}
}

package main

import "fmt"

// Propagation speeds in metres per second. Wavelength depends on the medium,
// so the same frequency is a different length in each of these.
const (
	speedInAir   = 343.0       // dry air at 20 degrees Celsius
	speedInWater = 1481.0      // fresh water at 20 degrees Celsius
	speedInSteel = 5960.0      // longitudinal waves in steel
	speedOfLight = 299792458.0 // electromagnetic waves in vacuum
)

func main() {
	const frequency = 440.0 // hertz: concert A

	media := []struct {
		name  string
		speed float64
	}{
		{"air", speedInAir},
		{"water", speedInWater},
		{"steel", speedInSteel},
		{"vacuum (as radio)", speedOfLight},
	}

	for _, m := range media {
		wavelength := m.speed / frequency // metres per cycle
		fmt.Printf("%-18s %12.1f m/s   wavelength %10.3f m\n",
			m.name, m.speed, wavelength)
	}
}

package main

import "fmt"

const sampleRate = 1000.0 // measurements per second

func main() {
	// A spectrogram computes one spectrum per window of the signal.
	// The window length fixes both resolutions at once, in opposite directions.
	fmt.Printf("%8s %12s %14s %10s\n", "samples", "window span", "bin spacing", "product")

	for _, n := range []int{16, 64, 256, 1024} {
		span := float64(n) / sampleRate     // seconds of signal inside one window
		binWidth := sampleRate / float64(n) // hertz between adjacent bins

		// The product is 1 for every window length. Improving one resolution
		// always costs exactly as much of the other.
		fmt.Printf("%8d %9.3f s %11.2f Hz %10.2f\n",
			n, span, binWidth, span*binWidth)
	}
}