htswanalysis/MACS/lib/gsl/gsl-1.11/cblas/test_scal.c

   1 #include <gsl/gsl_test.h>
   2 #include <gsl/gsl_ieee_utils.h>
   3 #include <gsl/gsl_math.h>
   4 #include <gsl/gsl_cblas.h>
   5
   6 #include "tests.h"
   7
   8 void
   9 test_scal (void) {
  10 const double flteps = 1e-4, dbleps = 1e-6;
  11   {
  12    int N = 1;
  13    float alpha = 0.0f;
  14    float X[] = { 0.651f };
  15    int incX = -1;
  16    float expected[] = { 0.651f };
  17    cblas_sscal(N, alpha, X, incX);
  18    {
  19      int i;
  20      for (i = 0; i < 1; i++) {
  21        gsl_test_rel(X[i], expected[i], flteps, "sscal(case 112)");
  22      }
  23    };
  24   };
  25
  26
  27   {
  28    int N = 1;
  29    float alpha = 0.1f;
  30    float X[] = { 0.651f };
  31    int incX = -1;
  32    float expected[] = { 0.651f };
  33    cblas_sscal(N, alpha, X, incX);
  34    {
  35      int i;
  36      for (i = 0; i < 1; i++) {
  37        gsl_test_rel(X[i], expected[i], flteps, "sscal(case 113)");
  38      }
  39    };
  40   };
  41
  42
  43   {
  44    int N = 1;
  45    float alpha = 1.0f;
  46    float X[] = { 0.651f };
  47    int incX = -1;
  48    float expected[] = { 0.651f };
  49    cblas_sscal(N, alpha, X, incX);
  50    {
  51      int i;
  52      for (i = 0; i < 1; i++) {
  53        gsl_test_rel(X[i], expected[i], flteps, "sscal(case 114)");
  54      }
  55    };
  56   };
  57
  58
  59   {
  60    int N = 1;
  61    double alpha = 0;
  62    double X[] = { 0.686 };
  63    int incX = -1;
  64    double expected[] = { 0.686 };
  65    cblas_dscal(N, alpha, X, incX);
  66    {
  67      int i;
  68      for (i = 0; i < 1; i++) {
  69        gsl_test_rel(X[i], expected[i], dbleps, "dscal(case 115)");
  70      }
  71    };
  72   };
  73
  74
  75   {
  76    int N = 1;
  77    double alpha = 0.1;
  78    double X[] = { 0.686 };
  79    int incX = -1;
  80    double expected[] = { 0.686 };
  81    cblas_dscal(N, alpha, X, incX);
  82    {
  83      int i;
  84      for (i = 0; i < 1; i++) {
  85        gsl_test_rel(X[i], expected[i], dbleps, "dscal(case 116)");
  86      }
  87    };
  88   };
  89
  90
  91   {
  92    int N = 1;
  93    double alpha = 1;
  94    double X[] = { 0.686 };
  95    int incX = -1;
  96    double expected[] = { 0.686 };
  97    cblas_dscal(N, alpha, X, incX);
  98    {
  99      int i;
 100      for (i = 0; i < 1; i++) {
 101        gsl_test_rel(X[i], expected[i], dbleps, "dscal(case 117)");
 102      }
 103    };
 104   };
 105
 106
 107   {
 108    int N = 1;
 109    float alpha[2] = {0.0f, 0.0f};
 110    float X[] = { 0.986f, -0.775f };
 111    int incX = -1;
 112    float expected[] = { 0.986f, -0.775f };
 113    cblas_cscal(N, alpha, X, incX);
 114    {
 115      int i;
 116      for (i = 0; i < 1; i++) {
 117        gsl_test_rel(X[2*i], expected[2*i], flteps, "cscal(case 118) real");
 118        gsl_test_rel(X[2*i+1], expected[2*i+1], flteps, "cscal(case 118) imag");
 119      };
 120    };
 121   };
 122
 123
 124   {
 125    int N = 1;
 126    float alpha[2] = {0.1f, 0.0f};
 127    float X[] = { 0.986f, -0.775f };
 128    int incX = -1;
 129    float expected[] = { 0.986f, -0.775f };
 130    cblas_cscal(N, alpha, X, incX);
 131    {
 132      int i;
 133      for (i = 0; i < 1; i++) {
 134        gsl_test_rel(X[2*i], expected[2*i], flteps, "cscal(case 119) real");
 135        gsl_test_rel(X[2*i+1], expected[2*i+1], flteps, "cscal(case 119) imag");
 136      };
 137    };
 138   };
 139
 140
 141   {
 142    int N = 1;
 143    float alpha[2] = {1.0f, 0.0f};
 144    float X[] = { 0.986f, -0.775f };
 145    int incX = -1;
 146    float expected[] = { 0.986f, -0.775f };
 147    cblas_cscal(N, alpha, X, incX);
 148    {
 149      int i;
 150      for (i = 0; i < 1; i++) {
 151        gsl_test_rel(X[2*i], expected[2*i], flteps, "cscal(case 120) real");
 152        gsl_test_rel(X[2*i+1], expected[2*i+1], flteps, "cscal(case 120) imag");
 153      };
 154    };
 155   };
 156
 157
 158   {
 159    int N = 1;
 160    float alpha[2] = {0.0f, 0.1f};
 161    float X[] = { 0.986f, -0.775f };
 162    int incX = -1;
 163    float expected[] = { 0.986f, -0.775f };
 164    cblas_cscal(N, alpha, X, incX);
 165    {
 166      int i;
 167      for (i = 0; i < 1; i++) {
 168        gsl_test_rel(X[2*i], expected[2*i], flteps, "cscal(case 121) real");
 169        gsl_test_rel(X[2*i+1], expected[2*i+1], flteps, "cscal(case 121) imag");
 170      };
 171    };
 172   };
 173
 174
 175   {
 176    int N = 1;
 177    float alpha[2] = {0.1f, 0.2f};
 178    float X[] = { 0.986f, -0.775f };
 179    int incX = -1;
 180    float expected[] = { 0.986f, -0.775f };
 181    cblas_cscal(N, alpha, X, incX);
 182    {
 183      int i;
 184      for (i = 0; i < 1; i++) {
 185        gsl_test_rel(X[2*i], expected[2*i], flteps, "cscal(case 122) real");
 186        gsl_test_rel(X[2*i+1], expected[2*i+1], flteps, "cscal(case 122) imag");
 187      };
 188    };
 189   };
 190
 191
 192   {
 193    int N = 1;
 194    float alpha[2] = {1.0f, 0.3f};
 195    float X[] = { 0.986f, -0.775f };
 196    int incX = -1;
 197    float expected[] = { 0.986f, -0.775f };
 198    cblas_cscal(N, alpha, X, incX);
 199    {
 200      int i;
 201      for (i = 0; i < 1; i++) {
 202        gsl_test_rel(X[2*i], expected[2*i], flteps, "cscal(case 123) real");
 203        gsl_test_rel(X[2*i+1], expected[2*i+1], flteps, "cscal(case 123) imag");
 204      };
 205    };
 206   };
 207
 208
 209   {
 210    int N = 1;
 211    double alpha[2] = {0, 0};
 212    double X[] = { 0.454, -0.478 };
 213    int incX = -1;
 214    double expected[] = { 0.454, -0.478 };
 215    cblas_zscal(N, alpha, X, incX);
 216    {
 217      int i;
 218      for (i = 0; i < 1; i++) {
 219        gsl_test_rel(X[2*i], expected[2*i], dbleps, "zscal(case 124) real");
 220        gsl_test_rel(X[2*i+1], expected[2*i+1], dbleps, "zscal(case 124) imag");
 221      };
 222    };
 223   };
 224
 225
 226   {
 227    int N = 1;
 228    double alpha[2] = {0.1, 0};
 229    double X[] = { 0.454, -0.478 };
 230    int incX = -1;
 231    double expected[] = { 0.454, -0.478 };
 232    cblas_zscal(N, alpha, X, incX);
 233    {
 234      int i;
 235      for (i = 0; i < 1; i++) {
 236        gsl_test_rel(X[2*i], expected[2*i], dbleps, "zscal(case 125) real");
 237        gsl_test_rel(X[2*i+1], expected[2*i+1], dbleps, "zscal(case 125) imag");
 238      };
 239    };
 240   };
 241
 242
 243   {
 244    int N = 1;
 245    double alpha[2] = {1, 0};
 246    double X[] = { 0.454, -0.478 };
 247    int incX = -1;
 248    double expected[] = { 0.454, -0.478 };
 249    cblas_zscal(N, alpha, X, incX);
 250    {
 251      int i;
 252      for (i = 0; i < 1; i++) {
 253        gsl_test_rel(X[2*i], expected[2*i], dbleps, "zscal(case 126) real");
 254        gsl_test_rel(X[2*i+1], expected[2*i+1], dbleps, "zscal(case 126) imag");
 255      };
 256    };
 257   };
 258
 259
 260   {
 261    int N = 1;
 262    double alpha[2] = {0, 0.1};
 263    double X[] = { 0.454, -0.478 };
 264    int incX = -1;
 265    double expected[] = { 0.454, -0.478 };
 266    cblas_zscal(N, alpha, X, incX);
 267    {
 268      int i;
 269      for (i = 0; i < 1; i++) {
 270        gsl_test_rel(X[2*i], expected[2*i], dbleps, "zscal(case 127) real");
 271        gsl_test_rel(X[2*i+1], expected[2*i+1], dbleps, "zscal(case 127) imag");
 272      };
 273    };
 274   };
 275
 276
 277   {
 278    int N = 1;
 279    double alpha[2] = {0.1, 0.2};
 280    double X[] = { 0.454, -0.478 };
 281    int incX = -1;
 282    double expected[] = { 0.454, -0.478 };
 283    cblas_zscal(N, alpha, X, incX);
 284    {
 285      int i;
 286      for (i = 0; i < 1; i++) {
 287        gsl_test_rel(X[2*i], expected[2*i], dbleps, "zscal(case 128) real");
 288        gsl_test_rel(X[2*i+1], expected[2*i+1], dbleps, "zscal(case 128) imag");
 289      };
 290    };
 291   };
 292
 293
 294   {
 295    int N = 1;
 296    double alpha[2] = {1, 0.3};
 297    double X[] = { 0.454, -0.478 };
 298    int incX = -1;
 299    double expected[] = { 0.454, -0.478 };
 300    cblas_zscal(N, alpha, X, incX);
 301    {
 302      int i;
 303      for (i = 0; i < 1; i++) {
 304        gsl_test_rel(X[2*i], expected[2*i], dbleps, "zscal(case 129) real");
 305        gsl_test_rel(X[2*i+1], expected[2*i+1], dbleps, "zscal(case 129) imag");
 306      };
 307    };
 308   };
 309
 310
 311   {
 312    int N = 2;
 313    float alpha = 0.0f;
 314    float X[] = { 0.389f, -0.236f };
 315    int incX = 1;
 316    float expected[] = { 0.0f, -0.0f };
 317    cblas_sscal(N, alpha, X, incX);
 318    {
 319      int i;
 320      for (i = 0; i < 2; i++) {
 321        gsl_test_rel(X[i], expected[i], flteps, "sscal(case 130)");
 322      }
 323    };
 324   };
 325
 326
 327   {
 328    int N = 2;
 329    float alpha = 0.1f;
 330    float X[] = { 0.389f, -0.236f };
 331    int incX = 1;
 332    float expected[] = { 0.0389f, -0.0236f };
 333    cblas_sscal(N, alpha, X, incX);
 334    {
 335      int i;
 336      for (i = 0; i < 2; i++) {
 337        gsl_test_rel(X[i], expected[i], flteps, "sscal(case 131)");
 338      }
 339    };
 340   };
 341
 342
 343   {
 344    int N = 2;
 345    float alpha = 1.0f;
 346    float X[] = { 0.389f, -0.236f };
 347    int incX = 1;
 348    float expected[] = { 0.389f, -0.236f };
 349    cblas_sscal(N, alpha, X, incX);
 350    {
 351      int i;
 352      for (i = 0; i < 2; i++) {
 353        gsl_test_rel(X[i], expected[i], flteps, "sscal(case 132)");
 354      }
 355    };
 356   };
 357
 358
 359   {
 360    int N = 2;
 361    double alpha = 0;
 362    double X[] = { -0.429, -0.183 };
 363    int incX = 1;
 364    double expected[] = { -0.0, -0.0 };
 365    cblas_dscal(N, alpha, X, incX);
 366    {
 367      int i;
 368      for (i = 0; i < 2; i++) {
 369        gsl_test_rel(X[i], expected[i], dbleps, "dscal(case 133)");
 370      }
 371    };
 372   };
 373
 374
 375   {
 376    int N = 2;
 377    double alpha = 0.1;
 378    double X[] = { -0.429, -0.183 };
 379    int incX = 1;
 380    double expected[] = { -0.0429, -0.0183 };
 381    cblas_dscal(N, alpha, X, incX);
 382    {
 383      int i;
 384      for (i = 0; i < 2; i++) {
 385        gsl_test_rel(X[i], expected[i], dbleps, "dscal(case 134)");
 386      }
 387    };
 388   };
 389
 390
 391   {
 392    int N = 2;
 393    double alpha = 1;
 394    double X[] = { -0.429, -0.183 };
 395    int incX = 1;
 396    double expected[] = { -0.429, -0.183 };
 397    cblas_dscal(N, alpha, X, incX);
 398    {
 399      int i;
 400      for (i = 0; i < 2; i++) {
 401        gsl_test_rel(X[i], expected[i], dbleps, "dscal(case 135)");
 402      }
 403    };
 404   };
 405
 406
 407   {
 408    int N = 2;
 409    float alpha[2] = {0.0f, 0.0f};
 410    float X[] = { -0.603f, 0.239f, 0.339f, -0.58f };
 411    int incX = 1;
 412    float expected[] = { -0.0f, 0.0f, 0.0f, 0.0f };
 413    cblas_cscal(N, alpha, X, incX);
 414    {
 415      int i;
 416      for (i = 0; i < 2; i++) {
 417        gsl_test_rel(X[2*i], expected[2*i], flteps, "cscal(case 136) real");
 418        gsl_test_rel(X[2*i+1], expected[2*i+1], flteps, "cscal(case 136) imag");
 419      };
 420    };
 421   };
 422
 423
 424   {
 425    int N = 2;
 426    float alpha[2] = {0.1f, 0.0f};
 427    float X[] = { -0.603f, 0.239f, 0.339f, -0.58f };
 428    int incX = 1;
 429    float expected[] = { -0.0603f, 0.0239f, 0.0339f, -0.058f };
 430    cblas_cscal(N, alpha, X, incX);
 431    {
 432      int i;
 433      for (i = 0; i < 2; i++) {
 434        gsl_test_rel(X[2*i], expected[2*i], flteps, "cscal(case 137) real");
 435        gsl_test_rel(X[2*i+1], expected[2*i+1], flteps, "cscal(case 137) imag");
 436      };
 437    };
 438   };
 439
 440
 441   {
 442    int N = 2;
 443    float alpha[2] = {1.0f, 0.0f};
 444    float X[] = { -0.603f, 0.239f, 0.339f, -0.58f };
 445    int incX = 1;
 446    float expected[] = { -0.603f, 0.239f, 0.339f, -0.58f };
 447    cblas_cscal(N, alpha, X, incX);
 448    {
 449      int i;
 450      for (i = 0; i < 2; i++) {
 451        gsl_test_rel(X[2*i], expected[2*i], flteps, "cscal(case 138) real");
 452        gsl_test_rel(X[2*i+1], expected[2*i+1], flteps, "cscal(case 138) imag");
 453      };
 454    };
 455   };
 456
 457
 458   {
 459    int N = 2;
 460    float alpha[2] = {0.0f, 0.1f};
 461    float X[] = { -0.603f, 0.239f, 0.339f, -0.58f };
 462    int incX = 1;
 463    float expected[] = { -0.0239f, -0.0603f, 0.058f, 0.0339f };
 464    cblas_cscal(N, alpha, X, incX);
 465    {
 466      int i;
 467      for (i = 0; i < 2; i++) {
 468        gsl_test_rel(X[2*i], expected[2*i], flteps, "cscal(case 139) real");
 469        gsl_test_rel(X[2*i+1], expected[2*i+1], flteps, "cscal(case 139) imag");
 470      };
 471    };
 472   };
 473
 474
 475   {
 476    int N = 2;
 477    float alpha[2] = {0.1f, 0.2f};
 478    float X[] = { -0.603f, 0.239f, 0.339f, -0.58f };
 479    int incX = 1;
 480    float expected[] = { -0.1081f, -0.0967f, 0.1499f, 0.0098f };
 481    cblas_cscal(N, alpha, X, incX);
 482    {
 483      int i;
 484      for (i = 0; i < 2; i++) {
 485        gsl_test_rel(X[2*i], expected[2*i], flteps, "cscal(case 140) real");
 486        gsl_test_rel(X[2*i+1], expected[2*i+1], flteps, "cscal(case 140) imag");
 487      };
 488    };
 489   };
 490
 491
 492   {
 493    int N = 2;
 494    float alpha[2] = {1.0f, 0.3f};
 495    float X[] = { -0.603f, 0.239f, 0.339f, -0.58f };
 496    int incX = 1;
 497    float expected[] = { -0.6747f, 0.0581f, 0.513f, -0.4783f };
 498    cblas_cscal(N, alpha, X, incX);
 499    {
 500      int i;
 501      for (i = 0; i < 2; i++) {
 502        gsl_test_rel(X[2*i], expected[2*i], flteps, "cscal(case 141) real");
 503        gsl_test_rel(X[2*i+1], expected[2*i+1], flteps, "cscal(case 141) imag");
 504      };
 505    };
 506   };
 507
 508
 509   {
 510    int N = 2;
 511    double alpha[2] = {0, 0};
 512    double X[] = { -0.956, 0.613, 0.443, 0.503 };
 513    int incX = 1;
 514    double expected[] = { -0.0, 0.0, 0.0, 0.0 };
 515    cblas_zscal(N, alpha, X, incX);
 516    {
 517      int i;
 518      for (i = 0; i < 2; i++) {
 519        gsl_test_rel(X[2*i], expected[2*i], dbleps, "zscal(case 142) real");
 520        gsl_test_rel(X[2*i+1], expected[2*i+1], dbleps, "zscal(case 142) imag");
 521      };
 522    };
 523   };
 524
 525
 526   {
 527    int N = 2;
 528    double alpha[2] = {0.1, 0};
 529    double X[] = { -0.956, 0.613, 0.443, 0.503 };
 530    int incX = 1;
 531    double expected[] = { -0.0956, 0.0613, 0.0443, 0.0503 };
 532    cblas_zscal(N, alpha, X, incX);
 533    {
 534      int i;
 535      for (i = 0; i < 2; i++) {
 536        gsl_test_rel(X[2*i], expected[2*i], dbleps, "zscal(case 143) real");
 537        gsl_test_rel(X[2*i+1], expected[2*i+1], dbleps, "zscal(case 143) imag");
 538      };
 539    };
 540   };
 541
 542
 543   {
 544    int N = 2;
 545    double alpha[2] = {1, 0};
 546    double X[] = { -0.956, 0.613, 0.443, 0.503 };
 547    int incX = 1;
 548    double expected[] = { -0.956, 0.613, 0.443, 0.503 };
 549    cblas_zscal(N, alpha, X, incX);
 550    {
 551      int i;
 552      for (i = 0; i < 2; i++) {
 553        gsl_test_rel(X[2*i], expected[2*i], dbleps, "zscal(case 144) real");
 554        gsl_test_rel(X[2*i+1], expected[2*i+1], dbleps, "zscal(case 144) imag");
 555      };
 556    };
 557   };
 558
 559
 560   {
 561    int N = 2;
 562    double alpha[2] = {0, 0.1};
 563    double X[] = { -0.956, 0.613, 0.443, 0.503 };
 564    int incX = 1;
 565    double expected[] = { -0.0613, -0.0956, -0.0503, 0.0443 };
 566    cblas_zscal(N, alpha, X, incX);
 567    {
 568      int i;
 569      for (i = 0; i < 2; i++) {
 570        gsl_test_rel(X[2*i], expected[2*i], dbleps, "zscal(case 145) real");
 571        gsl_test_rel(X[2*i+1], expected[2*i+1], dbleps, "zscal(case 145) imag");
 572      };
 573    };
 574   };
 575
 576
 577   {
 578    int N = 2;
 579    double alpha[2] = {0.1, 0.2};
 580    double X[] = { -0.956, 0.613, 0.443, 0.503 };
 581    int incX = 1;
 582    double expected[] = { -0.2182, -0.1299, -0.0563, 0.1389 };
 583    cblas_zscal(N, alpha, X, incX);
 584    {
 585      int i;
 586      for (i = 0; i < 2; i++) {
 587        gsl_test_rel(X[2*i], expected[2*i], dbleps, "zscal(case 146) real");
 588        gsl_test_rel(X[2*i+1], expected[2*i+1], dbleps, "zscal(case 146) imag");
 589      };
 590    };
 591   };
 592
 593
 594   {
 595    int N = 2;
 596    double alpha[2] = {1, 0.3};
 597    double X[] = { -0.956, 0.613, 0.443, 0.503 };
 598    int incX = 1;
 599    double expected[] = { -1.1399, 0.3262, 0.2921, 0.6359 };
 600    cblas_zscal(N, alpha, X, incX);
 601    {
 602      int i;
 603      for (i = 0; i < 2; i++) {
 604        gsl_test_rel(X[2*i], expected[2*i], dbleps, "zscal(case 147) real");
 605        gsl_test_rel(X[2*i+1], expected[2*i+1], dbleps, "zscal(case 147) imag");
 606      };
 607    };
 608   };
 609
 610
 611   {
 612    int N = 2;
 613    float alpha = 0.0f;
 614    float X[] = { 0.629f, -0.419f };
 615    int incX = -1;
 616    float expected[] = { 0.629f, -0.419f };
 617    cblas_sscal(N, alpha, X, incX);
 618    {
 619      int i;
 620      for (i = 0; i < 2; i++) {
 621        gsl_test_rel(X[i], expected[i], flteps, "sscal(case 148)");
 622      }
 623    };
 624   };
 625
 626
 627   {
 628    int N = 2;
 629    float alpha = 0.1f;
 630    float X[] = { 0.629f, -0.419f };
 631    int incX = -1;
 632    float expected[] = { 0.629f, -0.419f };
 633    cblas_sscal(N, alpha, X, incX);
 634    {
 635      int i;
 636      for (i = 0; i < 2; i++) {
 637        gsl_test_rel(X[i], expected[i], flteps, "sscal(case 149)");
 638      }
 639    };
 640   };
 641
 642
 643   {
 644    int N = 2;
 645    float alpha = 1.0f;
 646    float X[] = { 0.629f, -0.419f };
 647    int incX = -1;
 648    float expected[] = { 0.629f, -0.419f };
 649    cblas_sscal(N, alpha, X, incX);
 650    {
 651      int i;
 652      for (i = 0; i < 2; i++) {
 653        gsl_test_rel(X[i], expected[i], flteps, "sscal(case 150)");
 654      }
 655    };
 656   };
 657
 658
 659   {
 660    int N = 2;
 661    double alpha = 0;
 662    double X[] = { 0.398, -0.656 };
 663    int incX = -1;
 664    double expected[] = { 0.398, -0.656 };
 665    cblas_dscal(N, alpha, X, incX);
 666    {
 667      int i;
 668      for (i = 0; i < 2; i++) {
 669        gsl_test_rel(X[i], expected[i], dbleps, "dscal(case 151)");
 670      }
 671    };
 672   };
 673
 674
 675   {
 676    int N = 2;
 677    double alpha = 0.1;
 678    double X[] = { 0.398, -0.656 };
 679    int incX = -1;
 680    double expected[] = { 0.398, -0.656 };
 681    cblas_dscal(N, alpha, X, incX);
 682    {
 683      int i;
 684      for (i = 0; i < 2; i++) {
 685        gsl_test_rel(X[i], expected[i], dbleps, "dscal(case 152)");
 686      }
 687    };
 688   };
 689
 690
 691   {
 692    int N = 2;
 693    double alpha = 1;
 694    double X[] = { 0.398, -0.656 };
 695    int incX = -1;
 696    double expected[] = { 0.398, -0.656 };
 697    cblas_dscal(N, alpha, X, incX);
 698    {
 699      int i;
 700      for (i = 0; i < 2; i++) {
 701        gsl_test_rel(X[i], expected[i], dbleps, "dscal(case 153)");
 702      }
 703    };
 704   };
 705
 706
 707   {
 708    int N = 2;
 709    float alpha[2] = {0.0f, 0.0f};
 710    float X[] = { 0.736f, 0.331f, -0.318f, 0.622f };
 711    int incX = -1;
 712    float expected[] = { 0.736f, 0.331f, -0.318f, 0.622f };
 713    cblas_cscal(N, alpha, X, incX);
 714    {
 715      int i;
 716      for (i = 0; i < 2; i++) {
 717        gsl_test_rel(X[2*i], expected[2*i], flteps, "cscal(case 154) real");
 718        gsl_test_rel(X[2*i+1], expected[2*i+1], flteps, "cscal(case 154) imag");
 719      };
 720    };
 721   };
 722
 723
 724   {
 725    int N = 2;
 726    float alpha[2] = {0.1f, 0.0f};
 727    float X[] = { 0.736f, 0.331f, -0.318f, 0.622f };
 728    int incX = -1;
 729    float expected[] = { 0.736f, 0.331f, -0.318f, 0.622f };
 730    cblas_cscal(N, alpha, X, incX);
 731    {
 732      int i;
 733      for (i = 0; i < 2; i++) {
 734        gsl_test_rel(X[2*i], expected[2*i], flteps, "cscal(case 155) real");
 735        gsl_test_rel(X[2*i+1], expected[2*i+1], flteps, "cscal(case 155) imag");
 736      };
 737    };
 738   };
 739
 740
 741   {
 742    int N = 2;
 743    float alpha[2] = {1.0f, 0.0f};
 744    float X[] = { 0.736f, 0.331f, -0.318f, 0.622f };
 745    int incX = -1;
 746    float expected[] = { 0.736f, 0.331f, -0.318f, 0.622f };
 747    cblas_cscal(N, alpha, X, incX);
 748    {
 749      int i;
 750      for (i = 0; i < 2; i++) {
 751        gsl_test_rel(X[2*i], expected[2*i], flteps, "cscal(case 156) real");
 752        gsl_test_rel(X[2*i+1], expected[2*i+1], flteps, "cscal(case 156) imag");
 753      };
 754    };
 755   };
 756
 757
 758   {
 759    int N = 2;
 760    float alpha[2] = {0.0f, 0.1f};
 761    float X[] = { 0.736f, 0.331f, -0.318f, 0.622f };
 762    int incX = -1;
 763    float expected[] = { 0.736f, 0.331f, -0.318f, 0.622f };
 764    cblas_cscal(N, alpha, X, incX);
 765    {
 766      int i;
 767      for (i = 0; i < 2; i++) {
 768        gsl_test_rel(X[2*i], expected[2*i], flteps, "cscal(case 157) real");
 769        gsl_test_rel(X[2*i+1], expected[2*i+1], flteps, "cscal(case 157) imag");
 770      };
 771    };
 772   };
 773
 774
 775   {
 776    int N = 2;
 777    float alpha[2] = {0.1f, 0.2f};
 778    float X[] = { 0.736f, 0.331f, -0.318f, 0.622f };
 779    int incX = -1;
 780    float expected[] = { 0.736f, 0.331f, -0.318f, 0.622f };
 781    cblas_cscal(N, alpha, X, incX);
 782    {
 783      int i;
 784      for (i = 0; i < 2; i++) {
 785        gsl_test_rel(X[2*i], expected[2*i], flteps, "cscal(case 158) real");
 786        gsl_test_rel(X[2*i+1], expected[2*i+1], flteps, "cscal(case 158) imag");
 787      };
 788    };
 789   };
 790
 791
 792   {
 793    int N = 2;
 794    float alpha[2] = {1.0f, 0.3f};
 795    float X[] = { 0.736f, 0.331f, -0.318f, 0.622f };
 796    int incX = -1;
 797    float expected[] = { 0.736f, 0.331f, -0.318f, 0.622f };
 798    cblas_cscal(N, alpha, X, incX);
 799    {
 800      int i;
 801      for (i = 0; i < 2; i++) {
 802        gsl_test_rel(X[2*i], expected[2*i], flteps, "cscal(case 159) real");
 803        gsl_test_rel(X[2*i+1], expected[2*i+1], flteps, "cscal(case 159) imag");
 804      };
 805    };
 806   };
 807
 808
 809   {
 810    int N = 2;
 811    double alpha[2] = {0, 0};
 812    double X[] = { 0.521, -0.811, 0.556, -0.147 };
 813    int incX = -1;
 814    double expected[] = { 0.521, -0.811, 0.556, -0.147 };
 815    cblas_zscal(N, alpha, X, incX);
 816    {
 817      int i;
 818      for (i = 0; i < 2; i++) {
 819        gsl_test_rel(X[2*i], expected[2*i], dbleps, "zscal(case 160) real");
 820        gsl_test_rel(X[2*i+1], expected[2*i+1], dbleps, "zscal(case 160) imag");
 821      };
 822    };
 823   };
 824
 825
 826   {
 827    int N = 2;
 828    double alpha[2] = {0.1, 0};
 829    double X[] = { 0.521, -0.811, 0.556, -0.147 };
 830    int incX = -1;
 831    double expected[] = { 0.521, -0.811, 0.556, -0.147 };
 832    cblas_zscal(N, alpha, X, incX);
 833    {
 834      int i;
 835      for (i = 0; i < 2; i++) {
 836        gsl_test_rel(X[2*i], expected[2*i], dbleps, "zscal(case 161) real");
 837        gsl_test_rel(X[2*i+1], expected[2*i+1], dbleps, "zscal(case 161) imag");
 838      };
 839    };
 840   };
 841
 842
 843   {
 844    int N = 2;
 845    double alpha[2] = {1, 0};
 846    double X[] = { 0.521, -0.811, 0.556, -0.147 };
 847    int incX = -1;
 848    double expected[] = { 0.521, -0.811, 0.556, -0.147 };
 849    cblas_zscal(N, alpha, X, incX);
 850    {
 851      int i;
 852      for (i = 0; i < 2; i++) {
 853        gsl_test_rel(X[2*i], expected[2*i], dbleps, "zscal(case 162) real");
 854        gsl_test_rel(X[2*i+1], expected[2*i+1], dbleps, "zscal(case 162) imag");
 855      };
 856    };
 857   };
 858
 859
 860   {
 861    int N = 2;
 862    double alpha[2] = {0, 0.1};
 863    double X[] = { 0.521, -0.811, 0.556, -0.147 };
 864    int incX = -1;
 865    double expected[] = { 0.521, -0.811, 0.556, -0.147 };
 866    cblas_zscal(N, alpha, X, incX);
 867    {
 868      int i;
 869      for (i = 0; i < 2; i++) {
 870        gsl_test_rel(X[2*i], expected[2*i], dbleps, "zscal(case 163) real");
 871        gsl_test_rel(X[2*i+1], expected[2*i+1], dbleps, "zscal(case 163) imag");
 872      };
 873    };
 874   };
 875
 876
 877   {
 878    int N = 2;
 879    double alpha[2] = {0.1, 0.2};
 880    double X[] = { 0.521, -0.811, 0.556, -0.147 };
 881    int incX = -1;
 882    double expected[] = { 0.521, -0.811, 0.556, -0.147 };
 883    cblas_zscal(N, alpha, X, incX);
 884    {
 885      int i;
 886      for (i = 0; i < 2; i++) {
 887        gsl_test_rel(X[2*i], expected[2*i], dbleps, "zscal(case 164) real");
 888        gsl_test_rel(X[2*i+1], expected[2*i+1], dbleps, "zscal(case 164) imag");
 889      };
 890    };
 891   };
 892
 893
 894   {
 895    int N = 2;
 896    double alpha[2] = {1, 0.3};
 897    double X[] = { 0.521, -0.811, 0.556, -0.147 };
 898    int incX = -1;
 899    double expected[] = { 0.521, -0.811, 0.556, -0.147 };
 900    cblas_zscal(N, alpha, X, incX);
 901    {
 902      int i;
 903      for (i = 0; i < 2; i++) {
 904        gsl_test_rel(X[2*i], expected[2*i], dbleps, "zscal(case 165) real");
 905        gsl_test_rel(X[2*i+1], expected[2*i+1], dbleps, "zscal(case 165) imag");
 906      };
 907    };
 908   };
 909
 910
 911 }