__pragma__('opov')
sp = a - a
__pragma__('noopov')
timeStartEig = __new__(Date())
if useComplex:
evals, evecs = linalg.eig(a[:10, :10])
timeEnd = __new__(Date())
result += ('''
<pre>
a @ ai [0:5, 0:5] =
{}
''').format(str(num.round(id[0:5, 0:5], 2)).replace(' ', '\t'), )
if transpose:
result += ('''
Transpose took: {} ms''').format(timeStartInv - timeStartTranspose)
result += ('''
Inverse took: {} ms
Matrix product (@) took: {} ms
Elementwise product (*) took: {} ms
Division took: {} ms
Addition took: {} ms
Subtraction took: {} ms
Eigenvals/vecs took: {} ms
</pre>
''').format(timeStartMul - timeStartInv, timeStartScalp - timeStartMul,
def run(autoTester):
autoTester.check('====== inverse ======')
# Real
r = num.array([[2.12, -2.11, -1.23], [2.31, 1.14, 3.15],
[1.13, 1.98, 2.81]])
autoTester.check('Matrix r', num.round(r, 2).tolist(), '<br>')
ri = linalg.inv(r)
autoTester.check('Matrix ri', num.round(ri, 2).tolist(), '<br>')
__pragma__('opov')
rid = r @ ri
__pragma__('noopov')
autoTester.check('r @ ri', [[int(round(elem)) for elem in row]
for row in rid.tolist()], '<br>')
__pragma__('opov')
delta = 0.001
autoTester.check('r * r', num.round(r * r + delta, 3).tolist(), '<br>')
autoTester.check('r / r', num.round(r / r + delta, 3).tolist(), '<br>')
autoTester.check('r + r', num.round(r + r + delta, 3).tolist(), '<br>')
autoTester.check('r - r', num.round(r - r + delta, 3).tolist(), '<br>')
__pragma__('noopov')
# Complex
__pragma__('opov')
c = num.array([[2.12 - 3.15j, -2.11, -1.23], [2.31, 1.14, 3.15 + 2.75j],
[1.13, 1.98 - 4.33j, 2.81]], 'complex128')
__pragma__('noopov')
autoTester.check('Matrix c', num.round(c, 2).tolist(), '<br>')
ci = linalg.inv(c)
autoTester.check('Matrix ci', num.round(ci, 2).tolist(), '<br>')
__pragma__('opov')
cid = c @ ci
__pragma__('noopov')
# autoTester.check ('c @ ci', [['{} + j{}'.format (int (round (elem.real)), int (round (elem.imag))) for elem in row] for row in cid.tolist ()], '<br>')
__pragma__('opov')
delta = 0.001 + 0.001j
autoTester.check('c * c', num.round(c * c + delta, 3).tolist(), '<br>')
autoTester.check('c / c', num.round(c / c + delta, 3).tolist(), '<br>')
autoTester.check('c + c', num.round(c + c + delta, 3).tolist(), '<br>')
autoTester.check('c - c', num.round(c - c + delta, 3).tolist(), '<br>')
__pragma__('noopov')
autoTester.check('====== eigen ======')
__pragma__('opov')
for a in (
num.array([[0, 1j], [-1j, 1]], 'complex128'),
num.array(
[[1, -2, 3, 1], [5, 8, -1, -5], [2, 1, 1, 100], [2, 1, -1, 0]],
'complex128'),
):
eVals, eVecs = linalg.eig(a)
enumSorted = sorted(
enumerate(eVals.tolist()),
key=lambda elem: -(
elem[1].real + elem[1].imag / 1000
) # Order on primarily on real, secundarily on imag, note conjugate vals
)
indicesSorted = [elem[0] for elem in enumSorted]
eValsSorted = [elem[1] for elem in enumSorted]
eValsMat = num.empty(a.shape, a.dtype)
for iRow in range(a.shape[0]):
for iCol in range(a.shape[1]):
eValsMat[iRow, iCol] = eVals[iCol]
eVecsNorms = num.empty((eVecs.shape[1], ), a.dtype)
for iNorm in range(eVecsNorms.shape[0]):
eVecsNorms[iNorm] = complex(linalg.norm(eVecs[:, iNorm]))
eVecsCanon = num.empty(a.shape, a.dtype)
for iRow in range(a.shape[0]):
for iCol in range(a.shape[1]):
eVecsCanon[iRow, iCol] = eVecs[iRow, iCol] / eVecs[0, iCol]
eVecsSorted = num.empty(a.shape, a.dtype)
for iRow in range(a.shape[0]):
for iCol in range(a.shape[1]):
eVecsSorted[iRow, iCol] = eVecsCanon[iRow, indicesSorted[iCol]]
'''
autoTester.check ('\n---------------- a ----------------------')
autoTester.check (a)
autoTester.check ('\n---------------- eigVals ----------------')
autoTester.check (eVals)
autoTester.check ('\n---------------- eigValsMat--------------')
autoTester.check (eValsMat)
autoTester.check ('\n---------------- eigVecs ----------------')
autoTester.check (eVecs)
autoTester.check ('\n---------------- eigValsMat @ eigVecs ---')
autoTester.check (eValsMat * eVecs)
autoTester.check ('\n---------------- a @ eigVecs-------------')
autoTester.check (a @ eVecs)
autoTester.check ('\n---------------- eigVecsNorms -----------')
autoTester.check (eVecsNorms)
autoTester.check ('\n---------------- eigVecsCanon -----------')
autoTester.check (eVecsCanon)
'''
autoTester.check('\n---------------- eigVecsSorted ----------')
autoTester.check([[(round(value.real + 1e-3,
3), round(value.imag + 1e-3, 3))
for value in row] for row in eVecsSorted.tolist()])
autoTester.check('\n---------------- eigValsSorted ----------')
autoTester.check(
[(round(value.real + 1e-3, 3), round(value.imag + 1e-3, 3))
for value in eValsSorted], '\n')
def run (autoTester):
z = num.zeros ((4, 3), 'int32')
autoTester.check ('Zeros', z.tolist (), '<br>')
o = num.ones ((4, 5))
autoTester.check ('Ones', o.astype ('int32') .tolist ())
i = num.identity (3, 'int32')
autoTester.check ('Identity', i.tolist (), '<br>')
a = num.array ([
[1, 1, 2, 3],
[4, 5, 6, 7],
[8, 9, 10, 12]
])
autoTester.check ('Matrix a', a.tolist (), '<br>')
autoTester.check ('Transpose of a', a.transpose () .tolist (), '<br>')
b = num.array ([
[2, 2, 4, 6],
[8, 10, 12, 14],
[16, 18, 20, 24]
])
bp = b.transpose ()
autoTester.check ('Matrix b', b.tolist (), '<br>')
autoTester.check ('Permutation of b', bp.tolist (), '<br>')
c = num.array ([
[1, 2, 3, 4],
[5, 6, 7, 8],
[9, 10, 11, 12],
], 'int32')
autoTester.check ('Shape c', tuple (c.shape), '<br>')
autoTester.check ('Matrix c', c.tolist (), '<br>')
ct = c.transpose ()
autoTester.check ('Shape ct', tuple (ct.shape), '<br>')
autoTester.check ('Transpose of c', ct .tolist (), '<br>')
cs0, cs1 = num.hsplit (c, 2)
autoTester.check ('Matrix cs0', cs0.tolist (), '<br>')
autoTester.check ('Matrix cs1', cs1.tolist (), '<br>')
ci = num.hstack ((cs1, cs0))
autoTester.check ('Matrix ci', ci.tolist (), '<br>')
cts0, cts1, cts2 = num.hsplit (ct, 3)
autoTester.check ('Matrix cts0', cts0.tolist (), '<br>')
autoTester.check ('Matrix cts1', cts1.tolist (), '<br>')
autoTester.check ('Matrix cts2', cts2.tolist (), '<br>')
cti = num.hstack ((cts2, cts1, cts0))
autoTester.check ('Matrix ci', cti.tolist (), '<br>')
d = num.array ([
[13, 14],
[15, 16],
[17, 18],
[19, 20]
], 'int32')
autoTester.check ('Matrix d', d.tolist (), '<br>')
dt = d.transpose ()
autoTester.check ('Permutation of d', dt.tolist (), '<br>')
ds0, ds1, ds2, ds3 = num.vsplit (d, 4)
autoTester.check ('Matrix ds0', ds0.tolist (), '<br>')
autoTester.check ('Matrix ds1', ds1.tolist (), '<br>')
autoTester.check ('Matrix ds2', ds2.tolist (), '<br>')
autoTester.check ('Matrix ds3', ds3.tolist (), '<br>')
di = num.vstack ((ds3, ds2, ds1, ds0))
autoTester.check ('Matrix di', di.tolist (), '<br>')
dts0, dts1 = num.vsplit (dt, 2)
autoTester.check ('Matrix dts0', dts0.tolist (), '<br>')
autoTester.check ('Matrix dts1', dts1.tolist (), '<br>')
dti = num.vstack ((dts1, dts0))
autoTester.check ('Matrix dti', dti.tolist (), '<br>')
v0 = num.array (range (10))
v1 = num.array ((1, 2, 3, 1, 2, 3, 1, 2, 3, 1))
__pragma__ ('opov')
a [1, 0] = 177
el = b [1, 2]
bsl0 = b [1, 1 : 3]
bsl1 = b [1 : 2, 1 : 3]
bsl2 = b [1 : 2, 1]
bsl3 = b [1, 1 : 3]
bsl4 = b [ : , 1]
bsl5 = b [1, 1 : 3]
bsl6 = b [1, 1 : 3]
bsl7 = b [1, 2 : 3]
bpsl0 = bp [1, 1 : 3]
bpsl1 = bp [1 : 2, 1 : 3]
bpsl2 = bp [1, 0 : ]
bpsl3 = bp [1, 1 : 3]
bpsl4 = bp [ : , 1]
bpsl5 = bp [3, 1 : 3]
bpsl6 = bp [2 : 4, 1 : 3]
bpsl7 = bp [2 : 4, 2 : 3]
sum = a + b
dif = a - b
prod = a * b
quot = a / b
dot = c @ d
vsum = v0 + v1
vel = vsum [6]
vsum [6] = 70
mul_a3 = a * 3
mul_3a = 3 * a
div_a3 = a / 3.1234567
div_3a = 3.1234567 / a
add_a3 = a + 3
add_3a = 3 + a
sub_a3 = a - 3
sub_3a = 3 - a
neg_a = -a
__pragma__ ('noopov')
autoTester.check ('El a [1, 2, 3] alt', a.tolist (), '<br>')
autoTester.check ('El b [1, 2, 3]', el, '<br>')
autoTester.check ('Sl b0', bsl0.tolist (), '<br>')
autoTester.check ('Sl b1', bsl1.tolist (), '<br>')
autoTester.check ('Sl b2', bsl2.tolist (), '<br>')
autoTester.check ('Sl b3', bsl3.tolist (), '<br>')
autoTester.check ('Sl b4', bsl4.tolist (), '<br>')
autoTester.check ('Sl b5', bsl5.tolist (), '<br>')
autoTester.check ('Sl b6', bsl6.tolist (), '<br>')
autoTester.check ('Sl b7', bsl7.tolist (), '<br>')
autoTester.check ('Sl bp0', bpsl0.tolist (), '<br>')
autoTester.check ('Sl bp1', bpsl1.tolist (), '<br>')
autoTester.check ('Sl bp2', bpsl2.tolist (), '<br>')
autoTester.check ('Sl bp3', bpsl3.tolist (), '<br>')
autoTester.check ('Sl bp4', bpsl4.tolist (), '<br>')
autoTester.check ('Sl bp5', bpsl5.tolist (), '<br>')
autoTester.check ('Sl bp6', bpsl6.tolist (), '<br>')
autoTester.check ('Sl bp7', bpsl7.tolist (), '<br>')
autoTester.check ('Matrix sum', sum.tolist (), '<br>')
autoTester.check ('Matrix difference', dif.tolist (), '<br>')
autoTester.check ('Matrix product', prod.tolist (), '<br>')
autoTester.check ('Matrix quotient', quot.tolist (), '<br>')
autoTester.check ('Matrix dotproduct', dot.tolist (), '<br>')
autoTester.check ('Vector', v0.tolist (), '<br>')
autoTester.check ('Vector', v1.tolist (), '<br>')
autoTester.check ('El sum old', vel, '<br>')
autoTester.check ('Vector sum new', vsum.tolist (), '<br>')
autoTester.check ('mul_a3', mul_a3.tolist (), '<br>')
autoTester.check ('mul_3a', mul_3a.tolist (), '<br>')
autoTester.check ('div_a3', num.round (div_a3, 2).tolist (), '<br>')
autoTester.check ('div_3a', num.round (div_3a, 2).tolist (), '<br>')
autoTester.check ('add_a3', add_a3.tolist (), '<br>')
autoTester.check ('add_3a', add_3a.tolist (), '<br>')
autoTester.check ('sub_a3', sub_a3.tolist (), '<br>')
autoTester.check ('sub_3a', sub_3a.tolist (), '<br>')
autoTester.check ('neg_a', neg_a.tolist (), '<br>')
__pragma__ ('opov')
comp_a = num.array ([
[1 + 2j, 2 - 1j, 3],
[4, 5 + 3j, 7]
], 'complex128')
comp_b = num.array ([
[6, 8 - 1j],
[9 + 3j, 10],
[11, 12 - 6j]
], 'complex128')
comp_c = comp_a @ comp_b
__pragma__ ('noopov')
autoTester.check ('comp_a', comp_a.tolist (), '<br>')
autoTester.check ('comp_b', comp_b.tolist (), '<br>')
autoTester.check ('comp_c', comp_c.tolist (), '<br>')
__pragma__ ('opov')
comp_a_square = comp_a [ : , : 2]
comp_b_square = comp_b [1 : , : ]
comp_c_square = comp_a_square * comp_b_square
comp_d_square = comp_a_square / comp_b_square
comp_e_square = comp_a_square + comp_b_square
comp_f_square = comp_a_square - comp_b_square
__pragma__ ('noopov')
autoTester.check ('comp_a_square', comp_a_square.tolist (), '<br>')
autoTester.check ('comp_b_square', comp_b_square.tolist (), '<br>')
autoTester.check ('comp_c_square', comp_c_square.tolist (), '<br>')
autoTester.check ('comp_d_square', num.round (comp_d_square, 2).tolist (), '<br>')
autoTester.check ('comp_e_square', comp_e_square.tolist (), '<br>')
autoTester.check ('comp_f_square', comp_f_square.tolist (), '<br>')
__pragma__ ('opov')
sliceable_a = num.array ([
[1, 2, 3, 4],
[5, 6, 7, 8],
[9, 10, 11, 12],
[13, 14, 15, 16]
])
autoTester.check ('sliceable_a', sliceable_a.tolist ())
slice_a = sliceable_a [1 : , 1 : ]
autoTester.check ('slice_a')
sliceable_at = sliceable_a.transpose ()
slice_at = sliceable_at [1 : ]
__pragma__ ('noopov')
def run (autoTester):
autoTester.check ('====== inverse ======')
# Real
r = num.array ([
[2.12, -2.11, -1.23],
[2.31, 1.14, 3.15],
[1.13, 1.98, 2.81]
])
autoTester.check ('Matrix r', num.round (r, 2) .tolist (), '<br>')
ri = linalg.inv (r)
autoTester.check ('Matrix ri', num.round (ri, 2) .tolist (), '<br>')
__pragma__ ('opov')
rid = r @ ri
__pragma__ ('noopov')
autoTester.check ('r @ ri', [[int (round (elem)) for elem in row] for row in rid.tolist ()], '<br>')
__pragma__ ('opov')
delta = 0.001
autoTester.check ('r * r', num.round (r * r + delta, 3) .tolist (), '<br>')
autoTester.check ('r / r', num.round (r / r + delta, 3) .tolist (), '<br>')
autoTester.check ('r + r', num.round (r + r + delta, 3) .tolist (), '<br>')
autoTester.check ('r - r', num.round (r - r + delta, 3) .tolist (), '<br>')
__pragma__ ('noopov')
# Complex
__pragma__ ('opov')
c = num.array ([
[2.12 - 3.15j, -2.11, -1.23],
[2.31, 1.14, 3.15 + 2.75j],
[1.13, 1.98 - 4.33j, 2.81]
], 'complex128')
__pragma__ ('noopov')
autoTester.check ('Matrix c', num.round (c, 2) .tolist (), '<br>')
ci = linalg.inv (c)
autoTester.check ('Matrix ci', num.round (ci, 2) .tolist (), '<br>')
__pragma__ ('opov')
cid = c @ ci
__pragma__ ('noopov')
# autoTester.check ('c @ ci', [['{} + j{}'.format (int (round (elem.real)), int (round (elem.imag))) for elem in row] for row in cid.tolist ()], '<br>')
__pragma__ ('opov')
delta = 0.001 + 0.001j
autoTester.check ('c * c', num.round (c * c + delta , 3) .tolist (), '<br>')
autoTester.check ('c / c', num.round (c / c + delta, 3) .tolist (), '<br>')
autoTester.check ('c + c', num.round (c + c + delta, 3) .tolist (), '<br>')
autoTester.check ('c - c', num.round (c - c + delta, 3) .tolist (), '<br>')
__pragma__ ('noopov')
autoTester.check ('====== eigen ======')
__pragma__ ('opov')
for a in (
num.array ([
[0, 1j],
[-1j, 1]
], 'complex128'),
num.array ([
[1, -2, 3, 1],
[5, 8, -1, -5],
[2, 1, 1, 100],
[2, 1, -1, 0]
], 'complex128'),
):
eVals, eVecs = linalg.eig (a)
enumSorted = sorted (
enumerate (eVals.tolist ()),
key = lambda elem: -(elem [1].real + elem [1].imag / 1000) # Order on primarily on real, secundarily on imag, note conjugate vals
)
indicesSorted = [elem [0] for elem in enumSorted]
eValsSorted = [elem [1] for elem in enumSorted]
eValsMat = num.empty (a.shape, a.dtype)
for iRow in range (a.shape [0]):
for iCol in range (a.shape [1]):
eValsMat [iRow, iCol] = eVals [iCol]
eVecsNorms = num.empty ((eVecs.shape [1], ), a.dtype)
for iNorm in range (eVecsNorms.shape [0]):
eVecsNorms [iNorm] = complex (linalg.norm (eVecs [:, iNorm]))
eVecsCanon = num.empty (a.shape, a.dtype)
for iRow in range (a.shape [0]):
for iCol in range (a.shape [1]):
eVecsCanon [iRow, iCol] = eVecs [iRow, iCol] / eVecs [0, iCol]
eVecsSorted = num.empty (a.shape, a.dtype)
for iRow in range (a.shape [0]):
for iCol in range (a.shape [1]):
eVecsSorted [iRow, iCol] = eVecsCanon [iRow, indicesSorted [iCol]]
'''
autoTester.check ('\n---------------- a ----------------------')
autoTester.check (a)
autoTester.check ('\n---------------- eigVals ----------------')
autoTester.check (eVals)
autoTester.check ('\n---------------- eigValsMat--------------')
autoTester.check (eValsMat)
autoTester.check ('\n---------------- eigVecs ----------------')
autoTester.check (eVecs)
autoTester.check ('\n---------------- eigValsMat @ eigVecs ---')
autoTester.check (eValsMat * eVecs)
autoTester.check ('\n---------------- a @ eigVecs-------------')
autoTester.check (a @ eVecs)
autoTester.check ('\n---------------- eigVecsNorms -----------')
autoTester.check (eVecsNorms)
autoTester.check ('\n---------------- eigVecsCanon -----------')
autoTester.check (eVecsCanon)
'''
autoTester.check ('\n---------------- eigVecsSorted ----------')
autoTester.check ([[(round (value.real + 1e-3, 3), round (value.imag + 1e-3, 3)) for value in row] for row in eVecsSorted.tolist ()])
autoTester.check ('\n---------------- eigValsSorted ----------')
autoTester.check ([(round (value.real + 1e-3, 3), round (value.imag + 1e-3, 3)) for value in eValsSorted], '\n')
timeStartSub = __new__ (Date ())
__pragma__ ('opov')
sp = a - a
__pragma__ ('noopov')
timeEnd = __new__ (Date ())
result += (
'''
<pre>
a @ ai [0:5, 0:5] =
{}
'''
) .format (
str (num.round (id [0:5, 0:5], 2)) .replace (' ', '\t'),
)
if transpose:
result += (
'''
Transpose took: {} ms'''
).format (
timeStartInv - timeStartTranspose
)
result += (
'''
Inverse took: {} ms
Matrix product (@) took: {} ms
Elementwise product (*) took: {} ms
def run (autoTester):
__pragma__ ('opov')
delta = 0.001 + 0.001j
__pragma__ ('noopov')
autoTester.check ('<br>------ 1D ------<br>')
cut = 102
autoTester.check ('Samples computed: {}<br>'.format (tTotal * fSample))
autoTester.check ('Samples shown: {}<br>'.format (cut))
orig = num.array ([
complex (0.3 + sin (2 * pi * fSin * t) + 0.5 * cos (2 * pi * fCos * t), 0)
for t in [
iSample / fSample
for iSample in range (tTotal * fSample)
]
], 'complex128')
__pragma__ ('opov')
autoTester.check ('Original samples', num.round (orig + delta, 3) .tolist ()[ : cut], '<br>')
if transpiled:
timeStartFft = getNow ()
freqs = fft.fft (orig)
if transpiled:
timeStopFft = getNow ()
autoTester.check ('Frequencies', num.round (freqs + delta, 3) .tolist ()[ : cut], '<br>')
if transpiled:
timeStartIfft = getNow ()
reconstr = fft.ifft (freqs)
if transpiled:
timeStopIfft = getNow ()
autoTester.check ('Reconstructed samples', num.round (reconstr + delta, 3) .tolist ()[ : cut], '<br>')
__pragma__ ('noopov')
if transpiled:
print ('FFT for {} samples took {} ms'.format (tTotal * fSample, timeStopFft - timeStartFft))
print ('IFFT for {} samples took {} ms'.format (tTotal * fSample, timeStopIfft - timeStartIfft))
autoTester.check ('<br>------ 2D ------<br>')
__pragma__ ('opov')
orig2 = num.zeros ((128, 128), 'complex128')
orig2 [32 : 96, 32 : 96] = num.ones ((64, 64), 'complex128')
autoTester.check ('Original samples', num.round (orig2 + delta, 3) [64 : 68, 16 : 112] .tolist (), '<br>')
if transpiled:
timeStartFft = getNow ()
freqs2 = fft.fft2 (orig2)
if transpiled:
timeStopFft = getNow ()
autoTester.check ('Frequencies', num.round (freqs2 + delta, 3) [64 : 68, 16 : 112] .tolist (), '<br>')
if transpiled:
timeStartIfft = getNow ()
reconstr2 = fft.ifft2 (freqs2)
if transpiled:
timeStopIfft = getNow ()
if transpiled:
print ('FFT2 for {} samples took {} ms'.format (orig2.size, timeStopFft - timeStartFft))
print ('IFFT2 for {} samples took {} ms'.format (orig2.size, timeStopIfft - timeStartIfft))
autoTester.check ('Reconstructed samples', num.round (reconstr2 + delta, 3) [64 : 68, 16 : 112] .tolist (), '<br>')
__pragma__ ('noopov')
def run (autoTester):
z = num.zeros ((4, 3, 2), 'int32')
autoTester.check ('Zeros', z.tolist (), '<br>')
o = num.ones ((1, 2, 3))
autoTester.check ('Ones', o.astype ('int32') .tolist ())
i = num.identity (3, 'int32')
autoTester.check ('Identity', i.tolist (), '<br>')
# shape: 2 blocks x 3 rows x 4 columns
a = num.array ([
[
[1, 1, 2, 3],
[4, 5, 6, 7],
[8, 9, 10, 12]
], [
[100, 101, 102, 103],
[104, 105, 106, 107],
[108, 109, 110, 112]
]
])
# print (a)
autoTester.check ('Matrix a', a.tolist (), '<br>')
autoTester.check ('Transpose of a', a.transpose () .tolist (), '<br>')
b = num.array ([
[
[2, 2, 4, 6],
[8, 10, 12, 14],
[16, 18, 20, 24]
], [
[200, 202, 204, 206],
[208, 210, 212, 214],
[216, 218, 220, 224]
]
])
bp = b.transpose ((2, 1, 0))
autoTester.check ('Matrix b', b.tolist (), '<br>')
autoTester.check ('Permutation of b', bp.tolist (), '<br>')
c = num.array ([
[1, 2, 3, 4],
[5, 6, 7, 8],
[9, 10, 11, 12],
], 'int32')
autoTester.check ('Shape strides c', tuple (c.shape), tuple (c.strides), '<br>')
autoTester.check ('Matrix c', c.tolist (), '<br>')
ct = c.transpose ()
autoTester.check ('Shape strids ct', tuple (ct.shape), tuple (ct.strides), '<br>')
autoTester.check ('Transpose of c', ct .tolist (), '<br>')
cs0, cs1 = num.hsplit (c, 2)
autoTester.check ('Matrix cs0', cs0.tolist (), '<br>')
autoTester.check ('Matrix cs1', cs1.tolist (), '<br>')
ci = num.hstack ((cs1, cs0))
autoTester.check ('Matrix ci', ci.tolist (), '<br>')
cts0, cts1, cts2 = num.hsplit (ct, 3)
autoTester.check ('Matrix cts0', cts0.tolist (), '<br>')
autoTester.check ('Matrix cts1', cts1.tolist (), '<br>')
autoTester.check ('Matrix cts2', cts2.tolist (), '<br>')
cti = num.hstack ((cts2, cts1, cts0))
autoTester.check ('Matrix ci', cti.tolist (), '<br>')
d = num.array ([
[13, 14],
[15, 16],
[17, 18],
[19, 20]
], 'int32')
autoTester.check ('Matrix d', d.tolist (), '<br>')
dt = d.transpose ()
autoTester.check ('Permutation of d', dt.tolist (), '<br>')
ds0, ds1, ds2, ds3 = num.vsplit (d, 4)
autoTester.check ('Matrix ds0', ds0.tolist (), '<br>')
autoTester.check ('Matrix ds1', ds1.tolist (), '<br>')
autoTester.check ('Matrix ds2', ds2.tolist (), '<br>')
autoTester.check ('Matrix ds3', ds3.tolist (), '<br>')
di = num.vstack ((ds3, ds2, ds1, ds0))
autoTester.check ('Matrix di', di.tolist (), '<br>')
dts0, dts1 = num.vsplit (dt, 2)
autoTester.check ('Matrix dts0', dts0.tolist (), '<br>')
autoTester.check ('Matrix dts1', dts1.tolist (), '<br>')
dti = num.vstack ((dts1, dts0))
autoTester.check ('Matrix dti', dti.tolist (), '<br>')
v0 = num.array (range (10))
v1 = num.array ((1, 2, 3, 1, 2, 3, 1, 2, 3, 1))
__pragma__ ('opov')
a [1, 0, 2] = 177
el = b [1, 2, 3]
bsl0 = b [1, 1 : 3, : ]
bsl1 = b [1 : 2, 1 : 3, :]
bsl2 = b [1, 1, :]
bsl3 = b [1, 1 : 3, 1]
bsl4 = b [ : , 1, 1]
bsl5 = b [1, 1 : 3, :]
bsl6 = b [1, 1 : 3, 1 : 4]
bsl7 = b [1, 2 : 3, 2 : 4]
bpsl0 = bp [1, 1 : 3, : ]
bpsl1 = bp [1 : 2, 1 : 3, :]
bpsl2 = bp [1, 1, :]
bpsl3 = bp [1, 1 : 3, 1]
bpsl4 = bp [ : , 1, 1]
bpsl5 = bp [3, 1 : 3, :]
bpsl6 = bp [2 : 4, 1 : 3, 0 : 1]
bpsl7 = bp [2 : 4, 2 : 3, 1 : 2]
sum = a + b
dif = a - b
prod = a * b
quot = a / b
dot = c @ d
vsum = v0 + v1
vel = vsum [6]
vsum [6] = 70
mul_a3 = a * 3
mul_3a = 3 * a
div_a3 = a / 3.1234567
div_3a = 3.1234567 / a
add_a3 = a + 3
add_3a = 3 + a
sub_a3 = a - 3
sub_3a = 3 - a
neg_a = -a
__pragma__ ('noopov')
autoTester.check ('El a [1, 2, 3] alt', a.tolist (), '<br>')
autoTester.check ('El b [1, 2, 3]', el, '<br>')
autoTester.check ('Sl b0', bsl0.tolist (), '<br>')
autoTester.check ('Sl b1', bsl1.tolist (), '<br>')
autoTester.check ('Sl b2', bsl2.tolist (), '<br>')
autoTester.check ('Sl b3', bsl3.tolist (), '<br>')
autoTester.check ('Sl b4', bsl4.tolist (), '<br>')
autoTester.check ('Sl b5', bsl5.tolist (), '<br>')
autoTester.check ('Sl b6', bsl6.tolist (), '<br>')
autoTester.check ('Sl b7', bsl7.tolist (), '<br>')
autoTester.check ('Sl bp0', bpsl0.tolist (), '<br>')
autoTester.check ('Sl bp1', bpsl1.tolist (), '<br>')
autoTester.check ('Sl bp2', bpsl2.tolist (), '<br>')
autoTester.check ('Sl bp3', bpsl3.tolist (), '<br>')
autoTester.check ('Sl bp4', bpsl4.tolist (), '<br>')
autoTester.check ('Sl bp5', bpsl5.tolist (), '<br>')
autoTester.check ('Sl bp6', bpsl6.tolist (), '<br>')
autoTester.check ('Sl bp7', bpsl7.tolist (), '<br>')
autoTester.check ('Matrix sum', sum.tolist (), '<br>')
autoTester.check ('Matrix difference', dif.tolist (), '<br>')
autoTester.check ('Matrix product', prod.tolist (), '<br>')
autoTester.check ('Matrix quotient', quot.tolist (), '<br>')
autoTester.check ('Matrix dotproduct', dot.tolist (), '<br>')
autoTester.check ('Vector', v0.tolist (), '<br>')
autoTester.check ('Vector', v1.tolist (), '<br>')
autoTester.check ('El sum old', vel, '<br>')
autoTester.check ('Vector sum new', vsum.tolist (), '<br>')
autoTester.check ('mul_a3', mul_a3.tolist (), '<br>')
autoTester.check ('mul_3a', mul_3a.tolist (), '<br>')
autoTester.check ('div_a3', num.round (div_a3, 2).tolist (), '<br>')
autoTester.check ('div_3a', num.round (div_3a, 2).tolist (), '<br>')
autoTester.check ('add_a3', add_a3.tolist (), '<br>')
autoTester.check ('add_3a', add_3a.tolist (), '<br>')
autoTester.check ('sub_a3', sub_a3.tolist (), '<br>')
autoTester.check ('sub_3a', sub_3a.tolist (), '<br>')
autoTester.check ('neg_a', neg_a.tolist (), '<br>')
def run(autoTester):
__pragma__('opov')
delta = 0.001 + 0.001j
__pragma__('noopov')
autoTester.check('<br>------ 1D ------<br>')
cut = 102
autoTester.check('Samples computed: {}<br>'.format(tTotal * fSample))
autoTester.check('Samples shown: {}<br>'.format(cut))
orig = num.array([
complex(0.3 + sin(2 * pi * fSin * t) + 0.5 * cos(2 * pi * fCos * t), 0)
for t in [iSample / fSample for iSample in range(tTotal * fSample)]
], 'complex128')
__pragma__('opov')
autoTester.check('Original samples',
num.round(orig + delta, 3).tolist()[:cut], '<br>')
if transpiled:
timeStartFft = getNow()
freqs = fft.fft(orig)
if transpiled:
timeStopFft = getNow()
autoTester.check('Frequencies',
num.round(freqs + delta, 3).tolist()[:cut], '<br>')
if transpiled:
timeStartIfft = getNow()
reconstr = fft.ifft(freqs)
if transpiled:
timeStopIfft = getNow()
autoTester.check('Reconstructed samples',
num.round(reconstr + delta, 3).tolist()[:cut], '<br>')
__pragma__('noopov')
if transpiled:
print('FFT for {} samples took {} ms'.format(
tTotal * fSample, timeStopFft - timeStartFft))
print('IFFT for {} samples took {} ms'.format(
tTotal * fSample, timeStopIfft - timeStartIfft))
autoTester.check('<br>------ 2D ------<br>')
__pragma__('opov')
orig2 = num.zeros((128, 128), 'complex128')
orig2[32:96, 32:96] = num.ones((64, 64), 'complex128')
autoTester.check('Original samples',
num.round(orig2 + delta, 3)[64:68, 16:112].tolist(),
'<br>')
if transpiled:
timeStartFft = getNow()
freqs2 = fft.fft2(orig2)
if transpiled:
timeStopFft = getNow()
autoTester.check('Frequencies',
num.round(freqs2 + delta, 3)[64:68, 16:112].tolist(),
'<br>')
if transpiled:
timeStartIfft = getNow()
reconstr2 = fft.ifft2(freqs2)
if transpiled:
timeStopIfft = getNow()
if transpiled:
print('FFT2 for {} samples took {} ms'.format(
orig2.size, timeStopFft - timeStartFft))
print('IFFT2 for {} samples took {} ms'.format(
orig2.size, timeStopIfft - timeStartIfft))
autoTester.check('Reconstructed samples',
num.round(reconstr2 + delta, 3)[64:68, 16:112].tolist(),
'<br>')
__pragma__('noopov')
timeStartInv = __new__ (Date ())
ai = linalg.inv (a)
timeStartMul = __new__ (Date ())
__pragma__ ('opov')
id = a @ ai
__pragma__ ('noopov')
timeEnd = __new__ (Date ())
result += '''<pre>
Optimized for space instead of time: {}
{}: a @ ai [0:5, 0:5] =
{}
Transpose took: {} ms
Inverse took: {} ms
Product took: {} ms
</pre>'''.format (
optim_space,
'natural' if a.ns_natural else 'unnatural',
str (ns.round (id [0:5, 0:5], 2)) .replace (' ', '\t'),
timeStartInv - timeStartTranspose,
timeStartMul - timeStartInv,
timeEnd - timeStartMul
)
document.getElementById ('result') .innerHTML = result
def run(autoTester):
# Real
r = num.array([[2.12, -2.11, -1.23], [2.31, 1.14, 3.15],
[1.13, 1.98, 2.81]])
autoTester.check('Matrix r', num.round(r, 2).tolist(), '<br>')
ri = linalg.inv(r)
autoTester.check('Matrix ri', num.round(ri, 2).tolist(), '<br>')
__pragma__('opov')
rid = r @ ri
__pragma__('noopov')
autoTester.check('r @ ri', [[int(round(elem)) for elem in row]
for row in rid.tolist()], '<br>')
__pragma__('opov')
delta = 0.001
autoTester.check('r * r', num.round(r * r + delta, 3).tolist(), '<br>')
autoTester.check('r / r', num.round(r / r + delta, 3).tolist(), '<br>')
autoTester.check('r + r', num.round(r + r + delta, 3).tolist(), '<br>')
autoTester.check('r - r', num.round(r - r + delta, 3).tolist(), '<br>')
__pragma__('noopov')
# Complex
__pragma__('opov')
c = num.array([[2.12 - 3.15j, -2.11, -1.23], [2.31, 1.14, 3.15 + 2.75j],
[1.13, 1.98 - 4.33j, 2.81]], 'complex128')
__pragma__('noopov')
autoTester.check('Matrix c', num.round(c, 2).tolist(), '<br>')
ci = linalg.inv(c)
autoTester.check('Matrix ci', num.round(ci, 2).tolist(), '<br>')
__pragma__('opov')
cid = c @ ci
__pragma__('noopov')
# autoTester.check ('c @ ci', [['{} + j{}'.format (int (round (elem.real)), int (round (elem.imag))) for elem in row] for row in cid.tolist ()], '<br>')
__pragma__('opov')
delta = 0.001 + 0.001j
autoTester.check('c * c', num.round(c * c + delta, 3).tolist(), '<br>')
autoTester.check('c / c', num.round(c / c + delta, 3).tolist(), '<br>')
autoTester.check('c + c', num.round(c + c + delta, 3).tolist(), '<br>')
autoTester.check('c - c', num.round(c - c + delta, 3).tolist(), '<br>')
__pragma__('noopov')