xref: /aosp_15_r20/cts/tests/tests/rsblas/assets/blas_gen.py (revision b7c941bb3fa97aba169d73cee0bed2de8ac964bf) 
1#
2# Copyright (C) 2015 The Android Open Source Project
3#
4# Licensed under the Apache License, Version 2.0 (the "License");
5# you may not use this file except in compliance with the License.
6# You may obtain a copy of the License at
7#
8#      http://www.apache.org/licenses/LICENSE-2.0
9#
10# Unless required by applicable law or agreed to in writing, software
11# distributed under the License is distributed on an "AS IS" BASIS,
12# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13# See the License for the specific language governing permissions and
14# limitations under the License.
15#
16
17# This Python script is used to generate all input and output
18# reference data into BLASData.txt
19
20#!/usr/bin/python
21
22from numpy import *
23
24# functions used for generating input matrices.
25
26# Modify a regular matrix to a triangular matrix.
27def triangularMatrixGen(a, uplo):
28    if uplo == 'u': #upper = 1, lower = 2
29        for i in range(1, a.shape[0]):
30            for j in range(0, i):
31                a[i, j] = 0
32    elif uplo == 'l':
33        for i in range(0, a.shape[0]-1):
34            for j in range(i+1, a.shape[1]):
35                a[i, j] = 0
36
37# Modify a regular matrix to a symmetric matrix.
38def symm(a):
39    for i in range(1, a.shape[0]):
40        for j in range(0, i):
41            a[i, j] = a[j, i];
42
43# Modify a regular matrix to a hermitian matrix.
44def herm(a):
45    for i in range(0, a.shape[0]):
46        a[i,i] = complex(a[i,i].real, 0);
47    for i in range(1, a.shape[0]):
48        for j in range(0, i):
49            a[i, j] = complex(a[j, i].real, -a[j, i].imag);
50
51# Zero all elments in a matrix
52def zero(a):
53    for i in range(0, a.shape[0]):
54        for j in range(0, a.shape[1]):
55            a[i, j] = 0;
56
57# Generate a random float matrix given a scale.
58def sMatGen(m, n, scale):
59    a = mat(random.randint(1, 10, size=(m, n)).astype('f4')/scale)
60    return a;
61
62# Generate a random double matrix given a scale.
63def dMatGen(m, n, scale):
64    a = mat(random.randint(1, 10, size=(m, n)).astype('f8')/scale)
65    return a;
66
67# Generate a random float complex matrix given a scale.
68def cMatGen(m, n, scale):
69    a_real = mat(random.randint(1, 10, size=(m, n)).astype('f4')/scale)
70    a_img = mat(random.randint(1, 10, size=(m, n)).astype('f4')/scale)
71    a = a_real + 1j * a_img
72    return a;
73
74# Generate a random double complex matrix given a scale.
75def zMatGen(m, n, scale):
76    a_real = mat(random.randint(1, 10, size=(m, n)).astype('f8')/scale)
77    a_img = mat(random.randint(1, 10, size=(m, n)).astype('f8')/scale)
78    a = a_real + 1j * a_img
79    return a;
80
81# A wrapper to generated random matrices given a scale
82def matrixCreateScale(dt, m, n, scale):
83    if dt == 's':
84        return sMatGen(m, n, scale);
85    elif dt == 'd':
86        return dMatGen(m, n, scale);
87    elif dt == 'c':
88        return cMatGen(m, n, scale);
89    else:
90        return zMatGen(m, n, scale);
91
92# A wrapper to generated random matrices
93def matrixCreate(dt, m, n):
94    return matrixCreateScale(dt, m, n, 10);
95
96# Write a float matrix into a given file.
97# For each element, can pad arbitrary number of 0s after it.
98def writeFloatMatrix(a, name, skip, fo):
99    fo.write(name + '\n');
100    for i in range(0, a.shape[0]):
101        for j in range(0, a.shape[1]):
102            fo.write(str(a[i,j]) + ", ");
103            for hh in range(0, skip):
104                fo.write("0.0, ");
105    fo.write("\n\n");
106
107# Write a double matrix into a given file.
108# For each element, can pad arbitrary number of 0s after it.
109def writeDoubleMatrix(a, name, skip, fo):
110    writeFloatMatrix(a, name, skip, fo);
111
112# Write a float complex matrix into a given file.
113# For each element, can pad arbitrary number of 0s after it.
114def writeFloatComplexMatrix(a, name, skip, fo):
115    fo.write(name + '\n');
116    for i in range(0, a.shape[0]):
117        for j in range(0, a.shape[1]):
118            fo.write(str(real(a[i,j])) + ", ");
119            fo.write(str(imag(a[i,j])) + ", ");
120            for hh in range(0, skip):
121                fo.write("0.0, ");
122                fo.write("0.0, ");
123    fo.write("\n\n");
124
125# Write a double complex matrix into a given file.
126# For each element, can pad arbitrary number of 0s after it.
127def writeDoubleComplexMatrix(a, name, skip, fo):
128    writeFloatComplexMatrix(a, name, skip, fo);
129
130# Wrapper to write a matrix into a given file.
131# For each element, can pad arbitrary number of 0s after it.
132def writeMatrixWithIncrements(dt, a, name, skip, fo):
133    if dt == 's':
134        writeFloatMatrix(a, name, skip, fo);
135    elif dt == 'd':
136        writeDoubleMatrix(a, name, skip, fo);
137    elif dt == 'c':
138        writeFloatComplexMatrix(a, name, skip, fo);
139    else:
140        writeDoubleComplexMatrix(a, name, skip, fo);
141
142# Wrapper to write a matrix into a given file.
143def writeMatrix(dt, a, name, fo):
144    writeMatrixWithIncrements(dt, a, name, 0, fo);
145
146# Write a symmetric or hermitian float matrix into a given file, in a packed form.
147def writeFloatPackedMatrix(a, name, fo):
148    fo.write(name + '\n');
149    for i in range(0, a.shape[0]):
150        for j in range(i, a.shape[1]):
151            fo.write(str(a[i,j]) + ", ");
152    fo.write("\n\n");
153
154# Write a symmetric or hermitian double matrix into a given file, in a packed form.
155def writeDoublePackedMatrix(a, name, fo):
156    writeFloatPackedMatrix(a, name, fo);
157
158# Write a symmetric or hermitian float complex matrix into a given file, in a packed form.
159def writeFloatComplexPackedMatrix(a, name, fo):
160    fo.write(name + '\n');
161    for i in range(0, a.shape[0]):
162        for j in range(i, a.shape[1]):
163            fo.write(str(real(a[i,j])) + ", ");
164            fo.write(str(imag(a[i,j])) + ", ");
165    fo.write("\n\n");
166
167# Write a symmetric or hermitian double complex matrix into a given file, in a packed form.
168def writeDoubleComplexPackedMatrix(a, name, fo):
169    writeFloatComplexPackedMatrix(a, name, fo);
170
171# Wrapper to write a symmetric or hermitian matrix into a given file, in a packed form.
172def writePackedMatrix(dt, a, name, fo):
173    if dt == 's':
174        writeFloatPackedMatrix(a, name, fo);
175    elif dt == 'd':
176        writeDoublePackedMatrix(a, name, fo);
177    elif dt == 'c':
178        writeFloatComplexPackedMatrix(a, name, fo);
179    else:
180        writeDoubleComplexPackedMatrix(a, name, fo);
181
182# Write a float band matrix into a given file, in a banded-storage form.
183def writeGeneralFloatBandedMatrix(a, kl, ku, name, fo):
184    m = a.shape[0];
185    n = a.shape[1];
186    b = sMatGen(m, kl + ku + 1, 1);
187    zero(b);
188    for i in range(0, m):
189        for j in range(max(0, i-kl), min(i+ku+1, n)):
190            b[i, j-i+kl] = a[i, j]
191    writeFloatMatrix(b, name, 0, fo);
192    zero(a);
193    for i in range(0, m):
194        for j in range(max(0, i-kl), min(i+ku+1, n)):
195            a[i, j] = b[i, j-i+kl]
196
197# Write a double band matrix into a given file, in a banded-storage form.
198def writeGeneralDoubleBandedMatrix(a, kl, ku, name, fo):
199    m = a.shape[0];
200    n = a.shape[1];
201    b = dMatGen(m, kl + ku + 1, 1);
202    zero(b);
203    for i in range(0, m):
204        for j in range(max(0, i-kl), min(i+ku+1, n)):
205            b[i, j-i+kl] = a[i, j]
206    writeDoubleMatrix(b, name, 0, fo);
207    zero(a);
208    for i in range(0, m):
209        for j in range(max(0, i-kl), min(i+ku+1, n)):
210            a[i, j] = b[i, j-i+kl]
211
212# Write a float complex band matrix into a given file, in a banded-storage form.
213def writeGeneralFloatComplexBandedMatrix(a, kl, ku, name, fo):
214    m = a.shape[0];
215    n = a.shape[1];
216    b = cMatGen(m, kl + ku + 1, 1);
217    zero(b);
218    for i in range(0, m):
219        for j in range(max(0, i-kl), min(i+ku+1, n)):
220            b[i, j-i+kl] = a[i, j]
221    writeFloatComplexMatrix(b, name, 0, fo);
222    zero(a);
223    for i in range(0, m):
224        for j in range(max(0, i-kl), min(i+ku+1, n)):
225            a[i, j] = b[i, j-i+kl]
226
227# Write a double complex band matrix into a given file, in a banded-storage form.
228def writeGeneralDoubleComplexBandedMatrix(a, kl, ku, name, fo):
229    m = a.shape[0];
230    n = a.shape[1];
231    b = zMatGen(m, kl + ku + 1, 1);
232    zero(b);
233    for i in range(0, m):
234        for j in range(max(0, i-kl), min(i+ku+1, n)):
235            b[i, j-i+kl] = a[i, j]
236    writeDoubleComplexMatrix(b, name, 0, fo);
237    zero(a);
238    for i in range(0, m):
239        for j in range(max(0, i-kl), min(i+ku+1, n)):
240            a[i, j] = b[i, j-i+kl]
241
242# Wrapper to write a band matrix into a given file, in a banded-storage form.
243def writeGeneralBandedMatrix(dt, a, kl, ku, name, fo):
244    if dt == 's':
245        writeGeneralFloatBandedMatrix(a, kl, ku, name, fo);
246    elif dt == 'd':
247        writeGeneralDoubleBandedMatrix(a, kl, ku, name, fo);
248    elif dt == 'c':
249        writeGeneralFloatComplexBandedMatrix(a, kl, ku, name, fo);
250    else:
251        writeGeneralDoubleComplexBandedMatrix(a, kl, ku, name, fo);
252
253# Write a float symmetric or hermitian band matrix into a given file, in a banded-storage form.
254def writeFloatSymmBandedMatrix(a, k, name, fo):
255    n = a.shape[1];
256    b = sMatGen(n, k+1, 1);
257    zero(b);
258    for i in range(0, n):
259        for j in range(i, min(i+k+1, n)):
260            b[i, j-i] = a[i, j]
261    writeFloatMatrix(b, name, 0, fo);
262    zero(a);
263    for i in range(0, n):
264        for j in range(i, min(i+k+1, n)):
265            a[i, j] = b[i, j-i]
266
267# Write a double symmetric or hermitian band matrix into a given file, in a banded-storage form.
268def writeDoubleSymmBandedMatrix(a, k, name, fo):
269    n = a.shape[1];
270    b = dMatGen(n, k+1, 1);
271    zero(b);
272    for i in range(0, n):
273        for j in range(i, min(i+k+1, n)):
274            b[i, j-i] = a[i, j]
275    writeDoubleMatrix(b, name, 0, fo);
276    zero(a);
277    for i in range(0, n):
278        for j in range(i, min(i+k+1, n)):
279            a[i, j] = b[i, j-i]
280
281# Write a float complex symmetric or hermitian band matrix into a given file, in a banded-storage form.
282def writeFloatComplexSymmBandedMatrix(a, k, name, fo):
283    n = a.shape[1];
284    b = cMatGen(n, k+1, 1);
285    zero(b);
286    for i in range(0, n):
287        for j in range(i, min(i+k+1, n)):
288            b[i, j-i] = a[i, j]
289    writeFloatComplexMatrix(b, name, 0, fo);
290    zero(a);
291    for i in range(0, n):
292        for j in range(i, min(i+k+1, n)):
293            a[i, j] = b[i, j-i]
294
295# Write a double complex symmetric or hermitian band matrix into a given file, in a banded-storage form.
296def writeDoubleComplexSymmBandedMatrix(a, k, name, fo):
297    n = a.shape[1];
298    b = zMatGen(n, k+1, 1);
299    zero(b);
300    for i in range(0, n):
301        for j in range(i, min(i+k+1, n)):
302            b[i, j-i] = a[i, j]
303    writeDoubleComplexMatrix(b, name, 0, fo);
304    zero(a);
305    for i in range(0, n):
306        for j in range(i, min(i+k+1, n)):
307            a[i, j] = b[i, j-i]
308
309# Wrapper to write a symmetric or hermitian band matrix into a given file, in a banded-storage form.
310def writeSymmBandedMatrix(dt, a, k, name, fo):
311    if dt == 's':
312        writeFloatSymmBandedMatrix(a, k, name, fo);
313    elif dt == 'd':
314        writeDoubleSymmBandedMatrix(a, k, name, fo);
315    elif dt == 'c':
316        writeFloatComplexSymmBandedMatrix(a, k, name, fo);
317    else:
318        writeDoubleComplexSymmBandedMatrix(a, k, name, fo);
319
320
321
322#L3 Functions, generate input and output matrices to file.
323def L3_xGEMM(fo, alpha, beta, m, n, k):
324    dataType = ['s', 'd', 'c', 'z'];
325
326    for dt in dataType:
327        a = matrixCreate(dt, m, k);
328        b = matrixCreate(dt, k, n);
329        c = matrixCreate(dt, m, n);
330        writeMatrix(dt, a, "L3_" + dt + "GEMM_A_mk", fo);
331        writeMatrix(dt, b, "L3_" + dt + "GEMM_B_kn", fo);
332        writeMatrix(dt, c, "L3_" + dt + "GEMM_C_mn", fo);
333
334        d = alpha * a * b + beta * c;
335        writeMatrix(dt, d, "L3_" + dt + "GEMM_o_NN", fo);
336
337        a = matrixCreate(dt, k, m);
338        b = matrixCreate(dt, n, k);
339        writeMatrix(dt, a, "L3_" + dt + "GEMM_A_km", fo);
340        writeMatrix(dt, b, "L3_" + dt + "GEMM_B_nk", fo);
341
342        d = alpha * a.T * b.T + beta * c;
343        writeMatrix(dt, d, "L3_" + dt + "GEMM_o_TT", fo);
344        d = alpha * a.H * b.H + beta * c;
345        writeMatrix(dt, d, "L3_" + dt + "GEMM_o_HH", fo);
346
347def L3_xSYMM(fo, alpha, beta, m, n):
348    dataType = ['s', 'd', 'c', 'z'];
349
350    for dt in dataType:
351        a = matrixCreate(dt, m, m);
352        symm(a);
353        writeMatrix(dt, a, "L3_" + dt + "SYMM_A_mm", fo);
354
355        b = matrixCreate(dt, m, n);
356        c = matrixCreate(dt, m, n);
357        writeMatrix(dt, b, "L3_" + dt + "SYMM_B_mn", fo);
358        writeMatrix(dt, c, "L3_" + dt + "SYMM_C_mn", fo);
359
360        d = alpha * a * b + beta * c;
361        writeMatrix(dt, d, "L3_" + dt + "SYMM_o_L", fo);
362
363        a = matrixCreate(dt, n, n);
364        symm(a);
365        writeMatrix(dt, a, "L3_" + dt + "SYMM_A_nn", fo);
366        d = alpha * b * a + beta * c;
367        writeMatrix(dt, d, "L3_" + dt + "SYMM_o_R", fo);
368
369def L3_xHEMM(fo, alpha, beta, m, n):
370    dataType = ['c', 'z'];
371
372    for dt in dataType:
373        a = matrixCreate(dt, m, m);
374        herm(a);
375        writeMatrix(dt, a, "L3_" + dt + "HEMM_A_mm", fo);
376
377        b = matrixCreate(dt, m, n);
378        c = matrixCreate(dt, m, n);
379        writeMatrix(dt, b, "L3_" + dt + "HEMM_B_mn", fo);
380        writeMatrix(dt, c, "L3_" + dt + "HEMM_C_mn", fo);
381
382        d = alpha * a * b + beta * c;
383        writeMatrix(dt, d, "L3_" + dt + "HEMM_o_L", fo);
384
385        a = matrixCreate(dt, n, n);
386        herm(a);
387        writeMatrix(dt, a, "L3_" + dt + "HEMM_A_nn", fo);
388        d = alpha * b * a + beta * c;
389        writeMatrix(dt, d, "L3_" + dt + "HEMM_o_R", fo);
390
391def L3_xSYRK(fo, alpha, beta, n, k):
392    dataType = ['s', 'd', 'c', 'z'];
393
394    for dt in dataType:
395        a = matrixCreate(dt, n, k);
396        writeMatrix(dt, a, "L3_" + dt + "SYRK_A_nk", fo);
397        c = matrixCreate(dt, n, n);
398        symm(c);
399        writeMatrix(dt, c, "L3_" + dt + "SYRK_C_nn", fo);
400        d = alpha * a * a.T + beta * c;
401        writeMatrix(dt, d, "L3_" + dt + "SYRK_o_N", fo);
402
403        a = matrixCreate(dt, k, n);
404        writeMatrix(dt, a, "L3_" + dt + "SYRK_A_kn", fo);
405        d = alpha * a.T * a + beta * c;
406        writeMatrix(dt, d, "L3_" + dt + "SYRK_o_T", fo);
407
408def L3_xHERK(fo, alpha, beta, n, k):
409    dataType = ['c', 'z'];
410
411    for dt in dataType:
412        a = matrixCreate(dt, n, k);
413        writeMatrix(dt, a, "L3_" + dt + "HERK_A_nk", fo);
414        c = matrixCreate(dt, n, n);
415        herm(c);
416        writeMatrix(dt, c, "L3_" + dt + "HERK_C_nn", fo);
417        d = alpha * a * a.H + beta * c;
418        writeMatrix(dt, d, "L3_" + dt + "HERK_o_N", fo);
419
420        a = matrixCreate(dt, k, n);
421        writeMatrix(dt, a, "L3_" + dt + "HERK_A_kn", fo);
422        d = alpha * a.H * a + beta * c;
423        writeMatrix(dt, d, "L3_" + dt + "HERK_o_H", fo);
424
425def L3_xSYR2K(fo, alpha, beta, n, k):
426    dataType = ['s', 'd', 'c', 'z'];
427
428    for dt in dataType:
429        a = matrixCreate(dt, n, k);
430        b = matrixCreate(dt, n, k);
431        writeMatrix(dt, a, "L3_" + dt + "SYR2K_A_nk", fo);
432        writeMatrix(dt, b, "L3_" + dt + "SYR2K_B_nk", fo);
433        c = matrixCreate(dt, n, n);
434        symm(c);
435        writeMatrix(dt, c, "L3_" + dt + "SYR2K_C_nn", fo);
436        d = alpha * (a * b.T + b * a.T) + beta * c;
437        writeMatrix(dt, d, "L3_" + dt + "SYR2K_o_N", fo);
438
439        a = matrixCreate(dt, k, n);
440        b = matrixCreate(dt, k, n);
441        writeMatrix(dt, a, "L3_" + dt + "SYR2K_A_kn", fo);
442        writeMatrix(dt, b, "L3_" + dt + "SYR2K_B_kn", fo);
443        d = alpha * (a.T * b + b.T * a) + beta * c;
444        writeMatrix(dt, d, "L3_" + dt + "SYR2K_o_T", fo);
445
446def L3_xHER2K(fo, alpha, beta, n, k):
447    dataType = ['c', 'z'];
448
449    for dt in dataType:
450        a = matrixCreate(dt, n, k);
451        b = matrixCreate(dt, n, k);
452        writeMatrix(dt, a, "L3_" + dt + "HER2K_A_nk", fo);
453        writeMatrix(dt, b, "L3_" + dt + "HER2K_B_nk", fo);
454        c = matrixCreate(dt, n, n);
455        herm(c);
456        writeMatrix(dt, c, "L3_" + dt + "HER2K_C_nn", fo);
457        d = alpha * (a * b.H + b * a.H) + beta * c;
458        writeMatrix(dt, d, "L3_" + dt + "HER2K_o_N", fo);
459
460        a = matrixCreate(dt, k, n);
461        b = matrixCreate(dt, k, n);
462        writeMatrix(dt, a, "L3_" + dt + "HER2K_A_kn", fo);
463        writeMatrix(dt, b, "L3_" + dt + "HER2K_B_kn", fo);
464        d = alpha * (a.H * b + b.H * a) + beta * c;
465        writeMatrix(dt, d, "L3_" + dt + "HER2K_o_H", fo);
466
467
468def L3_xTRMM(fo, alpha, m, n):
469    dataType = ['s', 'd', 'c', 'z'];
470
471    for dt in dataType:
472        a = matrixCreate(dt, m, m);
473        triangularMatrixGen(a, 'u');
474        writeMatrix(dt, a, "L3_" + dt + "TRMM_A_mm", fo);
475        b = matrixCreate(dt, m, n);
476        writeMatrix(dt, b, "L3_" + dt + "TRMM_B_mn", fo);
477        d = alpha * a * b;
478        writeMatrix(dt, d, "L3_" + dt + "TRMM_o_LUN", fo);
479
480        a = matrixCreate(dt, n, n);
481        triangularMatrixGen(a, 'l');
482        writeMatrix(dt, a, "L3_" + dt + "TRMM_A_nn", fo);
483        d = alpha * b * a.T;
484        writeMatrix(dt, d, "L3_" + dt + "TRMM_o_RLT", fo);
485
486def L3_xTRSM(fo, alpha, m, n):
487    dataType = ['s', 'd', 'c', 'z'];
488
489    for dt in dataType:
490        a = matrixCreateScale(dt, m, m, 1);
491        triangularMatrixGen(a, 'u');
492        writeMatrix(dt, a, "L3_" + dt + "TRSM_A_mm", fo);
493        b = matrixCreate(dt, m, n);
494        writeMatrix(dt, b, "L3_" + dt + "TRSM_B_mn", fo);
495
496        d = alpha * (a.I * b);
497        writeMatrix(dt, d, "L3_" + dt + "TRSM_o_LUN", fo);
498
499        a = matrixCreate(dt, n, n);
500        triangularMatrixGen(a, 'l');
501        writeMatrix(dt, a, "L3_" + dt + "TRSM_A_nn", fo);
502
503        d = alpha * (b * a.I.T);
504        writeMatrix(dt, d, "L3_" + dt + "TRSM_o_RLT", fo);
505
506#L2 Functions, generate input and output matrices to file.
507def L2_xGEMV(fo, alpha, beta, m, n):
508    dataType = ['s', 'd', 'c', 'z'];
509    for dt in dataType:
510        a = matrixCreate(dt, m, n);
511        writeMatrix(dt, a, "L2_" + dt + "GEMV_A_mn", fo);
512
513        x = matrixCreate(dt, n, 1);
514        writeMatrix(dt, x, "L2_" + dt + "GEMV_x_n1", fo);
515        writeMatrixWithIncrements(dt, x, "L2_" + dt + "GEMV_x_n2", 1, fo);
516
517        y = matrixCreate(dt, m, 1);
518        writeMatrix(dt, y, "L2_" + dt + "GEMV_y_m1", fo);
519        writeMatrixWithIncrements(dt, y, "L2_" + dt + "GEMV_y_m2", 2, fo);
520
521        d = alpha * a * x + beta * y;
522        writeMatrix(dt, d, "L2_" + dt + "GEMV_o_N", fo);
523        writeMatrixWithIncrements(dt, d, "L2_" + dt + "GEMV_o_N2", 2, fo);
524
525        d = alpha * a.T * y + beta * x;
526        writeMatrix(dt, d, "L2_" + dt + "GEMV_o_T", fo);
527
528        d = alpha * a.H * y + beta * x;
529        writeMatrix(dt, d, "L2_" + dt + "GEMV_o_H", fo);
530
531def L2_xGBMV(fo, alpha, beta, m, n, kl, ku):
532    dataType = ['s', 'd', 'c', 'z'];
533    for dt in dataType:
534        a = matrixCreate(dt, m, n);
535        writeGeneralBandedMatrix(dt, a, kl, ku, "L2_" + dt + "GBMV_A_mn", fo);
536
537        x = matrixCreate(dt, n, 1);
538        writeMatrix(dt, x, "L2_" + dt + "GBMV_x_n1", fo);
539        writeMatrixWithIncrements(dt, x, "L2_" + dt + "GBMV_x_n2", 1, fo);
540
541        y = matrixCreate(dt, m, 1);
542        writeMatrix(dt, y, "L2_" + dt + "GBMV_y_m1", fo);
543        writeMatrixWithIncrements(dt, y, "L2_" + dt + "GBMV_y_m2", 2, fo);
544
545        d = alpha * a * x + beta * y;
546        writeMatrix(dt, d, "L2_" + dt + "GBMV_o_N", fo);
547        writeMatrixWithIncrements(dt, d, "L2_" + dt + "GBMV_o_N2", 2, fo);
548
549        d = alpha * a.T * y + beta * x;
550        writeMatrix(dt, d, "L2_" + dt + "GBMV_o_T", fo);
551
552        d = alpha * a.H * y + beta * x;
553        writeMatrix(dt, d, "L2_" + dt + "GBMV_o_H", fo);
554
555def L2_xHEMV(fo, alpha, beta, n):
556    dataType = ['c', 'z'];
557    for dt in dataType:
558        a = matrixCreate(dt, n, n);
559        herm(a);
560        writeMatrix(dt, a, "L2_" + dt + "HEMV_A_nn", fo);
561        writePackedMatrix(dt, a, "L2_" + dt + "HEMV_A_nn_pu", fo);
562
563        x = matrixCreate(dt, n, 1);
564        writeMatrix(dt, x, "L2_" + dt + "HEMV_x_n1", fo);
565        writeMatrixWithIncrements(dt, x, "L2_" + dt + "HEMV_x_n2", 1, fo);
566
567        y = matrixCreate(dt, n, 1);
568        writeMatrix(dt, y, "L2_" + dt + "HEMV_y_n1", fo);
569        writeMatrixWithIncrements(dt, y, "L2_" + dt + "HEMV_y_n2", 2, fo);
570
571        d = alpha * a * x + beta * y;
572        writeMatrix(dt, d, "L2_" + dt + "HEMV_o_N", fo);
573        writeMatrixWithIncrements(dt, d, "L2_" + dt + "HEMV_o_N2", 2, fo);
574
575def L2_xHBMV(fo, alpha, beta, n, k):
576    dataType = ['c', 'z'];
577    for dt in dataType:
578        a = matrixCreate(dt, n, n);
579        herm(a);
580        writeSymmBandedMatrix(dt, a, k, "L2_" + dt + "HBMV_A_nn", fo);
581        herm(a);
582
583        x = matrixCreate(dt, n, 1);
584        writeMatrix(dt, x, "L2_" + dt + "HBMV_x_n1", fo);
585        writeMatrixWithIncrements(dt, x, "L2_" + dt + "HBMV_x_n2", 1, fo);
586
587        y = matrixCreate(dt, n, 1);
588        writeMatrix(dt, y, "L2_" + dt + "HBMV_y_n1", fo);
589        writeMatrixWithIncrements(dt, y, "L2_" + dt + "HBMV_y_n2", 2, fo);
590
591        d = alpha * a * x + beta * y;
592        writeMatrix(dt, d, "L2_" + dt + "HBMV_o_N", fo);
593        writeMatrixWithIncrements(dt, d, "L2_" + dt + "HBMV_o_N2", 2, fo);
594
595
596def L2_xSYMV(fo, alpha, beta, n):
597    dataType = ['s', 'd'];
598    for dt in dataType:
599        a = matrixCreate(dt, n, n);
600        symm(a);
601        writeMatrix(dt, a, "L2_" + dt + "SYMV_A_nn", fo);
602        writePackedMatrix(dt, a, "L2_" + dt + "SYMV_A_nn_pu", fo);
603
604        x = matrixCreate(dt, n, 1);
605        writeMatrix(dt, x, "L2_" + dt + "SYMV_x_n1", fo);
606        writeMatrixWithIncrements(dt, x, "L2_" + dt + "SYMV_x_n2", 1, fo);
607
608        y = matrixCreate(dt, n, 1);
609        writeMatrix(dt, y, "L2_" + dt + "SYMV_y_n1", fo);
610        writeMatrixWithIncrements(dt, y, "L2_" + dt + "SYMV_y_n2", 2, fo);
611
612        d = alpha * a * x + beta * y;
613        writeMatrix(dt, d, "L2_" + dt + "SYMV_o_N", fo);
614        writeMatrixWithIncrements(dt, d, "L2_" + dt + "SYMV_o_N2", 2, fo);
615
616def L2_xSBMV(fo, alpha, beta, n, k):
617    dataType = ['s', 'd'];
618    for dt in dataType:
619        a = matrixCreate(dt, n, n);
620        symm(a);
621        writeSymmBandedMatrix(dt, a, k, "L2_" + dt + "SBMV_A_nn", fo);
622        symm(a);
623
624        x = matrixCreate(dt, n, 1);
625        writeMatrix(dt, x, "L2_" + dt + "SBMV_x_n1", fo);
626        writeMatrixWithIncrements(dt, x, "L2_" + dt + "SBMV_x_n2", 1, fo);
627
628        y = matrixCreate(dt, n, 1);
629        writeMatrix(dt, y, "L2_" + dt + "SBMV_y_n1", fo);
630        writeMatrixWithIncrements(dt, y, "L2_" + dt + "SBMV_y_n2", 2, fo);
631
632        d = alpha * a * x + beta * y;
633        writeMatrix(dt, d, "L2_" + dt + "SBMV_o_N", fo);
634        writeMatrixWithIncrements(dt, d, "L2_" + dt + "SBMV_o_N2", 2, fo);
635
636
637def L2_xTRMV(fo, n):
638    dataType = ['s', 'd', 'c', 'z'];
639    for dt in dataType:
640        a = matrixCreate(dt, n, n);
641        triangularMatrixGen(a, 'u');
642        writeMatrix(dt, a, "L2_" + dt + "TRMV_A_nn", fo);
643        writePackedMatrix(dt, a, "L2_" + dt + "TRMV_A_nn_pu", fo);
644
645        x = matrixCreate(dt, n, 1);
646        writeMatrix(dt, x, "L2_" + dt + "TRMV_x_n1", fo);
647        writeMatrixWithIncrements(dt, x, "L2_" + dt + "TRMV_x_n2", 1, fo);
648
649        d = a * x;
650        writeMatrix(dt, d, "L2_" + dt + "TRMV_o_UN", fo);
651        writeMatrixWithIncrements(dt, d, "L2_" + dt + "TRMV_o_UN2", 1, fo);
652
653        d = a.T * x;
654        writeMatrix(dt, d, "L2_" + dt + "TRMV_o_UT", fo);
655
656        d = a.H * x;
657        writeMatrix(dt, d, "L2_" + dt + "TRMV_o_UH", fo);
658
659def L2_xTBMV(fo, n, k):
660    dataType = ['s', 'd', 'c', 'z'];
661    for dt in dataType:
662        a = matrixCreate(dt, n, n);
663        writeSymmBandedMatrix(dt, a, k, "L2_" + dt + "TBMV_A_nn", fo);
664
665        x = matrixCreate(dt, n, 1);
666        writeMatrix(dt, x, "L2_" + dt + "TBMV_x_n1", fo);
667        writeMatrixWithIncrements(dt, x, "L2_" + dt + "TBMV_x_n2", 1, fo);
668
669        d = a * x;
670        writeMatrix(dt, d, "L2_" + dt + "TBMV_o_UN", fo);
671        writeMatrixWithIncrements(dt, d, "L2_" + dt + "TBMV_o_UN2", 1, fo);
672
673        d = a.T * x;
674        writeMatrix(dt, d, "L2_" + dt + "TBMV_o_UT", fo);
675
676        d = a.H * x;
677        writeMatrix(dt, d, "L2_" + dt + "TBMV_o_UH", fo);
678
679
680def L2_xTRSV(fo, n):
681    dataType = ['s', 'd', 'c', 'z'];
682    for dt in dataType:
683        a = matrixCreateScale(dt, n, n, 0.25);
684        triangularMatrixGen(a, 'u');
685        writeMatrix(dt, a, "L2_" + dt + "TRSV_A_nn", fo);
686        writePackedMatrix(dt, a, "L2_" + dt + "TRSV_A_nn_pu", fo);
687
688        x = matrixCreate(dt, n, 1);
689        writeMatrix(dt, x, "L2_" + dt + "TRSV_x_n1", fo);
690        writeMatrixWithIncrements(dt, x, "L2_" + dt + "TRSV_x_n2", 1, fo);
691
692        d = a.I * x;
693        writeMatrix(dt, d, "L2_" + dt + "TRSV_o_UN", fo);
694        writeMatrixWithIncrements(dt, d, "L2_" + dt + "TRSV_o_UN2", 1, fo);
695
696        d = a.I.T * x;
697        writeMatrix(dt, d, "L2_" + dt + "TRSV_o_UT", fo);
698
699        d = a.I.H * x;
700        writeMatrix(dt, d, "L2_" + dt + "TRSV_o_UH", fo);
701
702def L2_xTBSV(fo, n, k):
703    dataType = ['s', 'd', 'c', 'z'];
704    for dt in dataType:
705        a = matrixCreateScale(dt, n, n, 0.25);
706        writeSymmBandedMatrix(dt, a, k, "L2_" + dt + "TBSV_A_nn", fo);
707
708        x = matrixCreate(dt, n, 1);
709        writeMatrix(dt, x, "L2_" + dt + "TBSV_x_n1", fo);
710        writeMatrixWithIncrements(dt, x, "L2_" + dt + "TBSV_x_n2", 1, fo);
711
712        d = a.I * x;
713        writeMatrix(dt, d, "L2_" + dt + "TBSV_o_UN", fo);
714        writeMatrixWithIncrements(dt, d, "L2_" + dt + "TBSV_o_UN2", 1, fo);
715
716        d = a.I.T * x;
717        writeMatrix(dt, d, "L2_" + dt + "TBSV_o_UT", fo);
718
719        d = a.I.H * x;
720        writeMatrix(dt, d, "L2_" + dt + "TBSV_o_UH", fo);
721
722
723def L2_xGER(fo, alpha, m, n):
724    dataType = ['s', 'd'];
725    for dt in dataType:
726        a = matrixCreate(dt, m, n);
727        writeMatrix(dt, a, "L2_" + dt + "GER_A_mn", fo);
728
729        x = matrixCreate(dt, m, 1);
730        writeMatrix(dt, x, "L2_" + dt + "GER_x_m1", fo);
731        writeMatrixWithIncrements(dt, x, "L2_" + dt + "GER_x_m2", 1, fo);
732
733        y = matrixCreate(dt, n, 1);
734        writeMatrix(dt, y, "L2_" + dt + "GER_y_n1", fo);
735        writeMatrixWithIncrements(dt, y, "L2_" + dt + "GER_y_n2", 2, fo);
736
737        d = alpha * x * y.T + a;
738        writeMatrix(dt, d, "L2_" + dt + "GER_o_N", fo);
739
740def L2_xGERU(fo, alpha, m, n):
741    dataType = ['c', 'z'];
742    for dt in dataType:
743        a = matrixCreate(dt, m, n);
744        writeMatrix(dt, a, "L2_" + dt + "GERU_A_mn", fo);
745
746        x = matrixCreate(dt, m, 1);
747        writeMatrix(dt, x, "L2_" + dt + "GERU_x_m1", fo);
748        writeMatrixWithIncrements(dt, x, "L2_" + dt + "GERU_x_m2", 1, fo);
749
750        y = matrixCreate(dt, n, 1);
751        writeMatrix(dt, y, "L2_" + dt + "GERU_y_n1", fo);
752        writeMatrixWithIncrements(dt, y, "L2_" + dt + "GERU_y_n2", 2, fo);
753
754        d = alpha * x * y.T + a;
755        writeMatrix(dt, d, "L2_" + dt + "GERU_o_N", fo);
756
757def L2_xGERC(fo, alpha, m, n):
758    dataType = ['c', 'z'];
759    for dt in dataType:
760        a = matrixCreate(dt, m, n);
761        writeMatrix(dt, a, "L2_" + dt + "GERC_A_mn", fo);
762
763        x = matrixCreate(dt, m, 1);
764        writeMatrix(dt, x, "L2_" + dt + "GERC_x_m1", fo);
765        writeMatrixWithIncrements(dt, x, "L2_" + dt + "GERC_x_m2", 1, fo);
766
767        y = matrixCreate(dt, n, 1);
768        writeMatrix(dt, y, "L2_" + dt + "GERC_y_n1", fo);
769        writeMatrixWithIncrements(dt, y, "L2_" + dt + "GERC_y_n2", 2, fo);
770
771        d = alpha * x * y.H + a;
772        writeMatrix(dt, d, "L2_" + dt + "GERC_o_N", fo);
773
774def L2_xHER(fo, alpha, n):
775    dataType = ['c', 'z'];
776    for dt in dataType:
777        a = matrixCreate(dt, n, n);
778        herm(a);
779        writeMatrix(dt, a, "L2_" + dt + "HER_A_nn", fo);
780        writePackedMatrix(dt, a, "L2_" + dt + "HER_A_nn_pu", fo);
781
782        x = matrixCreate(dt, n, 1);
783        writeMatrix(dt, x, "L2_" + dt + "HER_x_n1", fo);
784        writeMatrixWithIncrements(dt, x, "L2_" + dt + "HER_x_n2", 1, fo);
785
786        d = alpha * x * x.H + a;
787        writeMatrix(dt, d, "L2_" + dt + "HER_o_N", fo);
788        writePackedMatrix(dt, d, "L2_" + dt + "HER_o_N_pu", fo);
789
790
791def L2_xHER2(fo, alpha, n):
792    dataType = ['c', 'z'];
793    for dt in dataType:
794        a = matrixCreate(dt, n, n);
795        herm(a);
796        writeMatrix(dt, a, "L2_" + dt + "HER2_A_nn", fo);
797        writePackedMatrix(dt, a, "L2_" + dt + "HER2_A_nn_pu", fo);
798
799        x = matrixCreate(dt, n, 1);
800        writeMatrix(dt, x, "L2_" + dt + "HER2_x_n1", fo);
801        writeMatrixWithIncrements(dt, x, "L2_" + dt + "HER2_x_n2", 1, fo);
802
803        y = matrixCreate(dt, n, 1);
804        writeMatrix(dt, y, "L2_" + dt + "HER2_y_n1", fo);
805        writeMatrixWithIncrements(dt, y, "L2_" + dt + "HER2_y_n2", 2, fo);
806
807        d = alpha * x * y.H + y * (alpha * x.H) + a;
808        writeMatrix(dt, d, "L2_" + dt + "HER2_o_N", fo);
809        writePackedMatrix(dt, d, "L2_" + dt + "HER2_o_N_pu", fo);
810
811def L2_xSYR(fo, alpha, n):
812    dataType = ['s', 'd'];
813    for dt in dataType:
814        a = matrixCreate(dt, n, n);
815        writeMatrix(dt, a, "L2_" + dt + "SYR_A_nn", fo);
816        writePackedMatrix(dt, a, "L2_" + dt + "SYR_A_nn_pu", fo);
817
818        x = matrixCreate(dt, n, 1);
819        writeMatrix(dt, x, "L2_" + dt + "SYR_x_n1", fo);
820        writeMatrixWithIncrements(dt, x, "L2_" + dt + "SYR_x_n2", 1, fo);
821
822        d = alpha * x * x.T + a;
823        writeMatrix(dt, d, "L2_" + dt + "SYR_o_N", fo);
824        writePackedMatrix(dt, d, "L2_" + dt + "SYR_o_N_pu", fo);
825
826def L2_xSYR2(fo, alpha, n):
827    dataType = ['s', 'd'];
828    for dt in dataType:
829        a = matrixCreate(dt, n, n);
830        writeMatrix(dt, a, "L2_" + dt + "SYR2_A_nn", fo);
831        writePackedMatrix(dt, a, "L2_" + dt + "SYR2_A_nn_pu", fo);
832
833        x = matrixCreate(dt, n, 1);
834        writeMatrix(dt, x, "L2_" + dt + "SYR2_x_n1", fo);
835        writeMatrixWithIncrements(dt, x, "L2_" + dt + "SYR2_x_n2", 1, fo);
836
837        y = matrixCreate(dt, n, 1);
838        writeMatrix(dt, y, "L2_" + dt + "SYR2_y_n1", fo);
839        writeMatrixWithIncrements(dt, y, "L2_" + dt + "SYR2_y_n2", 2, fo);
840
841        d = alpha * x * y.T + y * (alpha * x.T) + a;
842        writeMatrix(dt, d, "L2_" + dt + "SYR2_o_N", fo);
843        writePackedMatrix(dt, d, "L2_" + dt + "SYR2_o_N_pu", fo);
844
845
846def testBLASL2L3(fo):
847    m = random.randint(10, 20);
848    n = random.randint(10, 20);
849    k = random.randint(10, 20);
850    kl = random.randint(1, 5);
851    ku = random.randint(1, 5);
852
853    alpha = 1.0;
854    beta = 1.0;
855
856    fo.write("M, N, K, KL, KU" + ';\n');
857    fo.write(str(m) + " " + str(n) + " " + str(k) + " " + str(kl) + " " + str(ku) + '\n');
858    fo.write('\n');
859
860    L2_xGEMV(fo, alpha, beta, m, n);
861    L2_xGBMV(fo, alpha, beta, m, n, kl, ku);
862    L2_xHEMV(fo, alpha, beta, n);
863    L2_xHBMV(fo, alpha, beta, n, kl);
864    L2_xSYMV(fo, alpha, beta, n);
865    L2_xSBMV(fo, alpha, beta, n, kl);
866    L2_xTRMV(fo, n);
867    L2_xTBMV(fo, n, kl);
868    L2_xTRSV(fo, n);
869    L2_xTBSV(fo, n, kl);
870    L2_xGER(fo, alpha, m, n);
871    L2_xGERU(fo, alpha, m, n);
872    L2_xGERC(fo, alpha, m, n);
873    L2_xHER(fo, alpha, n);
874    L2_xHER2(fo, alpha, n);
875    L2_xSYR(fo, alpha, n);
876    L2_xSYR2(fo, alpha, n);
877
878    L3_xGEMM(fo, alpha, beta, m, n, k);
879    L3_xSYMM(fo, alpha, beta, m, n);
880    L3_xHEMM(fo, alpha, beta, m, n);
881    L3_xSYRK(fo, alpha, beta, n, k);
882    L3_xHERK(fo, alpha, beta, n, k);
883    L3_xSYR2K(fo, alpha, beta, n, k);
884    L3_xHER2K(fo, alpha, beta, n, k);
885    L3_xTRMM(fo, alpha, m, n);
886    L3_xTRSM(fo, alpha, m, n);
887
888    return;
889
890def javaDataGen():
891    fo = open("BLASData.txt", "w+")
892    fo.write("/* Don't edit this file!  It is auto-generated by blas_gen.py. */\n");
893    fo.write("\n");
894
895    #data body
896    testBLASL2L3(fo);
897    fo.close()
898    return;
899
900javaDataGen();
901
902