OSchip
/
OpenBLAS
Not watched
1
0
Fork 0
Code
Releases 66 Wiki evaluate Activity
Issues 0 Pull Requests 0 Datasets Model Cloudbrain HPC
You can not select more than 25 topics Topics must start with a chinese character,a letter or number, can include dashes ('-') and can be up to 35 characters long.
Tree: e3c9947c0f
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'e3c9947c0f'
${ noResults }
OpenBLAS/symcopy.h

1874 lines
30 kB
Raw Blame History 

  1. /*********************************************************************/

  2. /* Copyright 2009, 2010 The University of Texas at Austin.           */

  3. /* All rights reserved.                                              */

  4. /*                                                                   */

  5. /* Redistribution and use in source and binary forms, with or        */

  6. /* without modification, are permitted provided that the following   */

  7. /* conditions are met:                                               */

  8. /*                                                                   */

  9. /*   1. Redistributions of source code must retain the above         */

  10. /*      copyright notice, this list of conditions and the following  */

  11. /*      disclaimer.                                                  */

  12. /*                                                                   */

  13. /*   2. Redistributions in binary form must reproduce the above      */

  14. /*      copyright notice, this list of conditions and the following  */

  15. /*      disclaimer in the documentation and/or other materials       */

  16. /*      provided with the distribution.                              */

  17. /*                                                                   */

  18. /*    THIS  SOFTWARE IS PROVIDED  BY THE  UNIVERSITY OF  TEXAS AT    */

  19. /*    AUSTIN  ``AS IS''  AND ANY  EXPRESS OR  IMPLIED WARRANTIES,    */

  20. /*    INCLUDING, BUT  NOT LIMITED  TO, THE IMPLIED  WARRANTIES OF    */

  21. /*    MERCHANTABILITY  AND FITNESS FOR  A PARTICULAR  PURPOSE ARE    */

  22. /*    DISCLAIMED.  IN  NO EVENT SHALL THE UNIVERSITY  OF TEXAS AT    */

  23. /*    AUSTIN OR CONTRIBUTORS BE  LIABLE FOR ANY DIRECT, INDIRECT,    */

  24. /*    INCIDENTAL,  SPECIAL, EXEMPLARY,  OR  CONSEQUENTIAL DAMAGES    */

  25. /*    (INCLUDING, BUT  NOT LIMITED TO,  PROCUREMENT OF SUBSTITUTE    */

  26. /*    GOODS  OR  SERVICES; LOSS  OF  USE,  DATA,  OR PROFITS;  OR    */

  27. /*    BUSINESS INTERRUPTION) HOWEVER CAUSED  AND ON ANY THEORY OF    */

  28. /*    LIABILITY, WHETHER  IN CONTRACT, STRICT  LIABILITY, OR TORT    */

  29. /*    (INCLUDING NEGLIGENCE OR OTHERWISE)  ARISING IN ANY WAY OUT    */

  30. /*    OF  THE  USE OF  THIS  SOFTWARE,  EVEN  IF ADVISED  OF  THE    */

  31. /*    POSSIBILITY OF SUCH DAMAGE.                                    */

  32. /*                                                                   */

  33. /* The views and conclusions contained in the software and           */

  34. /* documentation are those of the authors and should not be          */

  35. /* interpreted as representing official policies, either expressed   */

  36. /* or implied, of The University of Texas at Austin.                 */

  37. /*********************************************************************/

  38. 

  39. /* This implementation is completely wrong. I'll rewrite this */

  40. 

  41. #ifndef SYMCOPY_H

  42. #define SYMCOPY_H

  43. 

  44. #if !defined(XDOUBLE) || !defined(QUAD_PRECISION)

  45. 

  46. static __inline void SYMCOPY_L(BLASLONG m, FLOAT *a, BLASLONG lda, FLOAT *b){

  47.   BLASLONG is, js;

  48. 

  49.   FLOAT *aa1, *aa2;

  50.   FLOAT *b1, *b2;

  51.   FLOAT *bb1, *bb2;

  52.   FLOAT *cc1, *cc2;

  53.   FLOAT a11, a12;

  54.   FLOAT a21, a22;

  55. 

  56.   b1 = b;

  57.   b2 = b;

  58. 

  59.   for (js = 0; js < m; js += 2){

  60. 

  61.     aa1 = a + 0 * lda;

  62.     aa2 = a + 1 * lda;

  63.     a  += 2 * lda + 2;

  64. 

  65.     bb1 = b1 + 0 * m;

  66.     bb2 = b1 + 1 * m;

  67.     b1 += 2 * m + 2;

  68. 

  69.     cc1 = b2 + 0 * m;

  70.     cc2 = b2 + 1 * m;

  71.     b2 += 2 * m + 2;

  72. 

  73.     if (m - js >= 2){

  74. 

  75.       a11 = *(aa1 + 0);

  76.       a21 = *(aa1 + 1);

  77. 

  78.       a22 = *(aa2 + 1);

  79. 

  80.       *(bb1 + 0) = a11;

  81.       *(bb1 + 1) = a21;

  82.       *(bb2 + 0) = a21;

  83.       *(bb2 + 1) = a22;

  84.       aa1 += 2;

  85.       aa2 += 2;

  86.       bb1 += 2;

  87.       bb2 += 2;

  88. 

  89.       cc1 += 2 * m;

  90.       cc2 += 2 * m;

  91. 

  92.       is = ((m - js - 2) >> 1);

  93. 

  94.       while (is > 0){

  95. 	a11 = *(aa1 + 0);

  96. 	a21 = *(aa1 + 1);

  97. 	a12 = *(aa2 + 0);

  98. 	a22 = *(aa2 + 1);

  99. 

  100. 	aa1 += 2;

  101. 	aa2 += 2;

  102. 

  103. 	*(bb1 + 0) = a11;

  104. 	*(bb1 + 1) = a21;

  105. 	*(bb2 + 0) = a12;

  106. 	*(bb2 + 1) = a22;

  107. 

  108. 	*(cc1 + 0) = a11;

  109. 	*(cc1 + 1) = a12;

  110. 	*(cc2 + 0) = a21;

  111. 	*(cc2 + 1) = a22;

  112. 

  113. 	bb1 += 2;

  114. 	bb2 += 2;

  115. 

  116. 	cc1 += 2 * m;

  117. 	cc2 += 2 * m;

  118. 

  119. 	is --;

  120.       }

  121. 

  122.       is = ((m - js - 2) & 1);

  123. 

  124.       if (is == 1){

  125. 	a11 = *(aa1 + 0);

  126. 	a12 = *(aa2 + 0);

  127. 

  128. 	*(bb1 + 0) = a11;

  129. 	*(bb2 + 0) = a12;

  130. 

  131. 	*(cc1 + 0) = a11;

  132. 	*(cc1 + 1) = a12;

  133.       }

  134.     }

  135. 

  136.     if (m - js == 1){

  137.       a11 = *(aa1 + 0);

  138.       *(bb1 + 0) = a11;

  139.     }

  140. 

  141.   }

  142. }

  143. 

  144. static __inline void SYMCOPY_U(BLASLONG m, FLOAT *a, BLASLONG lda, FLOAT *b){

  145.   BLASLONG is, js;

  146. 

  147.   FLOAT *aa1, *aa2;

  148.   FLOAT *b1, *b2;

  149.   FLOAT *bb1, *bb2;

  150.   FLOAT *cc1, *cc2;

  151.   FLOAT a11, a12;

  152.   FLOAT a21, a22;

  153. 

  154.   b1 = b;

  155.   b2 = b;

  156. 

  157.   for (js = 0; js < m; js += 2){

  158. 

  159.     aa1 = a + 0 * lda;

  160.     aa2 = a + 1 * lda;

  161.     a  += 2 * lda;

  162. 

  163.     bb1 = b1 + 0 * m;

  164.     bb2 = b1 + 1 * m;

  165.     b1 += 2 * m;

  166. 

  167.     cc1 = b2 + 0 * m;

  168.     cc2 = b2 + 1 * m;

  169.     b2 += 2;

  170. 

  171.     if (m - js >= 2){

  172. 

  173.       for (is = 0; is < js; is += 2){

  174. 

  175. 	a11 = *(aa1 + 0);

  176. 	a21 = *(aa1 + 1);

  177. 	a12 = *(aa2 + 0);

  178. 	a22 = *(aa2 + 1);

  179. 

  180. 	aa1 += 2;

  181. 	aa2 += 2;

  182. 

  183. 	*(bb1 + 0) = a11;

  184. 	*(bb1 + 1) = a21;

  185. 	*(bb2 + 0) = a12;

  186. 	*(bb2 + 1) = a22;

  187. 

  188. 	*(cc1 + 0) = a11;

  189. 	*(cc1 + 1) = a12;

  190. 	*(cc2 + 0) = a21;

  191. 	*(cc2 + 1) = a22;

  192. 

  193. 	bb1 += 2;

  194. 	bb2 += 2;

  195. 

  196. 	cc1 += 2 * m;

  197. 	cc2 += 2 * m;

  198.       }

  199. 

  200.       a11 = *(aa1 + 0);

  201. 

  202.       a12 = *(aa2 + 0);

  203.       a22 = *(aa2 + 1);

  204. 

  205.       *(bb1 + 0) = a11;

  206.       *(bb1 + 1) = a12;

  207.       *(bb2 + 0) = a12;

  208.       *(bb2 + 1) = a22;

  209.     }

  210. 

  211.     if (m - js == 1){

  212.       for (is = 0; is < js; is += 2){

  213. 

  214. 	a11 = *(aa1 + 0);

  215. 	a21 = *(aa1 + 1);

  216. 	aa1 += 2;

  217. 

  218. 	*(bb1 + 0) = a11;

  219. 	*(bb1 + 1) = a21;

  220. 	*(cc1 + 0) = a11;

  221. 	*(cc2 + 0) = a21;

  222. 	bb1 += 2;

  223. 

  224. 	cc1 += 2 * m;

  225. 	cc2 += 2 * m;

  226.       }

  227. 

  228.       a11 = *(aa1 + 0);

  229.       *(bb1 + 0) = a11;

  230.     }

  231.   }

  232. }

  233. 

  234. 

  235. static __inline void ZSYMCOPY_L(BLASLONG m, FLOAT *a, BLASLONG lda, FLOAT *b){

  236.   BLASLONG is, js;

  237. 

  238.   FLOAT *aa1, *aa2;

  239.   FLOAT *b1, *b2;

  240.   FLOAT *bb1, *bb2;

  241.   FLOAT *cc1, *cc2;

  242.   FLOAT a11, a21, a31, a41;

  243.   FLOAT a12, a22, a32, a42;

  244. 

  245.   b1 = b;

  246.   b2 = b;

  247. 

  248.   lda *= 2;

  249. 

  250.   for (js = 0; js < m; js += 2){

  251. 

  252.     aa1 = a + 0 * lda;

  253.     aa2 = a + 1 * lda;

  254.     a  += 2 * lda + 4;

  255. 

  256.     bb1 = b1 + 0 * m;

  257.     bb2 = b1 + 2 * m;

  258.     b1 += 4 * m + 4;

  259. 

  260.     cc1 = b2 + 0 * m;

  261.     cc2 = b2 + 2 * m;

  262.     b2 += 4 * m + 4;

  263. 

  264.     if (m - js >= 2){

  265. 

  266.       a11 = *(aa1 + 0);

  267.       a21 = *(aa1 + 1);

  268.       a31 = *(aa1 + 2);

  269.       a41 = *(aa1 + 3);

  270. 

  271.       a12 = *(aa2 + 2);

  272.       a22 = *(aa2 + 3);

  273. 

  274.       *(bb1 + 0) = a11;

  275.       *(bb1 + 1) = a21;

  276.       *(bb1 + 2) = a31;

  277.       *(bb1 + 3) = a41;

  278. 

  279.       *(bb2 + 0) = a31;

  280.       *(bb2 + 1) = a41;

  281.       *(bb2 + 2) = a12;

  282.       *(bb2 + 3) = a22;

  283. 

  284.       aa1 += 4;

  285.       aa2 += 4;

  286.       bb1 += 4;

  287.       bb2 += 4;

  288. 

  289.       cc1 += 4 * m;

  290.       cc2 += 4 * m;

  291. 

  292.       is = ((m - js - 2) >> 1);

  293. 

  294.       while (is > 0){

  295. 	a11 = *(aa1 + 0);

  296. 	a21 = *(aa1 + 1);

  297. 	a31 = *(aa1 + 2);

  298. 	a41 = *(aa1 + 3);

  299. 

  300. 	a12 = *(aa2 + 0);

  301. 	a22 = *(aa2 + 1);

  302. 	a32 = *(aa2 + 2);

  303. 	a42 = *(aa2 + 3);

  304. 

  305. 	aa1 += 4;

  306. 	aa2 += 4;

  307. 

  308. 	*(bb1 + 0) = a11;

  309. 	*(bb1 + 1) = a21;

  310. 	*(bb1 + 2) = a31;

  311. 	*(bb1 + 3) = a41;

  312. 

  313. 	*(bb2 + 0) = a12;

  314. 	*(bb2 + 1) = a22;

  315. 	*(bb2 + 2) = a32;

  316. 	*(bb2 + 3) = a42;

  317. 

  318. 	*(cc1 + 0) = a11;

  319. 	*(cc1 + 1) = a21;

  320. 	*(cc1 + 2) = a12;

  321. 	*(cc1 + 3) = a22;

  322. 

  323. 	*(cc2 + 0) = a31;

  324. 	*(cc2 + 1) = a41;

  325. 	*(cc2 + 2) = a32;

  326. 	*(cc2 + 3) = a42;

  327. 

  328. 	bb1 += 4;

  329. 	bb2 += 4;

  330. 

  331. 	cc1 += 4 * m;

  332. 	cc2 += 4 * m;

  333. 

  334. 	is --;

  335.       }

  336. 

  337.       if (m & 1){

  338. 	a11 = *(aa1 + 0);

  339. 	a21 = *(aa1 + 1);

  340. 	a12 = *(aa2 + 0);

  341. 	a22 = *(aa2 + 1);

  342. 

  343. 	*(bb1 + 0) = a11;

  344. 	*(bb1 + 1) = a21;

  345. 	*(bb2 + 0) = a12;

  346. 	*(bb2 + 1) = a22;

  347. 

  348. 	*(cc1 + 0) = a11;

  349. 	*(cc1 + 1) = a21;

  350. 	*(cc1 + 2) = a12;

  351. 	*(cc1 + 3) = a22;

  352.       }

  353.     }

  354. 

  355.     if (m - js == 1){

  356.       a11 = *(aa1 + 0);

  357.       a21 = *(aa1 + 1);

  358.       *(bb1 + 0) = a11;

  359.       *(bb1 + 1) = a21;

  360.     }

  361. 

  362.   }

  363. }

  364. 

  365. static __inline void ZSYMCOPY_U(BLASLONG m, FLOAT *a, BLASLONG lda, FLOAT *b){

  366.   BLASLONG is, js;

  367. 

  368.   FLOAT *aa1, *aa2;

  369.   FLOAT *b1, *b2;

  370.   FLOAT *bb1, *bb2;

  371.   FLOAT *cc1, *cc2;

  372.   FLOAT a11, a21, a31, a41;

  373.   FLOAT a12, a22, a32, a42;

  374. 

  375.   b1 = b;

  376.   b2 = b;

  377. 

  378.   lda *= 2;

  379. 

  380.   for (js = 0; js < m; js += 2){

  381. 

  382.     aa1 = a + 0 * lda;

  383.     aa2 = a + 1 * lda;

  384.     a  += 2 * lda;

  385. 

  386.     bb1 = b1 + 0 * m;

  387.     bb2 = b1 + 2 * m;

  388.     b1 += 4 * m;

  389. 

  390.     cc1 = b2 + 0 * m;

  391.     cc2 = b2 + 2 * m;

  392.     b2 += 4;

  393. 

  394.     if (m - js >= 2){

  395. 

  396.       for (is = 0; is < js; is += 2){

  397. 

  398. 	a11 = *(aa1 + 0);

  399. 	a21 = *(aa1 + 1);

  400. 	a31 = *(aa1 + 2);

  401. 	a41 = *(aa1 + 3);

  402. 

  403. 	a12 = *(aa2 + 0);

  404. 	a22 = *(aa2 + 1);

  405. 	a32 = *(aa2 + 2);

  406. 	a42 = *(aa2 + 3);

  407. 

  408. 	aa1 += 4;

  409. 	aa2 += 4;

  410. 

  411. 	*(bb1 + 0) = a11;

  412. 	*(bb1 + 1) = a21;

  413. 	*(bb1 + 2) = a31;

  414. 	*(bb1 + 3) = a41;

  415. 

  416. 	*(bb2 + 0) = a12;

  417. 	*(bb2 + 1) = a22;

  418. 	*(bb2 + 2) = a32;

  419. 	*(bb2 + 3) = a42;

  420. 

  421. 	*(cc1 + 0) = a11;

  422. 	*(cc1 + 1) = a21;

  423. 	*(cc1 + 2) = a12;

  424. 	*(cc1 + 3) = a22;

  425. 

  426. 	*(cc2 + 0) = a31;

  427. 	*(cc2 + 1) = a41;

  428. 	*(cc2 + 2) = a32;

  429. 	*(cc2 + 3) = a42;

  430. 

  431. 	bb1 += 4;

  432. 	bb2 += 4;

  433. 

  434. 	cc1 += 4 * m;

  435. 	cc2 += 4 * m;

  436.       }

  437. 

  438.       a11 = *(aa1 + 0);

  439.       a21 = *(aa1 + 1);

  440. 

  441.       a12 = *(aa2 + 0);

  442.       a22 = *(aa2 + 1);

  443.       a32 = *(aa2 + 2);

  444.       a42 = *(aa2 + 3);

  445. 

  446.       *(bb1 + 0) = a11;

  447.       *(bb1 + 1) = a21;

  448.       *(bb1 + 2) = a12;

  449.       *(bb1 + 3) = a22;

  450. 

  451.       *(bb2 + 0) = a12;

  452.       *(bb2 + 1) = a22;

  453.       *(bb2 + 2) = a32;

  454.       *(bb2 + 3) = a42;

  455.     }

  456. 

  457.     if (m - js == 1){

  458.       for (is = 0; is < js; is += 2){

  459. 

  460. 	a11 = *(aa1 + 0);

  461. 	a21 = *(aa1 + 1);

  462. 	a31 = *(aa1 + 2);

  463. 	a41 = *(aa1 + 3);

  464. 	aa1 += 4;

  465. 

  466. 	*(bb1 + 0) = a11;

  467. 	*(bb1 + 1) = a21;

  468. 	*(bb1 + 2) = a31;

  469. 	*(bb1 + 3) = a41;

  470. 

  471. 	*(cc1 + 0) = a11;

  472. 	*(cc1 + 1) = a21;

  473. 	*(cc2 + 0) = a31;

  474. 	*(cc2 + 1) = a41;

  475. 	bb1 += 4;

  476. 

  477. 	cc1 += 4 * m;

  478. 	cc2 += 4 * m;

  479.       }

  480. 

  481.       a11 = *(aa1 + 0);

  482.       a21 = *(aa1 + 1);

  483.       *(bb1 + 0) = a11;

  484.       *(bb1 + 1) = a21;

  485.     }

  486.   }

  487. }

  488. 

  489. static __inline void ZHEMCOPY_L(BLASLONG m, FLOAT *a, BLASLONG lda, FLOAT *b){

  490.   BLASLONG is, js;

  491. 

  492.   FLOAT *aa1, *aa2;

  493.   FLOAT *b1, *b2;

  494.   FLOAT *bb1, *bb2;

  495.   FLOAT *cc1, *cc2;

  496.   FLOAT a11, a21, a31, a41;

  497.   FLOAT a12, a22, a32, a42;

  498. 

  499.   b1 = b;

  500.   b2 = b;

  501. 

  502.   lda *= 2;

  503. 

  504.   for (js = 0; js < m; js += 2){

  505. 

  506.     aa1 = a + 0 * lda;

  507.     aa2 = a + 1 * lda;

  508.     a  += 2 * lda + 4;

  509. 

  510.     bb1 = b1 + 0 * m;

  511.     bb2 = b1 + 2 * m;

  512.     b1 += 4 * m + 4;

  513. 

  514.     cc1 = b2 + 0 * m;

  515.     cc2 = b2 + 2 * m;

  516.     b2 += 4 * m + 4;

  517. 

  518.     if (m - js >= 2){

  519. 

  520.       a11 = *(aa1 + 0);

  521.       a31 = *(aa1 + 2);

  522.       a41 = *(aa1 + 3);

  523. 

  524.       a12 = *(aa2 + 2);

  525. 

  526.       *(bb1 + 0) = a11;

  527.       *(bb1 + 1) = 0.;

  528.       *(bb1 + 2) = a31;

  529.       *(bb1 + 3) = a41;

  530. 

  531.       *(bb2 + 0) = a31;

  532.       *(bb2 + 1) = -a41;

  533.       *(bb2 + 2) = a12;

  534.       *(bb2 + 3) = 0.;

  535. 

  536.       aa1 += 4;

  537.       aa2 += 4;

  538.       bb1 += 4;

  539.       bb2 += 4;

  540. 

  541.       cc1 += 4 * m;

  542.       cc2 += 4 * m;

  543. 

  544.       is = ((m - js - 2) >> 1);

  545. 

  546.       while (is > 0){

  547. 	a11 = *(aa1 + 0);

  548. 	a21 = *(aa1 + 1);

  549. 	a31 = *(aa1 + 2);

  550. 	a41 = *(aa1 + 3);

  551. 

  552. 	a12 = *(aa2 + 0);

  553. 	a22 = *(aa2 + 1);

  554. 	a32 = *(aa2 + 2);

  555. 	a42 = *(aa2 + 3);

  556. 

  557. 	aa1 += 4;

  558. 	aa2 += 4;

  559. 

  560. 	*(bb1 + 0) = a11;

  561. 	*(bb1 + 1) = a21;

  562. 	*(bb1 + 2) = a31;

  563. 	*(bb1 + 3) = a41;

  564. 

  565. 	*(bb2 + 0) = a12;

  566. 	*(bb2 + 1) = a22;

  567. 	*(bb2 + 2) = a32;

  568. 	*(bb2 + 3) = a42;

  569. 

  570. 	*(cc1 + 0) = a11;

  571. 	*(cc1 + 1) = -a21;

  572. 	*(cc1 + 2) = a12;

  573. 	*(cc1 + 3) = -a22;

  574. 

  575. 	*(cc2 + 0) = a31;

  576. 	*(cc2 + 1) = -a41;

  577. 	*(cc2 + 2) = a32;

  578. 	*(cc2 + 3) = -a42;

  579. 

  580. 	bb1 += 4;

  581. 	bb2 += 4;

  582. 

  583. 	cc1 += 4 * m;

  584. 	cc2 += 4 * m;

  585. 

  586. 	is --;

  587.       }

  588. 

  589.       if (m & 1){

  590. 	a11 = *(aa1 + 0);

  591. 	a21 = *(aa1 + 1);

  592. 	a12 = *(aa2 + 0);

  593. 	a22 = *(aa2 + 1);

  594. 

  595. 	*(bb1 + 0) = a11;

  596. 	*(bb1 + 1) = a21;

  597. 	*(bb2 + 0) = a12;

  598. 	*(bb2 + 1) = a22;

  599. 

  600. 	*(cc1 + 0) = a11;

  601. 	*(cc1 + 1) = -a21;

  602. 	*(cc1 + 2) = a12;

  603. 	*(cc1 + 3) = -a22;

  604.       }

  605.     }

  606. 

  607.     if (m - js == 1){

  608.       a11 = *(aa1 + 0);

  609.       *(bb1 + 0) = a11;

  610.       *(bb1 + 1) = 0.;

  611.     }

  612. 

  613.   }

  614. }

  615. 

  616. static __inline void ZHEMCOPY_U(BLASLONG m, FLOAT *a, BLASLONG lda, FLOAT *b){

  617.   BLASLONG is, js;

  618. 

  619.   FLOAT *aa1, *aa2;

  620.   FLOAT *b1, *b2;

  621.   FLOAT *bb1, *bb2;

  622.   FLOAT *cc1, *cc2;

  623.   FLOAT a11, a21, a31, a41;

  624.   FLOAT a12, a22, a32, a42;

  625. 

  626.   b1 = b;

  627.   b2 = b;

  628. 

  629.   lda *= 2;

  630. 

  631.   for (js = 0; js < m; js += 2){

  632. 

  633.     aa1 = a + 0 * lda;

  634.     aa2 = a + 1 * lda;

  635.     a  += 2 * lda;

  636. 

  637.     bb1 = b1 + 0 * m;

  638.     bb2 = b1 + 2 * m;

  639.     b1 += 4 * m;

  640. 

  641.     cc1 = b2 + 0 * m;

  642.     cc2 = b2 + 2 * m;

  643.     b2 += 4;

  644. 

  645.     if (m - js >= 2){

  646. 

  647.       for (is = 0; is < js; is += 2){

  648. 

  649. 	a11 = *(aa1 + 0);

  650. 	a21 = *(aa1 + 1);

  651. 	a31 = *(aa1 + 2);

  652. 	a41 = *(aa1 + 3);

  653. 

  654. 	a12 = *(aa2 + 0);

  655. 	a22 = *(aa2 + 1);

  656. 	a32 = *(aa2 + 2);

  657. 	a42 = *(aa2 + 3);

  658. 

  659. 	aa1 += 4;

  660. 	aa2 += 4;

  661. 

  662. 	*(bb1 + 0) = a11;

  663. 	*(bb1 + 1) = a21;

  664. 	*(bb1 + 2) = a31;

  665. 	*(bb1 + 3) = a41;

  666. 

  667. 	*(bb2 + 0) = a12;

  668. 	*(bb2 + 1) = a22;

  669. 	*(bb2 + 2) = a32;

  670. 	*(bb2 + 3) = a42;

  671. 

  672. 	*(cc1 + 0) = a11;

  673. 	*(cc1 + 1) = -a21;

  674. 	*(cc1 + 2) = a12;

  675. 	*(cc1 + 3) = -a22;

  676. 

  677. 	*(cc2 + 0) = a31;

  678. 	*(cc2 + 1) = -a41;

  679. 	*(cc2 + 2) = a32;

  680. 	*(cc2 + 3) = -a42;

  681. 

  682. 	bb1 += 4;

  683. 	bb2 += 4;

  684. 

  685. 	cc1 += 4 * m;

  686. 	cc2 += 4 * m;

  687.       }

  688. 

  689.       a11 = *(aa1 + 0);

  690. 

  691.       a12 = *(aa2 + 0);

  692.       a22 = *(aa2 + 1);

  693.       a32 = *(aa2 + 2);

  694. 

  695.       *(bb1 + 0) = a11;

  696.       *(bb1 + 1) = 0.;

  697.       *(bb1 + 2) = a12;

  698.       *(bb1 + 3) = -a22;

  699. 

  700.       *(bb2 + 0) = a12;

  701.       *(bb2 + 1) = a22;

  702.       *(bb2 + 2) = a32;

  703.       *(bb2 + 3) = 0.;

  704.     }

  705. 

  706.     if (m - js == 1){

  707.       for (is = 0; is < js; is += 2){

  708. 

  709. 	a11 = *(aa1 + 0);

  710. 	a21 = *(aa1 + 1);

  711. 	a31 = *(aa1 + 2);

  712. 	a41 = *(aa1 + 3);

  713. 	aa1 += 4;

  714. 

  715. 	*(bb1 + 0) = a11;

  716. 	*(bb1 + 1) = a21;

  717. 	*(bb1 + 2) = a31;

  718. 	*(bb1 + 3) = a41;

  719. 

  720. 	*(cc1 + 0) = a11;

  721. 	*(cc1 + 1) = -a21;

  722. 	*(cc2 + 0) = a31;

  723. 	*(cc2 + 1) = -a41;

  724. 	bb1 += 4;

  725. 

  726. 	cc1 += 4 * m;

  727. 	cc2 += 4 * m;

  728.       }

  729. 

  730.       a11 = *(aa1 + 0);

  731.       *(bb1 + 0) = a11;

  732.       *(bb1 + 1) = 0.;

  733.     }

  734.   }

  735. }

  736. 

  737. 

  738. static __inline void ZHEMCOPY_M(BLASLONG m, FLOAT *a, BLASLONG lda, FLOAT *b){

  739.   BLASLONG is, js;

  740. 

  741.   FLOAT *aa1, *aa2;

  742.   FLOAT *b1, *b2;

  743.   FLOAT *bb1, *bb2;

  744.   FLOAT *cc1, *cc2;

  745.   FLOAT a11, a21, a31, a41;

  746.   FLOAT a12, a22, a32, a42;

  747. 

  748.   b1 = b;

  749.   b2 = b;

  750. 

  751.   lda *= 2;

  752. 

  753.   for (js = 0; js < m; js += 2){

  754. 

  755.     aa1 = a + 0 * lda;

  756.     aa2 = a + 1 * lda;

  757.     a  += 2 * lda + 4;

  758. 

  759.     bb1 = b1 + 0 * m;

  760.     bb2 = b1 + 2 * m;

  761.     b1 += 4 * m + 4;

  762. 

  763.     cc1 = b2 + 0 * m;

  764.     cc2 = b2 + 2 * m;

  765.     b2 += 4 * m + 4;

  766. 

  767.     if (m - js >= 2){

  768. 

  769.       a11 = *(aa1 + 0);

  770.       a31 = *(aa1 + 2);

  771.       a41 = *(aa1 + 3);

  772. 

  773.       a12 = *(aa2 + 2);

  774. 

  775.       *(bb1 + 0) = a11;

  776.       *(bb1 + 1) = 0.;

  777.       *(bb1 + 2) = a31;

  778.       *(bb1 + 3) = -a41;

  779. 

  780.       *(bb2 + 0) = a31;

  781.       *(bb2 + 1) = a41;

  782.       *(bb2 + 2) = a12;

  783.       *(bb2 + 3) = 0.;

  784. 

  785.       aa1 += 4;

  786.       aa2 += 4;

  787.       bb1 += 4;

  788.       bb2 += 4;

  789. 

  790.       cc1 += 4 * m;

  791.       cc2 += 4 * m;

  792. 

  793.       is = ((m - js - 2) >> 1);

  794. 

  795.       while (is > 0){

  796. 	a11 = *(aa1 + 0);

  797. 	a21 = *(aa1 + 1);

  798. 	a31 = *(aa1 + 2);

  799. 	a41 = *(aa1 + 3);

  800. 

  801. 	a12 = *(aa2 + 0);

  802. 	a22 = *(aa2 + 1);

  803. 	a32 = *(aa2 + 2);

  804. 	a42 = *(aa2 + 3);

  805. 

  806. 	aa1 += 4;

  807. 	aa2 += 4;

  808. 

  809. 	*(bb1 + 0) = a11;

  810. 	*(bb1 + 1) = -a21;

  811. 	*(bb1 + 2) = a31;

  812. 	*(bb1 + 3) = -a41;

  813. 

  814. 	*(bb2 + 0) = a12;

  815. 	*(bb2 + 1) = -a22;

  816. 	*(bb2 + 2) = a32;

  817. 	*(bb2 + 3) = -a42;

  818. 

  819. 	*(cc1 + 0) = a11;

  820. 	*(cc1 + 1) = a21;

  821. 	*(cc1 + 2) = a12;

  822. 	*(cc1 + 3) = a22;

  823. 

  824. 	*(cc2 + 0) = a31;

  825. 	*(cc2 + 1) = a41;

  826. 	*(cc2 + 2) = a32;

  827. 	*(cc2 + 3) = a42;

  828. 

  829. 	bb1 += 4;

  830. 	bb2 += 4;

  831. 

  832. 	cc1 += 4 * m;

  833. 	cc2 += 4 * m;

  834. 

  835. 	is --;

  836.       }

  837. 

  838.       if (m & 1){

  839. 	a11 = *(aa1 + 0);

  840. 	a21 = *(aa1 + 1);

  841. 	a12 = *(aa2 + 0);

  842. 	a22 = *(aa2 + 1);

  843. 

  844. 	*(bb1 + 0) = a11;

  845. 	*(bb1 + 1) = -a21;

  846. 	*(bb2 + 0) = a12;

  847. 	*(bb2 + 1) = -a22;

  848. 

  849. 	*(cc1 + 0) = a11;

  850. 	*(cc1 + 1) = a21;

  851. 	*(cc1 + 2) = a12;

  852. 	*(cc1 + 3) = a22;

  853.       }

  854.     }

  855. 

  856.     if (m - js == 1){

  857.       a11 = *(aa1 + 0);

  858.       *(bb1 + 0) = a11;

  859.       *(bb1 + 1) = 0.;

  860.     }

  861. 

  862.   }

  863. }

  864. 

  865. static __inline void ZHEMCOPY_V(BLASLONG m, FLOAT *a, BLASLONG lda, FLOAT *b){

  866.   BLASLONG is, js;

  867. 

  868.   FLOAT *aa1, *aa2;

  869.   FLOAT *b1, *b2;

  870.   FLOAT *bb1, *bb2;

  871.   FLOAT *cc1, *cc2;

  872.   FLOAT a11, a21, a31, a41;

  873.   FLOAT a12, a22, a32, a42;

  874. 

  875.   b1 = b;

  876.   b2 = b;

  877. 

  878.   lda *= 2;

  879. 

  880.   for (js = 0; js < m; js += 2){

  881. 

  882.     aa1 = a + 0 * lda;

  883.     aa2 = a + 1 * lda;

  884.     a  += 2 * lda;

  885. 

  886.     bb1 = b1 + 0 * m;

  887.     bb2 = b1 + 2 * m;

  888.     b1 += 4 * m;

  889. 

  890.     cc1 = b2 + 0 * m;

  891.     cc2 = b2 + 2 * m;

  892.     b2 += 4;

  893. 

  894.     if (m - js >= 2){

  895. 

  896.       for (is = 0; is < js; is += 2){

  897. 

  898. 	a11 = *(aa1 + 0);

  899. 	a21 = *(aa1 + 1);

  900. 	a31 = *(aa1 + 2);

  901. 	a41 = *(aa1 + 3);

  902. 

  903. 	a12 = *(aa2 + 0);

  904. 	a22 = *(aa2 + 1);

  905. 	a32 = *(aa2 + 2);

  906. 	a42 = *(aa2 + 3);

  907. 

  908. 	aa1 += 4;

  909. 	aa2 += 4;

  910. 

  911. 	*(bb1 + 0) = a11;

  912. 	*(bb1 + 1) = -a21;

  913. 	*(bb1 + 2) = a31;

  914. 	*(bb1 + 3) = -a41;

  915. 

  916. 	*(bb2 + 0) = a12;

  917. 	*(bb2 + 1) = -a22;

  918. 	*(bb2 + 2) = a32;

  919. 	*(bb2 + 3) = -a42;

  920. 

  921. 	*(cc1 + 0) = a11;

  922. 	*(cc1 + 1) = a21;

  923. 	*(cc1 + 2) = a12;

  924. 	*(cc1 + 3) = a22;

  925. 

  926. 	*(cc2 + 0) = a31;

  927. 	*(cc2 + 1) = a41;

  928. 	*(cc2 + 2) = a32;

  929. 	*(cc2 + 3) = a42;

  930. 

  931. 	bb1 += 4;

  932. 	bb2 += 4;

  933. 

  934. 	cc1 += 4 * m;

  935. 	cc2 += 4 * m;

  936.       }

  937. 

  938.       a11 = *(aa1 + 0);

  939. 

  940.       a12 = *(aa2 + 0);

  941.       a22 = *(aa2 + 1);

  942.       a32 = *(aa2 + 2);

  943. 

  944.       *(bb1 + 0) = a11;

  945.       *(bb1 + 1) = 0.;

  946.       *(bb1 + 2) = a12;

  947.       *(bb1 + 3) = a22;

  948. 

  949.       *(bb2 + 0) = a12;

  950.       *(bb2 + 1) = -a22;

  951.       *(bb2 + 2) = a32;

  952.       *(bb2 + 3) = 0.;

  953.     }

  954. 

  955.     if (m - js == 1){

  956.       for (is = 0; is < js; is += 2){

  957. 

  958. 	a11 = *(aa1 + 0);

  959. 	a21 = *(aa1 + 1);

  960. 	a31 = *(aa1 + 2);

  961. 	a41 = *(aa1 + 3);

  962. 	aa1 += 4;

  963. 

  964. 	*(bb1 + 0) = a11;

  965. 	*(bb1 + 1) = -a21;

  966. 	*(bb1 + 2) = a31;

  967. 	*(bb1 + 3) = -a41;

  968. 

  969. 	*(cc1 + 0) = a11;

  970. 	*(cc1 + 1) = a21;

  971. 	*(cc2 + 0) = a31;

  972. 	*(cc2 + 1) = a41;

  973. 	bb1 += 4;

  974. 

  975. 	cc1 += 4 * m;

  976. 	cc2 += 4 * m;

  977.       }

  978. 

  979.       a11 = *(aa1 + 0);

  980.       *(bb1 + 0) = a11;

  981.       *(bb1 + 1) = 0.;

  982.     }

  983.   }

  984. }

  985. 

  986. 

  987. static __inline void TRMCOPY_NL(BLASLONG m, FLOAT *a, BLASLONG lda, FLOAT *b){

  988.   BLASLONG is, js;

  989. 

  990.   FLOAT *aa1, *aa2;

  991.   FLOAT *b1, *b2;

  992.   FLOAT *bb1, *bb2;

  993.   FLOAT *cc1, *cc2;

  994.   FLOAT a11, a12;

  995.   FLOAT a21, a22;

  996. 

  997.   b1 = b;

  998.   b2 = b;

  999. 

  1000.   for (js = 0; js < m; js += 2){

  1001. 

  1002.     aa1 = a + 0 * lda;

  1003.     aa2 = a + 1 * lda;

  1004.     a  += 2 * lda + 2;

  1005. 

  1006.     bb1 = b1 + 0 * m;

  1007.     bb2 = b1 + 1 * m;

  1008.     b1 += 2 * m + 2;

  1009. 

  1010.     cc1 = b2 + 0 * m;

  1011.     cc2 = b2 + 1 * m;

  1012.     b2 += 2 * m + 2;

  1013. 

  1014.     if (m - js >= 2){

  1015. 

  1016.       a11 = *(aa1 + 0);

  1017.       a21 = *(aa1 + 1);

  1018. 

  1019.       a22 = *(aa2 + 1);

  1020. 

  1021.       *(bb1 + 0) = a11;

  1022.       *(bb1 + 1) = a21;

  1023.       *(bb2 + 0) = a21;

  1024.       *(bb2 + 1) = a22;

  1025.       aa1 += 2;

  1026.       aa2 += 2;

  1027.       bb1 += 2;

  1028.       bb2 += 2;

  1029. 

  1030.       cc1 += 2 * m;

  1031.       cc2 += 2 * m;

  1032. 

  1033.       is = ((m - js - 2) >> 1);

  1034. 

  1035.       while (is > 0){

  1036. 	a11 = *(aa1 + 0);

  1037. 	a21 = *(aa1 + 1);

  1038. 	a12 = *(aa2 + 0);

  1039. 	a22 = *(aa2 + 1);

  1040. 

  1041. 	aa1 += 2;

  1042. 	aa2 += 2;

  1043. 

  1044. 	*(bb1 + 0) = a11;

  1045. 	*(bb1 + 1) = a21;

  1046. 	*(bb2 + 0) = a12;

  1047. 	*(bb2 + 1) = a22;

  1048. 

  1049. 	*(cc1 + 0) = a11;

  1050. 	*(cc1 + 1) = a12;

  1051. 	*(cc2 + 0) = a21;

  1052. 	*(cc2 + 1) = a22;

  1053. 

  1054. 	bb1 += 2;

  1055. 	bb2 += 2;

  1056. 

  1057. 	cc1 += 2 * m;

  1058. 	cc2 += 2 * m;

  1059. 

  1060. 	is --;

  1061.       }

  1062. 

  1063.       is = ((m - js - 2) & 1);

  1064. 

  1065.       if (is == 1){

  1066. 	a11 = *(aa1 + 0);

  1067. 	a12 = *(aa2 + 0);

  1068. 

  1069. 	*(bb1 + 0) = a11;

  1070. 	*(bb2 + 0) = a12;

  1071. 

  1072. 	*(cc1 + 0) = a11;

  1073. 	*(cc1 + 1) = a12;

  1074.       }

  1075.     }

  1076. 

  1077.     if (m - js == 1){

  1078.       a11 = *(aa1 + 0);

  1079.       *(bb1 + 0) = a11;

  1080.     }

  1081. 

  1082.   }

  1083. }

  1084. 

  1085. static __inline void TRMCOPY_TL(BLASLONG m, FLOAT *a, BLASLONG lda, FLOAT *b){

  1086.   BLASLONG is, js;

  1087. 

  1088.   FLOAT *aa1, *aa2;

  1089.   FLOAT *b1, *b2;

  1090.   FLOAT *bb1, *bb2;

  1091.   FLOAT *cc1, *cc2;

  1092.   FLOAT a11, a12;

  1093.   FLOAT a21, a22;

  1094. 

  1095.   b1 = b;

  1096.   b2 = b;

  1097. 

  1098.   for (js = 0; js < m; js += 2){

  1099. 

  1100.     aa1 = a + 0 * lda;

  1101.     aa2 = a + 1 * lda;

  1102.     a  += 2 * lda + 2;

  1103. 

  1104.     bb1 = b1 + 0 * m;

  1105.     bb2 = b1 + 1 * m;

  1106.     b1 += 2 * m + 2;

  1107. 

  1108.     cc1 = b2 + 0 * m;

  1109.     cc2 = b2 + 1 * m;

  1110.     b2 += 2 * m + 2;

  1111. 

  1112.     if (m - js >= 2){

  1113. 

  1114.       a11 = *(aa1 + 0);

  1115.       a21 = *(aa1 + 1);

  1116. 

  1117.       a22 = *(aa2 + 1);

  1118. 

  1119.       *(bb1 + 0) = a11;

  1120.       *(bb1 + 1) = a21;

  1121.       *(bb2 + 0) = a21;

  1122.       *(bb2 + 1) = a22;

  1123.       aa1 += 2;

  1124.       aa2 += 2;

  1125.       bb1 += 2;

  1126.       bb2 += 2;

  1127. 

  1128.       cc1 += 2 * m;

  1129.       cc2 += 2 * m;

  1130. 

  1131.       is = ((m - js - 2) >> 1);

  1132. 

  1133.       while (is > 0){

  1134. 	a11 = *(aa1 + 0);

  1135. 	a21 = *(aa1 + 1);

  1136. 	a12 = *(aa2 + 0);

  1137. 	a22 = *(aa2 + 1);

  1138. 

  1139. 	aa1 += 2;

  1140. 	aa2 += 2;

  1141. 

  1142. 	*(bb1 + 0) = a11;

  1143. 	*(bb1 + 1) = a21;

  1144. 	*(bb2 + 0) = a12;

  1145. 	*(bb2 + 1) = a22;

  1146. 

  1147. 	*(cc1 + 0) = a11;

  1148. 	*(cc1 + 1) = a12;

  1149. 	*(cc2 + 0) = a21;

  1150. 	*(cc2 + 1) = a22;

  1151. 

  1152. 	bb1 += 2;

  1153. 	bb2 += 2;

  1154. 

  1155. 	cc1 += 2 * m;

  1156. 	cc2 += 2 * m;

  1157. 

  1158. 	is --;

  1159.       }

  1160. 

  1161.       is = ((m - js - 2) & 1);

  1162. 

  1163.       if (is == 1){

  1164. 	a11 = *(aa1 + 0);

  1165. 	a12 = *(aa2 + 0);

  1166. 

  1167. 	*(bb1 + 0) = a11;

  1168. 	*(bb2 + 0) = a12;

  1169. 

  1170. 	*(cc1 + 0) = a11;

  1171. 	*(cc1 + 1) = a12;

  1172.       }

  1173.     }

  1174. 

  1175.     if (m - js == 1){

  1176.       a11 = *(aa1 + 0);

  1177.       *(bb1 + 0) = a11;

  1178.     }

  1179. 

  1180.   }

  1181. }

  1182. 

  1183. static __inline void TRMCOPY_NU(BLASLONG m, FLOAT *a, BLASLONG lda, FLOAT *b){

  1184.   BLASLONG is, js;

  1185. 

  1186.   FLOAT *aa1, *aa2;

  1187.   FLOAT *b1, *b2;

  1188.   FLOAT *bb1, *bb2;

  1189.   FLOAT *cc1, *cc2;

  1190.   FLOAT a11, a12;

  1191.   FLOAT a21, a22;

  1192. 

  1193.   b1 = b;

  1194.   b2 = b;

  1195. 

  1196.   for (js = 0; js < m; js += 2){

  1197. 

  1198.     aa1 = a + 0 * lda;

  1199.     aa2 = a + 1 * lda;

  1200.     a  += 2 * lda;

  1201. 

  1202.     bb1 = b1 + 0 * m;

  1203.     bb2 = b1 + 1 * m;

  1204.     b1 += 2 * m;

  1205. 

  1206.     cc1 = b2 + 0 * m;

  1207.     cc2 = b2 + 1 * m;

  1208.     b2 += 2;

  1209. 

  1210.     if (m - js >= 2){

  1211. 

  1212.       for (is = 0; is < js; is += 2){

  1213. 

  1214. 	a11 = *(aa1 + 0);

  1215. 	a21 = *(aa1 + 1);

  1216. 	a12 = *(aa2 + 0);

  1217. 	a22 = *(aa2 + 1);

  1218. 

  1219. 	aa1 += 2;

  1220. 	aa2 += 2;

  1221. 

  1222. 	*(bb1 + 0) = a11;

  1223. 	*(bb1 + 1) = a21;

  1224. 	*(bb2 + 0) = a12;

  1225. 	*(bb2 + 1) = a22;

  1226. 

  1227. 	*(cc1 + 0) = a11;

  1228. 	*(cc1 + 1) = a12;

  1229. 	*(cc2 + 0) = a21;

  1230. 	*(cc2 + 1) = a22;

  1231. 

  1232. 	bb1 += 2;

  1233. 	bb2 += 2;

  1234. 

  1235. 	cc1 += 2 * m;

  1236. 	cc2 += 2 * m;

  1237.       }

  1238. 

  1239.       a11 = *(aa1 + 0);

  1240. 

  1241.       a12 = *(aa2 + 0);

  1242.       a22 = *(aa2 + 1);

  1243. 

  1244.       *(bb1 + 0) = a11;

  1245.       *(bb1 + 1) = a12;

  1246.       *(bb2 + 0) = a12;

  1247.       *(bb2 + 1) = a22;

  1248.     }

  1249. 

  1250.     if (m - js == 1){

  1251.       for (is = 0; is < js; is += 2){

  1252. 

  1253. 	a11 = *(aa1 + 0);

  1254. 	a21 = *(aa1 + 1);

  1255. 	aa1 += 2;

  1256. 

  1257. 	*(bb1 + 0) = a11;

  1258. 	*(bb1 + 1) = a21;

  1259. 	*(cc1 + 0) = a11;

  1260. 	*(cc2 + 0) = a21;

  1261. 	bb1 += 2;

  1262. 

  1263. 	cc1 += 2 * m;

  1264. 	cc2 += 2 * m;

  1265.       }

  1266. 

  1267.       a11 = *(aa1 + 0);

  1268.       *(bb1 + 0) = a11;

  1269.     }

  1270.   }

  1271. }

  1272. 

  1273. static __inline void TRMCOPY_TU(BLASLONG m, FLOAT *a, BLASLONG lda, FLOAT *b){

  1274.   BLASLONG is, js;

  1275. 

  1276.   FLOAT *aa1, *aa2;

  1277.   FLOAT *b1, *b2;

  1278.   FLOAT *bb1, *bb2;

  1279.   FLOAT *cc1, *cc2;

  1280.   FLOAT a11, a12;

  1281.   FLOAT a21, a22;

  1282. 

  1283.   b1 = b;

  1284.   b2 = b;

  1285. 

  1286.   for (js = 0; js < m; js += 2){

  1287. 

  1288.     aa1 = a + 0 * lda;

  1289.     aa2 = a + 1 * lda;

  1290.     a  += 2 * lda;

  1291. 

  1292.     bb1 = b1 + 0 * m;

  1293.     bb2 = b1 + 1 * m;

  1294.     b1 += 2 * m;

  1295. 

  1296.     cc1 = b2 + 0 * m;

  1297.     cc2 = b2 + 1 * m;

  1298.     b2 += 2;

  1299. 

  1300.     if (m - js >= 2){

  1301. 

  1302.       for (is = 0; is < js; is += 2){

  1303. 

  1304. 	a11 = *(aa1 + 0);

  1305. 	a21 = *(aa1 + 1);

  1306. 	a12 = *(aa2 + 0);

  1307. 	a22 = *(aa2 + 1);

  1308. 

  1309. 	aa1 += 2;

  1310. 	aa2 += 2;

  1311. 

  1312. 	*(bb1 + 0) = a11;

  1313. 	*(bb1 + 1) = a21;

  1314. 	*(bb2 + 0) = a12;

  1315. 	*(bb2 + 1) = a22;

  1316. 

  1317. 	*(cc1 + 0) = a11;

  1318. 	*(cc1 + 1) = a12;

  1319. 	*(cc2 + 0) = a21;

  1320. 	*(cc2 + 1) = a22;

  1321. 

  1322. 	bb1 += 2;

  1323. 	bb2 += 2;

  1324. 

  1325. 	cc1 += 2 * m;

  1326. 	cc2 += 2 * m;

  1327.       }

  1328. 

  1329.       a11 = *(aa1 + 0);

  1330. 

  1331.       a12 = *(aa2 + 0);

  1332.       a22 = *(aa2 + 1);

  1333. 

  1334.       *(bb1 + 0) = a11;

  1335.       *(bb1 + 1) = a12;

  1336.       *(bb2 + 0) = a12;

  1337.       *(bb2 + 1) = a22;

  1338.     }

  1339. 

  1340.     if (m - js == 1){

  1341.       for (is = 0; is < js; is += 2){

  1342. 

  1343. 	a11 = *(aa1 + 0);

  1344. 	a21 = *(aa1 + 1);

  1345. 	aa1 += 2;

  1346. 

  1347. 	*(bb1 + 0) = a11;

  1348. 	*(bb1 + 1) = a21;

  1349. 	*(cc1 + 0) = a11;

  1350. 	*(cc2 + 0) = a21;

  1351. 	bb1 += 2;

  1352. 

  1353. 	cc1 += 2 * m;

  1354. 	cc2 += 2 * m;

  1355.       }

  1356. 

  1357.       a11 = *(aa1 + 0);

  1358.       *(bb1 + 0) = a11;

  1359.     }

  1360.   }

  1361. }

  1362. 

  1363. static __inline void ZTRMCOPY_NL(BLASLONG m, FLOAT *a, BLASLONG lda, FLOAT *b){

  1364.   BLASLONG is, js;

  1365. 

  1366.   FLOAT *aa1, *aa2;

  1367.   FLOAT *b1, *b2;

  1368.   FLOAT *bb1, *bb2;

  1369.   FLOAT *cc1, *cc2;

  1370.   FLOAT a11, a21, a31, a41;

  1371.   FLOAT a12, a22, a32, a42;

  1372. 

  1373.   b1 = b;

  1374.   b2 = b;

  1375. 

  1376.   lda *= 2;

  1377. 

  1378.   for (js = 0; js < m; js += 2){

  1379. 

  1380.     aa1 = a + 0 * lda;

  1381.     aa2 = a + 1 * lda;

  1382.     a  += 2 * lda + 4;

  1383. 

  1384.     bb1 = b1 + 0 * m;

  1385.     bb2 = b1 + 2 * m;

  1386.     b1 += 4 * m + 4;

  1387. 

  1388.     cc1 = b2 + 0 * m;

  1389.     cc2 = b2 + 2 * m;

  1390.     b2 += 4 * m + 4;

  1391. 

  1392.     if (m - js >= 2){

  1393. 

  1394.       a11 = *(aa1 + 0);

  1395.       a21 = *(aa1 + 1);

  1396.       a31 = *(aa1 + 2);

  1397.       a41 = *(aa1 + 3);

  1398. 

  1399.       a12 = *(aa2 + 2);

  1400.       a22 = *(aa2 + 3);

  1401. 

  1402.       *(bb1 + 0) = a11;

  1403.       *(bb1 + 1) = a21;

  1404.       *(bb1 + 2) = a31;

  1405.       *(bb1 + 3) = a41;

  1406. 

  1407.       *(bb2 + 0) = a31;

  1408.       *(bb2 + 1) = a41;

  1409.       *(bb2 + 2) = a12;

  1410.       *(bb2 + 3) = a22;

  1411. 

  1412.       aa1 += 4;

  1413.       aa2 += 4;

  1414.       bb1 += 4;

  1415.       bb2 += 4;

  1416. 

  1417.       cc1 += 4 * m;

  1418.       cc2 += 4 * m;

  1419. 

  1420.       is = ((m - js - 2) >> 1);

  1421. 

  1422.       while (is > 0){

  1423. 	a11 = *(aa1 + 0);

  1424. 	a21 = *(aa1 + 1);

  1425. 	a31 = *(aa1 + 2);

  1426. 	a41 = *(aa1 + 3);

  1427. 

  1428. 	a12 = *(aa2 + 0);

  1429. 	a22 = *(aa2 + 1);

  1430. 	a32 = *(aa2 + 2);

  1431. 	a42 = *(aa2 + 3);

  1432. 

  1433. 	aa1 += 4;

  1434. 	aa2 += 4;

  1435. 

  1436. 	*(bb1 + 0) = a11;

  1437. 	*(bb1 + 1) = a21;

  1438. 	*(bb1 + 2) = a31;

  1439. 	*(bb1 + 3) = a41;

  1440. 

  1441. 	*(bb2 + 0) = a12;

  1442. 	*(bb2 + 1) = a22;

  1443. 	*(bb2 + 2) = a32;

  1444. 	*(bb2 + 3) = a42;

  1445. 

  1446. 	*(cc1 + 0) = a11;

  1447. 	*(cc1 + 1) = a21;

  1448. 	*(cc1 + 2) = a12;

  1449. 	*(cc1 + 3) = a22;

  1450. 

  1451. 	*(cc2 + 0) = a31;

  1452. 	*(cc2 + 1) = a41;

  1453. 	*(cc2 + 2) = a32;

  1454. 	*(cc2 + 3) = a42;

  1455. 

  1456. 	bb1 += 4;

  1457. 	bb2 += 4;

  1458. 

  1459. 	cc1 += 4 * m;

  1460. 	cc2 += 4 * m;

  1461. 

  1462. 	is --;

  1463.       }

  1464. 

  1465.       if (m & 1){

  1466. 	a11 = *(aa1 + 0);

  1467. 	a21 = *(aa1 + 1);

  1468. 	a12 = *(aa2 + 0);

  1469. 	a22 = *(aa2 + 1);

  1470. 

  1471. 	*(bb1 + 0) = a11;

  1472. 	*(bb1 + 1) = a21;

  1473. 	*(bb2 + 0) = a12;

  1474. 	*(bb2 + 1) = a22;

  1475. 

  1476. 	*(cc1 + 0) = a11;

  1477. 	*(cc1 + 1) = a21;

  1478. 	*(cc1 + 2) = a12;

  1479. 	*(cc1 + 3) = a22;

  1480.       }

  1481.     }

  1482. 

  1483.     if (m - js == 1){

  1484.       a11 = *(aa1 + 0);

  1485.       a21 = *(aa1 + 1);

  1486.       *(bb1 + 0) = a11;

  1487.       *(bb1 + 1) = a21;

  1488.     }

  1489. 

  1490.   }

  1491. }

  1492. 

  1493. static __inline void ZTRMCOPY_TL(BLASLONG m, FLOAT *a, BLASLONG lda, FLOAT *b){

  1494.   BLASLONG is, js;

  1495. 

  1496.   FLOAT *aa1, *aa2;

  1497.   FLOAT *b1, *b2;

  1498.   FLOAT *bb1, *bb2;

  1499.   FLOAT *cc1, *cc2;

  1500.   FLOAT a11, a21, a31, a41;

  1501.   FLOAT a12, a22, a32, a42;

  1502. 

  1503.   b1 = b;

  1504.   b2 = b;

  1505. 

  1506.   lda *= 2;

  1507. 

  1508.   for (js = 0; js < m; js += 2){

  1509. 

  1510.     aa1 = a + 0 * lda;

  1511.     aa2 = a + 1 * lda;

  1512.     a  += 2 * lda + 4;

  1513. 

  1514.     bb1 = b1 + 0 * m;

  1515.     bb2 = b1 + 2 * m;

  1516.     b1 += 4 * m + 4;

  1517. 

  1518.     cc1 = b2 + 0 * m;

  1519.     cc2 = b2 + 2 * m;

  1520.     b2 += 4 * m + 4;

  1521. 

  1522.     if (m - js >= 2){

  1523. 

  1524.       a11 = *(aa1 + 0);

  1525.       a21 = *(aa1 + 1);

  1526.       a31 = *(aa1 + 2);

  1527.       a41 = *(aa1 + 3);

  1528. 

  1529.       a12 = *(aa2 + 2);

  1530.       a22 = *(aa2 + 3);

  1531. 

  1532.       *(bb1 + 0) = a11;

  1533.       *(bb1 + 1) = a21;

  1534.       *(bb1 + 2) = a31;

  1535.       *(bb1 + 3) = a41;

  1536. 

  1537.       *(bb2 + 0) = a31;

  1538.       *(bb2 + 1) = a41;

  1539.       *(bb2 + 2) = a12;

  1540.       *(bb2 + 3) = a22;

  1541. 

  1542.       aa1 += 4;

  1543.       aa2 += 4;

  1544.       bb1 += 4;

  1545.       bb2 += 4;

  1546. 

  1547.       cc1 += 4 * m;

  1548.       cc2 += 4 * m;

  1549. 

  1550.       is = ((m - js - 2) >> 1);

  1551. 

  1552.       while (is > 0){

  1553. 	a11 = *(aa1 + 0);

  1554. 	a21 = *(aa1 + 1);

  1555. 	a31 = *(aa1 + 2);

  1556. 	a41 = *(aa1 + 3);

  1557. 

  1558. 	a12 = *(aa2 + 0);

  1559. 	a22 = *(aa2 + 1);

  1560. 	a32 = *(aa2 + 2);

  1561. 	a42 = *(aa2 + 3);

  1562. 

  1563. 	aa1 += 4;

  1564. 	aa2 += 4;

  1565. 

  1566. 	*(bb1 + 0) = a11;

  1567. 	*(bb1 + 1) = a21;

  1568. 	*(bb1 + 2) = a31;

  1569. 	*(bb1 + 3) = a41;

  1570. 

  1571. 	*(bb2 + 0) = a12;

  1572. 	*(bb2 + 1) = a22;

  1573. 	*(bb2 + 2) = a32;

  1574. 	*(bb2 + 3) = a42;

  1575. 

  1576. 	*(cc1 + 0) = a11;

  1577. 	*(cc1 + 1) = a21;

  1578. 	*(cc1 + 2) = a12;

  1579. 	*(cc1 + 3) = a22;

  1580. 

  1581. 	*(cc2 + 0) = a31;

  1582. 	*(cc2 + 1) = a41;

  1583. 	*(cc2 + 2) = a32;

  1584. 	*(cc2 + 3) = a42;

  1585. 

  1586. 	bb1 += 4;

  1587. 	bb2 += 4;

  1588. 

  1589. 	cc1 += 4 * m;

  1590. 	cc2 += 4 * m;

  1591. 

  1592. 	is --;

  1593.       }

  1594. 

  1595.       if (m & 1){

  1596. 	a11 = *(aa1 + 0);

  1597. 	a21 = *(aa1 + 1);

  1598. 	a12 = *(aa2 + 0);

  1599. 	a22 = *(aa2 + 1);

  1600. 

  1601. 	*(bb1 + 0) = a11;

  1602. 	*(bb1 + 1) = a21;

  1603. 	*(bb2 + 0) = a12;

  1604. 	*(bb2 + 1) = a22;

  1605. 

  1606. 	*(cc1 + 0) = a11;

  1607. 	*(cc1 + 1) = a21;

  1608. 	*(cc1 + 2) = a12;

  1609. 	*(cc1 + 3) = a22;

  1610.       }

  1611.     }

  1612. 

  1613.     if (m - js == 1){

  1614.       a11 = *(aa1 + 0);

  1615.       a21 = *(aa1 + 1);

  1616.       *(bb1 + 0) = a11;

  1617.       *(bb1 + 1) = a21;

  1618.     }

  1619. 

  1620.   }

  1621. }

  1622. 

  1623. static __inline void ZTRMCOPY_NU(BLASLONG m, FLOAT *a, BLASLONG lda, FLOAT *b){

  1624.   BLASLONG is, js;

  1625. 

  1626.   FLOAT *aa1, *aa2;

  1627.   FLOAT *b1, *b2;

  1628.   FLOAT *bb1, *bb2;

  1629.   FLOAT *cc1, *cc2;

  1630.   FLOAT a11, a21, a31, a41;

  1631.   FLOAT a12, a22, a32, a42;

  1632. 

  1633.   b1 = b;

  1634.   b2 = b;

  1635. 

  1636.   lda *= 2;

  1637. 

  1638.   for (js = 0; js < m; js += 2){

  1639. 

  1640.     aa1 = a + 0 * lda;

  1641.     aa2 = a + 1 * lda;

  1642.     a  += 2 * lda;

  1643. 

  1644.     bb1 = b1 + 0 * m;

  1645.     bb2 = b1 + 2 * m;

  1646.     b1 += 4 * m;

  1647. 

  1648.     cc1 = b2 + 0 * m;

  1649.     cc2 = b2 + 2 * m;

  1650.     b2 += 4;

  1651. 

  1652.     if (m - js >= 2){

  1653. 

  1654.       for (is = 0; is < js; is += 2){

  1655. 

  1656. 	a11 = *(aa1 + 0);

  1657. 	a21 = *(aa1 + 1);

  1658. 	a31 = *(aa1 + 2);

  1659. 	a41 = *(aa1 + 3);

  1660. 

  1661. 	a12 = *(aa2 + 0);

  1662. 	a22 = *(aa2 + 1);

  1663. 	a32 = *(aa2 + 2);

  1664. 	a42 = *(aa2 + 3);

  1665. 

  1666. 	aa1 += 4;

  1667. 	aa2 += 4;

  1668. 

  1669. 	*(bb1 + 0) = a11;

  1670. 	*(bb1 + 1) = a21;

  1671. 	*(bb1 + 2) = a31;

  1672. 	*(bb1 + 3) = a41;

  1673. 

  1674. 	*(bb2 + 0) = a12;

  1675. 	*(bb2 + 1) = a22;

  1676. 	*(bb2 + 2) = a32;

  1677. 	*(bb2 + 3) = a42;

  1678. 

  1679. 	*(cc1 + 0) = a11;

  1680. 	*(cc1 + 1) = a21;

  1681. 	*(cc1 + 2) = a12;

  1682. 	*(cc1 + 3) = a22;

  1683. 

  1684. 	*(cc2 + 0) = a31;

  1685. 	*(cc2 + 1) = a41;

  1686. 	*(cc2 + 2) = a32;

  1687. 	*(cc2 + 3) = a42;

  1688. 

  1689. 	bb1 += 4;

  1690. 	bb2 += 4;

  1691. 

  1692. 	cc1 += 4 * m;

  1693. 	cc2 += 4 * m;

  1694.       }

  1695. 

  1696.       a11 = *(aa1 + 0);

  1697.       a21 = *(aa1 + 1);

  1698. 

  1699.       a12 = *(aa2 + 0);

  1700.       a22 = *(aa2 + 1);

  1701.       a32 = *(aa2 + 2);

  1702.       a42 = *(aa2 + 3);

  1703. 

  1704.       *(bb1 + 0) = a11;

  1705.       *(bb1 + 1) = a21;

  1706.       *(bb1 + 2) = a12;

  1707.       *(bb1 + 3) = a22;

  1708. 

  1709.       *(bb2 + 0) = a12;

  1710.       *(bb2 + 1) = a22;

  1711.       *(bb2 + 2) = a32;

  1712.       *(bb2 + 3) = a42;

  1713.     }

  1714. 

  1715.     if (m - js == 1){

  1716.       for (is = 0; is < js; is += 2){

  1717. 

  1718. 	a11 = *(aa1 + 0);

  1719. 	a21 = *(aa1 + 1);

  1720. 	a31 = *(aa1 + 2);

  1721. 	a41 = *(aa1 + 3);

  1722. 	aa1 += 4;

  1723. 

  1724. 	*(bb1 + 0) = a11;

  1725. 	*(bb1 + 1) = a21;

  1726. 	*(bb1 + 2) = a31;

  1727. 	*(bb1 + 3) = a41;

  1728. 

  1729. 	*(cc1 + 0) = a11;

  1730. 	*(cc1 + 1) = a21;

  1731. 	*(cc2 + 0) = a31;

  1732. 	*(cc2 + 1) = a41;

  1733. 	bb1 += 4;

  1734. 

  1735. 	cc1 += 4 * m;

  1736. 	cc2 += 4 * m;

  1737.       }

  1738. 

  1739.       a11 = *(aa1 + 0);

  1740.       a21 = *(aa1 + 1);

  1741.       *(bb1 + 0) = a11;

  1742.       *(bb1 + 1) = a21;

  1743.     }

  1744.   }

  1745. }

  1746. 

  1747. static __inline void ZTRMCOPY_TU(BLASLONG m, FLOAT *a, BLASLONG lda, FLOAT *b){

  1748.   BLASLONG is, js;

  1749. 

  1750.   FLOAT *aa1, *aa2;

  1751.   FLOAT *b1, *b2;

  1752.   FLOAT *bb1, *bb2;

  1753.   FLOAT *cc1, *cc2;

  1754.   FLOAT a11, a21, a31, a41;

  1755.   FLOAT a12, a22, a32, a42;

  1756. 

  1757.   b1 = b;

  1758.   b2 = b;

  1759. 

  1760.   lda *= 2;

  1761. 

  1762.   for (js = 0; js < m; js += 2){

  1763. 

  1764.     aa1 = a + 0 * lda;

  1765.     aa2 = a + 1 * lda;

  1766.     a  += 2 * lda;

  1767. 

  1768.     bb1 = b1 + 0 * m;

  1769.     bb2 = b1 + 2 * m;

  1770.     b1 += 4 * m;

  1771. 

  1772.     cc1 = b2 + 0 * m;

  1773.     cc2 = b2 + 2 * m;

  1774.     b2 += 4;

  1775. 

  1776.     if (m - js >= 2){

  1777. 

  1778.       for (is = 0; is < js; is += 2){

  1779. 

  1780. 	a11 = *(aa1 + 0);

  1781. 	a21 = *(aa1 + 1);

  1782. 	a31 = *(aa1 + 2);

  1783. 	a41 = *(aa1 + 3);

  1784. 

  1785. 	a12 = *(aa2 + 0);

  1786. 	a22 = *(aa2 + 1);

  1787. 	a32 = *(aa2 + 2);

  1788. 	a42 = *(aa2 + 3);

  1789. 

  1790. 	aa1 += 4;

  1791. 	aa2 += 4;

  1792. 

  1793. 	*(bb1 + 0) = a11;

  1794. 	*(bb1 + 1) = a21;

  1795. 	*(bb1 + 2) = a31;

  1796. 	*(bb1 + 3) = a41;

  1797. 

  1798. 	*(bb2 + 0) = a12;

  1799. 	*(bb2 + 1) = a22;

  1800. 	*(bb2 + 2) = a32;

  1801. 	*(bb2 + 3) = a42;

  1802. 

  1803. 	*(cc1 + 0) = a11;

  1804. 	*(cc1 + 1) = a21;

  1805. 	*(cc1 + 2) = a12;

  1806. 	*(cc1 + 3) = a22;

  1807. 

  1808. 	*(cc2 + 0) = a31;

  1809. 	*(cc2 + 1) = a41;

  1810. 	*(cc2 + 2) = a32;

  1811. 	*(cc2 + 3) = a42;

  1812. 

  1813. 	bb1 += 4;

  1814. 	bb2 += 4;

  1815. 

  1816. 	cc1 += 4 * m;

  1817. 	cc2 += 4 * m;

  1818.       }

  1819. 

  1820.       a11 = *(aa1 + 0);

  1821.       a21 = *(aa1 + 1);

  1822. 

  1823.       a12 = *(aa2 + 0);

  1824.       a22 = *(aa2 + 1);

  1825.       a32 = *(aa2 + 2);

  1826.       a42 = *(aa2 + 3);

  1827. 

  1828.       *(bb1 + 0) = a11;

  1829.       *(bb1 + 1) = a21;

  1830.       *(bb1 + 2) = a12;

  1831.       *(bb1 + 3) = a22;

  1832. 

  1833.       *(bb2 + 0) = a12;

  1834.       *(bb2 + 1) = a22;

  1835.       *(bb2 + 2) = a32;

  1836.       *(bb2 + 3) = a42;

  1837.     }

  1838. 

  1839.     if (m - js == 1){

  1840.       for (is = 0; is < js; is += 2){

  1841. 

  1842. 	a11 = *(aa1 + 0);

  1843. 	a21 = *(aa1 + 1);

  1844. 	a31 = *(aa1 + 2);

  1845. 	a41 = *(aa1 + 3);

  1846. 	aa1 += 4;

  1847. 

  1848. 	*(bb1 + 0) = a11;

  1849. 	*(bb1 + 1) = a21;

  1850. 	*(bb1 + 2) = a31;

  1851. 	*(bb1 + 3) = a41;

  1852. 

  1853. 	*(cc1 + 0) = a11;

  1854. 	*(cc1 + 1) = a21;

  1855. 	*(cc2 + 0) = a31;

  1856. 	*(cc2 + 1) = a41;

  1857. 	bb1 += 4;

  1858. 

  1859. 	cc1 += 4 * m;

  1860. 	cc2 += 4 * m;

  1861.       }

  1862. 

  1863.       a11 = *(aa1 + 0);

  1864.       a21 = *(aa1 + 1);

  1865.       *(bb1 + 0) = a11;

  1866.       *(bb1 + 1) = a21;

  1867.     }

  1868.   }

  1869. }

  1870. 

  1871. #endif

  1872. #endif