libflame  revision_anchor
Functions
FLA_Apply_G_rf_asm_var3.c File Reference

(r)

Functions

FLA_Error FLA_Apply_G_rf_asm_var3 (FLA_Obj G, FLA_Obj A)
 
FLA_Error FLA_Apply_G_rf_ass_var3 (int k_G, int m_A, int n_A, scomplex *buff_G, int rs_G, int cs_G, float *buff_A, int rs_A, int cs_A)
 
FLA_Error FLA_Apply_G_rf_asd_var3 (int k_G, int m_A, int n_A, dcomplex *buff_G, int rs_G, int cs_G, double *buff_A, int rs_A, int cs_A)
 
FLA_Error FLA_Apply_G_rf_asc_var3 (int k_G, int m_A, int n_A, scomplex *buff_G, int rs_G, int cs_G, scomplex *buff_A, int rs_A, int cs_A)
 
FLA_Error FLA_Apply_G_rf_asz_var3 (int k_G, int m_A, int n_A, dcomplex *buff_G, int rs_G, int cs_G, dcomplex *buff_A, int rs_A, int cs_A)
 

Function Documentation

◆ FLA_Apply_G_rf_asc_var3()

FLA_Error FLA_Apply_G_rf_asc_var3 ( int  k_G,
int  m_A,
int  n_A,
scomplex buff_G,
int  rs_G,
int  cs_G,
scomplex buff_A,
int  rs_A,
int  cs_A 
)
1024 {
1025  float one = bl1_s1();
1026  float zero = bl1_s0();
1027  float gamma23_k1;
1028  float sigma23_k1;
1029  float gamma34_k1;
1030  float sigma34_k1;
1031  float gamma12_k2;
1032  float sigma12_k2;
1033  float gamma23_k2;
1034  float sigma23_k2;
1035  scomplex* a1;
1036  scomplex* a2;
1037  scomplex* a3;
1038  scomplex* a4;
1039  scomplex* g23_k1;
1040  scomplex* g34_k1;
1041  scomplex* g12_k2;
1042  scomplex* g23_k2;
1043  int i, j, g, k;
1044  int nG, nG_app;
1045  int n_iter;
1046  int n_left;
1047  int k_minus_1;
1048  int n_fuse;
1049  int k_fuse;
1050  int is_ident23_k1, is_ident34_k1;
1051  int is_ident12_k2, is_ident23_k2;
1052  int has_ident;
1053 
1054  k_minus_1 = k_G - 1;
1055  nG = n_A - 1;
1056  n_fuse = 2;
1057  k_fuse = 2;
1058 
1059  // Use the simple variant for nG < (k - 1) or k == 1.
1060  if ( nG < 2*k_minus_1 || k_G == 1 )
1061  {
1063  m_A,
1064  n_A,
1065  buff_G, rs_G, cs_G,
1066  buff_A, rs_A, cs_A );
1067  return FLA_SUCCESS;
1068  }
1069 
1070 
1071  // Start-up phase.
1072 
1073  for ( j = -1; j < k_minus_1; j += n_fuse )
1074  {
1075  nG_app = j + 2;
1076  n_iter = nG_app / k_fuse;
1077  //n_iter = nG_app % k_fuse;
1078  n_left = 1;
1079 
1080  for ( i = 0, k = 0, g = j; i < n_iter; ++i, k += k_fuse, g -= n_fuse )
1081  {
1082  g23_k1 = buff_G + (g )*rs_G + (k )*cs_G;
1083  g34_k1 = buff_G + (g + 1)*rs_G + (k )*cs_G;
1084  g12_k2 = buff_G + (g - 1)*rs_G + (k + 1)*cs_G;
1085  g23_k2 = buff_G + (g )*rs_G + (k + 1)*cs_G;
1086  a1 = buff_A + (g - 1)*cs_A;
1087  a2 = buff_A + (g )*cs_A;
1088  a3 = buff_A + (g + 1)*cs_A;
1089  a4 = buff_A + (g + 2)*cs_A;
1090 
1091  gamma23_k1 = g23_k1->real;
1092  sigma23_k1 = g23_k1->imag;
1093  gamma34_k1 = g34_k1->real;
1094  sigma34_k1 = g34_k1->imag;
1095  gamma12_k2 = g12_k2->real;
1096  sigma12_k2 = g12_k2->imag;
1097  gamma23_k2 = g23_k2->real;
1098  sigma23_k2 = g23_k2->imag;
1099 
1100  is_ident23_k1 = ( gamma23_k1 == one && sigma23_k1 == zero );
1101  is_ident34_k1 = ( gamma34_k1 == one && sigma34_k1 == zero );
1102  is_ident12_k2 = ( gamma12_k2 == one && sigma12_k2 == zero );
1103  is_ident23_k2 = ( gamma23_k2 == one && sigma23_k2 == zero );
1104  has_ident = ( is_ident23_k1 || is_ident34_k1 ||
1105  is_ident12_k2 || is_ident23_k2 );
1106 
1107  if ( has_ident )
1108  {
1109  // Apply to pairs of columns as needed.
1110 
1111  if ( !is_ident23_k1 )
1112  MAC_Apply_G_mx2_asc( m_A,
1113  &gamma23_k1,
1114  &sigma23_k1,
1115  a2, 1,
1116  a3, 1 );
1117 
1118  if ( !is_ident34_k1 )
1119  MAC_Apply_G_mx2_asc( m_A,
1120  &gamma34_k1,
1121  &sigma34_k1,
1122  a3, 1,
1123  a4, 1 );
1124 
1125  if ( !is_ident12_k2 )
1126  MAC_Apply_G_mx2_asc( m_A,
1127  &gamma12_k2,
1128  &sigma12_k2,
1129  a1, 1,
1130  a2, 1 );
1131 
1132  if ( !is_ident23_k2 )
1133  MAC_Apply_G_mx2_asc( m_A,
1134  &gamma23_k2,
1135  &sigma23_k2,
1136  a2, 1,
1137  a3, 1 );
1138  }
1139  else
1140  {
1141  // Apply to all four columns.
1142 
1143  MAC_Apply_G_mx4s_asc( m_A,
1144  &gamma23_k1,
1145  &sigma23_k1,
1146  &gamma34_k1,
1147  &sigma34_k1,
1148  &gamma12_k2,
1149  &sigma12_k2,
1150  &gamma23_k2,
1151  &sigma23_k2,
1152  a1, 1,
1153  a2, 1,
1154  a3, 1,
1155  a4, 1 );
1156  }
1157  }
1158 
1159  if ( n_left == 1 )
1160  {
1161  g34_k1 = buff_G + (g + 1)*rs_G + (k )*cs_G;
1162  a3 = buff_A + (g + 1)*cs_A;
1163  a4 = buff_A + (g + 2)*cs_A;
1164 
1165  gamma34_k1 = g34_k1->real;
1166  sigma34_k1 = g34_k1->imag;
1167 
1168  is_ident34_k1 = ( gamma34_k1 == one && sigma34_k1 == zero );
1169 
1170  if ( !is_ident34_k1 )
1171  MAC_Apply_G_mx2_asc( m_A,
1172  &gamma34_k1,
1173  &sigma34_k1,
1174  a3, 1,
1175  a4, 1 );
1176  }
1177  }
1178 
1179  // Pipeline stage
1180 
1181  for ( ; j < nG - 1; j += n_fuse )
1182  {
1183  nG_app = k_G;
1184  n_iter = nG_app / k_fuse;
1185  n_left = nG_app % k_fuse;
1186 
1187  for ( i = 0, k = 0, g = j; i < n_iter; ++i, k += k_fuse, g -= n_fuse )
1188  {
1189  g23_k1 = buff_G + (g )*rs_G + (k )*cs_G;
1190  g34_k1 = buff_G + (g + 1)*rs_G + (k )*cs_G;
1191  g12_k2 = buff_G + (g - 1)*rs_G + (k + 1)*cs_G;
1192  g23_k2 = buff_G + (g )*rs_G + (k + 1)*cs_G;
1193  a1 = buff_A + (g - 1)*cs_A;
1194  a2 = buff_A + (g )*cs_A;
1195  a3 = buff_A + (g + 1)*cs_A;
1196  a4 = buff_A + (g + 2)*cs_A;
1197 
1198  gamma23_k1 = g23_k1->real;
1199  sigma23_k1 = g23_k1->imag;
1200  gamma34_k1 = g34_k1->real;
1201  sigma34_k1 = g34_k1->imag;
1202  gamma12_k2 = g12_k2->real;
1203  sigma12_k2 = g12_k2->imag;
1204  gamma23_k2 = g23_k2->real;
1205  sigma23_k2 = g23_k2->imag;
1206 
1207  is_ident23_k1 = ( gamma23_k1 == one && sigma23_k1 == zero );
1208  is_ident34_k1 = ( gamma34_k1 == one && sigma34_k1 == zero );
1209  is_ident12_k2 = ( gamma12_k2 == one && sigma12_k2 == zero );
1210  is_ident23_k2 = ( gamma23_k2 == one && sigma23_k2 == zero );
1211  has_ident = ( is_ident23_k1 || is_ident34_k1 ||
1212  is_ident12_k2 || is_ident23_k2 );
1213 
1214  if ( has_ident )
1215  {
1216  // Apply to pairs of columns as needed.
1217 
1218  if ( !is_ident23_k1 )
1219  MAC_Apply_G_mx2_asc( m_A,
1220  &gamma23_k1,
1221  &sigma23_k1,
1222  a2, 1,
1223  a3, 1 );
1224 
1225  if ( !is_ident34_k1 )
1226  MAC_Apply_G_mx2_asc( m_A,
1227  &gamma34_k1,
1228  &sigma34_k1,
1229  a3, 1,
1230  a4, 1 );
1231 
1232  if ( !is_ident12_k2 )
1233  MAC_Apply_G_mx2_asc( m_A,
1234  &gamma12_k2,
1235  &sigma12_k2,
1236  a1, 1,
1237  a2, 1 );
1238 
1239  if ( !is_ident23_k2 )
1240  MAC_Apply_G_mx2_asc( m_A,
1241  &gamma23_k2,
1242  &sigma23_k2,
1243  a2, 1,
1244  a3, 1 );
1245  }
1246  else
1247  {
1248  // Apply to all four columns.
1249 
1250  MAC_Apply_G_mx4s_asc( m_A,
1251  &gamma23_k1,
1252  &sigma23_k1,
1253  &gamma34_k1,
1254  &sigma34_k1,
1255  &gamma12_k2,
1256  &sigma12_k2,
1257  &gamma23_k2,
1258  &sigma23_k2,
1259  a1, 1,
1260  a2, 1,
1261  a3, 1,
1262  a4, 1 );
1263  }
1264  }
1265 
1266  if ( n_left == 1 )
1267  {
1268  g23_k1 = buff_G + (g )*rs_G + (k )*cs_G;
1269  g34_k1 = buff_G + (g + 1)*rs_G + (k )*cs_G;
1270  a2 = buff_A + (g )*cs_A;
1271  a3 = buff_A + (g + 1)*cs_A;
1272  a4 = buff_A + (g + 2)*cs_A;
1273 
1274  gamma23_k1 = g23_k1->real;
1275  sigma23_k1 = g23_k1->imag;
1276  gamma34_k1 = g34_k1->real;
1277  sigma34_k1 = g34_k1->imag;
1278 
1279  is_ident23_k1 = ( gamma23_k1 == one && sigma23_k1 == zero );
1280  is_ident34_k1 = ( gamma34_k1 == one && sigma34_k1 == zero );
1281 
1282  if ( !is_ident23_k1 && is_ident34_k1 )
1283  {
1284  MAC_Apply_G_mx2_asc( m_A,
1285  &gamma23_k1,
1286  &sigma23_k1,
1287  a2, 1,
1288  a3, 1 );
1289  }
1290  else if ( is_ident23_k1 && !is_ident34_k1 )
1291  {
1292  MAC_Apply_G_mx2_asc( m_A,
1293  &gamma34_k1,
1294  &sigma34_k1,
1295  a3, 1,
1296  a4, 1 );
1297  }
1298  else
1299  {
1300  MAC_Apply_G_mx3_asc( m_A,
1301  &gamma23_k1,
1302  &sigma23_k1,
1303  &gamma34_k1,
1304  &sigma34_k1,
1305  a2, 1,
1306  a3, 1,
1307  a4, 1 );
1308  }
1309  }
1310  }
1311 
1312  // Shutdown stage
1313 
1314  for ( j = nG % n_fuse; j < k_G; j += n_fuse )
1315  {
1316  g = nG - 1;
1317  k = j;
1318 
1319  //n_left = 1;
1320  //if ( n_left == 1 )
1321  {
1322  g23_k1 = buff_G + (g )*rs_G + (k )*cs_G;
1323  a2 = buff_A + (g )*cs_A;
1324  a3 = buff_A + (g + 1)*cs_A;
1325 
1326  gamma23_k1 = g23_k1->real;
1327  sigma23_k1 = g23_k1->imag;
1328 
1329  is_ident23_k1 = ( gamma23_k1 == one && sigma23_k1 == zero );
1330 
1331  if ( !is_ident23_k1 )
1332  MAC_Apply_G_mx2_asc( m_A,
1333  &gamma23_k1,
1334  &sigma23_k1,
1335  a2, 1,
1336  a3, 1 );
1337  ++k;
1338  --g;
1339  }
1340 
1341  nG_app = k_minus_1 - j;
1342  n_iter = nG_app / k_fuse;
1343  n_left = nG_app % k_fuse;
1344 
1345  for ( i = 0; i < n_iter; ++i, k += k_fuse, g -= n_fuse )
1346  {
1347  g23_k1 = buff_G + (g )*rs_G + (k )*cs_G;
1348  g34_k1 = buff_G + (g + 1)*rs_G + (k )*cs_G;
1349  g12_k2 = buff_G + (g - 1)*rs_G + (k + 1)*cs_G;
1350  g23_k2 = buff_G + (g )*rs_G + (k + 1)*cs_G;
1351  a1 = buff_A + (g - 1)*cs_A;
1352  a2 = buff_A + (g )*cs_A;
1353  a3 = buff_A + (g + 1)*cs_A;
1354  a4 = buff_A + (g + 2)*cs_A;
1355 
1356  gamma23_k1 = g23_k1->real;
1357  sigma23_k1 = g23_k1->imag;
1358  gamma34_k1 = g34_k1->real;
1359  sigma34_k1 = g34_k1->imag;
1360  gamma12_k2 = g12_k2->real;
1361  sigma12_k2 = g12_k2->imag;
1362  gamma23_k2 = g23_k2->real;
1363  sigma23_k2 = g23_k2->imag;
1364 
1365  is_ident23_k1 = ( gamma23_k1 == one && sigma23_k1 == zero );
1366  is_ident34_k1 = ( gamma34_k1 == one && sigma34_k1 == zero );
1367  is_ident12_k2 = ( gamma12_k2 == one && sigma12_k2 == zero );
1368  is_ident23_k2 = ( gamma23_k2 == one && sigma23_k2 == zero );
1369  has_ident = ( is_ident23_k1 || is_ident34_k1 ||
1370  is_ident12_k2 || is_ident23_k2 );
1371 
1372  if ( has_ident )
1373  {
1374  // Apply to pairs of columns as needed.
1375 
1376  if ( !is_ident23_k1 )
1377  MAC_Apply_G_mx2_asc( m_A,
1378  &gamma23_k1,
1379  &sigma23_k1,
1380  a2, 1,
1381  a3, 1 );
1382 
1383  if ( !is_ident34_k1 )
1384  MAC_Apply_G_mx2_asc( m_A,
1385  &gamma34_k1,
1386  &sigma34_k1,
1387  a3, 1,
1388  a4, 1 );
1389 
1390  if ( !is_ident12_k2 )
1391  MAC_Apply_G_mx2_asc( m_A,
1392  &gamma12_k2,
1393  &sigma12_k2,
1394  a1, 1,
1395  a2, 1 );
1396 
1397  if ( !is_ident23_k2 )
1398  MAC_Apply_G_mx2_asc( m_A,
1399  &gamma23_k2,
1400  &sigma23_k2,
1401  a2, 1,
1402  a3, 1 );
1403  }
1404  else
1405  {
1406  // Apply to all four columns.
1407 
1408  MAC_Apply_G_mx4s_asc( m_A,
1409  &gamma23_k1,
1410  &sigma23_k1,
1411  &gamma34_k1,
1412  &sigma34_k1,
1413  &gamma12_k2,
1414  &sigma12_k2,
1415  &gamma23_k2,
1416  &sigma23_k2,
1417  a1, 1,
1418  a2, 1,
1419  a3, 1,
1420  a4, 1 );
1421  }
1422  }
1423 
1424  if ( n_left == 1 )
1425  {
1426  g23_k1 = buff_G + (g )*rs_G + (k )*cs_G;
1427  g34_k1 = buff_G + (g + 1)*rs_G + (k )*cs_G;
1428  a2 = buff_A + (g )*cs_A;
1429  a3 = buff_A + (g + 1)*cs_A;
1430  a4 = buff_A + (g + 2)*cs_A;
1431 
1432  gamma23_k1 = g23_k1->real;
1433  sigma23_k1 = g23_k1->imag;
1434  gamma34_k1 = g34_k1->real;
1435  sigma34_k1 = g34_k1->imag;
1436 
1437  is_ident23_k1 = ( gamma23_k1 == one && sigma23_k1 == zero );
1438  is_ident34_k1 = ( gamma34_k1 == one && sigma34_k1 == zero );
1439 
1440  if ( !is_ident23_k1 && is_ident34_k1 )
1441  {
1442  MAC_Apply_G_mx2_asc( m_A,
1443  &gamma23_k1,
1444  &sigma23_k1,
1445  a2, 1,
1446  a3, 1 );
1447  }
1448  else if ( is_ident23_k1 && !is_ident34_k1 )
1449  {
1450  MAC_Apply_G_mx2_asc( m_A,
1451  &gamma34_k1,
1452  &sigma34_k1,
1453  a3, 1,
1454  a4, 1 );
1455  }
1456  else
1457  {
1458  MAC_Apply_G_mx3_asc( m_A,
1459  &gamma23_k1,
1460  &sigma23_k1,
1461  &gamma34_k1,
1462  &sigma34_k1,
1463  a2, 1,
1464  a3, 1,
1465  a4, 1 );
1466  }
1467  }
1468  }
1469 
1470  return FLA_SUCCESS;
1471 }
FLA_Error FLA_Apply_G_rf_asc_var1(int k_G, int m_A, int n_A, scomplex *buff_G, int rs_G, int cs_G, scomplex *buff_A, int rs_A, int cs_A)
Definition: FLA_Apply_G_rf_asm_var1.c:215
int n_left
Definition: bl1_axmyv2.c:149
int i
Definition: bl1_axmyv2.c:145
float bl1_s0(void)
Definition: bl1_constants.c:111
float bl1_s1(void)
Definition: bl1_constants.c:47
Definition: blis_type_defs.h:133
float imag
Definition: blis_type_defs.h:134
float real
Definition: blis_type_defs.h:134

References bl1_s0(), bl1_s1(), FLA_Apply_G_rf_asc_var1(), i, scomplex::imag, n_left, and scomplex::real.

Referenced by FLA_Apply_G_rf_asm_var3().

◆ FLA_Apply_G_rf_asd_var3()

FLA_Error FLA_Apply_G_rf_asd_var3 ( int  k_G,
int  m_A,
int  n_A,
dcomplex buff_G,
int  rs_G,
int  cs_G,
double *  buff_A,
int  rs_A,
int  cs_A 
)
571 {
572  double one = bl1_d1();
573  double zero = bl1_d0();
574  double gamma23_k1;
575  double sigma23_k1;
576  double gamma34_k1;
577  double sigma34_k1;
578  double gamma12_k2;
579  double sigma12_k2;
580  double gamma23_k2;
581  double sigma23_k2;
582  double* a1;
583  double* a2;
584  double* a3;
585  double* a4;
586  dcomplex* g23_k1;
587  dcomplex* g34_k1;
588  dcomplex* g12_k2;
589  dcomplex* g23_k2;
590  int i, j, g, k;
591  int nG, nG_app;
592  int n_iter;
593  int n_left;
594  int k_minus_1;
595  int n_fuse;
596  int k_fuse;
597  int is_ident23_k1, is_ident34_k1;
598  int is_ident12_k2, is_ident23_k2;
599  int has_ident;
600 
601  k_minus_1 = k_G - 1;
602  nG = n_A - 1;
603  n_fuse = 2;
604  k_fuse = 2;
605 
606  // Use the simple variant for nG < (k - 1) or k == 1.
607  if ( nG < 2*k_minus_1 || k_G == 1 )
608  {
610  m_A,
611  n_A,
612  buff_G, rs_G, cs_G,
613  buff_A, rs_A, cs_A );
614  return FLA_SUCCESS;
615  }
616 
617 
618  // Start-up phase.
619 
620  for ( j = -1; j < k_minus_1; j += n_fuse )
621  {
622  nG_app = j + 2;
623  n_iter = nG_app / k_fuse;
624  n_left = 1;
625 
626  for ( i = 0, k = 0, g = j; i < n_iter; ++i, k += k_fuse, g -= n_fuse )
627  {
628  g23_k1 = buff_G + (g )*rs_G + (k )*cs_G;
629  g34_k1 = buff_G + (g + 1)*rs_G + (k )*cs_G;
630  g12_k2 = buff_G + (g - 1)*rs_G + (k + 1)*cs_G;
631  g23_k2 = buff_G + (g )*rs_G + (k + 1)*cs_G;
632  a1 = buff_A + (g - 1)*cs_A;
633  a2 = buff_A + (g )*cs_A;
634  a3 = buff_A + (g + 1)*cs_A;
635  a4 = buff_A + (g + 2)*cs_A;
636 
637  gamma23_k1 = g23_k1->real;
638  sigma23_k1 = g23_k1->imag;
639  gamma34_k1 = g34_k1->real;
640  sigma34_k1 = g34_k1->imag;
641  gamma12_k2 = g12_k2->real;
642  sigma12_k2 = g12_k2->imag;
643  gamma23_k2 = g23_k2->real;
644  sigma23_k2 = g23_k2->imag;
645 
646  is_ident23_k1 = ( gamma23_k1 == one && sigma23_k1 == zero );
647  is_ident34_k1 = ( gamma34_k1 == one && sigma34_k1 == zero );
648  is_ident12_k2 = ( gamma12_k2 == one && sigma12_k2 == zero );
649  is_ident23_k2 = ( gamma23_k2 == one && sigma23_k2 == zero );
650  has_ident = ( is_ident23_k1 || is_ident34_k1 ||
651  is_ident12_k2 || is_ident23_k2 );
652 
653  if ( has_ident )
654  {
655  // Apply to pairs of columns as needed.
656 
657  if ( !is_ident23_k1 )
658  MAC_Apply_G_mx2_asd( m_A,
659  &gamma23_k1,
660  &sigma23_k1,
661  a2, 1,
662  a3, 1 );
663 
664  if ( !is_ident34_k1 )
665  MAC_Apply_G_mx2_asd( m_A,
666  &gamma34_k1,
667  &sigma34_k1,
668  a3, 1,
669  a4, 1 );
670 
671  if ( !is_ident12_k2 )
672  MAC_Apply_G_mx2_asd( m_A,
673  &gamma12_k2,
674  &sigma12_k2,
675  a1, 1,
676  a2, 1 );
677 
678  if ( !is_ident23_k2 )
679  MAC_Apply_G_mx2_asd( m_A,
680  &gamma23_k2,
681  &sigma23_k2,
682  a2, 1,
683  a3, 1 );
684  }
685  else
686  {
687  // Apply to all four columns.
688 
689  MAC_Apply_G_mx4s_asd( m_A,
690  &gamma23_k1,
691  &sigma23_k1,
692  &gamma34_k1,
693  &sigma34_k1,
694  &gamma12_k2,
695  &sigma12_k2,
696  &gamma23_k2,
697  &sigma23_k2,
698  a1, 1,
699  a2, 1,
700  a3, 1,
701  a4, 1 );
702  }
703  }
704 
705  if ( n_left == 1 )
706  {
707  g34_k1 = buff_G + (g + 1)*rs_G + (k )*cs_G;
708  a3 = buff_A + (g + 1)*cs_A;
709  a4 = buff_A + (g + 2)*cs_A;
710 
711  gamma34_k1 = g34_k1->real;
712  sigma34_k1 = g34_k1->imag;
713 
714  is_ident34_k1 = ( gamma34_k1 == one && sigma34_k1 == zero );
715 
716  if ( !is_ident34_k1 )
717  MAC_Apply_G_mx2_asd( m_A,
718  &gamma34_k1,
719  &sigma34_k1,
720  a3, 1,
721  a4, 1 );
722  }
723  }
724 
725  // Pipeline stage
726 
727  for ( ; j < nG - 1; j += n_fuse )
728  {
729  nG_app = k_G;
730  n_iter = nG_app / k_fuse;
731  n_left = nG_app % k_fuse;
732 
733  for ( i = 0, k = 0, g = j; i < n_iter; ++i, k += k_fuse, g -= n_fuse )
734  {
735  g23_k1 = buff_G + (g )*rs_G + (k )*cs_G;
736  g34_k1 = buff_G + (g + 1)*rs_G + (k )*cs_G;
737  g12_k2 = buff_G + (g - 1)*rs_G + (k + 1)*cs_G;
738  g23_k2 = buff_G + (g )*rs_G + (k + 1)*cs_G;
739  a1 = buff_A + (g - 1)*cs_A;
740  a2 = buff_A + (g )*cs_A;
741  a3 = buff_A + (g + 1)*cs_A;
742  a4 = buff_A + (g + 2)*cs_A;
743 
744  gamma23_k1 = g23_k1->real;
745  sigma23_k1 = g23_k1->imag;
746  gamma34_k1 = g34_k1->real;
747  sigma34_k1 = g34_k1->imag;
748  gamma12_k2 = g12_k2->real;
749  sigma12_k2 = g12_k2->imag;
750  gamma23_k2 = g23_k2->real;
751  sigma23_k2 = g23_k2->imag;
752 
753  is_ident23_k1 = ( gamma23_k1 == one && sigma23_k1 == zero );
754  is_ident34_k1 = ( gamma34_k1 == one && sigma34_k1 == zero );
755  is_ident12_k2 = ( gamma12_k2 == one && sigma12_k2 == zero );
756  is_ident23_k2 = ( gamma23_k2 == one && sigma23_k2 == zero );
757  has_ident = ( is_ident23_k1 || is_ident34_k1 ||
758  is_ident12_k2 || is_ident23_k2 );
759 
760  if ( has_ident )
761  {
762  // Apply to pairs of columns as needed.
763 
764  if ( !is_ident23_k1 )
765  MAC_Apply_G_mx2_asd( m_A,
766  &gamma23_k1,
767  &sigma23_k1,
768  a2, 1,
769  a3, 1 );
770 
771  if ( !is_ident34_k1 )
772  MAC_Apply_G_mx2_asd( m_A,
773  &gamma34_k1,
774  &sigma34_k1,
775  a3, 1,
776  a4, 1 );
777 
778  if ( !is_ident12_k2 )
779  MAC_Apply_G_mx2_asd( m_A,
780  &gamma12_k2,
781  &sigma12_k2,
782  a1, 1,
783  a2, 1 );
784 
785  if ( !is_ident23_k2 )
786  MAC_Apply_G_mx2_asd( m_A,
787  &gamma23_k2,
788  &sigma23_k2,
789  a2, 1,
790  a3, 1 );
791  }
792  else
793  {
794  // Apply to all four columns.
795 
796  MAC_Apply_G_mx4s_asd( m_A,
797  &gamma23_k1,
798  &sigma23_k1,
799  &gamma34_k1,
800  &sigma34_k1,
801  &gamma12_k2,
802  &sigma12_k2,
803  &gamma23_k2,
804  &sigma23_k2,
805  a1, 1,
806  a2, 1,
807  a3, 1,
808  a4, 1 );
809  }
810  }
811 
812  if ( n_left == 1 )
813  {
814  g23_k1 = buff_G + (g )*rs_G + (k )*cs_G;
815  g34_k1 = buff_G + (g + 1)*rs_G + (k )*cs_G;
816  a2 = buff_A + (g )*cs_A;
817  a3 = buff_A + (g + 1)*cs_A;
818  a4 = buff_A + (g + 2)*cs_A;
819 
820  gamma23_k1 = g23_k1->real;
821  sigma23_k1 = g23_k1->imag;
822  gamma34_k1 = g34_k1->real;
823  sigma34_k1 = g34_k1->imag;
824 
825  is_ident23_k1 = ( gamma23_k1 == one && sigma23_k1 == zero );
826  is_ident34_k1 = ( gamma34_k1 == one && sigma34_k1 == zero );
827 
828  if ( !is_ident23_k1 && is_ident34_k1 )
829  {
830  MAC_Apply_G_mx2_asd( m_A,
831  &gamma23_k1,
832  &sigma23_k1,
833  a2, 1,
834  a3, 1 );
835  }
836  else if ( is_ident23_k1 && !is_ident34_k1 )
837  {
838  MAC_Apply_G_mx2_asd( m_A,
839  &gamma34_k1,
840  &sigma34_k1,
841  a3, 1,
842  a4, 1 );
843  }
844  else
845  {
846  MAC_Apply_G_mx3_asd( m_A,
847  &gamma23_k1,
848  &sigma23_k1,
849  &gamma34_k1,
850  &sigma34_k1,
851  a2, 1,
852  a3, 1,
853  a4, 1 );
854  }
855  }
856  }
857 
858  // Shutdown stage
859 
860  for ( j = nG % n_fuse; j < k_G; j += n_fuse )
861  {
862  g = nG - 1;
863  k = j;
864 
865  //n_left = 1;
866  //if ( n_left == 1 )
867  {
868  g23_k1 = buff_G + (g )*rs_G + (k )*cs_G;
869  a2 = buff_A + (g )*cs_A;
870  a3 = buff_A + (g + 1)*cs_A;
871 
872  gamma23_k1 = g23_k1->real;
873  sigma23_k1 = g23_k1->imag;
874 
875  is_ident23_k1 = ( gamma23_k1 == one && sigma23_k1 == zero );
876 
877  if ( !is_ident23_k1 )
878  MAC_Apply_G_mx2_asd( m_A,
879  &gamma23_k1,
880  &sigma23_k1,
881  a2, 1,
882  a3, 1 );
883  ++k;
884  --g;
885  }
886 
887  nG_app = k_minus_1 - j;
888  n_iter = nG_app / k_fuse;
889  n_left = nG_app % k_fuse;
890 
891  for ( i = 0; i < n_iter; ++i, k += k_fuse, g -= n_fuse )
892  {
893  g23_k1 = buff_G + (g )*rs_G + (k )*cs_G;
894  g34_k1 = buff_G + (g + 1)*rs_G + (k )*cs_G;
895  g12_k2 = buff_G + (g - 1)*rs_G + (k + 1)*cs_G;
896  g23_k2 = buff_G + (g )*rs_G + (k + 1)*cs_G;
897  a1 = buff_A + (g - 1)*cs_A;
898  a2 = buff_A + (g )*cs_A;
899  a3 = buff_A + (g + 1)*cs_A;
900  a4 = buff_A + (g + 2)*cs_A;
901 
902  gamma23_k1 = g23_k1->real;
903  sigma23_k1 = g23_k1->imag;
904  gamma34_k1 = g34_k1->real;
905  sigma34_k1 = g34_k1->imag;
906  gamma12_k2 = g12_k2->real;
907  sigma12_k2 = g12_k2->imag;
908  gamma23_k2 = g23_k2->real;
909  sigma23_k2 = g23_k2->imag;
910 
911  is_ident23_k1 = ( gamma23_k1 == one && sigma23_k1 == zero );
912  is_ident34_k1 = ( gamma34_k1 == one && sigma34_k1 == zero );
913  is_ident12_k2 = ( gamma12_k2 == one && sigma12_k2 == zero );
914  is_ident23_k2 = ( gamma23_k2 == one && sigma23_k2 == zero );
915  has_ident = ( is_ident23_k1 || is_ident34_k1 ||
916  is_ident12_k2 || is_ident23_k2 );
917 
918  if ( has_ident )
919  {
920  // Apply to pairs of columns as needed.
921 
922  if ( !is_ident23_k1 )
923  MAC_Apply_G_mx2_asd( m_A,
924  &gamma23_k1,
925  &sigma23_k1,
926  a2, 1,
927  a3, 1 );
928 
929  if ( !is_ident34_k1 )
930  MAC_Apply_G_mx2_asd( m_A,
931  &gamma34_k1,
932  &sigma34_k1,
933  a3, 1,
934  a4, 1 );
935 
936  if ( !is_ident12_k2 )
937  MAC_Apply_G_mx2_asd( m_A,
938  &gamma12_k2,
939  &sigma12_k2,
940  a1, 1,
941  a2, 1 );
942 
943  if ( !is_ident23_k2 )
944  MAC_Apply_G_mx2_asd( m_A,
945  &gamma23_k2,
946  &sigma23_k2,
947  a2, 1,
948  a3, 1 );
949  }
950  else
951  {
952  // Apply to all four columns.
953 
954  MAC_Apply_G_mx4s_asd( m_A,
955  &gamma23_k1,
956  &sigma23_k1,
957  &gamma34_k1,
958  &sigma34_k1,
959  &gamma12_k2,
960  &sigma12_k2,
961  &gamma23_k2,
962  &sigma23_k2,
963  a1, 1,
964  a2, 1,
965  a3, 1,
966  a4, 1 );
967  }
968  }
969 
970  if ( n_left == 1 )
971  {
972  g23_k1 = buff_G + (g )*rs_G + (k )*cs_G;
973  g34_k1 = buff_G + (g + 1)*rs_G + (k )*cs_G;
974  a2 = buff_A + (g )*cs_A;
975  a3 = buff_A + (g + 1)*cs_A;
976  a4 = buff_A + (g + 2)*cs_A;
977 
978  gamma23_k1 = g23_k1->real;
979  sigma23_k1 = g23_k1->imag;
980  gamma34_k1 = g34_k1->real;
981  sigma34_k1 = g34_k1->imag;
982 
983  is_ident23_k1 = ( gamma23_k1 == one && sigma23_k1 == zero );
984  is_ident34_k1 = ( gamma34_k1 == one && sigma34_k1 == zero );
985 
986  if ( !is_ident23_k1 && is_ident34_k1 )
987  {
988  MAC_Apply_G_mx2_asd( m_A,
989  &gamma23_k1,
990  &sigma23_k1,
991  a2, 1,
992  a3, 1 );
993  }
994  else if ( is_ident23_k1 && !is_ident34_k1 )
995  {
996  MAC_Apply_G_mx2_asd( m_A,
997  &gamma34_k1,
998  &sigma34_k1,
999  a3, 1,
1000  a4, 1 );
1001  }
1002  else
1003  {
1004  MAC_Apply_G_mx3_asd( m_A,
1005  &gamma23_k1,
1006  &sigma23_k1,
1007  &gamma34_k1,
1008  &sigma34_k1,
1009  a2, 1,
1010  a3, 1,
1011  a4, 1 );
1012  }
1013  }
1014  }
1015 
1016  return FLA_SUCCESS;
1017 }
FLA_Error FLA_Apply_G_rf_asd_var1(int k_G, int m_A, int n_A, dcomplex *buff_G, int rs_G, int cs_G, double *buff_A, int rs_A, int cs_A)
Definition: FLA_Apply_G_rf_asm_var1.c:164
double bl1_d0(void)
Definition: bl1_constants.c:118
double bl1_d1(void)
Definition: bl1_constants.c:54
Definition: blis_type_defs.h:138
double real
Definition: blis_type_defs.h:139
double imag
Definition: blis_type_defs.h:139

References bl1_d0(), bl1_d1(), FLA_Apply_G_rf_asd_var1(), i, dcomplex::imag, n_left, and dcomplex::real.

Referenced by FLA_Apply_G_rf_asm_var3().

◆ FLA_Apply_G_rf_asm_var3()

FLA_Error FLA_Apply_G_rf_asm_var3 ( FLA_Obj  G,
FLA_Obj  A 
)
32 {
33  FLA_Datatype datatype;
34  int k_G, m_A, n_A;
35  int rs_G, cs_G;
36  int rs_A, cs_A;
37 
38  datatype = FLA_Obj_datatype( A );
39 
40  k_G = FLA_Obj_width( G );
41  m_A = FLA_Obj_length( A );
42  n_A = FLA_Obj_width( A );
43 
44  rs_G = FLA_Obj_row_stride( G );
45  cs_G = FLA_Obj_col_stride( G );
46 
47  rs_A = FLA_Obj_row_stride( A );
48  cs_A = FLA_Obj_col_stride( A );
49 
50  switch ( datatype )
51  {
52  case FLA_FLOAT:
53  {
54  scomplex* buff_G = ( scomplex* ) FLA_COMPLEX_PTR( G );
55  float* buff_A = ( float* ) FLA_FLOAT_PTR( A );
56 
58  m_A,
59  n_A,
60  buff_G, rs_G, cs_G,
61  buff_A, rs_A, cs_A );
62 
63  break;
64  }
65 
66  case FLA_DOUBLE:
67  {
68  dcomplex* buff_G = ( dcomplex* ) FLA_DOUBLE_COMPLEX_PTR( G );
69  double* buff_A = ( double* ) FLA_DOUBLE_PTR( A );
70 
72  m_A,
73  n_A,
74  buff_G, rs_G, cs_G,
75  buff_A, rs_A, cs_A );
76 
77  break;
78  }
79 
80  case FLA_COMPLEX:
81  {
82  scomplex* buff_G = ( scomplex* ) FLA_COMPLEX_PTR( G );
83  scomplex* buff_A = ( scomplex* ) FLA_COMPLEX_PTR( A );
84 
86  m_A,
87  n_A,
88  buff_G, rs_G, cs_G,
89  buff_A, rs_A, cs_A );
90 
91  break;
92  }
93 
94  case FLA_DOUBLE_COMPLEX:
95  {
96  dcomplex* buff_G = ( dcomplex* ) FLA_DOUBLE_COMPLEX_PTR( G );
97  dcomplex* buff_A = ( dcomplex* ) FLA_DOUBLE_COMPLEX_PTR( A );
98 
100  m_A,
101  n_A,
102  buff_G, rs_G, cs_G,
103  buff_A, rs_A, cs_A );
104 
105  break;
106  }
107  }
108 
109  return FLA_SUCCESS;
110 }
FLA_Error FLA_Apply_G_rf_ass_var3(int k_G, int m_A, int n_A, scomplex *buff_G, int rs_G, int cs_G, float *buff_A, int rs_A, int cs_A)
Definition: FLA_Apply_G_rf_asm_var3.c:113
FLA_Error FLA_Apply_G_rf_asz_var3(int k_G, int m_A, int n_A, dcomplex *buff_G, int rs_G, int cs_G, dcomplex *buff_A, int rs_A, int cs_A)
Definition: FLA_Apply_G_rf_asm_var3.c:1473
FLA_Error FLA_Apply_G_rf_asd_var3(int k_G, int m_A, int n_A, dcomplex *buff_G, int rs_G, int cs_G, double *buff_A, int rs_A, int cs_A)
Definition: FLA_Apply_G_rf_asm_var3.c:566
FLA_Error FLA_Apply_G_rf_asc_var3(int k_G, int m_A, int n_A, scomplex *buff_G, int rs_G, int cs_G, scomplex *buff_A, int rs_A, int cs_A)
Definition: FLA_Apply_G_rf_asm_var3.c:1019
dim_t FLA_Obj_width(FLA_Obj obj)
Definition: FLA_Query.c:123
dim_t FLA_Obj_row_stride(FLA_Obj obj)
Definition: FLA_Query.c:167
dim_t FLA_Obj_length(FLA_Obj obj)
Definition: FLA_Query.c:116
dim_t FLA_Obj_col_stride(FLA_Obj obj)
Definition: FLA_Query.c:174
FLA_Datatype FLA_Obj_datatype(FLA_Obj obj)
Definition: FLA_Query.c:13
int FLA_Datatype
Definition: FLA_type_defs.h:49

References FLA_Apply_G_rf_asc_var3(), FLA_Apply_G_rf_asd_var3(), FLA_Apply_G_rf_ass_var3(), FLA_Apply_G_rf_asz_var3(), FLA_Obj_col_stride(), FLA_Obj_datatype(), FLA_Obj_length(), FLA_Obj_row_stride(), and FLA_Obj_width().

◆ FLA_Apply_G_rf_ass_var3()

FLA_Error FLA_Apply_G_rf_ass_var3 ( int  k_G,
int  m_A,
int  n_A,
scomplex buff_G,
int  rs_G,
int  cs_G,
float *  buff_A,
int  rs_A,
int  cs_A 
)
118 {
119  float one = bl1_s1();
120  float zero = bl1_s0();
121  float gamma23_k1;
122  float sigma23_k1;
123  float gamma34_k1;
124  float sigma34_k1;
125  float gamma12_k2;
126  float sigma12_k2;
127  float gamma23_k2;
128  float sigma23_k2;
129  float* a1;
130  float* a2;
131  float* a3;
132  float* a4;
133  scomplex* g23_k1;
134  scomplex* g34_k1;
135  scomplex* g12_k2;
136  scomplex* g23_k2;
137  int i, j, g, k;
138  int nG, nG_app;
139  int n_iter;
140  int n_left;
141  int k_minus_1;
142  int n_fuse;
143  int k_fuse;
144  int is_ident23_k1, is_ident34_k1;
145  int is_ident12_k2, is_ident23_k2;
146  int has_ident;
147 
148  k_minus_1 = k_G - 1;
149  nG = n_A - 1;
150  n_fuse = 2;
151  k_fuse = 2;
152 
153  // Use the simple variant for nG < (k - 1) or k == 1.
154  if ( nG < 2*k_minus_1 || k_G == 1 )
155  {
157  m_A,
158  n_A,
159  buff_G, rs_G, cs_G,
160  buff_A, rs_A, cs_A );
161  return FLA_SUCCESS;
162  }
163 
164 
165  // Start-up phase.
166 
167  for ( j = -1; j < k_minus_1; j += n_fuse )
168  {
169  nG_app = j + 2;
170  n_iter = nG_app / k_fuse;
171  n_left = 1;
172 
173  for ( i = 0, k = 0, g = j; i < n_iter; ++i, k += k_fuse, g -= n_fuse )
174  {
175  g23_k1 = buff_G + (g )*rs_G + (k )*cs_G;
176  g34_k1 = buff_G + (g + 1)*rs_G + (k )*cs_G;
177  g12_k2 = buff_G + (g - 1)*rs_G + (k + 1)*cs_G;
178  g23_k2 = buff_G + (g )*rs_G + (k + 1)*cs_G;
179  a1 = buff_A + (g - 1)*cs_A;
180  a2 = buff_A + (g )*cs_A;
181  a3 = buff_A + (g + 1)*cs_A;
182  a4 = buff_A + (g + 2)*cs_A;
183 
184  gamma23_k1 = g23_k1->real;
185  sigma23_k1 = g23_k1->imag;
186  gamma34_k1 = g34_k1->real;
187  sigma34_k1 = g34_k1->imag;
188  gamma12_k2 = g12_k2->real;
189  sigma12_k2 = g12_k2->imag;
190  gamma23_k2 = g23_k2->real;
191  sigma23_k2 = g23_k2->imag;
192 
193  is_ident23_k1 = ( gamma23_k1 == one && sigma23_k1 == zero );
194  is_ident34_k1 = ( gamma34_k1 == one && sigma34_k1 == zero );
195  is_ident12_k2 = ( gamma12_k2 == one && sigma12_k2 == zero );
196  is_ident23_k2 = ( gamma23_k2 == one && sigma23_k2 == zero );
197  has_ident = ( is_ident23_k1 || is_ident34_k1 ||
198  is_ident12_k2 || is_ident23_k2 );
199 
200  if ( has_ident )
201  {
202  // Apply to pairs of columns as needed.
203 
204  if ( !is_ident23_k1 )
205  MAC_Apply_G_mx2_ass( m_A,
206  &gamma23_k1,
207  &sigma23_k1,
208  a2, 1,
209  a3, 1 );
210 
211  if ( !is_ident34_k1 )
212  MAC_Apply_G_mx2_ass( m_A,
213  &gamma34_k1,
214  &sigma34_k1,
215  a3, 1,
216  a4, 1 );
217 
218  if ( !is_ident12_k2 )
219  MAC_Apply_G_mx2_ass( m_A,
220  &gamma12_k2,
221  &sigma12_k2,
222  a1, 1,
223  a2, 1 );
224 
225  if ( !is_ident23_k2 )
226  MAC_Apply_G_mx2_ass( m_A,
227  &gamma23_k2,
228  &sigma23_k2,
229  a2, 1,
230  a3, 1 );
231  }
232  else
233  {
234  // Apply to all four columns.
235 
236  MAC_Apply_G_mx4s_ass( m_A,
237  &gamma23_k1,
238  &sigma23_k1,
239  &gamma34_k1,
240  &sigma34_k1,
241  &gamma12_k2,
242  &sigma12_k2,
243  &gamma23_k2,
244  &sigma23_k2,
245  a1, 1,
246  a2, 1,
247  a3, 1,
248  a4, 1 );
249  }
250  }
251 
252  if ( n_left == 1 )
253  {
254  g34_k1 = buff_G + (g + 1)*rs_G + (k )*cs_G;
255  a3 = buff_A + (g + 1)*cs_A;
256  a4 = buff_A + (g + 2)*cs_A;
257 
258  gamma34_k1 = g34_k1->real;
259  sigma34_k1 = g34_k1->imag;
260 
261  is_ident34_k1 = ( gamma34_k1 == one && sigma34_k1 == zero );
262 
263  if ( !is_ident34_k1 )
264  MAC_Apply_G_mx2_ass( m_A,
265  &gamma34_k1,
266  &sigma34_k1,
267  a3, 1,
268  a4, 1 );
269  }
270  }
271 
272  // Pipeline stage
273 
274  for ( ; j < nG - 1; j += n_fuse )
275  {
276  nG_app = k_G;
277  n_iter = nG_app / k_fuse;
278  n_left = nG_app % k_fuse;
279 
280  for ( i = 0, k = 0, g = j; i < n_iter; ++i, k += k_fuse, g -= n_fuse )
281  {
282  g23_k1 = buff_G + (g )*rs_G + (k )*cs_G;
283  g34_k1 = buff_G + (g + 1)*rs_G + (k )*cs_G;
284  g12_k2 = buff_G + (g - 1)*rs_G + (k + 1)*cs_G;
285  g23_k2 = buff_G + (g )*rs_G + (k + 1)*cs_G;
286  a1 = buff_A + (g - 1)*cs_A;
287  a2 = buff_A + (g )*cs_A;
288  a3 = buff_A + (g + 1)*cs_A;
289  a4 = buff_A + (g + 2)*cs_A;
290 
291  gamma23_k1 = g23_k1->real;
292  sigma23_k1 = g23_k1->imag;
293  gamma34_k1 = g34_k1->real;
294  sigma34_k1 = g34_k1->imag;
295  gamma12_k2 = g12_k2->real;
296  sigma12_k2 = g12_k2->imag;
297  gamma23_k2 = g23_k2->real;
298  sigma23_k2 = g23_k2->imag;
299 
300  is_ident23_k1 = ( gamma23_k1 == one && sigma23_k1 == zero );
301  is_ident34_k1 = ( gamma34_k1 == one && sigma34_k1 == zero );
302  is_ident12_k2 = ( gamma12_k2 == one && sigma12_k2 == zero );
303  is_ident23_k2 = ( gamma23_k2 == one && sigma23_k2 == zero );
304  has_ident = ( is_ident23_k1 || is_ident34_k1 ||
305  is_ident12_k2 || is_ident23_k2 );
306 
307  if ( has_ident )
308  {
309  // Apply to pairs of columns as needed.
310 
311  if ( !is_ident23_k1 )
312  MAC_Apply_G_mx2_ass( m_A,
313  &gamma23_k1,
314  &sigma23_k1,
315  a2, 1,
316  a3, 1 );
317 
318  if ( !is_ident34_k1 )
319  MAC_Apply_G_mx2_ass( m_A,
320  &gamma34_k1,
321  &sigma34_k1,
322  a3, 1,
323  a4, 1 );
324 
325  if ( !is_ident12_k2 )
326  MAC_Apply_G_mx2_ass( m_A,
327  &gamma12_k2,
328  &sigma12_k2,
329  a1, 1,
330  a2, 1 );
331 
332  if ( !is_ident23_k2 )
333  MAC_Apply_G_mx2_ass( m_A,
334  &gamma23_k2,
335  &sigma23_k2,
336  a2, 1,
337  a3, 1 );
338  }
339  else
340  {
341  // Apply to all four columns.
342 
343  MAC_Apply_G_mx4s_ass( m_A,
344  &gamma23_k1,
345  &sigma23_k1,
346  &gamma34_k1,
347  &sigma34_k1,
348  &gamma12_k2,
349  &sigma12_k2,
350  &gamma23_k2,
351  &sigma23_k2,
352  a1, 1,
353  a2, 1,
354  a3, 1,
355  a4, 1 );
356  }
357  }
358 
359  if ( n_left == 1 )
360  {
361  g23_k1 = buff_G + (g )*rs_G + (k )*cs_G;
362  g34_k1 = buff_G + (g + 1)*rs_G + (k )*cs_G;
363  a2 = buff_A + (g )*cs_A;
364  a3 = buff_A + (g + 1)*cs_A;
365  a4 = buff_A + (g + 2)*cs_A;
366 
367  gamma23_k1 = g23_k1->real;
368  sigma23_k1 = g23_k1->imag;
369  gamma34_k1 = g34_k1->real;
370  sigma34_k1 = g34_k1->imag;
371 
372  is_ident23_k1 = ( gamma23_k1 == one && sigma23_k1 == zero );
373  is_ident34_k1 = ( gamma34_k1 == one && sigma34_k1 == zero );
374 
375  if ( !is_ident23_k1 && is_ident34_k1 )
376  {
377  MAC_Apply_G_mx2_ass( m_A,
378  &gamma23_k1,
379  &sigma23_k1,
380  a2, 1,
381  a3, 1 );
382  }
383  else if ( is_ident23_k1 && !is_ident34_k1 )
384  {
385  MAC_Apply_G_mx2_ass( m_A,
386  &gamma34_k1,
387  &sigma34_k1,
388  a3, 1,
389  a4, 1 );
390  }
391  else
392  {
393  MAC_Apply_G_mx3_ass( m_A,
394  &gamma23_k1,
395  &sigma23_k1,
396  &gamma34_k1,
397  &sigma34_k1,
398  a2, 1,
399  a3, 1,
400  a4, 1 );
401  }
402  }
403  }
404 
405  // Shutdown stage
406 
407  for ( j = nG % n_fuse; j < k_G; j += n_fuse )
408  {
409  g = nG - 1;
410  k = j;
411 
412  //n_left = 1;
413  //if ( n_left == 1 )
414  {
415  g23_k1 = buff_G + (g )*rs_G + (k )*cs_G;
416  a2 = buff_A + (g )*cs_A;
417  a3 = buff_A + (g + 1)*cs_A;
418 
419  gamma23_k1 = g23_k1->real;
420  sigma23_k1 = g23_k1->imag;
421 
422  is_ident23_k1 = ( gamma23_k1 == one && sigma23_k1 == zero );
423 
424  if ( !is_ident23_k1 )
425  MAC_Apply_G_mx2_ass( m_A,
426  &gamma23_k1,
427  &sigma23_k1,
428  a2, 1,
429  a3, 1 );
430  ++k;
431  --g;
432  }
433 
434  nG_app = k_minus_1 - j;
435  n_iter = nG_app / k_fuse;
436  n_left = nG_app % k_fuse;
437 
438  for ( i = 0; i < n_iter; ++i, k += k_fuse, g -= n_fuse )
439  {
440  g23_k1 = buff_G + (g )*rs_G + (k )*cs_G;
441  g34_k1 = buff_G + (g + 1)*rs_G + (k )*cs_G;
442  g12_k2 = buff_G + (g - 1)*rs_G + (k + 1)*cs_G;
443  g23_k2 = buff_G + (g )*rs_G + (k + 1)*cs_G;
444  a1 = buff_A + (g - 1)*cs_A;
445  a2 = buff_A + (g )*cs_A;
446  a3 = buff_A + (g + 1)*cs_A;
447  a4 = buff_A + (g + 2)*cs_A;
448 
449  gamma23_k1 = g23_k1->real;
450  sigma23_k1 = g23_k1->imag;
451  gamma34_k1 = g34_k1->real;
452  sigma34_k1 = g34_k1->imag;
453  gamma12_k2 = g12_k2->real;
454  sigma12_k2 = g12_k2->imag;
455  gamma23_k2 = g23_k2->real;
456  sigma23_k2 = g23_k2->imag;
457 
458  is_ident23_k1 = ( gamma23_k1 == one && sigma23_k1 == zero );
459  is_ident34_k1 = ( gamma34_k1 == one && sigma34_k1 == zero );
460  is_ident12_k2 = ( gamma12_k2 == one && sigma12_k2 == zero );
461  is_ident23_k2 = ( gamma23_k2 == one && sigma23_k2 == zero );
462  has_ident = ( is_ident23_k1 || is_ident34_k1 ||
463  is_ident12_k2 || is_ident23_k2 );
464 
465  if ( has_ident )
466  {
467  // Apply to pairs of columns as needed.
468 
469  if ( !is_ident23_k1 )
470  MAC_Apply_G_mx2_ass( m_A,
471  &gamma23_k1,
472  &sigma23_k1,
473  a2, 1,
474  a3, 1 );
475 
476  if ( !is_ident34_k1 )
477  MAC_Apply_G_mx2_ass( m_A,
478  &gamma34_k1,
479  &sigma34_k1,
480  a3, 1,
481  a4, 1 );
482 
483  if ( !is_ident12_k2 )
484  MAC_Apply_G_mx2_ass( m_A,
485  &gamma12_k2,
486  &sigma12_k2,
487  a1, 1,
488  a2, 1 );
489 
490  if ( !is_ident23_k2 )
491  MAC_Apply_G_mx2_ass( m_A,
492  &gamma23_k2,
493  &sigma23_k2,
494  a2, 1,
495  a3, 1 );
496  }
497  else
498  {
499  // Apply to all four columns.
500 
501  MAC_Apply_G_mx4s_ass( m_A,
502  &gamma23_k1,
503  &sigma23_k1,
504  &gamma34_k1,
505  &sigma34_k1,
506  &gamma12_k2,
507  &sigma12_k2,
508  &gamma23_k2,
509  &sigma23_k2,
510  a1, 1,
511  a2, 1,
512  a3, 1,
513  a4, 1 );
514  }
515  }
516 
517  if ( n_left == 1 )
518  {
519  g23_k1 = buff_G + (g )*rs_G + (k )*cs_G;
520  g34_k1 = buff_G + (g + 1)*rs_G + (k )*cs_G;
521  a2 = buff_A + (g )*cs_A;
522  a3 = buff_A + (g + 1)*cs_A;
523  a4 = buff_A + (g + 2)*cs_A;
524 
525  gamma23_k1 = g23_k1->real;
526  sigma23_k1 = g23_k1->imag;
527  gamma34_k1 = g34_k1->real;
528  sigma34_k1 = g34_k1->imag;
529 
530  is_ident23_k1 = ( gamma23_k1 == one && sigma23_k1 == zero );
531  is_ident34_k1 = ( gamma34_k1 == one && sigma34_k1 == zero );
532 
533  if ( !is_ident23_k1 && is_ident34_k1 )
534  {
535  MAC_Apply_G_mx2_ass( m_A,
536  &gamma23_k1,
537  &sigma23_k1,
538  a2, 1,
539  a3, 1 );
540  }
541  else if ( is_ident23_k1 && !is_ident34_k1 )
542  {
543  MAC_Apply_G_mx2_ass( m_A,
544  &gamma34_k1,
545  &sigma34_k1,
546  a3, 1,
547  a4, 1 );
548  }
549  else
550  {
551  MAC_Apply_G_mx3_ass( m_A,
552  &gamma23_k1,
553  &sigma23_k1,
554  &gamma34_k1,
555  &sigma34_k1,
556  a2, 1,
557  a3, 1,
558  a4, 1 );
559  }
560  }
561  }
562 
563  return FLA_SUCCESS;
564 }
FLA_Error FLA_Apply_G_rf_ass_var1(int k_G, int m_A, int n_A, scomplex *buff_G, int rs_G, int cs_G, float *buff_A, int rs_A, int cs_A)
Definition: FLA_Apply_G_rf_asm_var1.c:113

References bl1_s0(), bl1_s1(), FLA_Apply_G_rf_ass_var1(), i, scomplex::imag, n_left, and scomplex::real.

Referenced by FLA_Apply_G_rf_asm_var3().

◆ FLA_Apply_G_rf_asz_var3()

FLA_Error FLA_Apply_G_rf_asz_var3 ( int  k_G,
int  m_A,
int  n_A,
dcomplex buff_G,
int  rs_G,
int  cs_G,
dcomplex buff_A,
int  rs_A,
int  cs_A 
)
1478 {
1479  double one = bl1_d1();
1480  double zero = bl1_d0();
1481  double gamma23_k1;
1482  double sigma23_k1;
1483  double gamma34_k1;
1484  double sigma34_k1;
1485  double gamma12_k2;
1486  double sigma12_k2;
1487  double gamma23_k2;
1488  double sigma23_k2;
1489  dcomplex* a1;
1490  dcomplex* a2;
1491  dcomplex* a3;
1492  dcomplex* a4;
1493  dcomplex* g23_k1;
1494  dcomplex* g34_k1;
1495  dcomplex* g12_k2;
1496  dcomplex* g23_k2;
1497  int i, j, g, k;
1498  int nG, nG_app;
1499  int n_iter;
1500  int n_left;
1501  int k_minus_1;
1502  int n_fuse;
1503  int k_fuse;
1504  int is_ident23_k1, is_ident34_k1;
1505  int is_ident12_k2, is_ident23_k2;
1506  int has_ident;
1507 
1508  k_minus_1 = k_G - 1;
1509  nG = n_A - 1;
1510  n_fuse = 2;
1511  k_fuse = 2;
1512 
1513  // Use the simple variant for nG < (k - 1) or k == 1.
1514  if ( nG < 2*k_minus_1 || k_G == 1 )
1515  {
1517  m_A,
1518  n_A,
1519  buff_G, rs_G, cs_G,
1520  buff_A, rs_A, cs_A );
1521  return FLA_SUCCESS;
1522  }
1523 
1524 
1525  // Start-up phase.
1526 
1527  for ( j = -1; j < k_minus_1; j += n_fuse )
1528  {
1529  nG_app = j + 2;
1530  n_iter = nG_app / k_fuse;
1531  //n_iter = nG_app % k_fuse;
1532  n_left = 1;
1533 
1534  for ( i = 0, k = 0, g = j; i < n_iter; ++i, k += k_fuse, g -= n_fuse )
1535  {
1536  g23_k1 = buff_G + (g )*rs_G + (k )*cs_G;
1537  g34_k1 = buff_G + (g + 1)*rs_G + (k )*cs_G;
1538  g12_k2 = buff_G + (g - 1)*rs_G + (k + 1)*cs_G;
1539  g23_k2 = buff_G + (g )*rs_G + (k + 1)*cs_G;
1540  a1 = buff_A + (g - 1)*cs_A;
1541  a2 = buff_A + (g )*cs_A;
1542  a3 = buff_A + (g + 1)*cs_A;
1543  a4 = buff_A + (g + 2)*cs_A;
1544 
1545  gamma23_k1 = g23_k1->real;
1546  sigma23_k1 = g23_k1->imag;
1547  gamma34_k1 = g34_k1->real;
1548  sigma34_k1 = g34_k1->imag;
1549  gamma12_k2 = g12_k2->real;
1550  sigma12_k2 = g12_k2->imag;
1551  gamma23_k2 = g23_k2->real;
1552  sigma23_k2 = g23_k2->imag;
1553 
1554  is_ident23_k1 = ( gamma23_k1 == one && sigma23_k1 == zero );
1555  is_ident34_k1 = ( gamma34_k1 == one && sigma34_k1 == zero );
1556  is_ident12_k2 = ( gamma12_k2 == one && sigma12_k2 == zero );
1557  is_ident23_k2 = ( gamma23_k2 == one && sigma23_k2 == zero );
1558  has_ident = ( is_ident23_k1 || is_ident34_k1 ||
1559  is_ident12_k2 || is_ident23_k2 );
1560 
1561  if ( has_ident )
1562  {
1563  // Apply to pairs of columns as needed.
1564 
1565  if ( !is_ident23_k1 )
1566  MAC_Apply_G_mx2_asz( m_A,
1567  &gamma23_k1,
1568  &sigma23_k1,
1569  a2, 1,
1570  a3, 1 );
1571 
1572  if ( !is_ident34_k1 )
1573  MAC_Apply_G_mx2_asz( m_A,
1574  &gamma34_k1,
1575  &sigma34_k1,
1576  a3, 1,
1577  a4, 1 );
1578 
1579  if ( !is_ident12_k2 )
1580  MAC_Apply_G_mx2_asz( m_A,
1581  &gamma12_k2,
1582  &sigma12_k2,
1583  a1, 1,
1584  a2, 1 );
1585 
1586  if ( !is_ident23_k2 )
1587  MAC_Apply_G_mx2_asz( m_A,
1588  &gamma23_k2,
1589  &sigma23_k2,
1590  a2, 1,
1591  a3, 1 );
1592  }
1593  else
1594  {
1595  // Apply to all four columns.
1596 
1597  MAC_Apply_G_mx4s_asz( m_A,
1598  &gamma23_k1,
1599  &sigma23_k1,
1600  &gamma34_k1,
1601  &sigma34_k1,
1602  &gamma12_k2,
1603  &sigma12_k2,
1604  &gamma23_k2,
1605  &sigma23_k2,
1606  a1, 1,
1607  a2, 1,
1608  a3, 1,
1609  a4, 1 );
1610  }
1611  }
1612 
1613  if ( n_left == 1 )
1614  {
1615  g34_k1 = buff_G + (g + 1)*rs_G + (k )*cs_G;
1616  a3 = buff_A + (g + 1)*cs_A;
1617  a4 = buff_A + (g + 2)*cs_A;
1618 
1619  gamma34_k1 = g34_k1->real;
1620  sigma34_k1 = g34_k1->imag;
1621 
1622  is_ident34_k1 = ( gamma34_k1 == one && sigma34_k1 == zero );
1623 
1624  if ( !is_ident34_k1 )
1625  MAC_Apply_G_mx2_asz( m_A,
1626  &gamma34_k1,
1627  &sigma34_k1,
1628  a3, 1,
1629  a4, 1 );
1630  }
1631  }
1632 
1633  // Pipeline stage
1634 
1635  for ( ; j < nG - 1; j += n_fuse )
1636  {
1637  nG_app = k_G;
1638  n_iter = nG_app / k_fuse;
1639  n_left = nG_app % k_fuse;
1640 
1641  for ( i = 0, k = 0, g = j; i < n_iter; ++i, k += k_fuse, g -= n_fuse )
1642  {
1643  g23_k1 = buff_G + (g )*rs_G + (k )*cs_G;
1644  g34_k1 = buff_G + (g + 1)*rs_G + (k )*cs_G;
1645  g12_k2 = buff_G + (g - 1)*rs_G + (k + 1)*cs_G;
1646  g23_k2 = buff_G + (g )*rs_G + (k + 1)*cs_G;
1647  a1 = buff_A + (g - 1)*cs_A;
1648  a2 = buff_A + (g )*cs_A;
1649  a3 = buff_A + (g + 1)*cs_A;
1650  a4 = buff_A + (g + 2)*cs_A;
1651 
1652  gamma23_k1 = g23_k1->real;
1653  sigma23_k1 = g23_k1->imag;
1654  gamma34_k1 = g34_k1->real;
1655  sigma34_k1 = g34_k1->imag;
1656  gamma12_k2 = g12_k2->real;
1657  sigma12_k2 = g12_k2->imag;
1658  gamma23_k2 = g23_k2->real;
1659  sigma23_k2 = g23_k2->imag;
1660 
1661  is_ident23_k1 = ( gamma23_k1 == one && sigma23_k1 == zero );
1662  is_ident34_k1 = ( gamma34_k1 == one && sigma34_k1 == zero );
1663  is_ident12_k2 = ( gamma12_k2 == one && sigma12_k2 == zero );
1664  is_ident23_k2 = ( gamma23_k2 == one && sigma23_k2 == zero );
1665  has_ident = ( is_ident23_k1 || is_ident34_k1 ||
1666  is_ident12_k2 || is_ident23_k2 );
1667 
1668  if ( has_ident )
1669  {
1670  // Apply to pairs of columns as needed.
1671 
1672  if ( !is_ident23_k1 )
1673  MAC_Apply_G_mx2_asz( m_A,
1674  &gamma23_k1,
1675  &sigma23_k1,
1676  a2, 1,
1677  a3, 1 );
1678 
1679  if ( !is_ident34_k1 )
1680  MAC_Apply_G_mx2_asz( m_A,
1681  &gamma34_k1,
1682  &sigma34_k1,
1683  a3, 1,
1684  a4, 1 );
1685 
1686  if ( !is_ident12_k2 )
1687  MAC_Apply_G_mx2_asz( m_A,
1688  &gamma12_k2,
1689  &sigma12_k2,
1690  a1, 1,
1691  a2, 1 );
1692 
1693  if ( !is_ident23_k2 )
1694  MAC_Apply_G_mx2_asz( m_A,
1695  &gamma23_k2,
1696  &sigma23_k2,
1697  a2, 1,
1698  a3, 1 );
1699  }
1700  else
1701  {
1702  // Apply to all four columns.
1703 
1704  MAC_Apply_G_mx4s_asz( m_A,
1705  &gamma23_k1,
1706  &sigma23_k1,
1707  &gamma34_k1,
1708  &sigma34_k1,
1709  &gamma12_k2,
1710  &sigma12_k2,
1711  &gamma23_k2,
1712  &sigma23_k2,
1713  a1, 1,
1714  a2, 1,
1715  a3, 1,
1716  a4, 1 );
1717  }
1718  }
1719 
1720  if ( n_left == 1 )
1721  {
1722  g23_k1 = buff_G + (g )*rs_G + (k )*cs_G;
1723  g34_k1 = buff_G + (g + 1)*rs_G + (k )*cs_G;
1724  a2 = buff_A + (g )*cs_A;
1725  a3 = buff_A + (g + 1)*cs_A;
1726  a4 = buff_A + (g + 2)*cs_A;
1727 
1728  gamma23_k1 = g23_k1->real;
1729  sigma23_k1 = g23_k1->imag;
1730  gamma34_k1 = g34_k1->real;
1731  sigma34_k1 = g34_k1->imag;
1732 
1733  is_ident23_k1 = ( gamma23_k1 == one && sigma23_k1 == zero );
1734  is_ident34_k1 = ( gamma34_k1 == one && sigma34_k1 == zero );
1735 
1736  if ( !is_ident23_k1 && is_ident34_k1 )
1737  {
1738  MAC_Apply_G_mx2_asz( m_A,
1739  &gamma23_k1,
1740  &sigma23_k1,
1741  a2, 1,
1742  a3, 1 );
1743  }
1744  else if ( is_ident23_k1 && !is_ident34_k1 )
1745  {
1746  MAC_Apply_G_mx2_asz( m_A,
1747  &gamma34_k1,
1748  &sigma34_k1,
1749  a3, 1,
1750  a4, 1 );
1751  }
1752  else
1753  {
1754  MAC_Apply_G_mx3_asz( m_A,
1755  &gamma23_k1,
1756  &sigma23_k1,
1757  &gamma34_k1,
1758  &sigma34_k1,
1759  a2, 1,
1760  a3, 1,
1761  a4, 1 );
1762  }
1763  }
1764  }
1765 
1766  // Shutdown stage
1767 
1768  for ( j = nG % n_fuse; j < k_G; j += n_fuse )
1769  {
1770  g = nG - 1;
1771  k = j;
1772 
1773  //n_left = 1;
1774  //if ( n_left == 1 )
1775  {
1776  g23_k1 = buff_G + (g )*rs_G + (k )*cs_G;
1777  a2 = buff_A + (g )*cs_A;
1778  a3 = buff_A + (g + 1)*cs_A;
1779 
1780  gamma23_k1 = g23_k1->real;
1781  sigma23_k1 = g23_k1->imag;
1782 
1783  is_ident23_k1 = ( gamma23_k1 == one && sigma23_k1 == zero );
1784 
1785  if ( !is_ident23_k1 )
1786  MAC_Apply_G_mx2_asz( m_A,
1787  &gamma23_k1,
1788  &sigma23_k1,
1789  a2, 1,
1790  a3, 1 );
1791  ++k;
1792  --g;
1793  }
1794 
1795  nG_app = k_minus_1 - j;
1796  n_iter = nG_app / k_fuse;
1797  n_left = nG_app % k_fuse;
1798 
1799  for ( i = 0; i < n_iter; ++i, k += k_fuse, g -= n_fuse )
1800  {
1801  g23_k1 = buff_G + (g )*rs_G + (k )*cs_G;
1802  g34_k1 = buff_G + (g + 1)*rs_G + (k )*cs_G;
1803  g12_k2 = buff_G + (g - 1)*rs_G + (k + 1)*cs_G;
1804  g23_k2 = buff_G + (g )*rs_G + (k + 1)*cs_G;
1805  a1 = buff_A + (g - 1)*cs_A;
1806  a2 = buff_A + (g )*cs_A;
1807  a3 = buff_A + (g + 1)*cs_A;
1808  a4 = buff_A + (g + 2)*cs_A;
1809 
1810  gamma23_k1 = g23_k1->real;
1811  sigma23_k1 = g23_k1->imag;
1812  gamma34_k1 = g34_k1->real;
1813  sigma34_k1 = g34_k1->imag;
1814  gamma12_k2 = g12_k2->real;
1815  sigma12_k2 = g12_k2->imag;
1816  gamma23_k2 = g23_k2->real;
1817  sigma23_k2 = g23_k2->imag;
1818 
1819  is_ident23_k1 = ( gamma23_k1 == one && sigma23_k1 == zero );
1820  is_ident34_k1 = ( gamma34_k1 == one && sigma34_k1 == zero );
1821  is_ident12_k2 = ( gamma12_k2 == one && sigma12_k2 == zero );
1822  is_ident23_k2 = ( gamma23_k2 == one && sigma23_k2 == zero );
1823  has_ident = ( is_ident23_k1 || is_ident34_k1 ||
1824  is_ident12_k2 || is_ident23_k2 );
1825 
1826  if ( has_ident )
1827  {
1828  // Apply to pairs of columns as needed.
1829 
1830  if ( !is_ident23_k1 )
1831  MAC_Apply_G_mx2_asz( m_A,
1832  &gamma23_k1,
1833  &sigma23_k1,
1834  a2, 1,
1835  a3, 1 );
1836 
1837  if ( !is_ident34_k1 )
1838  MAC_Apply_G_mx2_asz( m_A,
1839  &gamma34_k1,
1840  &sigma34_k1,
1841  a3, 1,
1842  a4, 1 );
1843 
1844  if ( !is_ident12_k2 )
1845  MAC_Apply_G_mx2_asz( m_A,
1846  &gamma12_k2,
1847  &sigma12_k2,
1848  a1, 1,
1849  a2, 1 );
1850 
1851  if ( !is_ident23_k2 )
1852  MAC_Apply_G_mx2_asz( m_A,
1853  &gamma23_k2,
1854  &sigma23_k2,
1855  a2, 1,
1856  a3, 1 );
1857  }
1858  else
1859  {
1860  // Apply to all four columns.
1861 
1862  MAC_Apply_G_mx4s_asz( m_A,
1863  &gamma23_k1,
1864  &sigma23_k1,
1865  &gamma34_k1,
1866  &sigma34_k1,
1867  &gamma12_k2,
1868  &sigma12_k2,
1869  &gamma23_k2,
1870  &sigma23_k2,
1871  a1, 1,
1872  a2, 1,
1873  a3, 1,
1874  a4, 1 );
1875  }
1876  }
1877 
1878  if ( n_left == 1 )
1879  {
1880  g23_k1 = buff_G + (g )*rs_G + (k )*cs_G;
1881  g34_k1 = buff_G + (g + 1)*rs_G + (k )*cs_G;
1882  a2 = buff_A + (g )*cs_A;
1883  a3 = buff_A + (g + 1)*cs_A;
1884  a4 = buff_A + (g + 2)*cs_A;
1885 
1886  gamma23_k1 = g23_k1->real;
1887  sigma23_k1 = g23_k1->imag;
1888  gamma34_k1 = g34_k1->real;
1889  sigma34_k1 = g34_k1->imag;
1890 
1891  is_ident23_k1 = ( gamma23_k1 == one && sigma23_k1 == zero );
1892  is_ident34_k1 = ( gamma34_k1 == one && sigma34_k1 == zero );
1893 
1894  if ( !is_ident23_k1 && is_ident34_k1 )
1895  {
1896  MAC_Apply_G_mx2_asz( m_A,
1897  &gamma23_k1,
1898  &sigma23_k1,
1899  a2, 1,
1900  a3, 1 );
1901  }
1902  else if ( is_ident23_k1 && !is_ident34_k1 )
1903  {
1904  MAC_Apply_G_mx2_asz( m_A,
1905  &gamma34_k1,
1906  &sigma34_k1,
1907  a3, 1,
1908  a4, 1 );
1909  }
1910  else
1911  {
1912  MAC_Apply_G_mx3_asz( m_A,
1913  &gamma23_k1,
1914  &sigma23_k1,
1915  &gamma34_k1,
1916  &sigma34_k1,
1917  a2, 1,
1918  a3, 1,
1919  a4, 1 );
1920  }
1921  }
1922  }
1923 
1924  return FLA_SUCCESS;
1925 }
FLA_Error FLA_Apply_G_rf_asz_var1(int k_G, int m_A, int n_A, dcomplex *buff_G, int rs_G, int cs_G, dcomplex *buff_A, int rs_A, int cs_A)
Definition: FLA_Apply_G_rf_asm_var1.c:267

References bl1_d0(), bl1_d1(), FLA_Apply_G_rf_asz_var1(), i, dcomplex::imag, n_left, and dcomplex::real.

Referenced by FLA_Apply_G_rf_asm_var3().