Source file src/math/cmplx/cmath_test.go

Documentation: math/cmplx

     1  // Copyright 2010 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  package cmplx
     6  
     7  import (
     8  	"math"
     9  	"testing"
    10  )
    11  
    12  // The higher-precision values in vc26 were used to derive the
    13  // input arguments vc (see also comment below). For reference
    14  // only (do not delete).
    15  var vc26 = []complex128{
    16  	(4.97901192488367350108546816 + 7.73887247457810456552351752i),
    17  	(7.73887247457810456552351752 - 0.27688005719200159404635997i),
    18  	(-0.27688005719200159404635997 - 5.01060361827107492160848778i),
    19  	(-5.01060361827107492160848778 + 9.63629370719841737980004837i),
    20  	(9.63629370719841737980004837 + 2.92637723924396464525443662i),
    21  	(2.92637723924396464525443662 + 5.22908343145930665230025625i),
    22  	(5.22908343145930665230025625 + 2.72793991043601025126008608i),
    23  	(2.72793991043601025126008608 + 1.82530809168085506044576505i),
    24  	(1.82530809168085506044576505 - 8.68592476857560136238589621i),
    25  	(-8.68592476857560136238589621 + 4.97901192488367350108546816i),
    26  }
    27  
    28  var vc = []complex128{
    29  	(4.9790119248836735e+00 + 7.7388724745781045e+00i),
    30  	(7.7388724745781045e+00 - 2.7688005719200159e-01i),
    31  	(-2.7688005719200159e-01 - 5.0106036182710749e+00i),
    32  	(-5.0106036182710749e+00 + 9.6362937071984173e+00i),
    33  	(9.6362937071984173e+00 + 2.9263772392439646e+00i),
    34  	(2.9263772392439646e+00 + 5.2290834314593066e+00i),
    35  	(5.2290834314593066e+00 + 2.7279399104360102e+00i),
    36  	(2.7279399104360102e+00 + 1.8253080916808550e+00i),
    37  	(1.8253080916808550e+00 - 8.6859247685756013e+00i),
    38  	(-8.6859247685756013e+00 + 4.9790119248836735e+00i),
    39  }
    40  
    41  // The expected results below were computed by the high precision calculators
    42  // at https://keisan.casio.com/.  More exact input values (array vc[], above)
    43  // were obtained by printing them with "%.26f".  The answers were calculated
    44  // to 26 digits (by using the "Digit number" drop-down control of each
    45  // calculator).
    46  
    47  var abs = []float64{
    48  	9.2022120669932650313380972e+00,
    49  	7.7438239742296106616261394e+00,
    50  	5.0182478202557746902556648e+00,
    51  	1.0861137372799545160704002e+01,
    52  	1.0070841084922199607011905e+01,
    53  	5.9922447613166942183705192e+00,
    54  	5.8978784056736762299945176e+00,
    55  	3.2822866700678709020367184e+00,
    56  	8.8756430028990417290744307e+00,
    57  	1.0011785496777731986390856e+01,
    58  }
    59  
    60  var acos = []complex128{
    61  	(1.0017679804707456328694569 - 2.9138232718554953784519807i),
    62  	(0.03606427612041407369636057 + 2.7358584434576260925091256i),
    63  	(1.6249365462333796703711823 + 2.3159537454335901187730929i),
    64  	(2.0485650849650740120660391 - 3.0795576791204117911123886i),
    65  	(0.29621132089073067282488147 - 3.0007392508200622519398814i),
    66  	(1.0664555914934156601503632 - 2.4872865024796011364747111i),
    67  	(0.48681307452231387690013905 - 2.463655912283054555225301i),
    68  	(0.6116977071277574248407752 - 1.8734458851737055262693056i),
    69  	(1.3649311280370181331184214 + 2.8793528632328795424123832i),
    70  	(2.6189310485682988308904501 - 2.9956543302898767795858704i),
    71  }
    72  var acosh = []complex128{
    73  	(2.9138232718554953784519807 + 1.0017679804707456328694569i),
    74  	(2.7358584434576260925091256 - 0.03606427612041407369636057i),
    75  	(2.3159537454335901187730929 - 1.6249365462333796703711823i),
    76  	(3.0795576791204117911123886 + 2.0485650849650740120660391i),
    77  	(3.0007392508200622519398814 + 0.29621132089073067282488147i),
    78  	(2.4872865024796011364747111 + 1.0664555914934156601503632i),
    79  	(2.463655912283054555225301 + 0.48681307452231387690013905i),
    80  	(1.8734458851737055262693056 + 0.6116977071277574248407752i),
    81  	(2.8793528632328795424123832 - 1.3649311280370181331184214i),
    82  	(2.9956543302898767795858704 + 2.6189310485682988308904501i),
    83  }
    84  var asin = []complex128{
    85  	(0.56902834632415098636186476 + 2.9138232718554953784519807i),
    86  	(1.5347320506744825455349611 - 2.7358584434576260925091256i),
    87  	(-0.054140219438483051139860579 - 2.3159537454335901187730929i),
    88  	(-0.47776875817017739283471738 + 3.0795576791204117911123886i),
    89  	(1.2745850059041659464064402 + 3.0007392508200622519398814i),
    90  	(0.50434073530148095908095852 + 2.4872865024796011364747111i),
    91  	(1.0839832522725827423311826 + 2.463655912283054555225301i),
    92  	(0.9590986196671391943905465 + 1.8734458851737055262693056i),
    93  	(0.20586519875787848611290031 - 2.8793528632328795424123832i),
    94  	(-1.0481347217734022116591284 + 2.9956543302898767795858704i),
    95  }
    96  var asinh = []complex128{
    97  	(2.9113760469415295679342185 + 0.99639459545704326759805893i),
    98  	(2.7441755423994259061579029 - 0.035468308789000500601119392i),
    99  	(-2.2962136462520690506126678 - 1.5144663565690151885726707i),
   100  	(-3.0771233459295725965402455 + 1.0895577967194013849422294i),
   101  	(3.0048366100923647417557027 + 0.29346979169819220036454168i),
   102  	(2.4800059370795363157364643 + 1.0545868606049165710424232i),
   103  	(2.4718773838309585611141821 + 0.47502344364250803363708842i),
   104  	(1.8910743588080159144378396 + 0.56882925572563602341139174i),
   105  	(2.8735426423367341878069406 - 1.362376149648891420997548i),
   106  	(-2.9981750586172477217567878 + 0.5183571985225367505624207i),
   107  }
   108  var atan = []complex128{
   109  	(1.5115747079332741358607654 + 0.091324403603954494382276776i),
   110  	(1.4424504323482602560806727 - 0.0045416132642803911503770933i),
   111  	(-1.5593488703630532674484026 - 0.20163295409248362456446431i),
   112  	(-1.5280619472445889867794105 + 0.081721556230672003746956324i),
   113  	(1.4759909163240799678221039 + 0.028602969320691644358773586i),
   114  	(1.4877353772046548932715555 + 0.14566877153207281663773599i),
   115  	(1.4206983927779191889826 + 0.076830486127880702249439993i),
   116  	(1.3162236060498933364869556 + 0.16031313000467530644933363i),
   117  	(1.5473450684303703578810093 - 0.11064907507939082484935782i),
   118  	(-1.4841462340185253987375812 + 0.049341850305024399493142411i),
   119  }
   120  var atanh = []complex128{
   121  	(0.058375027938968509064640438 + 1.4793488495105334458167782i),
   122  	(0.12977343497790381229915667 - 1.5661009410463561327262499i),
   123  	(-0.010576456067347252072200088 - 1.3743698658402284549750563i),
   124  	(-0.042218595678688358882784918 + 1.4891433968166405606692604i),
   125  	(0.095218997991316722061828397 + 1.5416884098777110330499698i),
   126  	(0.079965459366890323857556487 + 1.4252510353873192700350435i),
   127  	(0.15051245471980726221708301 + 1.4907432533016303804884461i),
   128  	(0.25082072933993987714470373 + 1.392057665392187516442986i),
   129  	(0.022896108815797135846276662 - 1.4609224989282864208963021i),
   130  	(-0.08665624101841876130537396 + 1.5207902036935093480142159i),
   131  }
   132  var conj = []complex128{
   133  	(4.9790119248836735e+00 - 7.7388724745781045e+00i),
   134  	(7.7388724745781045e+00 + 2.7688005719200159e-01i),
   135  	(-2.7688005719200159e-01 + 5.0106036182710749e+00i),
   136  	(-5.0106036182710749e+00 - 9.6362937071984173e+00i),
   137  	(9.6362937071984173e+00 - 2.9263772392439646e+00i),
   138  	(2.9263772392439646e+00 - 5.2290834314593066e+00i),
   139  	(5.2290834314593066e+00 - 2.7279399104360102e+00i),
   140  	(2.7279399104360102e+00 - 1.8253080916808550e+00i),
   141  	(1.8253080916808550e+00 + 8.6859247685756013e+00i),
   142  	(-8.6859247685756013e+00 - 4.9790119248836735e+00i),
   143  }
   144  var cos = []complex128{
   145  	(3.024540920601483938336569e+02 + 1.1073797572517071650045357e+03i),
   146  	(1.192858682649064973252758e-01 + 2.7857554122333065540970207e-01i),
   147  	(7.2144394304528306603857962e+01 - 2.0500129667076044169954205e+01i),
   148  	(2.24921952538403984190541e+03 - 7.317363745602773587049329e+03i),
   149  	(-9.148222970032421760015498e+00 + 1.953124661113563541862227e+00i),
   150  	(-9.116081175857732248227078e+01 - 1.992669213569952232487371e+01i),
   151  	(3.795639179042704640002918e+00 + 6.623513350981458399309662e+00i),
   152  	(-2.9144840732498869560679084e+00 - 1.214620271628002917638748e+00i),
   153  	(-7.45123482501299743872481e+02 + 2.8641692314488080814066734e+03i),
   154  	(-5.371977967039319076416747e+01 + 4.893348341339375830564624e+01i),
   155  }
   156  var cosh = []complex128{
   157  	(8.34638383523018249366948e+00 + 7.2181057886425846415112064e+01i),
   158  	(1.10421967379919366952251e+03 - 3.1379638689277575379469861e+02i),
   159  	(3.051485206773701584738512e-01 - 2.6805384730105297848044485e-01i),
   160  	(-7.33294728684187933370938e+01 + 1.574445942284918251038144e+01i),
   161  	(-7.478643293945957535757355e+03 + 1.6348382209913353929473321e+03i),
   162  	(4.622316522966235701630926e+00 - 8.088695185566375256093098e+00i),
   163  	(-8.544333183278877406197712e+01 + 3.7505836120128166455231717e+01i),
   164  	(-1.934457815021493925115198e+00 + 7.3725859611767228178358673e+00i),
   165  	(-2.352958770061749348353548e+00 - 2.034982010440878358915409e+00i),
   166  	(7.79756457532134748165069e+02 + 2.8549350716819176560377717e+03i),
   167  }
   168  var exp = []complex128{
   169  	(1.669197736864670815125146e+01 + 1.4436895109507663689174096e+02i),
   170  	(2.2084389286252583447276212e+03 - 6.2759289284909211238261917e+02i),
   171  	(2.227538273122775173434327e-01 + 7.2468284028334191250470034e-01i),
   172  	(-6.5182985958153548997881627e-03 - 1.39965837915193860879044e-03i),
   173  	(-1.4957286524084015746110777e+04 + 3.269676455931135688988042e+03i),
   174  	(9.218158701983105935659273e+00 - 1.6223985291084956009304582e+01i),
   175  	(-1.7088175716853040841444505e+02 + 7.501382609870410713795546e+01i),
   176  	(-3.852461315830959613132505e+00 + 1.4808420423156073221970892e+01i),
   177  	(-4.586775503301407379786695e+00 - 4.178501081246873415144744e+00i),
   178  	(4.451337963005453491095747e-05 - 1.62977574205442915935263e-04i),
   179  }
   180  var log = []complex128{
   181  	(2.2194438972179194425697051e+00 + 9.9909115046919291062461269e-01i),
   182  	(2.0468956191154167256337289e+00 - 3.5762575021856971295156489e-02i),
   183  	(1.6130808329853860438751244e+00 - 1.6259990074019058442232221e+00i),
   184  	(2.3851910394823008710032651e+00 + 2.0502936359659111755031062e+00i),
   185  	(2.3096442270679923004800651e+00 + 2.9483213155446756211881774e-01i),
   186  	(1.7904660933974656106951860e+00 + 1.0605860367252556281902109e+00i),
   187  	(1.7745926939841751666177512e+00 + 4.8084556083358307819310911e-01i),
   188  	(1.1885403350045342425648780e+00 + 5.8969634164776659423195222e-01i),
   189  	(2.1833107837679082586772505e+00 - 1.3636647724582455028314573e+00i),
   190  	(2.3037629487273259170991671e+00 + 2.6210913895386013290915234e+00i),
   191  }
   192  var log10 = []complex128{
   193  	(9.6389223745559042474184943e-01 + 4.338997735671419492599631e-01i),
   194  	(8.8895547241376579493490892e-01 - 1.5531488990643548254864806e-02i),
   195  	(7.0055210462945412305244578e-01 - 7.0616239649481243222248404e-01i),
   196  	(1.0358753067322445311676952e+00 + 8.9043121238134980156490909e-01i),
   197  	(1.003065742975330237172029e+00 + 1.2804396782187887479857811e-01i),
   198  	(7.7758954439739162532085157e-01 + 4.6060666333341810869055108e-01i),
   199  	(7.7069581462315327037689152e-01 + 2.0882857371769952195512475e-01i),
   200  	(5.1617650901191156135137239e-01 + 2.5610186717615977620363299e-01i),
   201  	(9.4819982567026639742663212e-01 - 5.9223208584446952284914289e-01i),
   202  	(1.0005115362454417135973429e+00 + 1.1383255270407412817250921e+00i),
   203  }
   204  
   205  type ff struct {
   206  	r, theta float64
   207  }
   208  
   209  var polar = []ff{
   210  	{9.2022120669932650313380972e+00, 9.9909115046919291062461269e-01},
   211  	{7.7438239742296106616261394e+00, -3.5762575021856971295156489e-02},
   212  	{5.0182478202557746902556648e+00, -1.6259990074019058442232221e+00},
   213  	{1.0861137372799545160704002e+01, 2.0502936359659111755031062e+00},
   214  	{1.0070841084922199607011905e+01, 2.9483213155446756211881774e-01},
   215  	{5.9922447613166942183705192e+00, 1.0605860367252556281902109e+00},
   216  	{5.8978784056736762299945176e+00, 4.8084556083358307819310911e-01},
   217  	{3.2822866700678709020367184e+00, 5.8969634164776659423195222e-01},
   218  	{8.8756430028990417290744307e+00, -1.3636647724582455028314573e+00},
   219  	{1.0011785496777731986390856e+01, 2.6210913895386013290915234e+00},
   220  }
   221  var pow = []complex128{
   222  	(-2.499956739197529585028819e+00 + 1.759751724335650228957144e+00i),
   223  	(7.357094338218116311191939e+04 - 5.089973412479151648145882e+04i),
   224  	(1.320777296067768517259592e+01 - 3.165621914333901498921986e+01i),
   225  	(-3.123287828297300934072149e-07 - 1.9849567521490553032502223e-7i),
   226  	(8.0622651468477229614813e+04 - 7.80028727944573092944363e+04i),
   227  	(-1.0268824572103165858577141e+00 - 4.716844738244989776610672e-01i),
   228  	(-4.35953819012244175753187e+01 + 2.2036445974645306917648585e+02i),
   229  	(8.3556092283250594950239e-01 - 1.2261571947167240272593282e+01i),
   230  	(1.582292972120769306069625e+03 + 1.273564263524278244782512e+04i),
   231  	(6.592208301642122149025369e-08 + 2.584887236651661903526389e-08i),
   232  }
   233  var sin = []complex128{
   234  	(-1.1073801774240233539648544e+03 + 3.024539773002502192425231e+02i),
   235  	(1.0317037521400759359744682e+00 - 3.2208979799929570242818e-02i),
   236  	(-2.0501952097271429804261058e+01 - 7.2137981348240798841800967e+01i),
   237  	(7.3173638080346338642193078e+03 + 2.249219506193664342566248e+03i),
   238  	(-1.964375633631808177565226e+00 - 9.0958264713870404464159683e+00i),
   239  	(1.992783647158514838337674e+01 - 9.11555769410191350416942e+01i),
   240  	(-6.680335650741921444300349e+00 + 3.763353833142432513086117e+00i),
   241  	(1.2794028166657459148245993e+00 - 2.7669092099795781155109602e+00i),
   242  	(2.8641693949535259594188879e+03 + 7.451234399649871202841615e+02i),
   243  	(-4.893811726244659135553033e+01 - 5.371469305562194635957655e+01i),
   244  }
   245  var sinh = []complex128{
   246  	(8.34559353341652565758198e+00 + 7.2187893208650790476628899e+01i),
   247  	(1.1042192548260646752051112e+03 - 3.1379650595631635858792056e+02i),
   248  	(-8.239469336509264113041849e-02 + 9.9273668758439489098514519e-01i),
   249  	(7.332295456982297798219401e+01 - 1.574585908122833444899023e+01i),
   250  	(-7.4786432301380582103534216e+03 + 1.63483823493980029604071e+03i),
   251  	(4.595842179016870234028347e+00 - 8.135290105518580753211484e+00i),
   252  	(-8.543842533574163435246793e+01 + 3.750798997857594068272375e+01i),
   253  	(-1.918003500809465688017307e+00 + 7.4358344619793504041350251e+00i),
   254  	(-2.233816733239658031433147e+00 - 2.143519070805995056229335e+00i),
   255  	(-7.797564130187551181105341e+02 - 2.8549352346594918614806877e+03i),
   256  }
   257  var sqrt = []complex128{
   258  	(2.6628203086086130543813948e+00 + 1.4531345674282185229796902e+00i),
   259  	(2.7823278427251986247149295e+00 - 4.9756907317005224529115567e-02i),
   260  	(1.5397025302089642757361015e+00 - 1.6271336573016637535695727e+00i),
   261  	(1.7103411581506875260277898e+00 + 2.8170677122737589676157029e+00i),
   262  	(3.1390392472953103383607947e+00 + 4.6612625849858653248980849e-01i),
   263  	(2.1117080764822417640789287e+00 + 1.2381170223514273234967850e+00i),
   264  	(2.3587032281672256703926939e+00 + 5.7827111903257349935720172e-01i),
   265  	(1.7335262588873410476661577e+00 + 5.2647258220721269141550382e-01i),
   266  	(2.3131094974708716531499282e+00 - 1.8775429304303785570775490e+00i),
   267  	(8.1420535745048086240947359e-01 + 3.0575897587277248522656113e+00i),
   268  }
   269  var tan = []complex128{
   270  	(-1.928757919086441129134525e-07 + 1.0000003267499169073251826e+00i),
   271  	(1.242412685364183792138948e+00 - 3.17149693883133370106696e+00i),
   272  	(-4.6745126251587795225571826e-05 - 9.9992439225263959286114298e-01i),
   273  	(4.792363401193648192887116e-09 + 1.0000000070589333451557723e+00i),
   274  	(2.345740824080089140287315e-03 + 9.947733046570988661022763e-01i),
   275  	(-2.396030789494815566088809e-05 + 9.9994781345418591429826779e-01i),
   276  	(-7.370204836644931340905303e-03 + 1.0043553413417138987717748e+00i),
   277  	(-3.691803847992048527007457e-02 + 9.6475071993469548066328894e-01i),
   278  	(-2.781955256713729368401878e-08 - 1.000000049848910609006646e+00i),
   279  	(9.4281590064030478879791249e-05 + 9.9999119340863718183758545e-01i),
   280  }
   281  var tanh = []complex128{
   282  	(1.0000921981225144748819918e+00 + 2.160986245871518020231507e-05i),
   283  	(9.9999967727531993209562591e-01 - 1.9953763222959658873657676e-07i),
   284  	(-1.765485739548037260789686e+00 + 1.7024216325552852445168471e+00i),
   285  	(-9.999189442732736452807108e-01 + 3.64906070494473701938098e-05i),
   286  	(9.9999999224622333738729767e-01 - 3.560088949517914774813046e-09i),
   287  	(1.0029324933367326862499343e+00 - 4.948790309797102353137528e-03i),
   288  	(9.9996113064788012488693567e-01 - 4.226995742097032481451259e-05i),
   289  	(1.0074784189316340029873945e+00 - 4.194050814891697808029407e-03i),
   290  	(9.9385534229718327109131502e-01 + 5.144217985914355502713437e-02i),
   291  	(-1.0000000491604982429364892e+00 - 2.901873195374433112227349e-08i),
   292  }
   293  
   294  // huge values along the real axis for testing reducePi in Tan
   295  var hugeIn = []complex128{
   296  	1 << 28,
   297  	1 << 29,
   298  	1 << 30,
   299  	1 << 35,
   300  	-1 << 120,
   301  	1 << 240,
   302  	1 << 300,
   303  	-1 << 480,
   304  	1234567891234567 << 180,
   305  	-1234567891234567 << 300,
   306  }
   307  
   308  // Results for tanHuge[i] calculated with https://github.com/robpike/ivy
   309  // using 4096 bits of working precision.
   310  var tanHuge = []complex128{
   311  	5.95641897939639421,
   312  	-0.34551069233430392,
   313  	-0.78469661331920043,
   314  	0.84276385870875983,
   315  	0.40806638884180424,
   316  	-0.37603456702698076,
   317  	4.60901287677810962,
   318  	3.39135965054779932,
   319  	-6.76813854009065030,
   320  	-0.76417695016604922,
   321  }
   322  
   323  // special cases conform to C99 standard appendix G.6 Complex arithmetic
   324  var inf, nan = math.Inf(1), math.NaN()
   325  
   326  var vcAbsSC = []complex128{
   327  	NaN(),
   328  }
   329  var absSC = []float64{
   330  	math.NaN(),
   331  }
   332  var acosSC = []struct {
   333  	in,
   334  	want complex128
   335  }{
   336  	// G.6.1.1
   337  	{complex(zero, zero),
   338  		complex(math.Pi/2, -zero)},
   339  	{complex(-zero, zero),
   340  		complex(math.Pi/2, -zero)},
   341  	{complex(zero, nan),
   342  		complex(math.Pi/2, nan)},
   343  	{complex(-zero, nan),
   344  		complex(math.Pi/2, nan)},
   345  	{complex(1.0, inf),
   346  		complex(math.Pi/2, -inf)},
   347  	{complex(1.0, nan),
   348  		NaN()},
   349  	{complex(-inf, 1.0),
   350  		complex(math.Pi, -inf)},
   351  	{complex(inf, 1.0),
   352  		complex(0.0, -inf)},
   353  	{complex(-inf, inf),
   354  		complex(3*math.Pi/4, -inf)},
   355  	{complex(inf, inf),
   356  		complex(math.Pi/4, -inf)},
   357  	{complex(inf, nan),
   358  		complex(nan, -inf)}, // imaginary sign unspecified
   359  	{complex(-inf, nan),
   360  		complex(nan, inf)}, // imaginary sign unspecified
   361  	{complex(nan, 1.0),
   362  		NaN()},
   363  	{complex(nan, inf),
   364  		complex(nan, -inf)},
   365  	{NaN(),
   366  		NaN()},
   367  }
   368  var acoshSC = []struct {
   369  	in,
   370  	want complex128
   371  }{
   372  	// G.6.2.1
   373  	{complex(zero, zero),
   374  		complex(zero, math.Pi/2)},
   375  	{complex(-zero, zero),
   376  		complex(zero, math.Pi/2)},
   377  	{complex(1.0, inf),
   378  		complex(inf, math.Pi/2)},
   379  	{complex(1.0, nan),
   380  		NaN()},
   381  	{complex(-inf, 1.0),
   382  		complex(inf, math.Pi)},
   383  	{complex(inf, 1.0),
   384  		complex(inf, zero)},
   385  	{complex(-inf, inf),
   386  		complex(inf, 3*math.Pi/4)},
   387  	{complex(inf, inf),
   388  		complex(inf, math.Pi/4)},
   389  	{complex(inf, nan),
   390  		complex(inf, nan)},
   391  	{complex(-inf, nan),
   392  		complex(inf, nan)},
   393  	{complex(nan, 1.0),
   394  		NaN()},
   395  	{complex(nan, inf),
   396  		complex(inf, nan)},
   397  	{NaN(),
   398  		NaN()},
   399  }
   400  var asinSC = []struct {
   401  	in,
   402  	want complex128
   403  }{
   404  	// Derived from Asin(z) = -i * Asinh(i * z), G.6 #7
   405  	{complex(zero, zero),
   406  		complex(zero, zero)},
   407  	{complex(1.0, inf),
   408  		complex(0, inf)},
   409  	{complex(1.0, nan),
   410  		NaN()},
   411  	{complex(inf, 1),
   412  		complex(math.Pi/2, inf)},
   413  	{complex(inf, inf),
   414  		complex(math.Pi/4, inf)},
   415  	{complex(inf, nan),
   416  		complex(nan, inf)}, // imaginary sign unspecified
   417  	{complex(nan, zero),
   418  		NaN()},
   419  	{complex(nan, 1),
   420  		NaN()},
   421  	{complex(nan, inf),
   422  		complex(nan, inf)},
   423  	{NaN(),
   424  		NaN()},
   425  }
   426  var asinhSC = []struct {
   427  	in,
   428  	want complex128
   429  }{
   430  	// G.6.2.2
   431  	{complex(zero, zero),
   432  		complex(zero, zero)},
   433  	{complex(1.0, inf),
   434  		complex(inf, math.Pi/2)},
   435  	{complex(1.0, nan),
   436  		NaN()},
   437  	{complex(inf, 1.0),
   438  		complex(inf, zero)},
   439  	{complex(inf, inf),
   440  		complex(inf, math.Pi/4)},
   441  	{complex(inf, nan),
   442  		complex(inf, nan)},
   443  	{complex(nan, zero),
   444  		complex(nan, zero)},
   445  	{complex(nan, 1.0),
   446  		NaN()},
   447  	{complex(nan, inf),
   448  		complex(inf, nan)}, // sign of real part unspecified
   449  	{NaN(),
   450  		NaN()},
   451  }
   452  var atanSC = []struct {
   453  	in,
   454  	want complex128
   455  }{
   456  	// Derived from Atan(z) = -i * Atanh(i * z), G.6 #7
   457  	{complex(0, zero),
   458  		complex(0, zero)},
   459  	{complex(0, nan),
   460  		NaN()},
   461  	{complex(1.0, zero),
   462  		complex(math.Pi/4, zero)},
   463  	{complex(1.0, inf),
   464  		complex(math.Pi/2, zero)},
   465  	{complex(1.0, nan),
   466  		NaN()},
   467  	{complex(inf, 1),
   468  		complex(math.Pi/2, zero)},
   469  	{complex(inf, inf),
   470  		complex(math.Pi/2, zero)},
   471  	{complex(inf, nan),
   472  		complex(math.Pi/2, zero)},
   473  	{complex(nan, 1),
   474  		NaN()},
   475  	{complex(nan, inf),
   476  		complex(nan, zero)},
   477  	{NaN(),
   478  		NaN()},
   479  }
   480  var atanhSC = []struct {
   481  	in,
   482  	want complex128
   483  }{
   484  	// G.6.2.3
   485  	{complex(zero, zero),
   486  		complex(zero, zero)},
   487  	{complex(zero, nan),
   488  		complex(zero, nan)},
   489  	{complex(1.0, zero),
   490  		complex(inf, zero)},
   491  	{complex(1.0, inf),
   492  		complex(0, math.Pi/2)},
   493  	{complex(1.0, nan),
   494  		NaN()},
   495  	{complex(inf, 1.0),
   496  		complex(zero, math.Pi/2)},
   497  	{complex(inf, inf),
   498  		complex(zero, math.Pi/2)},
   499  	{complex(inf, nan),
   500  		complex(0, nan)},
   501  	{complex(nan, 1.0),
   502  		NaN()},
   503  	{complex(nan, inf),
   504  		complex(zero, math.Pi/2)}, // sign of real part not specified.
   505  	{NaN(),
   506  		NaN()},
   507  }
   508  var vcConjSC = []complex128{
   509  	NaN(),
   510  }
   511  var conjSC = []complex128{
   512  	NaN(),
   513  }
   514  var cosSC = []struct {
   515  	in,
   516  	want complex128
   517  }{
   518  	// Derived from Cos(z) = Cosh(i * z), G.6 #7
   519  	{complex(zero, zero),
   520  		complex(1.0, -zero)},
   521  	{complex(zero, inf),
   522  		complex(inf, -zero)},
   523  	{complex(zero, nan),
   524  		complex(nan, zero)}, // imaginary sign unspecified
   525  	{complex(1.0, inf),
   526  		complex(inf, -inf)},
   527  	{complex(1.0, nan),
   528  		NaN()},
   529  	{complex(inf, zero),
   530  		complex(nan, -zero)},
   531  	{complex(inf, 1.0),
   532  		NaN()},
   533  	{complex(inf, inf),
   534  		complex(inf, nan)}, // real sign unspecified
   535  	{complex(inf, nan),
   536  		NaN()},
   537  	{complex(nan, zero),
   538  		complex(nan, -zero)}, // imaginary sign unspecified
   539  	{complex(nan, 1.0),
   540  		NaN()},
   541  	{complex(nan, inf),
   542  		complex(inf, nan)},
   543  	{NaN(),
   544  		NaN()},
   545  }
   546  var coshSC = []struct {
   547  	in,
   548  	want complex128
   549  }{
   550  	// G.6.2.4
   551  	{complex(zero, zero),
   552  		complex(1.0, zero)},
   553  	{complex(zero, inf),
   554  		complex(nan, zero)}, // imaginary sign unspecified
   555  	{complex(zero, nan),
   556  		complex(nan, zero)}, // imaginary sign unspecified
   557  	{complex(1.0, inf),
   558  		NaN()},
   559  	{complex(1.0, nan),
   560  		NaN()},
   561  	{complex(inf, zero),
   562  		complex(inf, zero)},
   563  	{complex(inf, 1.0),
   564  		complex(inf*math.Cos(1.0), inf*math.Sin(1.0))}, // +inf  cis(y)
   565  	{complex(inf, inf),
   566  		complex(inf, nan)}, // real sign unspecified
   567  	{complex(inf, nan),
   568  		complex(inf, nan)},
   569  	{complex(nan, zero),
   570  		complex(nan, zero)}, // imaginary sign unspecified
   571  	{complex(nan, 1.0),
   572  		NaN()},
   573  	{complex(nan, inf),
   574  		NaN()},
   575  	{NaN(),
   576  		NaN()},
   577  }
   578  var expSC = []struct {
   579  	in,
   580  	want complex128
   581  }{
   582  	// G.6.3.1
   583  	{complex(zero, zero),
   584  		complex(1.0, zero)},
   585  	{complex(-zero, zero),
   586  		complex(1.0, zero)},
   587  	{complex(1.0, inf),
   588  		NaN()},
   589  	{complex(1.0, nan),
   590  		NaN()},
   591  	{complex(inf, zero),
   592  		complex(inf, zero)},
   593  	{complex(-inf, 1.0),
   594  		complex(math.Copysign(0.0, math.Cos(1.0)), math.Copysign(0.0, math.Sin(1.0)))}, // +0 cis(y)
   595  	{complex(inf, 1.0),
   596  		complex(inf*math.Cos(1.0), inf*math.Sin(1.0))}, // +inf  cis(y)
   597  	{complex(-inf, inf),
   598  		complex(zero, zero)}, // real and imaginary sign unspecified
   599  	{complex(inf, inf),
   600  		complex(inf, nan)}, // real sign unspecified
   601  	{complex(-inf, nan),
   602  		complex(zero, zero)}, // real and imaginary sign unspecified
   603  	{complex(inf, nan),
   604  		complex(inf, nan)}, // real sign unspecified
   605  	{complex(nan, zero),
   606  		complex(nan, zero)},
   607  	{complex(nan, 1.0),
   608  		NaN()},
   609  	{complex(nan, inf),
   610  		NaN()},
   611  	{NaN(),
   612  		NaN()},
   613  }
   614  var vcIsNaNSC = []complex128{
   615  	complex(math.Inf(-1), math.Inf(-1)),
   616  	complex(math.Inf(-1), math.NaN()),
   617  	complex(math.NaN(), math.Inf(-1)),
   618  	complex(0, math.NaN()),
   619  	complex(math.NaN(), 0),
   620  	complex(math.Inf(1), math.Inf(1)),
   621  	complex(math.Inf(1), math.NaN()),
   622  	complex(math.NaN(), math.Inf(1)),
   623  	complex(math.NaN(), math.NaN()),
   624  }
   625  var isNaNSC = []bool{
   626  	false,
   627  	false,
   628  	false,
   629  	true,
   630  	true,
   631  	false,
   632  	false,
   633  	false,
   634  	true,
   635  }
   636  
   637  var logSC = []struct {
   638  	in,
   639  	want complex128
   640  }{
   641  	// G.6.3.2
   642  	{complex(zero, zero),
   643  		complex(-inf, zero)},
   644  	{complex(-zero, zero),
   645  		complex(-inf, math.Pi)},
   646  	{complex(1.0, inf),
   647  		complex(inf, math.Pi/2)},
   648  	{complex(1.0, nan),
   649  		NaN()},
   650  	{complex(-inf, 1.0),
   651  		complex(inf, math.Pi)},
   652  	{complex(inf, 1.0),
   653  		complex(inf, 0.0)},
   654  	{complex(-inf, inf),
   655  		complex(inf, 3*math.Pi/4)},
   656  	{complex(inf, inf),
   657  		complex(inf, math.Pi/4)},
   658  	{complex(-inf, nan),
   659  		complex(inf, nan)},
   660  	{complex(inf, nan),
   661  		complex(inf, nan)},
   662  	{complex(nan, 1.0),
   663  		NaN()},
   664  	{complex(nan, inf),
   665  		complex(inf, nan)},
   666  	{NaN(),
   667  		NaN()},
   668  }
   669  var log10SC = []struct {
   670  	in,
   671  	want complex128
   672  }{
   673  	// derived from Log special cases via Log10(x) = math.Log10E*Log(x)
   674  	{complex(zero, zero),
   675  		complex(-inf, zero)},
   676  	{complex(-zero, zero),
   677  		complex(-inf, float64(math.Log10E)*float64(math.Pi))},
   678  	{complex(1.0, inf),
   679  		complex(inf, float64(math.Log10E)*float64(math.Pi/2))},
   680  	{complex(1.0, nan),
   681  		NaN()},
   682  	{complex(-inf, 1.0),
   683  		complex(inf, float64(math.Log10E)*float64(math.Pi))},
   684  	{complex(inf, 1.0),
   685  		complex(inf, 0.0)},
   686  	{complex(-inf, inf),
   687  		complex(inf, float64(math.Log10E)*float64(3*math.Pi/4))},
   688  	{complex(inf, inf),
   689  		complex(inf, float64(math.Log10E)*float64(math.Pi/4))},
   690  	{complex(-inf, nan),
   691  		complex(inf, nan)},
   692  	{complex(inf, nan),
   693  		complex(inf, nan)},
   694  	{complex(nan, 1.0),
   695  		NaN()},
   696  	{complex(nan, inf),
   697  		complex(inf, nan)},
   698  	{NaN(),
   699  		NaN()},
   700  }
   701  var vcPolarSC = []complex128{
   702  	NaN(),
   703  }
   704  var polarSC = []ff{
   705  	{math.NaN(), math.NaN()},
   706  }
   707  var vcPowSC = [][2]complex128{
   708  	{NaN(), NaN()},
   709  	{0, NaN()},
   710  }
   711  var powSC = []complex128{
   712  	NaN(),
   713  	NaN(),
   714  }
   715  var sinSC = []struct {
   716  	in,
   717  	want complex128
   718  }{
   719  	// Derived from Sin(z) = -i * Sinh(i * z), G.6 #7
   720  	{complex(zero, zero),
   721  		complex(zero, zero)},
   722  	{complex(zero, inf),
   723  		complex(zero, inf)},
   724  	{complex(zero, nan),
   725  		complex(zero, nan)},
   726  	{complex(1.0, inf),
   727  		complex(inf, inf)},
   728  	{complex(1.0, nan),
   729  		NaN()},
   730  	{complex(inf, zero),
   731  		complex(nan, zero)},
   732  	{complex(inf, 1.0),
   733  		NaN()},
   734  	{complex(inf, inf),
   735  		complex(nan, inf)},
   736  	{complex(inf, nan),
   737  		NaN()},
   738  	{complex(nan, zero),
   739  		complex(nan, zero)},
   740  	{complex(nan, 1.0),
   741  		NaN()},
   742  	{complex(nan, inf),
   743  		complex(nan, inf)},
   744  	{NaN(),
   745  		NaN()},
   746  }
   747  
   748  var sinhSC = []struct {
   749  	in,
   750  	want complex128
   751  }{
   752  	// G.6.2.5
   753  	{complex(zero, zero),
   754  		complex(zero, zero)},
   755  	{complex(zero, inf),
   756  		complex(zero, nan)}, // real sign unspecified
   757  	{complex(zero, nan),
   758  		complex(zero, nan)}, // real sign unspecified
   759  	{complex(1.0, inf),
   760  		NaN()},
   761  	{complex(1.0, nan),
   762  		NaN()},
   763  	{complex(inf, zero),
   764  		complex(inf, zero)},
   765  	{complex(inf, 1.0),
   766  		complex(inf*math.Cos(1.0), inf*math.Sin(1.0))}, // +inf  cis(y)
   767  	{complex(inf, inf),
   768  		complex(inf, nan)}, // real sign unspecified
   769  	{complex(inf, nan),
   770  		complex(inf, nan)}, // real sign unspecified
   771  	{complex(nan, zero),
   772  		complex(nan, zero)},
   773  	{complex(nan, 1.0),
   774  		NaN()},
   775  	{complex(nan, inf),
   776  		NaN()},
   777  	{NaN(),
   778  		NaN()},
   779  }
   780  
   781  var sqrtSC = []struct {
   782  	in,
   783  	want complex128
   784  }{
   785  	// G.6.4.2
   786  	{complex(zero, zero),
   787  		complex(zero, zero)},
   788  	{complex(-zero, zero),
   789  		complex(zero, zero)},
   790  	{complex(1.0, inf),
   791  		complex(inf, inf)},
   792  	{complex(nan, inf),
   793  		complex(inf, inf)},
   794  	{complex(1.0, nan),
   795  		NaN()},
   796  	{complex(-inf, 1.0),
   797  		complex(zero, inf)},
   798  	{complex(inf, 1.0),
   799  		complex(inf, zero)},
   800  	{complex(-inf, nan),
   801  		complex(nan, inf)}, // imaginary sign unspecified
   802  	{complex(inf, nan),
   803  		complex(inf, nan)},
   804  	{complex(nan, 1.0),
   805  		NaN()},
   806  	{NaN(),
   807  		NaN()},
   808  }
   809  var tanSC = []struct {
   810  	in,
   811  	want complex128
   812  }{
   813  	// Derived from Tan(z) = -i * Tanh(i * z), G.6 #7
   814  	{complex(zero, zero),
   815  		complex(zero, zero)},
   816  	{complex(zero, nan),
   817  		complex(zero, nan)},
   818  	{complex(1.0, inf),
   819  		complex(zero, 1.0)},
   820  	{complex(1.0, nan),
   821  		NaN()},
   822  	{complex(inf, 1.0),
   823  		NaN()},
   824  	{complex(inf, inf),
   825  		complex(zero, 1.0)},
   826  	{complex(inf, nan),
   827  		NaN()},
   828  	{complex(nan, zero),
   829  		NaN()},
   830  	{complex(nan, 1.0),
   831  		NaN()},
   832  	{complex(nan, inf),
   833  		complex(zero, 1.0)},
   834  	{NaN(),
   835  		NaN()},
   836  }
   837  var tanhSC = []struct {
   838  	in,
   839  	want complex128
   840  }{
   841  	// G.6.2.6
   842  	{complex(zero, zero),
   843  		complex(zero, zero)},
   844  	{complex(1.0, inf),
   845  		NaN()},
   846  	{complex(1.0, nan),
   847  		NaN()},
   848  	{complex(inf, 1.0),
   849  		complex(1.0, math.Copysign(0.0, math.Sin(2*1.0)))}, // 1 + i 0 sin(2y)
   850  	{complex(inf, inf),
   851  		complex(1.0, zero)}, // imaginary sign unspecified
   852  	{complex(inf, nan),
   853  		complex(1.0, zero)}, // imaginary sign unspecified
   854  	{complex(nan, zero),
   855  		complex(nan, zero)},
   856  	{complex(nan, 1.0),
   857  		NaN()},
   858  	{complex(nan, inf),
   859  		NaN()},
   860  	{NaN(),
   861  		NaN()},
   862  }
   863  
   864  // branch cut continuity checks
   865  // points on each axis at |z| > 1 are checked for one-sided continuity from both the positive and negative side
   866  // all possible branch cuts for the elementary functions are at one of these points
   867  
   868  var zero = 0.0
   869  var eps = 1.0 / (1 << 53)
   870  
   871  var branchPoints = [][2]complex128{
   872  	{complex(2.0, zero), complex(2.0, eps)},
   873  	{complex(2.0, -zero), complex(2.0, -eps)},
   874  	{complex(-2.0, zero), complex(-2.0, eps)},
   875  	{complex(-2.0, -zero), complex(-2.0, -eps)},
   876  	{complex(zero, 2.0), complex(eps, 2.0)},
   877  	{complex(-zero, 2.0), complex(-eps, 2.0)},
   878  	{complex(zero, -2.0), complex(eps, -2.0)},
   879  	{complex(-zero, -2.0), complex(-eps, -2.0)},
   880  }
   881  
   882  // functions borrowed from pkg/math/all_test.go
   883  func tolerance(a, b, e float64) bool {
   884  	d := a - b
   885  	if d < 0 {
   886  		d = -d
   887  	}
   888  
   889  	// note: b is correct (expected) value, a is actual value.
   890  	// make error tolerance a fraction of b, not a.
   891  	if b != 0 {
   892  		e = e * b
   893  		if e < 0 {
   894  			e = -e
   895  		}
   896  	}
   897  	return d < e
   898  }
   899  func veryclose(a, b float64) bool { return tolerance(a, b, 4e-16) }
   900  func alike(a, b float64) bool {
   901  	switch {
   902  	case a != a && b != b: // math.IsNaN(a) && math.IsNaN(b):
   903  		return true
   904  	case a == b:
   905  		return math.Signbit(a) == math.Signbit(b)
   906  	}
   907  	return false
   908  }
   909  
   910  func cTolerance(a, b complex128, e float64) bool {
   911  	d := Abs(a - b)
   912  	if b != 0 {
   913  		e = e * Abs(b)
   914  		if e < 0 {
   915  			e = -e
   916  		}
   917  	}
   918  	return d < e
   919  }
   920  func cSoclose(a, b complex128, e float64) bool { return cTolerance(a, b, e) }
   921  func cVeryclose(a, b complex128) bool          { return cTolerance(a, b, 4e-16) }
   922  func cAlike(a, b complex128) bool {
   923  	var realAlike, imagAlike bool
   924  	if isExact(real(b)) {
   925  		realAlike = alike(real(a), real(b))
   926  	} else {
   927  		// Allow non-exact special cases to have errors in ULP.
   928  		realAlike = veryclose(real(a), real(b))
   929  	}
   930  	if isExact(imag(b)) {
   931  		imagAlike = alike(imag(a), imag(b))
   932  	} else {
   933  		// Allow non-exact special cases to have errors in ULP.
   934  		imagAlike = veryclose(imag(a), imag(b))
   935  	}
   936  	return realAlike && imagAlike
   937  }
   938  func isExact(x float64) bool {
   939  	// Special cases that should match exactly.  Other cases are multiples
   940  	// of Pi that may not be last bit identical on all platforms.
   941  	return math.IsNaN(x) || math.IsInf(x, 0) || x == 0 || x == 1 || x == -1
   942  }
   943  
   944  func TestAbs(t *testing.T) {
   945  	for i := 0; i < len(vc); i++ {
   946  		if f := Abs(vc[i]); !veryclose(abs[i], f) {
   947  			t.Errorf("Abs(%g) = %g, want %g", vc[i], f, abs[i])
   948  		}
   949  	}
   950  	for i := 0; i < len(vcAbsSC); i++ {
   951  		if f := Abs(vcAbsSC[i]); !alike(absSC[i], f) {
   952  			t.Errorf("Abs(%g) = %g, want %g", vcAbsSC[i], f, absSC[i])
   953  		}
   954  	}
   955  }
   956  func TestAcos(t *testing.T) {
   957  	for i := 0; i < len(vc); i++ {
   958  		if f := Acos(vc[i]); !cSoclose(acos[i], f, 1e-14) {
   959  			t.Errorf("Acos(%g) = %g, want %g", vc[i], f, acos[i])
   960  		}
   961  	}
   962  	for _, v := range acosSC {
   963  		if f := Acos(v.in); !cAlike(v.want, f) {
   964  			t.Errorf("Acos(%g) = %g, want %g", v.in, f, v.want)
   965  		}
   966  		if math.IsNaN(imag(v.in)) || math.IsNaN(imag(v.want)) {
   967  			// Negating NaN is undefined with regard to the sign bit produced.
   968  			continue
   969  		}
   970  		// Acos(Conj(z))  == Conj(Acos(z))
   971  		if f := Acos(Conj(v.in)); !cAlike(Conj(v.want), f) && !cAlike(v.in, Conj(v.in)) {
   972  			t.Errorf("Acos(%g) = %g, want %g", Conj(v.in), f, Conj(v.want))
   973  		}
   974  	}
   975  	for _, pt := range branchPoints {
   976  		if f0, f1 := Acos(pt[0]), Acos(pt[1]); !cVeryclose(f0, f1) {
   977  			t.Errorf("Acos(%g) not continuous, got %g want %g", pt[0], f0, f1)
   978  		}
   979  	}
   980  }
   981  func TestAcosh(t *testing.T) {
   982  	for i := 0; i < len(vc); i++ {
   983  		if f := Acosh(vc[i]); !cSoclose(acosh[i], f, 1e-14) {
   984  			t.Errorf("Acosh(%g) = %g, want %g", vc[i], f, acosh[i])
   985  		}
   986  	}
   987  	for _, v := range acoshSC {
   988  		if f := Acosh(v.in); !cAlike(v.want, f) {
   989  			t.Errorf("Acosh(%g) = %g, want %g", v.in, f, v.want)
   990  		}
   991  		if math.IsNaN(imag(v.in)) || math.IsNaN(imag(v.want)) {
   992  			// Negating NaN is undefined with regard to the sign bit produced.
   993  			continue
   994  		}
   995  		// Acosh(Conj(z))  == Conj(Acosh(z))
   996  		if f := Acosh(Conj(v.in)); !cAlike(Conj(v.want), f) && !cAlike(v.in, Conj(v.in)) {
   997  			t.Errorf("Acosh(%g) = %g, want %g", Conj(v.in), f, Conj(v.want))
   998  		}
   999  
  1000  	}
  1001  	for _, pt := range branchPoints {
  1002  		if f0, f1 := Acosh(pt[0]), Acosh(pt[1]); !cVeryclose(f0, f1) {
  1003  			t.Errorf("Acosh(%g) not continuous, got %g want %g", pt[0], f0, f1)
  1004  		}
  1005  	}
  1006  }
  1007  func TestAsin(t *testing.T) {
  1008  	for i := 0; i < len(vc); i++ {
  1009  		if f := Asin(vc[i]); !cSoclose(asin[i], f, 1e-14) {
  1010  			t.Errorf("Asin(%g) = %g, want %g", vc[i], f, asin[i])
  1011  		}
  1012  	}
  1013  	for _, v := range asinSC {
  1014  		if f := Asin(v.in); !cAlike(v.want, f) {
  1015  			t.Errorf("Asin(%g) = %g, want %g", v.in, f, v.want)
  1016  		}
  1017  		if math.IsNaN(imag(v.in)) || math.IsNaN(imag(v.want)) {
  1018  			// Negating NaN is undefined with regard to the sign bit produced.
  1019  			continue
  1020  		}
  1021  		// Asin(Conj(z))  == Asin(Sinh(z))
  1022  		if f := Asin(Conj(v.in)); !cAlike(Conj(v.want), f) && !cAlike(v.in, Conj(v.in)) {
  1023  			t.Errorf("Asin(%g) = %g, want %g", Conj(v.in), f, Conj(v.want))
  1024  		}
  1025  		if math.IsNaN(real(v.in)) || math.IsNaN(real(v.want)) {
  1026  			// Negating NaN is undefined with regard to the sign bit produced.
  1027  			continue
  1028  		}
  1029  		// Asin(-z)  == -Asin(z)
  1030  		if f := Asin(-v.in); !cAlike(-v.want, f) && !cAlike(v.in, -v.in) {
  1031  			t.Errorf("Asin(%g) = %g, want %g", -v.in, f, -v.want)
  1032  		}
  1033  	}
  1034  	for _, pt := range branchPoints {
  1035  		if f0, f1 := Asin(pt[0]), Asin(pt[1]); !cVeryclose(f0, f1) {
  1036  			t.Errorf("Asin(%g) not continuous, got %g want %g", pt[0], f0, f1)
  1037  		}
  1038  	}
  1039  }
  1040  func TestAsinh(t *testing.T) {
  1041  	for i := 0; i < len(vc); i++ {
  1042  		if f := Asinh(vc[i]); !cSoclose(asinh[i], f, 4e-15) {
  1043  			t.Errorf("Asinh(%g) = %g, want %g", vc[i], f, asinh[i])
  1044  		}
  1045  	}
  1046  	for _, v := range asinhSC {
  1047  		if f := Asinh(v.in); !cAlike(v.want, f) {
  1048  			t.Errorf("Asinh(%g) = %g, want %g", v.in, f, v.want)
  1049  		}
  1050  		if math.IsNaN(imag(v.in)) || math.IsNaN(imag(v.want)) {
  1051  			// Negating NaN is undefined with regard to the sign bit produced.
  1052  			continue
  1053  		}
  1054  		// Asinh(Conj(z))  == Asinh(Sinh(z))
  1055  		if f := Asinh(Conj(v.in)); !cAlike(Conj(v.want), f) && !cAlike(v.in, Conj(v.in)) {
  1056  			t.Errorf("Asinh(%g) = %g, want %g", Conj(v.in), f, Conj(v.want))
  1057  		}
  1058  		if math.IsNaN(real(v.in)) || math.IsNaN(real(v.want)) {
  1059  			// Negating NaN is undefined with regard to the sign bit produced.
  1060  			continue
  1061  		}
  1062  		// Asinh(-z)  == -Asinh(z)
  1063  		if f := Asinh(-v.in); !cAlike(-v.want, f) && !cAlike(v.in, -v.in) {
  1064  			t.Errorf("Asinh(%g) = %g, want %g", -v.in, f, -v.want)
  1065  		}
  1066  	}
  1067  	for _, pt := range branchPoints {
  1068  		if f0, f1 := Asinh(pt[0]), Asinh(pt[1]); !cVeryclose(f0, f1) {
  1069  			t.Errorf("Asinh(%g) not continuous, got %g want %g", pt[0], f0, f1)
  1070  		}
  1071  	}
  1072  }
  1073  func TestAtan(t *testing.T) {
  1074  	for i := 0; i < len(vc); i++ {
  1075  		if f := Atan(vc[i]); !cVeryclose(atan[i], f) {
  1076  			t.Errorf("Atan(%g) = %g, want %g", vc[i], f, atan[i])
  1077  		}
  1078  	}
  1079  	for _, v := range atanSC {
  1080  		if f := Atan(v.in); !cAlike(v.want, f) {
  1081  			t.Errorf("Atan(%g) = %g, want %g", v.in, f, v.want)
  1082  		}
  1083  		if math.IsNaN(imag(v.in)) || math.IsNaN(imag(v.want)) {
  1084  			// Negating NaN is undefined with regard to the sign bit produced.
  1085  			continue
  1086  		}
  1087  		// Atan(Conj(z))  == Conj(Atan(z))
  1088  		if f := Atan(Conj(v.in)); !cAlike(Conj(v.want), f) && !cAlike(v.in, Conj(v.in)) {
  1089  			t.Errorf("Atan(%g) = %g, want %g", Conj(v.in), f, Conj(v.want))
  1090  		}
  1091  		if math.IsNaN(real(v.in)) || math.IsNaN(real(v.want)) {
  1092  			// Negating NaN is undefined with regard to the sign bit produced.
  1093  			continue
  1094  		}
  1095  		// Atan(-z)  == -Atan(z)
  1096  		if f := Atan(-v.in); !cAlike(-v.want, f) && !cAlike(v.in, -v.in) {
  1097  			t.Errorf("Atan(%g) = %g, want %g", -v.in, f, -v.want)
  1098  		}
  1099  	}
  1100  	for _, pt := range branchPoints {
  1101  		if f0, f1 := Atan(pt[0]), Atan(pt[1]); !cVeryclose(f0, f1) {
  1102  			t.Errorf("Atan(%g) not continuous, got %g want %g", pt[0], f0, f1)
  1103  		}
  1104  	}
  1105  }
  1106  func TestAtanh(t *testing.T) {
  1107  	for i := 0; i < len(vc); i++ {
  1108  		if f := Atanh(vc[i]); !cVeryclose(atanh[i], f) {
  1109  			t.Errorf("Atanh(%g) = %g, want %g", vc[i], f, atanh[i])
  1110  		}
  1111  	}
  1112  	for _, v := range atanhSC {
  1113  		if f := Atanh(v.in); !cAlike(v.want, f) {
  1114  			t.Errorf("Atanh(%g) = %g, want %g", v.in, f, v.want)
  1115  		}
  1116  		if math.IsNaN(imag(v.in)) || math.IsNaN(imag(v.want)) {
  1117  			// Negating NaN is undefined with regard to the sign bit produced.
  1118  			continue
  1119  		}
  1120  		// Atanh(Conj(z))  == Conj(Atanh(z))
  1121  		if f := Atanh(Conj(v.in)); !cAlike(Conj(v.want), f) && !cAlike(v.in, Conj(v.in)) {
  1122  			t.Errorf("Atanh(%g) = %g, want %g", Conj(v.in), f, Conj(v.want))
  1123  		}
  1124  		if math.IsNaN(real(v.in)) || math.IsNaN(real(v.want)) {
  1125  			// Negating NaN is undefined with regard to the sign bit produced.
  1126  			continue
  1127  		}
  1128  		// Atanh(-z)  == -Atanh(z)
  1129  		if f := Atanh(-v.in); !cAlike(-v.want, f) && !cAlike(v.in, -v.in) {
  1130  			t.Errorf("Atanh(%g) = %g, want %g", -v.in, f, -v.want)
  1131  		}
  1132  	}
  1133  	for _, pt := range branchPoints {
  1134  		if f0, f1 := Atanh(pt[0]), Atanh(pt[1]); !cVeryclose(f0, f1) {
  1135  			t.Errorf("Atanh(%g) not continuous, got %g want %g", pt[0], f0, f1)
  1136  		}
  1137  	}
  1138  }
  1139  func TestConj(t *testing.T) {
  1140  	for i := 0; i < len(vc); i++ {
  1141  		if f := Conj(vc[i]); !cVeryclose(conj[i], f) {
  1142  			t.Errorf("Conj(%g) = %g, want %g", vc[i], f, conj[i])
  1143  		}
  1144  	}
  1145  	for i := 0; i < len(vcConjSC); i++ {
  1146  		if f := Conj(vcConjSC[i]); !cAlike(conjSC[i], f) {
  1147  			t.Errorf("Conj(%g) = %g, want %g", vcConjSC[i], f, conjSC[i])
  1148  		}
  1149  	}
  1150  }
  1151  func TestCos(t *testing.T) {
  1152  	for i := 0; i < len(vc); i++ {
  1153  		if f := Cos(vc[i]); !cSoclose(cos[i], f, 3e-15) {
  1154  			t.Errorf("Cos(%g) = %g, want %g", vc[i], f, cos[i])
  1155  		}
  1156  	}
  1157  	for _, v := range cosSC {
  1158  		if f := Cos(v.in); !cAlike(v.want, f) {
  1159  			t.Errorf("Cos(%g) = %g, want %g", v.in, f, v.want)
  1160  		}
  1161  		if math.IsNaN(imag(v.in)) || math.IsNaN(imag(v.want)) {
  1162  			// Negating NaN is undefined with regard to the sign bit produced.
  1163  			continue
  1164  		}
  1165  		// Cos(Conj(z))  == Cos(Cosh(z))
  1166  		if f := Cos(Conj(v.in)); !cAlike(Conj(v.want), f) && !cAlike(v.in, Conj(v.in)) {
  1167  			t.Errorf("Cos(%g) = %g, want %g", Conj(v.in), f, Conj(v.want))
  1168  		}
  1169  		if math.IsNaN(real(v.in)) || math.IsNaN(real(v.want)) {
  1170  			// Negating NaN is undefined with regard to the sign bit produced.
  1171  			continue
  1172  		}
  1173  		// Cos(-z)  == Cos(z)
  1174  		if f := Cos(-v.in); !cAlike(v.want, f) && !cAlike(v.in, -v.in) {
  1175  			t.Errorf("Cos(%g) = %g, want %g", -v.in, f, v.want)
  1176  		}
  1177  	}
  1178  }
  1179  func TestCosh(t *testing.T) {
  1180  	for i := 0; i < len(vc); i++ {
  1181  		if f := Cosh(vc[i]); !cSoclose(cosh[i], f, 2e-15) {
  1182  			t.Errorf("Cosh(%g) = %g, want %g", vc[i], f, cosh[i])
  1183  		}
  1184  	}
  1185  	for _, v := range coshSC {
  1186  		if f := Cosh(v.in); !cAlike(v.want, f) {
  1187  			t.Errorf("Cosh(%g) = %g, want %g", v.in, f, v.want)
  1188  		}
  1189  		if math.IsNaN(imag(v.in)) || math.IsNaN(imag(v.want)) {
  1190  			// Negating NaN is undefined with regard to the sign bit produced.
  1191  			continue
  1192  		}
  1193  		// Cosh(Conj(z))  == Conj(Cosh(z))
  1194  		if f := Cosh(Conj(v.in)); !cAlike(Conj(v.want), f) && !cAlike(v.in, Conj(v.in)) {
  1195  			t.Errorf("Cosh(%g) = %g, want %g", Conj(v.in), f, Conj(v.want))
  1196  		}
  1197  		if math.IsNaN(real(v.in)) || math.IsNaN(real(v.want)) {
  1198  			// Negating NaN is undefined with regard to the sign bit produced.
  1199  			continue
  1200  		}
  1201  		// Cosh(-z)  == Cosh(z)
  1202  		if f := Cosh(-v.in); !cAlike(v.want, f) && !cAlike(v.in, -v.in) {
  1203  			t.Errorf("Cosh(%g) = %g, want %g", -v.in, f, v.want)
  1204  		}
  1205  	}
  1206  }
  1207  func TestExp(t *testing.T) {
  1208  	for i := 0; i < len(vc); i++ {
  1209  		if f := Exp(vc[i]); !cSoclose(exp[i], f, 1e-15) {
  1210  			t.Errorf("Exp(%g) = %g, want %g", vc[i], f, exp[i])
  1211  		}
  1212  	}
  1213  	for _, v := range expSC {
  1214  		if f := Exp(v.in); !cAlike(v.want, f) {
  1215  			t.Errorf("Exp(%g) = %g, want %g", v.in, f, v.want)
  1216  		}
  1217  		if math.IsNaN(imag(v.in)) || math.IsNaN(imag(v.want)) {
  1218  			// Negating NaN is undefined with regard to the sign bit produced.
  1219  			continue
  1220  		}
  1221  		// Exp(Conj(z))  == Exp(Cosh(z))
  1222  		if f := Exp(Conj(v.in)); !cAlike(Conj(v.want), f) && !cAlike(v.in, Conj(v.in)) {
  1223  			t.Errorf("Exp(%g) = %g, want %g", Conj(v.in), f, Conj(v.want))
  1224  		}
  1225  	}
  1226  }
  1227  func TestIsNaN(t *testing.T) {
  1228  	for i := 0; i < len(vcIsNaNSC); i++ {
  1229  		if f := IsNaN(vcIsNaNSC[i]); isNaNSC[i] != f {
  1230  			t.Errorf("IsNaN(%v) = %v, want %v", vcIsNaNSC[i], f, isNaNSC[i])
  1231  		}
  1232  	}
  1233  }
  1234  func TestLog(t *testing.T) {
  1235  	for i := 0; i < len(vc); i++ {
  1236  		if f := Log(vc[i]); !cVeryclose(log[i], f) {
  1237  			t.Errorf("Log(%g) = %g, want %g", vc[i], f, log[i])
  1238  		}
  1239  	}
  1240  	for _, v := range logSC {
  1241  		if f := Log(v.in); !cAlike(v.want, f) {
  1242  			t.Errorf("Log(%g) = %g, want %g", v.in, f, v.want)
  1243  		}
  1244  		if math.IsNaN(imag(v.in)) || math.IsNaN(imag(v.want)) {
  1245  			// Negating NaN is undefined with regard to the sign bit produced.
  1246  			continue
  1247  		}
  1248  		// Log(Conj(z))  == Conj(Log(z))
  1249  		if f := Log(Conj(v.in)); !cAlike(Conj(v.want), f) && !cAlike(v.in, Conj(v.in)) {
  1250  			t.Errorf("Log(%g) = %g, want %g", Conj(v.in), f, Conj(v.want))
  1251  		}
  1252  	}
  1253  	for _, pt := range branchPoints {
  1254  		if f0, f1 := Log(pt[0]), Log(pt[1]); !cVeryclose(f0, f1) {
  1255  			t.Errorf("Log(%g) not continuous, got %g want %g", pt[0], f0, f1)
  1256  		}
  1257  	}
  1258  }
  1259  func TestLog10(t *testing.T) {
  1260  	for i := 0; i < len(vc); i++ {
  1261  		if f := Log10(vc[i]); !cVeryclose(log10[i], f) {
  1262  			t.Errorf("Log10(%g) = %g, want %g", vc[i], f, log10[i])
  1263  		}
  1264  	}
  1265  	for _, v := range log10SC {
  1266  		if f := Log10(v.in); !cAlike(v.want, f) {
  1267  			t.Errorf("Log10(%g) = %g, want %g", v.in, f, v.want)
  1268  		}
  1269  		if math.IsNaN(imag(v.in)) || math.IsNaN(imag(v.want)) {
  1270  			// Negating NaN is undefined with regard to the sign bit produced.
  1271  			continue
  1272  		}
  1273  		// Log10(Conj(z))  == Conj(Log10(z))
  1274  		if f := Log10(Conj(v.in)); !cAlike(Conj(v.want), f) && !cAlike(v.in, Conj(v.in)) {
  1275  			t.Errorf("Log10(%g) = %g, want %g", Conj(v.in), f, Conj(v.want))
  1276  		}
  1277  	}
  1278  }
  1279  func TestPolar(t *testing.T) {
  1280  	for i := 0; i < len(vc); i++ {
  1281  		if r, theta := Polar(vc[i]); !veryclose(polar[i].r, r) && !veryclose(polar[i].theta, theta) {
  1282  			t.Errorf("Polar(%g) = %g, %g want %g, %g", vc[i], r, theta, polar[i].r, polar[i].theta)
  1283  		}
  1284  	}
  1285  	for i := 0; i < len(vcPolarSC); i++ {
  1286  		if r, theta := Polar(vcPolarSC[i]); !alike(polarSC[i].r, r) && !alike(polarSC[i].theta, theta) {
  1287  			t.Errorf("Polar(%g) = %g, %g, want %g, %g", vcPolarSC[i], r, theta, polarSC[i].r, polarSC[i].theta)
  1288  		}
  1289  	}
  1290  }
  1291  func TestPow(t *testing.T) {
  1292  	// Special cases for Pow(0, c).
  1293  	var zero = complex(0, 0)
  1294  	zeroPowers := [][2]complex128{
  1295  		{0, 1 + 0i},
  1296  		{1.5, 0 + 0i},
  1297  		{-1.5, complex(math.Inf(0), 0)},
  1298  		{-1.5 + 1.5i, Inf()},
  1299  	}
  1300  	for _, zp := range zeroPowers {
  1301  		if f := Pow(zero, zp[0]); f != zp[1] {
  1302  			t.Errorf("Pow(%g, %g) = %g, want %g", zero, zp[0], f, zp[1])
  1303  		}
  1304  	}
  1305  	var a = complex(3.0, 3.0)
  1306  	for i := 0; i < len(vc); i++ {
  1307  		if f := Pow(a, vc[i]); !cSoclose(pow[i], f, 4e-15) {
  1308  			t.Errorf("Pow(%g, %g) = %g, want %g", a, vc[i], f, pow[i])
  1309  		}
  1310  	}
  1311  	for i := 0; i < len(vcPowSC); i++ {
  1312  		if f := Pow(vcPowSC[i][0], vcPowSC[i][1]); !cAlike(powSC[i], f) {
  1313  			t.Errorf("Pow(%g, %g) = %g, want %g", vcPowSC[i][0], vcPowSC[i][1], f, powSC[i])
  1314  		}
  1315  	}
  1316  	for _, pt := range branchPoints {
  1317  		if f0, f1 := Pow(pt[0], 0.1), Pow(pt[1], 0.1); !cVeryclose(f0, f1) {
  1318  			t.Errorf("Pow(%g, 0.1) not continuous, got %g want %g", pt[0], f0, f1)
  1319  		}
  1320  	}
  1321  }
  1322  func TestRect(t *testing.T) {
  1323  	for i := 0; i < len(vc); i++ {
  1324  		if f := Rect(polar[i].r, polar[i].theta); !cVeryclose(vc[i], f) {
  1325  			t.Errorf("Rect(%g, %g) = %g want %g", polar[i].r, polar[i].theta, f, vc[i])
  1326  		}
  1327  	}
  1328  	for i := 0; i < len(vcPolarSC); i++ {
  1329  		if f := Rect(polarSC[i].r, polarSC[i].theta); !cAlike(vcPolarSC[i], f) {
  1330  			t.Errorf("Rect(%g, %g) = %g, want %g", polarSC[i].r, polarSC[i].theta, f, vcPolarSC[i])
  1331  		}
  1332  	}
  1333  }
  1334  func TestSin(t *testing.T) {
  1335  	for i := 0; i < len(vc); i++ {
  1336  		if f := Sin(vc[i]); !cSoclose(sin[i], f, 2e-15) {
  1337  			t.Errorf("Sin(%g) = %g, want %g", vc[i], f, sin[i])
  1338  		}
  1339  	}
  1340  	for _, v := range sinSC {
  1341  		if f := Sin(v.in); !cAlike(v.want, f) {
  1342  			t.Errorf("Sin(%g) = %g, want %g", v.in, f, v.want)
  1343  		}
  1344  		if math.IsNaN(imag(v.in)) || math.IsNaN(imag(v.want)) {
  1345  			// Negating NaN is undefined with regard to the sign bit produced.
  1346  			continue
  1347  		}
  1348  		// Sin(Conj(z))  == Conj(Sin(z))
  1349  		if f := Sin(Conj(v.in)); !cAlike(Conj(v.want), f) && !cAlike(v.in, Conj(v.in)) {
  1350  			t.Errorf("Sinh(%g) = %g, want %g", Conj(v.in), f, Conj(v.want))
  1351  		}
  1352  		if math.IsNaN(real(v.in)) || math.IsNaN(real(v.want)) {
  1353  			// Negating NaN is undefined with regard to the sign bit produced.
  1354  			continue
  1355  		}
  1356  		// Sin(-z)  == -Sin(z)
  1357  		if f := Sin(-v.in); !cAlike(-v.want, f) && !cAlike(v.in, -v.in) {
  1358  			t.Errorf("Sinh(%g) = %g, want %g", -v.in, f, -v.want)
  1359  		}
  1360  	}
  1361  }
  1362  func TestSinh(t *testing.T) {
  1363  	for i := 0; i < len(vc); i++ {
  1364  		if f := Sinh(vc[i]); !cSoclose(sinh[i], f, 2e-15) {
  1365  			t.Errorf("Sinh(%g) = %g, want %g", vc[i], f, sinh[i])
  1366  		}
  1367  	}
  1368  	for _, v := range sinhSC {
  1369  		if f := Sinh(v.in); !cAlike(v.want, f) {
  1370  			t.Errorf("Sinh(%g) = %g, want %g", v.in, f, v.want)
  1371  		}
  1372  		if math.IsNaN(imag(v.in)) || math.IsNaN(imag(v.want)) {
  1373  			// Negating NaN is undefined with regard to the sign bit produced.
  1374  			continue
  1375  		}
  1376  		// Sinh(Conj(z))  == Conj(Sinh(z))
  1377  		if f := Sinh(Conj(v.in)); !cAlike(Conj(v.want), f) && !cAlike(v.in, Conj(v.in)) {
  1378  			t.Errorf("Sinh(%g) = %g, want %g", Conj(v.in), f, Conj(v.want))
  1379  		}
  1380  		if math.IsNaN(real(v.in)) || math.IsNaN(real(v.want)) {
  1381  			// Negating NaN is undefined with regard to the sign bit produced.
  1382  			continue
  1383  		}
  1384  		// Sinh(-z)  == -Sinh(z)
  1385  		if f := Sinh(-v.in); !cAlike(-v.want, f) && !cAlike(v.in, -v.in) {
  1386  			t.Errorf("Sinh(%g) = %g, want %g", -v.in, f, -v.want)
  1387  		}
  1388  	}
  1389  }
  1390  func TestSqrt(t *testing.T) {
  1391  	for i := 0; i < len(vc); i++ {
  1392  		if f := Sqrt(vc[i]); !cVeryclose(sqrt[i], f) {
  1393  			t.Errorf("Sqrt(%g) = %g, want %g", vc[i], f, sqrt[i])
  1394  		}
  1395  	}
  1396  	for _, v := range sqrtSC {
  1397  		if f := Sqrt(v.in); !cAlike(v.want, f) {
  1398  			t.Errorf("Sqrt(%g) = %g, want %g", v.in, f, v.want)
  1399  		}
  1400  		if math.IsNaN(imag(v.in)) || math.IsNaN(imag(v.want)) {
  1401  			// Negating NaN is undefined with regard to the sign bit produced.
  1402  			continue
  1403  		}
  1404  		// Sqrt(Conj(z)) == Conj(Sqrt(z))
  1405  		if f := Sqrt(Conj(v.in)); !cAlike(Conj(v.want), f) && !cAlike(v.in, Conj(v.in)) {
  1406  			t.Errorf("Sqrt(%g) = %g, want %g", Conj(v.in), f, Conj(v.want))
  1407  		}
  1408  	}
  1409  	for _, pt := range branchPoints {
  1410  		if f0, f1 := Sqrt(pt[0]), Sqrt(pt[1]); !cVeryclose(f0, f1) {
  1411  			t.Errorf("Sqrt(%g) not continuous, got %g want %g", pt[0], f0, f1)
  1412  		}
  1413  	}
  1414  }
  1415  func TestTan(t *testing.T) {
  1416  	for i := 0; i < len(vc); i++ {
  1417  		if f := Tan(vc[i]); !cSoclose(tan[i], f, 3e-15) {
  1418  			t.Errorf("Tan(%g) = %g, want %g", vc[i], f, tan[i])
  1419  		}
  1420  	}
  1421  	for _, v := range tanSC {
  1422  		if f := Tan(v.in); !cAlike(v.want, f) {
  1423  			t.Errorf("Tan(%g) = %g, want %g", v.in, f, v.want)
  1424  		}
  1425  		if math.IsNaN(imag(v.in)) || math.IsNaN(imag(v.want)) {
  1426  			// Negating NaN is undefined with regard to the sign bit produced.
  1427  			continue
  1428  		}
  1429  		// Tan(Conj(z))  == Conj(Tan(z))
  1430  		if f := Tan(Conj(v.in)); !cAlike(Conj(v.want), f) && !cAlike(v.in, Conj(v.in)) {
  1431  			t.Errorf("Tan(%g) = %g, want %g", Conj(v.in), f, Conj(v.want))
  1432  		}
  1433  		if math.IsNaN(real(v.in)) || math.IsNaN(real(v.want)) {
  1434  			// Negating NaN is undefined with regard to the sign bit produced.
  1435  			continue
  1436  		}
  1437  		// Tan(-z)  == -Tan(z)
  1438  		if f := Tan(-v.in); !cAlike(-v.want, f) && !cAlike(v.in, -v.in) {
  1439  			t.Errorf("Tan(%g) = %g, want %g", -v.in, f, -v.want)
  1440  		}
  1441  	}
  1442  }
  1443  func TestTanh(t *testing.T) {
  1444  	for i := 0; i < len(vc); i++ {
  1445  		if f := Tanh(vc[i]); !cSoclose(tanh[i], f, 2e-15) {
  1446  			t.Errorf("Tanh(%g) = %g, want %g", vc[i], f, tanh[i])
  1447  		}
  1448  	}
  1449  	for _, v := range tanhSC {
  1450  		if f := Tanh(v.in); !cAlike(v.want, f) {
  1451  			t.Errorf("Tanh(%g) = %g, want %g", v.in, f, v.want)
  1452  		}
  1453  		if math.IsNaN(imag(v.in)) || math.IsNaN(imag(v.want)) {
  1454  			// Negating NaN is undefined with regard to the sign bit produced.
  1455  			continue
  1456  		}
  1457  		// Tanh(Conj(z))  == Conj(Tanh(z))
  1458  		if f := Tanh(Conj(v.in)); !cAlike(Conj(v.want), f) && !cAlike(v.in, Conj(v.in)) {
  1459  			t.Errorf("Tanh(%g) = %g, want %g", Conj(v.in), f, Conj(v.want))
  1460  		}
  1461  		if math.IsNaN(real(v.in)) || math.IsNaN(real(v.want)) {
  1462  			// Negating NaN is undefined with regard to the sign bit produced.
  1463  			continue
  1464  		}
  1465  		// Tanh(-z)  == -Tanh(z)
  1466  		if f := Tanh(-v.in); !cAlike(-v.want, f) && !cAlike(v.in, -v.in) {
  1467  			t.Errorf("Tanh(%g) = %g, want %g", -v.in, f, -v.want)
  1468  		}
  1469  	}
  1470  }
  1471  
  1472  // See issue 17577
  1473  func TestInfiniteLoopIntanSeries(t *testing.T) {
  1474  	want := Inf()
  1475  	if got := Cot(0); got != want {
  1476  		t.Errorf("Cot(0): got %g, want %g", got, want)
  1477  	}
  1478  }
  1479  
  1480  func BenchmarkAbs(b *testing.B) {
  1481  	for i := 0; i < b.N; i++ {
  1482  		Abs(complex(2.5, 3.5))
  1483  	}
  1484  }
  1485  func BenchmarkAcos(b *testing.B) {
  1486  	for i := 0; i < b.N; i++ {
  1487  		Acos(complex(2.5, 3.5))
  1488  	}
  1489  }
  1490  func BenchmarkAcosh(b *testing.B) {
  1491  	for i := 0; i < b.N; i++ {
  1492  		Acosh(complex(2.5, 3.5))
  1493  	}
  1494  }
  1495  func BenchmarkAsin(b *testing.B) {
  1496  	for i := 0; i < b.N; i++ {
  1497  		Asin(complex(2.5, 3.5))
  1498  	}
  1499  }
  1500  func BenchmarkAsinh(b *testing.B) {
  1501  	for i := 0; i < b.N; i++ {
  1502  		Asinh(complex(2.5, 3.5))
  1503  	}
  1504  }
  1505  func BenchmarkAtan(b *testing.B) {
  1506  	for i := 0; i < b.N; i++ {
  1507  		Atan(complex(2.5, 3.5))
  1508  	}
  1509  }
  1510  func BenchmarkAtanh(b *testing.B) {
  1511  	for i := 0; i < b.N; i++ {
  1512  		Atanh(complex(2.5, 3.5))
  1513  	}
  1514  }
  1515  func BenchmarkConj(b *testing.B) {
  1516  	for i := 0; i < b.N; i++ {
  1517  		Conj(complex(2.5, 3.5))
  1518  	}
  1519  }
  1520  func BenchmarkCos(b *testing.B) {
  1521  	for i := 0; i < b.N; i++ {
  1522  		Cos(complex(2.5, 3.5))
  1523  	}
  1524  }
  1525  func BenchmarkCosh(b *testing.B) {
  1526  	for i := 0; i < b.N; i++ {
  1527  		Cosh(complex(2.5, 3.5))
  1528  	}
  1529  }
  1530  func BenchmarkExp(b *testing.B) {
  1531  	for i := 0; i < b.N; i++ {
  1532  		Exp(complex(2.5, 3.5))
  1533  	}
  1534  }
  1535  func BenchmarkLog(b *testing.B) {
  1536  	for i := 0; i < b.N; i++ {
  1537  		Log(complex(2.5, 3.5))
  1538  	}
  1539  }
  1540  func BenchmarkLog10(b *testing.B) {
  1541  	for i := 0; i < b.N; i++ {
  1542  		Log10(complex(2.5, 3.5))
  1543  	}
  1544  }
  1545  func BenchmarkPhase(b *testing.B) {
  1546  	for i := 0; i < b.N; i++ {
  1547  		Phase(complex(2.5, 3.5))
  1548  	}
  1549  }
  1550  func BenchmarkPolar(b *testing.B) {
  1551  	for i := 0; i < b.N; i++ {
  1552  		Polar(complex(2.5, 3.5))
  1553  	}
  1554  }
  1555  func BenchmarkPow(b *testing.B) {
  1556  	for i := 0; i < b.N; i++ {
  1557  		Pow(complex(2.5, 3.5), complex(2.5, 3.5))
  1558  	}
  1559  }
  1560  func BenchmarkRect(b *testing.B) {
  1561  	for i := 0; i < b.N; i++ {
  1562  		Rect(2.5, 1.5)
  1563  	}
  1564  }
  1565  func BenchmarkSin(b *testing.B) {
  1566  	for i := 0; i < b.N; i++ {
  1567  		Sin(complex(2.5, 3.5))
  1568  	}
  1569  }
  1570  func BenchmarkSinh(b *testing.B) {
  1571  	for i := 0; i < b.N; i++ {
  1572  		Sinh(complex(2.5, 3.5))
  1573  	}
  1574  }
  1575  func BenchmarkSqrt(b *testing.B) {
  1576  	for i := 0; i < b.N; i++ {
  1577  		Sqrt(complex(2.5, 3.5))
  1578  	}
  1579  }
  1580  func BenchmarkTan(b *testing.B) {
  1581  	for i := 0; i < b.N; i++ {
  1582  		Tan(complex(2.5, 3.5))
  1583  	}
  1584  }
  1585  func BenchmarkTanh(b *testing.B) {
  1586  	for i := 0; i < b.N; i++ {
  1587  		Tanh(complex(2.5, 3.5))
  1588  	}
  1589  }
  1590  

View as plain text