gonum.org/v1/gonum@v0.14.0/cmplxs/cmplxs_test.go (about) 1 // Copyright ©2013 The Gonum Authors. All rights reserved. 2 // Use of this code is governed by a BSD-style 3 // license that can be found in the LICENSE file 4 5 package cmplxs 6 7 import ( 8 "fmt" 9 "math" 10 "math/cmplx" 11 "strconv" 12 "testing" 13 14 "golang.org/x/exp/rand" 15 16 "gonum.org/v1/gonum/cmplxs/cscalar" 17 "gonum.org/v1/gonum/floats" 18 ) 19 20 const ( 21 EqTolerance = 1e-14 22 Small = 10 23 Medium = 1000 24 Large = 100000 25 Huge = 10000000 26 ) 27 28 func areSlicesEqual(t *testing.T, truth, comp []complex128, str string) { 29 if !EqualApprox(comp, truth, EqTolerance) { 30 t.Errorf(str+". Expected %v, returned %v", truth, comp) 31 } 32 } 33 34 func areSlicesSame(t *testing.T, truth, comp []complex128, str string) { 35 ok := len(truth) == len(comp) 36 if ok { 37 for i, a := range truth { 38 if !cscalar.EqualWithinAbsOrRel(a, comp[i], EqTolerance, EqTolerance) && !cscalar.Same(a, comp[i]) { 39 ok = false 40 break 41 } 42 } 43 } 44 if !ok { 45 t.Errorf(str+". Expected %v, returned %v", truth, comp) 46 } 47 } 48 49 func Panics(fun func()) (b bool) { 50 defer func() { 51 err := recover() 52 if err != nil { 53 b = true 54 } 55 }() 56 fun() 57 return 58 } 59 60 func TestAdd(t *testing.T) { 61 a := []complex128{1 + 1i, 2 + 2i, 3 + 3i} 62 b := []complex128{4 + 4i, 5 + 5i, 6 + 6i} 63 c := []complex128{7 + 7i, 8 + 8i, 9 + 9i} 64 truth := []complex128{12 + 12i, 15 + 15i, 18 + 18i} 65 n := make([]complex128, len(a)) 66 67 Add(n, a) 68 Add(n, b) 69 Add(n, c) 70 areSlicesEqual(t, truth, n, "Wrong addition of slices new receiver") 71 Add(a, b) 72 Add(a, c) 73 areSlicesEqual(t, truth, n, "Wrong addition of slices for no new receiver") 74 75 // Test that it panics 76 if !Panics(func() { Add(make([]complex128, 2), make([]complex128, 3)) }) { 77 t.Errorf("Did not panic with length mismatch") 78 } 79 } 80 81 func TestAddTo(t *testing.T) { 82 a := []complex128{1 + 1i, 2 + 2i, 3 + 3i} 83 b := []complex128{4 + 4i, 5 + 5i, 6 + 6i} 84 truth := []complex128{5 + 5i, 7 + 7i, 9 + 9i} 85 n1 := make([]complex128, len(a)) 86 87 n2 := AddTo(n1, a, b) 88 areSlicesEqual(t, truth, n1, "Bad addition from mutator") 89 areSlicesEqual(t, truth, n2, "Bad addition from returned slice") 90 91 // Test that it panics 92 if !Panics(func() { AddTo(make([]complex128, 2), make([]complex128, 3), make([]complex128, 3)) }) { 93 t.Errorf("Did not panic with length mismatch") 94 } 95 if !Panics(func() { AddTo(make([]complex128, 3), make([]complex128, 3), make([]complex128, 2)) }) { 96 t.Errorf("Did not panic with length mismatch") 97 } 98 } 99 100 func TestAddConst(t *testing.T) { 101 s := []complex128{3 + 1i, 4 + 2i, 1 + 3i, 7 + 4i, 5 + 5i} 102 c := 6 + 1i 103 truth := []complex128{9 + 2i, 10 + 3i, 7 + 4i, 13 + 5i, 11 + 6i} 104 AddConst(c, s) 105 areSlicesEqual(t, truth, s, "Wrong addition of constant") 106 } 107 108 func TestAddScaled(t *testing.T) { 109 s := []complex128{3, 4, 1, 7, 5} 110 alpha := 6 + 1i 111 dst := []complex128{1, 2, 3, 4, 5} 112 ans := []complex128{19 + 3i, 26 + 4i, 9 + 1i, 46 + 7i, 35 + 5i} 113 AddScaled(dst, alpha, s) 114 if !EqualApprox(dst, ans, EqTolerance) { 115 t.Errorf("Adding scaled did not match. Expected %v, returned %v", ans, dst) 116 } 117 short := []complex128{1} 118 if !Panics(func() { AddScaled(dst, alpha, short) }) { 119 t.Errorf("Doesn't panic if s is smaller than dst") 120 } 121 if !Panics(func() { AddScaled(short, alpha, s) }) { 122 t.Errorf("Doesn't panic if dst is smaller than s") 123 } 124 } 125 126 func TestAddScaledTo(t *testing.T) { 127 s := []complex128{3, 4, 1, 7, 5} 128 alpha := 6 + 1i 129 y := []complex128{1, 2, 3, 4, 5} 130 dst1 := make([]complex128, 5) 131 ans := []complex128{19 + 3i, 26 + 4i, 9 + 1i, 46 + 7i, 35 + 5i} 132 dst2 := AddScaledTo(dst1, y, alpha, s) 133 if !EqualApprox(dst1, ans, EqTolerance) { 134 t.Errorf("AddScaledTo did not match for mutator") 135 } 136 if !EqualApprox(dst2, ans, EqTolerance) { 137 t.Errorf("AddScaledTo did not match for returned slice") 138 } 139 AddScaledTo(dst1, y, alpha, s) 140 if !EqualApprox(dst1, ans, EqTolerance) { 141 t.Errorf("Reusing dst did not match") 142 } 143 short := []complex128{1} 144 if !Panics(func() { AddScaledTo(dst1, y, alpha, short) }) { 145 t.Errorf("Doesn't panic if s is smaller than dst") 146 } 147 if !Panics(func() { AddScaledTo(short, y, alpha, s) }) { 148 t.Errorf("Doesn't panic if dst is smaller than s") 149 } 150 if !Panics(func() { AddScaledTo(dst1, short, alpha, s) }) { 151 t.Errorf("Doesn't panic if y is smaller than dst") 152 } 153 } 154 155 func TestCount(t *testing.T) { 156 s := []complex128{3, 4, 1, 7, 5} 157 f := func(v complex128) bool { return cmplx.Abs(v) > 3.5 } 158 truth := 3 159 n := Count(f, s) 160 if n != truth { 161 t.Errorf("Wrong number of elements counted") 162 } 163 } 164 165 func TestCumProd(t *testing.T) { 166 s := []complex128{3 + 1i, 4 + 2i, 1 + 3i, 7 + 4i, 5 + 5i} 167 receiver := make([]complex128, len(s)) 168 result := CumProd(receiver, s) 169 truth := []complex128{3 + 1i, 10 + 10i, -20 + 40i, -300 + 200i, -2500 - 500i} 170 areSlicesEqual(t, truth, receiver, "Wrong cumprod mutated with new receiver") 171 areSlicesEqual(t, truth, result, "Wrong cumprod result with new receiver") 172 CumProd(receiver, s) 173 areSlicesEqual(t, truth, receiver, "Wrong cumprod returned with reused receiver") 174 175 // Test that it panics 176 if !Panics(func() { CumProd(make([]complex128, 2), make([]complex128, 3)) }) { 177 t.Errorf("Did not panic with length mismatch") 178 } 179 180 // Test empty CumProd 181 emptyReceiver := make([]complex128, 0) 182 truth = []complex128{} 183 CumProd(emptyReceiver, emptyReceiver) 184 areSlicesEqual(t, truth, emptyReceiver, "Wrong cumprod returned with empty receiver") 185 } 186 187 func TestComplex(t *testing.T) { 188 for i, test := range []struct { 189 dst []complex128 190 real, imag []float64 191 want []complex128 192 panics bool 193 }{ 194 {}, 195 { 196 dst: make([]complex128, 4), 197 real: []float64{1, 2, 3, 4}, 198 imag: []float64{1, 2, 3, 4}, 199 want: []complex128{1 + 1i, 2 + 2i, 3 + 3i, 4 + 4i}, 200 }, 201 { 202 dst: make([]complex128, 3), 203 real: []float64{1, 2, 3, 4}, 204 imag: []float64{1, 2, 3, 4}, 205 panics: true, 206 }, 207 { 208 dst: make([]complex128, 4), 209 real: []float64{1, 2, 3}, 210 imag: []float64{1, 2, 3, 4}, 211 panics: true, 212 }, 213 { 214 dst: make([]complex128, 4), 215 real: []float64{1, 2, 3, 4}, 216 imag: []float64{1, 2, 3}, 217 panics: true, 218 }, 219 { 220 dst: make([]complex128, 4), 221 real: []float64{1, 2, 3, 4}, 222 imag: []float64{1, 2, 3, math.NaN()}, 223 want: []complex128{1 + 1i, 2 + 2i, 3 + 3i, cmplx.NaN()}, 224 }, 225 } { 226 var got []complex128 227 panicked := Panics(func() { 228 got = Complex(test.dst, test.real, test.imag) 229 }) 230 if panicked != test.panics { 231 if panicked { 232 t.Errorf("unexpected panic for test %d", i) 233 } else { 234 t.Errorf("expected panic for test %d", i) 235 } 236 } 237 if panicked || test.panics { 238 continue 239 } 240 if !Same(got, test.dst) { 241 t.Errorf("mismatch between dst and return test %d: got:%v want:%v", i, got, test.dst) 242 } 243 if !Same(got, test.want) { 244 t.Errorf("unexpected result for test %d: got:%v want:%v", i, got, test.want) 245 } 246 } 247 248 } 249 250 func TestCumSum(t *testing.T) { 251 s := []complex128{3 + 1i, 4 + 2i, 1 + 3i, 7 + 4i, 5 + 5i} 252 receiver := make([]complex128, len(s)) 253 result := CumSum(receiver, s) 254 truth := []complex128{3 + 1i, 7 + 3i, 8 + 6i, 15 + 10i, 20 + 15i} 255 areSlicesEqual(t, truth, receiver, "Wrong cumsum mutated with new receiver") 256 areSlicesEqual(t, truth, result, "Wrong cumsum returned with new receiver") 257 CumSum(receiver, s) 258 areSlicesEqual(t, truth, receiver, "Wrong cumsum returned with reused receiver") 259 260 // Test that it panics 261 if !Panics(func() { CumSum(make([]complex128, 2), make([]complex128, 3)) }) { 262 t.Errorf("Did not panic with length mismatch") 263 } 264 265 // Test empty CumSum 266 emptyReceiver := make([]complex128, 0) 267 truth = []complex128{} 268 CumSum(emptyReceiver, emptyReceiver) 269 areSlicesEqual(t, truth, emptyReceiver, "Wrong cumsum returned with empty receiver") 270 } 271 272 func TestDistance(t *testing.T) { 273 norms := []float64{1, 2, 4, math.Inf(1)} 274 slices := []struct { 275 s []complex128 276 t []complex128 277 }{ 278 { 279 nil, 280 nil, 281 }, 282 { 283 []complex128{8 + 1i, 9 + 2i, 10 + 3i, -12 + 4i}, 284 []complex128{8 + 1i, 9 + 2i, 10 + 3i, -12 + 4i}, 285 }, 286 { 287 []complex128{1 + 1i, 2 + 2i, 3 + 3i, -4 + 4i, -5 + 5i, 8 + 6i}, 288 []complex128{-9.2 - 1i, -6.8 - 2i, 9 - 3i, -3 - 4i, -2 - 5i, 1 - 6i}, 289 }, 290 } 291 292 for j, test := range slices { 293 tmp := make([]complex128, len(test.s)) 294 for i, L := range norms { 295 dist := Distance(test.s, test.t, L) 296 copy(tmp, test.s) 297 Sub(tmp, test.t) 298 norm := Norm(tmp, L) 299 if dist != norm { // Use equality because they should be identical. 300 t.Errorf("Distance does not match norm for case %v, %v. Expected %v, Found %v.", i, j, norm, dist) 301 } 302 } 303 } 304 305 if !Panics(func() { Distance([]complex128{}, []complex128{1}, 1) }) { 306 t.Errorf("Did not panic with unequal lengths") 307 } 308 } 309 310 func TestDiv(t *testing.T) { 311 s1 := []complex128{5 - 5i, 12 + 2i, 27 - 3i} 312 s2 := []complex128{1 - 1i, 2 + 2i, 3 - 1i} 313 ans := []complex128{5 + 0i, 3.5 - 2.5i, 8.4 + 1.8i} 314 Div(s1, s2) 315 if !EqualApprox(s1, ans, EqTolerance) { 316 t.Errorf("Div doesn't give correct answer. Expected %v, Found %v.", ans, s1) 317 } 318 s1short := []complex128{1} 319 if !Panics(func() { Div(s1short, s2) }) { 320 t.Errorf("Did not panic with unequal lengths") 321 } 322 s2short := []complex128{1} 323 if !Panics(func() { Div(s1, s2short) }) { 324 t.Errorf("Did not panic with unequal lengths") 325 } 326 } 327 328 func TestDivTo(t *testing.T) { 329 s1 := []complex128{5 - 5i, 12 + 2i, 27 - 3i} 330 s1orig := []complex128{5 - 5i, 12 + 2i, 27 - 3i} 331 s2 := []complex128{1 - 1i, 2 + 2i, 3 - 1i} 332 s2orig := []complex128{1 - 1i, 2 + 2i, 3 - 1i} 333 dst1 := make([]complex128, 3) 334 ans := []complex128{5 + 0i, 3.5 - 2.5i, 8.4 + 1.8i} 335 dst2 := DivTo(dst1, s1, s2) 336 if !EqualApprox(dst1, ans, EqTolerance) { 337 t.Errorf("DivTo doesn't give correct answer in mutated slice") 338 } 339 if !EqualApprox(dst2, ans, EqTolerance) { 340 t.Errorf("DivTo doesn't give correct answer in returned slice") 341 } 342 if !EqualApprox(s1, s1orig, EqTolerance) { 343 t.Errorf("S1 changes during multo") 344 } 345 if !EqualApprox(s2, s2orig, EqTolerance) { 346 t.Errorf("s2 changes during multo") 347 } 348 DivTo(dst1, s1, s2) 349 if !EqualApprox(dst1, ans, EqTolerance) { 350 t.Errorf("DivTo doesn't give correct answer reusing dst") 351 } 352 dstShort := []complex128{1} 353 if !Panics(func() { DivTo(dstShort, s1, s2) }) { 354 t.Errorf("Did not panic with s1 wrong length") 355 } 356 s1short := []complex128{1} 357 if !Panics(func() { DivTo(dst1, s1short, s2) }) { 358 t.Errorf("Did not panic with s1 wrong length") 359 } 360 s2short := []complex128{1} 361 if !Panics(func() { DivTo(dst1, s1, s2short) }) { 362 t.Errorf("Did not panic with s2 wrong length") 363 } 364 } 365 366 func TestDot(t *testing.T) { 367 s1 := []complex128{1 + 1i, 2 + 2i, 3 + 3i, 4 + 4i} 368 s2 := []complex128{-3 + 4i, 4 + 3i, 5 + 2i, -6 + 1i} 369 truth := 16 + 24i 370 ans := Dot(s1, s2) 371 if ans != truth { 372 t.Errorf("Dot product computed incorrectly. Expected %v, Found %v.", truth, ans) 373 } 374 375 // Test that it panics 376 if !Panics(func() { Dot(make([]complex128, 2), make([]complex128, 3)) }) { 377 t.Errorf("Did not panic with length mismatch") 378 } 379 } 380 381 func TestEquals(t *testing.T) { 382 s1 := []complex128{1 + 1i, 2 + 4i, 3 + 8i, 4 + 16i} 383 s2 := []complex128{1 + 1i, 2 + 4i, 3 + 8i, 4 + 16i} 384 if !Equal(s1, s2) { 385 t.Errorf("Equal slices returned as unequal") 386 } 387 s2 = []complex128{1 + 1i, 2 + 4i, 3 + 8i, 4 + 16i + 1e-14} 388 if Equal(s1, s2) { 389 t.Errorf("Unequal slices returned as equal") 390 } 391 if Equal(s1, []complex128{}) { 392 t.Errorf("Unequal slice lengths returned as equal") 393 } 394 } 395 396 func TestEqualApprox(t *testing.T) { 397 s1 := []complex128{1 + 1i, 2 + 4i, 3 + 8i, 4 + 16i} 398 s2 := []complex128{1 + 1i, 2 + 4i, 3 + 8i, 4 + 16i + 1e-10} 399 if EqualApprox(s1, s2, 1e-13) { 400 t.Errorf("Unequal slices returned as equal for absolute") 401 } 402 if !EqualApprox(s1, s2, 1e-5) { 403 t.Errorf("Equal slices returned as unequal for absolute") 404 } 405 s1 = []complex128{1 + 1i, 2 + 4i, 3 + 8i, 1000 + 1000i} 406 s2 = []complex128{1 + 1i, 2 + 4i, 3 + 8i, (1000 + 1000i) * (1 + 1e-7)} 407 if EqualApprox(s1, s2, 1e-8) { 408 t.Errorf("Unequal slices returned as equal for relative") 409 } 410 if !EqualApprox(s1, s2, 1e-5) { 411 t.Errorf("Equal slices returned as unequal for relative") 412 } 413 if EqualApprox(s1, []complex128{}, 1e-5) { 414 t.Errorf("Unequal slice lengths returned as equal") 415 } 416 } 417 418 func TestEqualFunc(t *testing.T) { 419 s1 := []complex128{1 + 1i, 2 + 4i, 3 + 8i, 4 + 16i} 420 s2 := []complex128{1 + 1i, 2 + 4i, 3 + 8i, 4 + 16i} 421 eq := func(x, y complex128) bool { return x == y } 422 if !EqualFunc(s1, s2, eq) { 423 t.Errorf("Equal slices returned as unequal") 424 } 425 s2 = []complex128{1 + 1i, 2 + 4i, 3 + 8i, 4 + 16i + 1e-14} 426 if EqualFunc(s1, s2, eq) { 427 t.Errorf("Unequal slices returned as equal") 428 } 429 if EqualFunc(s1, []complex128{}, eq) { 430 t.Errorf("Unequal slice lengths returned as equal") 431 } 432 } 433 434 func TestEqualLengths(t *testing.T) { 435 s1 := []complex128{1 + 1i, 2 + 2i, 3 + 3i, 4 + 4i} 436 s2 := []complex128{1 + 1i, 2 + 2i, 3 + 3i, 4 + 4i} 437 s3 := []complex128{1 + 1i, 2 + 2i, 3 + 3i} 438 if !EqualLengths(s1, s2) { 439 t.Errorf("Equal lengths returned as unequal") 440 } 441 if EqualLengths(s1, s3) { 442 t.Errorf("Unequal lengths returned as equal") 443 } 444 if !EqualLengths(s1) { 445 t.Errorf("Single slice returned as unequal") 446 } 447 if !EqualLengths() { 448 t.Errorf("No slices returned as unequal") 449 } 450 } 451 452 func eqIntSlice(one, two []int) string { 453 if len(one) != len(two) { 454 return "Length mismatch" 455 } 456 for i, val := range one { 457 if val != two[i] { 458 return "Index " + strconv.Itoa(i) + " mismatch" 459 } 460 } 461 return "" 462 } 463 464 func TestFind(t *testing.T) { 465 s := []complex128{3 + 1i, 4 - 1i, 1 + 2i, 7 + 10i, 5 - 100i} 466 f := func(v complex128) bool { return cmplx.Abs(v) > 3.5 } 467 allTrueInds := []int{1, 3, 4} 468 469 // Test finding first two elements 470 inds, err := Find(nil, f, s, 2) 471 if err != nil { 472 t.Errorf("Find first two: Improper error return") 473 } 474 trueInds := allTrueInds[:2] 475 str := eqIntSlice(inds, trueInds) 476 if str != "" { 477 t.Errorf("Find first two: " + str) 478 } 479 480 // Test finding no elements with non nil slice 481 inds = []int{1, 2, 3, 4, 5, 6} 482 inds, err = Find(inds, f, s, 0) 483 if err != nil { 484 t.Errorf("Find no elements: Improper error return") 485 } 486 str = eqIntSlice(inds, []int{}) 487 if str != "" { 488 t.Errorf("Find no non-nil: " + str) 489 } 490 491 // Test finding first two elements with non nil slice 492 inds = []int{1, 2, 3, 4, 5, 6} 493 inds, err = Find(inds, f, s, 2) 494 if err != nil { 495 t.Errorf("Find first two non-nil: Improper error return") 496 } 497 str = eqIntSlice(inds, trueInds) 498 if str != "" { 499 t.Errorf("Find first two non-nil: " + str) 500 } 501 502 // Test finding too many elements 503 inds, err = Find(inds, f, s, 4) 504 if err == nil { 505 t.Errorf("Request too many: No error returned") 506 } 507 str = eqIntSlice(inds, allTrueInds) 508 if str != "" { 509 t.Errorf("Request too many: Does not match all of the inds: " + str) 510 } 511 512 // Test finding all elements 513 inds, err = Find(nil, f, s, -1) 514 if err != nil { 515 t.Errorf("Find all: Improper error returned") 516 } 517 str = eqIntSlice(inds, allTrueInds) 518 if str != "" { 519 t.Errorf("Find all: Does not match all of the inds: " + str) 520 } 521 } 522 523 func TestHasNaN(t *testing.T) { 524 for i, test := range []struct { 525 s []complex128 526 ans bool 527 }{ 528 {}, 529 { 530 s: []complex128{1 + 1i, 2 + 2i, 3 + 3i, 4 + 4i}, 531 }, 532 { 533 s: []complex128{1 + 1i, cmplx.NaN(), 3 + 3i, 4 + 4i}, 534 ans: true, 535 }, 536 { 537 s: []complex128{1 + 1i, 2 + 2i, 3 + 3i, cmplx.NaN()}, 538 ans: true, 539 }, 540 } { 541 b := HasNaN(test.s) 542 if b != test.ans { 543 t.Errorf("HasNaN mismatch case %d. Expected %v, Found %v", i, test.ans, b) 544 } 545 } 546 } 547 548 func TestImag(t *testing.T) { 549 for i, test := range []struct { 550 dst []float64 551 src []complex128 552 want []float64 553 panics bool 554 }{ 555 {}, 556 { 557 dst: make([]float64, 4), 558 src: []complex128{1 + 1i, 2 + 2i, 3 + 3i, 4 + 4i}, 559 want: []float64{1, 2, 3, 4}, 560 }, 561 { 562 dst: make([]float64, 3), 563 src: []complex128{1 + 1i, 2 + 2i, 3 + 3i, 4 + 4i}, 564 panics: true, 565 }, 566 { 567 dst: make([]float64, 4), 568 src: []complex128{1 + 1i, 2 + 2i, 3 + 3i, cmplx.NaN()}, 569 want: []float64{1, 2, 3, math.NaN()}, 570 }, 571 } { 572 var got []float64 573 panicked := Panics(func() { 574 got = Imag(test.dst, test.src) 575 }) 576 if panicked != test.panics { 577 if panicked { 578 t.Errorf("unexpected panic for test %d", i) 579 } else { 580 t.Errorf("expected panic for test %d", i) 581 } 582 } 583 if panicked || test.panics { 584 continue 585 } 586 if !floats.Same(got, test.dst) { 587 t.Errorf("mismatch between dst and return test %d: got:%v want:%v", i, got, test.dst) 588 } 589 if !floats.Same(got, test.want) { 590 t.Errorf("unexpected result for test %d: got:%v want:%v", i, got, test.want) 591 } 592 } 593 594 } 595 596 func TestLogSpan(t *testing.T) { 597 // FIXME(kortschak) 598 receiver1 := make([]complex128, 6) 599 truth := []complex128{0.001, 0.01, 0.1, 1, 10, 100} 600 receiver2 := LogSpan(receiver1, 0.001, 100) 601 tst := make([]complex128, 6) 602 for i := range truth { 603 tst[i] = receiver1[i] / truth[i] 604 } 605 comp := make([]complex128, 6) 606 for i := range comp { 607 comp[i] = 1 608 } 609 areSlicesEqual(t, comp, tst, "Improper logspace from mutator") 610 611 for i := range truth { 612 tst[i] = receiver2[i] / truth[i] 613 } 614 areSlicesEqual(t, comp, tst, "Improper logspace from returned slice") 615 616 if !Panics(func() { LogSpan(nil, 1, 5) }) { 617 t.Errorf("Span accepts nil argument") 618 } 619 if !Panics(func() { LogSpan(make([]complex128, 1), 1, 5) }) { 620 t.Errorf("Span accepts argument of len = 1") 621 } 622 } 623 624 func TestMaxAbsAndIdx(t *testing.T) { 625 for _, test := range []struct { 626 in []complex128 627 wantIdx int 628 wantVal complex128 629 desc string 630 }{ 631 { 632 in: []complex128{3 + 1i, 4 + 1i, 1 + 1i, 7 + 1i, 5 + 1i}, 633 wantIdx: 3, 634 wantVal: 7 + 1i, 635 desc: "with only finite entries", 636 }, 637 { 638 in: []complex128{cmplx.NaN(), 4 + 1i, 1 + 1i, 7 + 1i, 5 + 1i}, 639 wantIdx: 3, 640 wantVal: 7 + 1i, 641 desc: "with leading NaN", 642 }, 643 { 644 in: []complex128{cmplx.NaN(), cmplx.NaN(), cmplx.NaN()}, 645 wantIdx: 0, 646 wantVal: cmplx.NaN(), 647 desc: "when only NaN elements exist", 648 }, 649 { 650 in: []complex128{cmplx.NaN(), cmplx.Inf()}, 651 wantIdx: 1, 652 wantVal: cmplx.Inf(), 653 desc: "leading NaN followed by Inf", 654 }, 655 } { 656 ind := MaxAbsIdx(test.in) 657 if ind != test.wantIdx { 658 t.Errorf("Wrong index "+test.desc+": got:%d want:%d", ind, test.wantIdx) 659 } 660 val := MaxAbs(test.in) 661 if !cscalar.Same(val, test.wantVal) { 662 t.Errorf("Wrong value "+test.desc+": got:%f want:%f", val, test.wantVal) 663 } 664 } 665 } 666 667 func TestMinAbsAndIdx(t *testing.T) { 668 for _, test := range []struct { 669 in []complex128 670 wantIdx int 671 wantVal complex128 672 desc string 673 }{ 674 { 675 in: []complex128{3 + 1i, 4 + 1i, 1 + 1i, 7 + 1i, 5 + 1i}, 676 wantIdx: 2, 677 wantVal: 1 + 1i, 678 desc: "with only finite entries", 679 }, 680 { 681 in: []complex128{cmplx.NaN(), 4 + 1i, 1 + 1i, 7 + 1i, 5 + 1i}, 682 wantIdx: 2, 683 wantVal: 1 + 1i, 684 desc: "with leading NaN", 685 }, 686 { 687 in: []complex128{cmplx.NaN(), cmplx.NaN(), cmplx.NaN()}, 688 wantIdx: 0, 689 wantVal: cmplx.NaN(), 690 desc: "when only NaN elements exist", 691 }, 692 { 693 in: []complex128{cmplx.NaN(), cmplx.Inf()}, 694 wantIdx: 1, 695 wantVal: cmplx.Inf(), 696 desc: "leading NaN followed by Inf", 697 }, 698 } { 699 ind := MinAbsIdx(test.in) 700 if ind != test.wantIdx { 701 t.Errorf("Wrong index "+test.desc+": got:%d want:%d", ind, test.wantIdx) 702 } 703 val := MinAbs(test.in) 704 if !cscalar.Same(val, test.wantVal) { 705 t.Errorf("Wrong value "+test.desc+": got:%f want:%f", val, test.wantVal) 706 } 707 } 708 } 709 710 func TestMul(t *testing.T) { 711 s1 := []complex128{1 + 1i, 2 + 2i, 3 + 3i} 712 s2 := []complex128{1 + 1i, 2 + 2i, 3 + 3i} 713 ans := []complex128{0 + 2i, 0 + 8i, 0 + 18i} 714 Mul(s1, s2) 715 if !EqualApprox(s1, ans, EqTolerance) { 716 t.Errorf("Mul doesn't give correct answer. Expected %v, Found %v", ans, s1) 717 } 718 s1short := []complex128{1} 719 if !Panics(func() { Mul(s1short, s2) }) { 720 t.Errorf("Did not panic with unequal lengths") 721 } 722 s2short := []complex128{1} 723 if !Panics(func() { Mul(s1, s2short) }) { 724 t.Errorf("Did not panic with unequal lengths") 725 } 726 } 727 728 func TestMulConj(t *testing.T) { 729 s1 := []complex128{2 + 1i, 3 + 2i, 4 + 3i} 730 s2 := []complex128{1 + 2i, 2 + 3i, 3 + 4i} 731 s2orig := []complex128{1 + 2i, 2 + 3i, 3 + 4i} 732 ans := []complex128{4 - 3i, 12 - 5i, 24 - 7i} 733 MulConj(s1, s2) 734 if !Equal(s1, ans) { 735 t.Errorf("MulConj doesn't give correct answer. Expected %v, Found %v", ans, s1) 736 } 737 if !Equal(s2, s2orig) { 738 t.Errorf("s2 changes during MulTo") 739 } 740 s1short := []complex128{1} 741 if !Panics(func() { MulConj(s1short, s2) }) { 742 t.Errorf("Did not panic with unequal lengths") 743 } 744 s2short := []complex128{1} 745 if !Panics(func() { MulConj(s1, s2short) }) { 746 t.Errorf("Did not panic with unequal lengths") 747 } 748 } 749 750 func TestMulConjTo(t *testing.T) { 751 s1 := []complex128{2 + 1i, 3 + 2i, 4 + 3i} 752 s1orig := []complex128{2 + 1i, 3 + 2i, 4 + 3i} 753 s2 := []complex128{1 + 2i, 2 + 3i, 3 + 4i} 754 s2orig := []complex128{1 + 2i, 2 + 3i, 3 + 4i} 755 dst1 := make([]complex128, 3) 756 ans := []complex128{4 - 3i, 12 - 5i, 24 - 7i} 757 dst2 := MulConjTo(dst1, s1, s2) 758 if !Equal(dst1, ans) { 759 t.Errorf("MulConjTo doesn't give correct answer in mutated slice") 760 } 761 if !Equal(dst2, ans) { 762 t.Errorf("MulConjTo doesn't give correct answer in returned slice") 763 } 764 if !Equal(s1, s1orig) { 765 t.Errorf("S1 changes during MulConjTo") 766 } 767 if !Equal(s2, s2orig) { 768 t.Errorf("s2 changes during MulConjTo") 769 } 770 MulConjTo(dst1, s1, s2) 771 if !Equal(dst1, ans) { 772 t.Errorf("MulConjTo doesn't give correct answer reusing dst") 773 } 774 dstShort := []complex128{1} 775 if !Panics(func() { MulConjTo(dstShort, s1, s2) }) { 776 t.Errorf("Did not panic with dst wrong length") 777 } 778 s1short := []complex128{1} 779 if !Panics(func() { MulConjTo(dst1, s1short, s2) }) { 780 t.Errorf("Did not panic with s1 wrong length") 781 } 782 s2short := []complex128{1} 783 if !Panics(func() { MulConjTo(dst1, s1, s2short) }) { 784 t.Errorf("Did not panic with s2 wrong length") 785 } 786 } 787 788 func TestMulTo(t *testing.T) { 789 s1 := []complex128{1 + 1i, 2 + 2i, 3 + 3i} 790 s1orig := []complex128{1 + 1i, 2 + 2i, 3 + 3i} 791 s2 := []complex128{1 + 1i, 2 + 2i, 3 + 3i} 792 s2orig := []complex128{1 + 1i, 2 + 2i, 3 + 3i} 793 dst1 := make([]complex128, 3) 794 ans := []complex128{0 + 2i, 0 + 8i, 0 + 18i} 795 dst2 := MulTo(dst1, s1, s2) 796 if !EqualApprox(dst1, ans, EqTolerance) { 797 t.Errorf("MulTo doesn't give correct answer in mutated slice") 798 } 799 if !EqualApprox(dst2, ans, EqTolerance) { 800 t.Errorf("MulTo doesn't give correct answer in returned slice") 801 } 802 if !EqualApprox(s1, s1orig, EqTolerance) { 803 t.Errorf("S1 changes during multo") 804 } 805 if !EqualApprox(s2, s2orig, EqTolerance) { 806 t.Errorf("s2 changes during multo") 807 } 808 MulTo(dst1, s1, s2) 809 if !EqualApprox(dst1, ans, EqTolerance) { 810 t.Errorf("MulTo doesn't give correct answer reusing dst") 811 } 812 dstShort := []complex128{1} 813 if !Panics(func() { MulTo(dstShort, s1, s2) }) { 814 t.Errorf("Did not panic with s1 wrong length") 815 } 816 s1short := []complex128{1} 817 if !Panics(func() { MulTo(dst1, s1short, s2) }) { 818 t.Errorf("Did not panic with s1 wrong length") 819 } 820 s2short := []complex128{1} 821 if !Panics(func() { MulTo(dst1, s1, s2short) }) { 822 t.Errorf("Did not panic with s2 wrong length") 823 } 824 } 825 826 // Complexify 827 828 func TestNearestIdx(t *testing.T) { 829 for _, test := range []struct { 830 in []complex128 831 query complex128 832 want int 833 desc string 834 }{ 835 { 836 in: []complex128{6.2, 3, 5, 6.2, 8}, 837 query: 2, 838 want: 1, 839 desc: "Wrong index returned when value is less than all of elements", 840 }, 841 { 842 in: []complex128{6.2, 3, 5, 6.2, 8}, 843 query: 9, 844 want: 4, 845 desc: "Wrong index returned when value is greater than all of elements", 846 }, 847 { 848 in: []complex128{6.2, 3, 5, 6.2, 8}, 849 query: 3.1, 850 want: 1, 851 desc: "Wrong index returned when value is greater than closest element", 852 }, 853 { 854 in: []complex128{6.2, 3, 5, 6.2, 8}, 855 query: 2.9, 856 want: 1, 857 desc: "Wrong index returned when value is less than closest element", 858 }, 859 { 860 in: []complex128{6.2, 3, 5, 6.2, 8}, 861 query: 3, 862 want: 1, 863 desc: "Wrong index returned when value is equal to element", 864 }, 865 { 866 in: []complex128{6.2, 3, 5, 6.2, 8}, 867 query: 6.2, 868 want: 0, 869 desc: "Wrong index returned when value is equal to several elements", 870 }, 871 { 872 in: []complex128{6.2, 3, 5, 6.2, 8}, 873 query: 4, 874 want: 1, 875 desc: "Wrong index returned when value is exactly between two closest elements", 876 }, 877 { 878 in: []complex128{cmplx.NaN(), 3, 2, -1}, 879 query: 2, 880 want: 2, 881 desc: "Wrong index returned when initial element is NaN", 882 }, 883 { 884 in: []complex128{0, cmplx.NaN(), -1, 2}, 885 query: cmplx.NaN(), 886 want: 0, 887 desc: "Wrong index returned when query is NaN and a NaN element exists", 888 }, 889 { 890 in: []complex128{0, cmplx.NaN(), -1, 2}, 891 query: cmplx.Inf(), 892 want: 3, 893 desc: "Wrong index returned when query is Inf and no Inf element exists", 894 }, 895 { 896 in: []complex128{cmplx.NaN(), cmplx.NaN(), cmplx.NaN()}, 897 query: 1, 898 want: 0, 899 desc: "Wrong index returned when query is a number and only NaN elements exist", 900 }, 901 { 902 in: []complex128{cmplx.NaN(), cmplx.Inf()}, 903 query: 1, 904 want: 1, 905 desc: "Wrong index returned when query is a number and single NaN precedes Inf", 906 }, 907 } { 908 ind := NearestIdx(test.in, test.query) 909 if ind != test.want { 910 t.Errorf(test.desc+": got:%d want:%d", ind, test.want) 911 } 912 } 913 } 914 915 func TestNorm(t *testing.T) { 916 s := []complex128{-1, -3.4, 5, -6} 917 val := Norm(s, math.Inf(1)) 918 truth := 6.0 919 if math.Abs(val-truth) > EqTolerance { 920 t.Errorf("Doesn't match for inf norm. %v expected, %v found", truth, val) 921 } 922 // http://www.wolframalpha.com/input/?i=%28%28-1%29%5E2+%2B++%28-3.4%29%5E2+%2B+5%5E2%2B++6%5E2%29%5E%281%2F2%29 923 val = Norm(s, 2) 924 truth = 8.5767126569566267590651614132751986658027271236078592 925 if math.Abs(val-truth) > EqTolerance { 926 t.Errorf("Doesn't match for inf norm. %v expected, %v found", truth, val) 927 } 928 // http://www.wolframalpha.com/input/?i=%28%28%7C-1%7C%29%5E3+%2B++%28%7C-3.4%7C%29%5E3+%2B+%7C5%7C%5E3%2B++%7C6%7C%5E3%29%5E%281%2F3%29 929 val = Norm(s, 3) 930 truth = 7.2514321388020228478109121239004816430071237369356233 931 if math.Abs(val-truth) > EqTolerance { 932 t.Errorf("Doesn't match for inf norm. %v expected, %v found", truth, val) 933 } 934 935 //http://www.wolframalpha.com/input/?i=%7C-1%7C+%2B+%7C-3.4%7C+%2B+%7C5%7C%2B++%7C6%7C 936 val = Norm(s, 1) 937 truth = 15.4 938 if math.Abs(val-truth) > EqTolerance { 939 t.Errorf("Doesn't match for inf norm. %v expected, %v found", truth, val) 940 } 941 } 942 943 func TestProd(t *testing.T) { 944 s := []complex128{} 945 val := Prod(s) 946 if val != 1 { 947 t.Errorf("Val not returned as default when slice length is zero") 948 } 949 s = []complex128{3, 4, 1, 7, 5} 950 val = Prod(s) 951 if val != 420 { 952 t.Errorf("Wrong prod returned. Expected %v returned %v", 420, val) 953 } 954 } 955 956 func TestReverse(t *testing.T) { 957 for _, s := range [][]complex128{ 958 {0}, 959 {1, 0}, 960 {2, 1, 0}, 961 {3, 2, 1, 0}, 962 {9, 8, 7, 6, 5, 4, 3, 2, 1, 0}, 963 } { 964 Reverse(s) 965 for i, v := range s { 966 if v != complex(float64(i), 0) { 967 t.Errorf("unexpected values for element %d: got:%v want:%v", i, v, i) 968 } 969 } 970 } 971 } 972 973 func TestReal(t *testing.T) { 974 for i, test := range []struct { 975 dst []float64 976 src []complex128 977 want []float64 978 panics bool 979 }{ 980 {}, 981 { 982 dst: make([]float64, 4), 983 src: []complex128{1 + 1i, 2 + 2i, 3 + 3i, 4 + 4i}, 984 want: []float64{1, 2, 3, 4}, 985 }, 986 { 987 dst: make([]float64, 3), 988 src: []complex128{1 + 1i, 2 + 2i, 3 + 3i, 4 + 4i}, 989 panics: true, 990 }, 991 { 992 dst: make([]float64, 4), 993 src: []complex128{1 + 1i, 2 + 2i, 3 + 3i, cmplx.NaN()}, 994 want: []float64{1, 2, 3, math.NaN()}, 995 }, 996 } { 997 var got []float64 998 panicked := Panics(func() { 999 got = Real(test.dst, test.src) 1000 }) 1001 if panicked != test.panics { 1002 if panicked { 1003 t.Errorf("unexpected panic for test %d", i) 1004 } else { 1005 t.Errorf("expected panic for test %d", i) 1006 } 1007 } 1008 if panicked || test.panics { 1009 continue 1010 } 1011 if !floats.Same(got, test.dst) { 1012 t.Errorf("mismatch between dst and return test %d: got:%v want:%v", i, got, test.dst) 1013 } 1014 if !floats.Same(got, test.want) { 1015 t.Errorf("unexpected result for test %d: got:%v want:%v", i, got, test.want) 1016 } 1017 } 1018 1019 } 1020 func TestSame(t *testing.T) { 1021 s1 := []complex128{1 + 1i, 2 + 2i, 3 + 3i, 4 + 4i} 1022 s2 := []complex128{1 + 1i, 2 + 2i, 3 + 3i, 4 + 4i} 1023 if !Same(s1, s2) { 1024 t.Errorf("Equal slices returned as unequal") 1025 } 1026 s2 = []complex128{1 + 1i, 2 + 2i, 3 + 3i, 4 + 4i + 1e-14} 1027 if Same(s1, s2) { 1028 t.Errorf("Unequal slices returned as equal") 1029 } 1030 if Same(s1, []complex128{}) { 1031 t.Errorf("Unequal slice lengths returned as equal") 1032 } 1033 s1 = []complex128{1 + 1i, 2 + 2i, cmplx.NaN(), 4 + 4i} 1034 s2 = []complex128{1 + 1i, 2 + 2i, cmplx.NaN(), 4 + 4i} 1035 if !Same(s1, s2) { 1036 t.Errorf("Slices with matching NaN values returned as unequal") 1037 } 1038 s1 = []complex128{1 + 1i, 2 + 2i, cmplx.NaN(), 4 + 4i} 1039 s2 = []complex128{1 + 1i, cmplx.NaN(), 3 + 3i, 4 + 4i} 1040 if Same(s1, s2) { 1041 t.Errorf("Slices with unmatching NaN values returned as equal") 1042 } 1043 } 1044 1045 func TestScale(t *testing.T) { 1046 s := []complex128{3, 4, 1, 7, 5} 1047 c := 4 + 5i 1048 truth := []complex128{12 + 15i, 16 + 20i, 4 + 5i, 28 + 35i, 20 + 25i} 1049 Scale(c, s) 1050 areSlicesEqual(t, truth, s, "Bad scaling") 1051 } 1052 1053 func TestScaleReal(t *testing.T) { 1054 s := []complex128{3 + 4i, 4 + 5i, 1 + 2i, 7 + 6i, 5 + 2i} 1055 f := 5.0 1056 truth := []complex128{15 + 20i, 20 + 25i, 5 + 10i, 35 + 30i, 25 + 10i} 1057 ScaleReal(f, s) 1058 areSlicesEqual(t, truth, s, "Bad scaling") 1059 } 1060 1061 func TestScaleRealTo(t *testing.T) { 1062 s := []complex128{3 + 4i, 4 + 5i, 1 + 2i, 7 + 6i, 5 + 2i} 1063 sCopy := make([]complex128, len(s)) 1064 copy(sCopy, s) 1065 f := 5.0 1066 truth := []complex128{15 + 20i, 20 + 25i, 5 + 10i, 35 + 30i, 25 + 10i} 1067 dst := make([]complex128, len(s)) 1068 ScaleRealTo(dst, f, s) 1069 if !Same(dst, truth) { 1070 t.Errorf("ScaleRealTo dst does not match. Got %v, want %v", dst, truth) 1071 } 1072 if !Same(s, sCopy) { 1073 t.Errorf("SourceRealTo s modified during call. Got %v, want %v", s, sCopy) 1074 } 1075 } 1076 1077 func TestScaleTo(t *testing.T) { 1078 s := []complex128{3, 4, 1, 7, 5} 1079 sCopy := make([]complex128, len(s)) 1080 copy(sCopy, s) 1081 c := 4 + 5i 1082 truth := []complex128{12 + 15i, 16 + 20i, 4 + 5i, 28 + 35i, 20 + 25i} 1083 dst := make([]complex128, len(s)) 1084 ScaleTo(dst, c, s) 1085 if !Same(dst, truth) { 1086 t.Errorf("ScaleTo dst does not match. Got %v, want %v", dst, truth) 1087 } 1088 if !Same(s, sCopy) { 1089 t.Errorf("SourceTo s modified during call. Got %v, want %v", s, sCopy) 1090 } 1091 } 1092 1093 func TestSpan(t *testing.T) { 1094 receiver1 := make([]complex128, 5) 1095 truth := []complex128{1 + 1i, 2 + 2i, 3 + 3i, 4 + 4i, 5 + 5i} 1096 receiver2 := Span(receiver1, 1+1i, 5+5i) 1097 areSlicesEqual(t, truth, receiver1, "Improper linspace from mutator") 1098 areSlicesEqual(t, truth, receiver2, "Improper linspace from returned slice") 1099 receiver1 = make([]complex128, 6) 1100 truth = []complex128{0, 0.2 + 0.4i, 0.4 + 0.8i, 0.6 + 1.2i, 0.8 + 1.6i, 1 + 2i} 1101 Span(receiver1, 0, 1+2i) 1102 areSlicesEqual(t, truth, receiver1, "Improper linspace") 1103 if !Panics(func() { Span(nil, 1, 5) }) { 1104 t.Errorf("Span accepts nil argument") 1105 } 1106 if !Panics(func() { Span(make([]complex128, 1), 1, 5) }) { 1107 t.Errorf("Span accepts argument of len = 1") 1108 } 1109 1110 for _, test := range []struct { 1111 n int 1112 l, u complex128 1113 want []complex128 1114 }{ 1115 { 1116 n: 5, l: cmplx.Inf(), u: cmplx.Inf(), 1117 want: []complex128{cmplx.Inf(), cmplx.Inf(), cmplx.Inf(), cmplx.Inf(), cmplx.Inf()}, 1118 }, 1119 { 1120 n: 5, l: cmplx.Inf(), u: cmplx.NaN(), 1121 want: []complex128{cmplx.Inf(), cmplx.NaN(), cmplx.NaN(), cmplx.NaN(), cmplx.NaN()}, 1122 }, 1123 { 1124 n: 5, l: cmplx.NaN(), u: cmplx.Inf(), 1125 want: []complex128{cmplx.NaN(), cmplx.NaN(), cmplx.NaN(), cmplx.NaN(), cmplx.Inf()}, 1126 }, 1127 { 1128 n: 5, l: 42, u: cmplx.Inf(), 1129 want: []complex128{42, cmplx.Inf(), cmplx.Inf(), cmplx.Inf(), cmplx.Inf()}, 1130 }, 1131 { 1132 n: 5, l: 42, u: cmplx.NaN(), 1133 want: []complex128{42, cmplx.NaN(), cmplx.NaN(), cmplx.NaN(), cmplx.NaN()}, 1134 }, 1135 { 1136 n: 5, l: cmplx.Inf(), u: 42, 1137 want: []complex128{cmplx.Inf(), cmplx.Inf(), cmplx.Inf(), cmplx.Inf(), 42}, 1138 }, 1139 { 1140 n: 5, l: cmplx.NaN(), u: 42, 1141 want: []complex128{cmplx.NaN(), cmplx.NaN(), cmplx.NaN(), cmplx.NaN(), 42}, 1142 }, 1143 } { 1144 got := Span(make([]complex128, test.n), test.l, test.u) 1145 areSlicesSame(t, test.want, got, 1146 fmt.Sprintf("Unexpected slice of length %d for %f to %f", test.n, test.l, test.u)) 1147 } 1148 } 1149 1150 func TestSub(t *testing.T) { 1151 s := []complex128{3 + 2i, 4 + 3i, 1 + 7i, 7 + 1i, 5 - 1i} 1152 v := []complex128{1 + 1i, 2 + 4i, 3, 4, 5 - 1i} 1153 truth := []complex128{2 + 1i, 2 - 1i, -2 + 7i, 3 + 1i, 0} 1154 Sub(s, v) 1155 areSlicesEqual(t, truth, s, "Bad subtract") 1156 // Test that it panics 1157 if !Panics(func() { Sub(make([]complex128, 2), make([]complex128, 3)) }) { 1158 t.Errorf("Did not panic with length mismatch") 1159 } 1160 } 1161 1162 func TestSubTo(t *testing.T) { 1163 s := []complex128{3 + 2i, 4 + 3i, 1 + 7i, 7 + 1i, 5 - 1i} 1164 v := []complex128{1 + 1i, 2 + 4i, 3, 4, 5 - 1i} 1165 truth := []complex128{2 + 1i, 2 - 1i, -2 + 7i, 3 + 1i, 0} 1166 dst1 := make([]complex128, len(s)) 1167 dst2 := SubTo(dst1, s, v) 1168 areSlicesEqual(t, truth, dst1, "Bad subtract from mutator") 1169 areSlicesEqual(t, truth, dst2, "Bad subtract from returned slice") 1170 // Test that all mismatch combinations panic 1171 if !Panics(func() { SubTo(make([]complex128, 2), make([]complex128, 3), make([]complex128, 3)) }) { 1172 t.Errorf("Did not panic with dst different length") 1173 } 1174 if !Panics(func() { SubTo(make([]complex128, 3), make([]complex128, 2), make([]complex128, 3)) }) { 1175 t.Errorf("Did not panic with subtractor different length") 1176 } 1177 if !Panics(func() { SubTo(make([]complex128, 3), make([]complex128, 3), make([]complex128, 2)) }) { 1178 t.Errorf("Did not panic with subtractee different length") 1179 } 1180 } 1181 1182 func TestSum(t *testing.T) { 1183 s := []complex128{} 1184 val := Sum(s) 1185 if val != 0 { 1186 t.Errorf("Val not returned as default when slice length is zero") 1187 } 1188 s = []complex128{3 + 1i, 4 + 2i, 1 + 3i, 7 + 4i, 5 + 5i} 1189 val = Sum(s) 1190 if val != 20+15i { 1191 t.Errorf("Wrong sum returned") 1192 } 1193 } 1194 1195 func randomSlice(l int, src rand.Source) []complex128 { 1196 rnd := rand.New(src) 1197 s := make([]complex128, l) 1198 for i := range s { 1199 s[i] = complex(rnd.Float64(), rnd.Float64()) 1200 } 1201 return s 1202 } 1203 1204 func benchmarkAdd(b *testing.B, size int) { 1205 src := rand.NewSource(1) 1206 s1 := randomSlice(size, src) 1207 s2 := randomSlice(size, src) 1208 b.ResetTimer() 1209 for i := 0; i < b.N; i++ { 1210 Add(s1, s2) 1211 } 1212 } 1213 func BenchmarkAddSmall(b *testing.B) { benchmarkAdd(b, Small) } 1214 func BenchmarkAddMed(b *testing.B) { benchmarkAdd(b, Medium) } 1215 func BenchmarkAddLarge(b *testing.B) { benchmarkAdd(b, Large) } 1216 func BenchmarkAddHuge(b *testing.B) { benchmarkAdd(b, Huge) } 1217 1218 func benchmarkAddTo(b *testing.B, size int) { 1219 src := rand.NewSource(1) 1220 s1 := randomSlice(size, src) 1221 s2 := randomSlice(size, src) 1222 dst := randomSlice(size, src) 1223 b.ResetTimer() 1224 for i := 0; i < b.N; i++ { 1225 AddTo(dst, s1, s2) 1226 } 1227 } 1228 func BenchmarkAddToSmall(b *testing.B) { benchmarkAddTo(b, Small) } 1229 func BenchmarkAddToMed(b *testing.B) { benchmarkAddTo(b, Medium) } 1230 func BenchmarkAddToLarge(b *testing.B) { benchmarkAddTo(b, Large) } 1231 func BenchmarkAddToHuge(b *testing.B) { benchmarkAddTo(b, Huge) } 1232 1233 func benchmarkCumProd(b *testing.B, size int) { 1234 src := rand.NewSource(1) 1235 s := randomSlice(size, src) 1236 dst := randomSlice(size, src) 1237 b.ResetTimer() 1238 for i := 0; i < b.N; i++ { 1239 CumProd(dst, s) 1240 } 1241 } 1242 func BenchmarkCumProdSmall(b *testing.B) { benchmarkCumProd(b, Small) } 1243 func BenchmarkCumProdMed(b *testing.B) { benchmarkCumProd(b, Medium) } 1244 func BenchmarkCumProdLarge(b *testing.B) { benchmarkCumProd(b, Large) } 1245 func BenchmarkCumProdHuge(b *testing.B) { benchmarkCumProd(b, Huge) } 1246 1247 func benchmarkCumSum(b *testing.B, size int) { 1248 src := rand.NewSource(1) 1249 s := randomSlice(size, src) 1250 dst := randomSlice(size, src) 1251 b.ResetTimer() 1252 for i := 0; i < b.N; i++ { 1253 CumSum(dst, s) 1254 } 1255 } 1256 func BenchmarkCumSumSmall(b *testing.B) { benchmarkCumSum(b, Small) } 1257 func BenchmarkCumSumMed(b *testing.B) { benchmarkCumSum(b, Medium) } 1258 func BenchmarkCumSumLarge(b *testing.B) { benchmarkCumSum(b, Large) } 1259 func BenchmarkCumSumHuge(b *testing.B) { benchmarkCumSum(b, Huge) } 1260 1261 func benchmarkDiv(b *testing.B, size int) { 1262 src := rand.NewSource(1) 1263 s := randomSlice(size, src) 1264 dst := randomSlice(size, src) 1265 b.ResetTimer() 1266 for i := 0; i < b.N; i++ { 1267 Div(dst, s) 1268 } 1269 } 1270 func BenchmarkDivSmall(b *testing.B) { benchmarkDiv(b, Small) } 1271 func BenchmarkDivMed(b *testing.B) { benchmarkDiv(b, Medium) } 1272 func BenchmarkDivLarge(b *testing.B) { benchmarkDiv(b, Large) } 1273 func BenchmarkDivHuge(b *testing.B) { benchmarkDiv(b, Huge) } 1274 1275 func benchmarkDivTo(b *testing.B, size int) { 1276 src := rand.NewSource(1) 1277 s1 := randomSlice(size, src) 1278 s2 := randomSlice(size, src) 1279 dst := randomSlice(size, src) 1280 b.ResetTimer() 1281 for i := 0; i < b.N; i++ { 1282 DivTo(dst, s1, s2) 1283 } 1284 } 1285 func BenchmarkDivToSmall(b *testing.B) { benchmarkDivTo(b, Small) } 1286 func BenchmarkDivToMed(b *testing.B) { benchmarkDivTo(b, Medium) } 1287 func BenchmarkDivToLarge(b *testing.B) { benchmarkDivTo(b, Large) } 1288 func BenchmarkDivToHuge(b *testing.B) { benchmarkDivTo(b, Huge) } 1289 1290 func benchmarkSub(b *testing.B, size int) { 1291 src := rand.NewSource(1) 1292 s1 := randomSlice(size, src) 1293 s2 := randomSlice(size, src) 1294 b.ResetTimer() 1295 for i := 0; i < b.N; i++ { 1296 Sub(s1, s2) 1297 } 1298 } 1299 func BenchmarkSubSmall(b *testing.B) { benchmarkSub(b, Small) } 1300 func BenchmarkSubMed(b *testing.B) { benchmarkSub(b, Medium) } 1301 func BenchmarkSubLarge(b *testing.B) { benchmarkSub(b, Large) } 1302 func BenchmarkSubHuge(b *testing.B) { benchmarkSub(b, Huge) } 1303 1304 func benchmarkSubTo(b *testing.B, size int) { 1305 src := rand.NewSource(1) 1306 s1 := randomSlice(size, src) 1307 s2 := randomSlice(size, src) 1308 dst := randomSlice(size, src) 1309 b.ResetTimer() 1310 for i := 0; i < b.N; i++ { 1311 SubTo(dst, s1, s2) 1312 } 1313 } 1314 func BenchmarkSubToSmall(b *testing.B) { benchmarkSubTo(b, Small) } 1315 func BenchmarkSubToMed(b *testing.B) { benchmarkSubTo(b, Medium) } 1316 func BenchmarkSubToLarge(b *testing.B) { benchmarkSubTo(b, Large) } 1317 func BenchmarkSubToHuge(b *testing.B) { benchmarkSubTo(b, Huge) } 1318 1319 func benchmarkDot(b *testing.B, size int) { 1320 src := rand.NewSource(1) 1321 s1 := randomSlice(size, src) 1322 s2 := randomSlice(size, src) 1323 b.ResetTimer() 1324 for i := 0; i < b.N; i++ { 1325 Dot(s1, s2) 1326 } 1327 } 1328 func BenchmarkDotSmall(b *testing.B) { benchmarkDot(b, Small) } 1329 func BenchmarkDotMed(b *testing.B) { benchmarkDot(b, Medium) } 1330 func BenchmarkDotLarge(b *testing.B) { benchmarkDot(b, Large) } 1331 func BenchmarkDotHuge(b *testing.B) { benchmarkDot(b, Huge) } 1332 1333 func benchmarkAddScaledTo(b *testing.B, size int) { 1334 src := rand.NewSource(1) 1335 dst := randomSlice(size, src) 1336 y := randomSlice(size, src) 1337 s := randomSlice(size, src) 1338 b.ResetTimer() 1339 for i := 0; i < b.N; i++ { 1340 AddScaledTo(dst, y, 2.3, s) 1341 } 1342 } 1343 func BenchmarkAddScaledToSmall(b *testing.B) { benchmarkAddScaledTo(b, Small) } 1344 func BenchmarkAddScaledToMedium(b *testing.B) { benchmarkAddScaledTo(b, Medium) } 1345 func BenchmarkAddScaledToLarge(b *testing.B) { benchmarkAddScaledTo(b, Large) } 1346 func BenchmarkAddScaledToHuge(b *testing.B) { benchmarkAddScaledTo(b, Huge) } 1347 1348 func benchmarkScale(b *testing.B, size int) { 1349 src := rand.NewSource(1) 1350 dst := randomSlice(size, src) 1351 b.ResetTimer() 1352 for i := 0; i < b.N; i += 2 { 1353 Scale(2.0, dst) 1354 Scale(0.5, dst) 1355 } 1356 } 1357 func BenchmarkScaleSmall(b *testing.B) { benchmarkScale(b, Small) } 1358 func BenchmarkScaleMedium(b *testing.B) { benchmarkScale(b, Medium) } 1359 func BenchmarkScaleLarge(b *testing.B) { benchmarkScale(b, Large) } 1360 func BenchmarkScaleHuge(b *testing.B) { benchmarkScale(b, Huge) } 1361 1362 func benchmarkNorm2(b *testing.B, size int) { 1363 src := rand.NewSource(1) 1364 s := randomSlice(size, src) 1365 b.ResetTimer() 1366 for i := 0; i < b.N; i++ { 1367 Norm(s, 2) 1368 } 1369 } 1370 func BenchmarkNorm2Small(b *testing.B) { benchmarkNorm2(b, Small) } 1371 func BenchmarkNorm2Medium(b *testing.B) { benchmarkNorm2(b, Medium) } 1372 func BenchmarkNorm2Large(b *testing.B) { benchmarkNorm2(b, Large) } 1373 func BenchmarkNorm2Huge(b *testing.B) { benchmarkNorm2(b, Huge) }