func mergeChannels(in1 <-chan []complex128, in2 <-chan []complex128) chan []complex128 { out := make(chan []complex128) go func() { fmt.Printf("Writing...\n") for cIn1 := range in1 { cIn2 := <-in2 if len(cIn1) != len(cIn2) { panic("oops, columns don't match... :(") } cOut := make([]complex128, len(cIn1), len(cIn1)) for i := range cIn1 { power1, angle1 := cmplx.Polar(cIn1[i]) power2, angle2 := cmplx.Polar(cIn2[i]) cOut[i] = cmplx.Rect(power1, angle1) if i > 48 && i <= 72 { cOut[i] = 0 } // HACK variable to stop go complaining about unused variables :( cIn2[i] = cmplx.Rect(power2, angle2) } out <- cOut } close(out) }() return out }
func TestSineOsc_expwdt_approx(t *testing.T) { const sampleRate = 96000 var osc SineOsc Init(&osc, Params{sampleRate}) for freq, err := range map[float64]float64{ 32: 0.00, 64: 0.00, 128: 0.00, 256: 0.00, 512: 0.00, 1024: 0.00, 2048: 0.00, 4096: 0.01, 8192: 0.02, 16384: 0.09, } { _, θ := cmplx.Polar(osc.expwdt_approx(freq)) actualFreq := θ / 2 / math.Pi * sampleRate actualErr := freq/actualFreq - 1 if math.Abs(err-actualErr) > .01 { t.Errorf("freq=%5.f:, expected %.2f, got %.2f", freq, err, actualErr) } } }
func addPolar(a, b Polar) Polar { // Add polar coordinates (5,140) and (3,70) x := cmplx.Rect(a.radius, a.angle) y := cmplx.Rect(b.radius, b.angle) radius, angle := cmplx.Polar(x + y) return Polar{radius, angle} }
func NaiveSpec(c gospec.Context) { in := make([]complex128, 8) for i := range in { in[i] = complex(math.Cos(float64(i)/float64(len(in))*2*math.Pi), 0) } verify := func(out []complex128, start, stride int, name string) { c.Specify(name, func() { for i := start; i < len(out); i += stride { mag, ang := cmplx.Polar(out[i]) if i == start+stride || i == len(out)+start-stride { c.Expect(mag, IsWithin(1e-9), float64(len(out)/stride)/2) if real(out[i]) < 0 { if ang < 0 { c.Expect(ang, IsWithin(1e-9), -math.Pi) } else { c.Expect(ang, IsWithin(1e-9), math.Pi) } } else { c.Expect(ang, IsWithin(1e-9), 0.0) } } else { c.Expect(mag, IsWithin(1e-9), 0.0) } } }) } c.Specify("Test basic DFT", func() { out := make([]complex128, len(in)) fft.DFT(in, out, 0, 1) verify(out, 0, 1, "Start/Stride 0/1") in2 := make([]complex128, 2*len(in)) out2 := make([]complex128, 2*len(in)) for i := range in2 { in2[i] = in[i/2] } fft.DFT(in2, out2, 0, 2) verify(out2, 0, 2, "Start/Stride 0/2") fft.DFT(in2, out2, 1, 2) verify(out2, 1, 2, "Start/Stride 1/2") in5 := make([]complex128, 5*len(in)) out5 := make([]complex128, 5*len(in)) for i := range in5 { in5[i] = in[i/5] } for i := 0; i < 5; i++ { fft.DFT(in5, out5, i, 5) verify(out5, i, 5, fmt.Sprintf("Start/Stride %d/%d", i, len(in5)/len(in))) } }) }
func iteration(c complex128, iterations int) int { var z complex128 for i := 0; i < iterations; i++ { z = mandelbrot(z, c) r, _ := cmplx.Polar(z) if r >= 2 { return i } } return 0 }
func (ft *FT) encodeSpectrumComponent(i int, im *image.RGBA) { xo, yo := (ft.w-1)/2, (ft.h-1)/2 for x := 0; x < ft.w; x++ { if cornered { xo, yo = 0, 0 } for y := 0; y < ft.h; y++ { f := func(c complex128) (float64, float64, float64) { r, theta := cmplx.Polar(c) if r > 1.0 { r = math.Log(r) / math.Log(float64(ft.w*ft.h)) } else { r = 0.0 } theta = math.Mod(theta/(2.0*math.Pi)+1.0, 1.0) return HSLToRGB(theta, 1.0, r) } im.SetRGBA((x+xo)%ft.w+ft.w*i, (y+yo)%ft.h, ft.channels.LoadComplex(i, x, y, f)) } } }
func clicking(c complex128, rot float64, biowl bool) game.Pos { var r, p float64 var m uint16 var pr, pf int8 log.Println("RawClick:", c) c -= Center r, p = cmplx.Polar(c) p -= rot r -= InnerRadius if r < 0 { return game.Pos{-1, -1} } p = adowbiowl(p, biowl) m = uint16(r) / 35 if m < 24 { pr = int8(m) } else { return game.Pos{127, 127} } pf = int8(p / OneFile) return game.Pos{pr, pf} }
// This example is adapted from Richard Lyon's "Understanding Digital Signal Processing," section 3.1.1. func ExampleFFTReal() { numSamples := 8 // Equation 3-10. x := func(n int) float64 { wave0 := math.Sin(2.0 * math.Pi * float64(n) / 8.0) wave1 := 0.5 * math.Sin(2*math.Pi*float64(n)/4.0+3.0*math.Pi/4.0) return wave0 + wave1 } // Discretize our function by sampling at 8 points. a := make([]float64, numSamples) for i := 0; i < numSamples; i++ { a[i] = x(i) } X := FFTReal(a) // Print the magnitude and phase at each frequency. for i := 0; i < numSamples; i++ { r, θ := cmplx.Polar(X[i]) θ *= 360.0 / (2 * math.Pi) if dsputils.Float64Equal(r, 0) { θ = 0 // (When the magnitude is close to 0, the angle is meaningless) } fmt.Printf("X(%d) = %.1f ∠ %.1f°\n", i, r, θ) } // Output: // X(0) = 0.0 ∠ 0.0° // X(1) = 4.0 ∠ -90.0° // X(2) = 2.0 ∠ 45.0° // X(3) = 0.0 ∠ 0.0° // X(4) = 0.0 ∠ 0.0° // X(5) = 0.0 ∠ 0.0° // X(6) = 2.0 ∠ -45.0° // X(7) = 4.0 ∠ 90.0° }
func (Polar) CognizeComplex(eye *be.Eye, v interface{}) { r, theta := cmplx.Polar(v.(complex128)) eye.Show("Polar", New().Grow("R", r).Grow("Theta", theta)) }
func ExamplePolar() { r, theta := cmplx.Polar(2i) fmt.Printf("r: %.1f, θ: %.1f*π", r, theta/math.Pi) // Output: r: 2.0, θ: 0.5*π }
func add180ToComplexNumner(complexNumber *complex128) { r, θ := cmplx.Polar(*complexNumber) *complexNumber = cmplx.Rect(r, θ+math.Pi/2) }