def main():
# This precomputes the color palette for maximum speed
# You could change it to compute the color palette of your choice
w = [wheel(i) for i in range(256)]
# This sets up the initial wave as a smooth gradient
u = ulab.zeros(num_pixels)
um = ulab.zeros(num_pixels)
f = ulab.zeros(num_pixels)
slope = ulab.linspace(0, 256, num=num_pixels)
th = 1
# the first time is always random (is that a contradiction?)
r = 0
while True:
# Some of the time, add a random new wave to the mix
# increase .15 to add waves more often
# decrease it to add waves less often
if r < .01:
ii = random.randrange(1, num_pixels - 1)
# increase 2 to make bigger waves
f[ii] = (random.random() - .5) * 2
# Here's where to change dx, dt, and c
# try .2, .02, 2 for relaxed
# try 1., .7, .2 for very busy / almost random
u, um = step(u, um, f, num_pixels, .1, .02, 1), u
v = u * 200000 + slope + th
for i, vi in enumerate(v):
# Scale up by an empirical value, rotate by th, and look up the color
pixels[i] = w[round(vi) % 256]
# Take away a portion of the energy of the waves so they don't get out
# of control
u = u * .99
# incrementing th causes the wheel to slowly cycle even if nothing else is happening
th = (th + .25) % 256
pixels.show()
# Clear out the old random value, if any
f[ii] = 0
# and get a new random value
r = random.random()
def __call__(self, leds):
num = len(leds)
left = np.zeros(num, dtype=np.uint8)
right = np.zeros(num, dtype=np.uint8)
right[:self.length] = np.linspace(0, 255, self.length)
while True:
# Shift left/right
offLeft = left[0]
offRight = right[num - 1]
left[:-1] = left[1:]
right[1:] = right[:-1]
right[0] = offLeft
left[num - 1] = offRight
# Display
value = np.clip * ((left + right) / 255, 0.0, 1.0)
leds[:] = hsv2rgb(self.hue, self.sat, value)
yield self.pause
import math
try:
import ulab as np
use_ulab = True
except ImportError:
import numpy as np
use_ulab = False
x = np.linspace(-np.pi, np.pi, num=8)
y = np.sin(x)
if use_ulab:
a, b = np.fft.fft(y)
c, d = np.fft.ifft(a, b)
# c should be equal to y
cmp_result = []
for p, q in zip(list(y), list(c)):
cmp_result.append(math.isclose(p, q, rel_tol=1e-09, abs_tol=1e-09))
print(cmp_result)
z = np.zeros(len(x))
a, b = np.fft.fft(y, z)
c, d = np.fft.ifft(a, b)
# c should be equal to y
cmp_result = []
for p, q in zip(list(y), list(c)):
cmp_result.append(math.isclose(p, q, rel_tol=1e-09, abs_tol=1e-09))
print(cmp_result)
g = np.fft.spectrogram(y)
h = np.sqrt(a * a + b * b)
cmp_result = []
#PYCLOUDIOT : LIBRARY,2,4,polyfit_library.py,
import ulab as np
def polyvalCalc(array1, array2):
return np.polyval(array1, array2)
#PYCLOUDIOT : MAIN,7,10,polyfit_main.py, #IMPORTS :polyfit_library.py ;ulab,
N = 1000
x = np.linspace(0, 10, num=N)
p = [1, 2, 3, 4]
polyvalCalc(x, p)
print(np.log2(2**1))
print(np.log10(10**1))
print(np.exp(1) - np.expm1(1))
x = np.array([-1, +1, +1, -1])
y = np.array([-1, -1, +1, +1])
result = (np.arctan2(y, x) * 180 / np.pi)
ref_result = np.array([-135.0, -45.0, 45.0, 135.0], dtype=np.float)
cmp_result = []
for i in range(len(x)):
cmp_result.append(
math.isclose(result[i], ref_result[i], rel_tol=1E-9, abs_tol=1E-9))
print(cmp_result)
x = np.linspace(-2 * np.pi, 2 * np.pi, 5)
result = np.sin(x)
ref_result = np.array([
2.4492936e-16, -1.2246468e-16, 0.0000000e+00, 1.2246468e-16, -2.4492936e-16
],
dtype=np.float)
cmp_result = []
for i in range(len(x)):
cmp_result.append(
math.isclose(result[i], ref_result[i], rel_tol=1E-9, abs_tol=1E-9))
print(cmp_result)
result = np.cos(x)
ref_result = np.array([1., -1., 1., -1., 1.], dtype=np.float)
cmp_result = []
for i in range(len(x)):
import gc
gc.collect()
free_ram_i = gc.mem_free()
import time
ti_time = time.ticks_us()
dt_time = time.ticks_diff(time.ticks_us(), ti_time)
ti_import = time.ticks_us()
import ulab as np
from ulab import vector
from ulab import fft
dt_import = time.ticks_diff(time.ticks_us(), ti_import)
n_points = 1024
x = np.linspace(0, 10, num=n_points)
y = vector.sin(x)
ti_fft = time.ticks_us()
a, b = fft.fft(y)
dt_fft = time.ticks_diff(time.ticks_us(), ti_fft)
gc.collect()
free_ram_f = gc.mem_free()
print("Free RAM from {} to {} bytes, so {} bytes used ".format(free_ram_i, free_ram_f, free_ram_i - free_ram_f))
print("Time to import ulab v{} : {:.3f} ms".format(np.__version__, (dt_import - dt_time)/1000))
print("Time to calculate FFT of {} points : {:.3f} ms".format(n_points, (dt_fft - dt_time)/1000))
try:
import ulab as np
except ImportError:
import numpy as np
x = np.linspace(0, 9, num=10)
y = x * x
print(np.trapz(y))
print(np.trapz(y, x=x))
def generateLinSpace(N):
return np.linspace(0, N, N)
p = [1, 1, 1, 0]
x = [0, 1, 2, 3, 4]
result = np.polyval(p, x)
ref_result = np.array([0, 3, 14, 39, 84])
for i in range(len(x)):
print(math.isclose(result[i], ref_result[i], rel_tol=1E-9, abs_tol=1E-9))
a = np.array(x)
result = np.polyval(p, a)
ref_result = np.array([0, 3, 14, 39, 84])
for i in range(len(x)):
print(math.isclose(result[i], ref_result[i], rel_tol=1E-9, abs_tol=1E-9))
# linear fit
x = np.linspace(-10, 10, 20)
y = 1.5 * x + 3
result = np.polyfit(x, y, 1)
ref_result = np.array([1.5, 3.0])
for i in range(2):
print(math.isclose(result[i], ref_result[i], rel_tol=1E-9, abs_tol=1E-9))
# 2nd degree fit
x = np.linspace(-10, 10, 20)
y = x * x * 2.5 - x * 0.5 + 1.2
result = np.polyfit(x, y, 2)
ref_result = np.array([2.5, -0.5, 1.2])
for i in range(3):
print(math.isclose(result[i], ref_result[i], rel_tol=1E-9, abs_tol=1E-9))
# 3rd degree fit
import ulab as np # polynom evaluation x = np.linspace(0, 10, num=9) p = [1, 2, 3] y = np.polyval(p, x) print(y) # linear fit x = np.linspace(-5, 5, num=11) y = x + np.sin(x) p = np.polyfit(x, y, 1) print(p) # quadratic fit x = np.linspace(-5, 5, num=11) y = x * x + np.sin(x) * 3.0 p = np.polyfit(x, y, 2) print(p) # cubic fit x = np.linspace(-5, 5, num=11) y = x * x * x + np.sin(x) * 10.0 p = np.polyfit(x, y, 3) print(p)
from ulab import linalg import ulab print(ulab.ones(3)) print(ulab.ones((2,3))) print(ulab.zeros(3)) print(ulab.zeros((2,3))) print(ulab.eye(3)) print(ulab.ones(1, dtype=ulab.int8)) print(ulab.ones(2, dtype=ulab.uint8)) print(ulab.ones(3, dtype=ulab.int16)) print(ulab.ones(4, dtype=ulab.uint16)) print(ulab.ones(5, dtype=ulab.float)) print(ulab.linspace(0, 1, 9))
import ulab from ulab import poly from ulab import vector # polynom evaluation x = ulab.linspace(0, 10, num=9) p = [1, 2, 3] y = poly.polyval(p, x) print(y) # linear fit x = ulab.linspace(-5, 5, num=11) y = x + vector.sin(x) p = poly.polyfit(x, y, 1) print(p) # quadratic fit x = ulab.linspace(-5, 5, num=11) y = x * x + vector.sin(x) * 3.0 p = poly.polyfit(x, y, 2) print(p) # cubic fit x = ulab.linspace(-5, 5, num=11) y = x * x * x + vector.sin(x) * 10.0 p = poly.polyfit(x, y, 3) print(p)
print(np.eye(3, M=4, k=1))
print(np.eye(3, M=4, k=2))
print(np.eye(3, M=4, k=3))
print(np.eye(4, M=4))
print(np.eye(4, M=3, k=0))
print(np.eye(4, M=3, k=-1))
print(np.eye(4, M=3, k=-2))
print(np.eye(4, M=3, k=-3))
print(np.eye(4, M=3, k=1))
print(np.eye(4, M=3, k=2))
print(np.eye(4, M=3, k=3))
print("Array creation using FULL:")
print(np.full((2, 4), 3, dtype=np.float))
print(np.full((2, 4), 3, dtype=np.uint8))
print("Array creation using LINSPACE:")
print(np.linspace(0, 10, num=5))
print(np.linspace(0, 10, num=5, endpoint=False))
print(np.linspace(0, 10, num=5, endpoint=True))
print(np.linspace(0, 10, num=5, endpoint=False, dtype=np.uint8))
print(np.linspace(0, 10, num=5, endpoint=False, dtype=np.uint16))
print(np.linspace(0, 10, num=5, endpoint=False, dtype=np.int8))
print(np.linspace(0, 10, num=5, endpoint=False, dtype=np.int16))
print("Array creation using LOGSPACE:")
print(np.logspace(0, 10, num=5))
print(np.logspace(0, 10, num=5, endpoint=False))
print(np.logspace(0, 10, num=5, endpoint=True))
print(np.logspace(0, 10, num=5, endpoint=False, dtype=np.uint8))
print(np.logspace(0, 10, num=5, endpoint=False, dtype=np.uint16))
print(np.logspace(0, 10, num=5, endpoint=False, dtype=np.int8))
print(np.logspace(0, 10, num=5, endpoint=False, dtype=np.int16))
print("Array creation using ZEROS:")
def quasicrystal_opt(width, height, N=256, group=None, f=None, p=None, n=None):
"""
# Quasicrystal Pattern Generator
# https://code.activestate.com/recipes/579094-quasicrystal-pattern-generator/
# https://en.wikipedia.org/wiki/Quasicrystal
# http://mainisusuallyafunction.blogspot.com/2011/10/quasicrystals-as-sums-of-waves-in-plane.html
#
N : number of colors (default : 256)
group : displayio.Group object.
f : frequency, int [5-30] (default : random)
p : phase, float [0-pi] (default : random)
n : rotations, int [5-20] (default: random)
(range indicate random range choice)
"""
init = 0
init_calc = 0
time_row = 0
inner = 0
draw = 0
start = time.monotonic()
if group is None:
group = displayio.Group()
elif group:
group.pop()
gc.collect()
pixels = displayio.Bitmap(width, height, N)
palette = displayio.Palette(N)
# corral colors
def ColorMap(p):
sr = sg = sb = 0
if (p < 64):
sr=0 ; sg=p*4 ; sb=255
elif (p < 128):
sr=(p-64)*4 ; sg=255 ; sb=(255-(p-64)*4)
elif (p < 192):
sr=255 ; sg=255 ;sb = (p-128)*4
elif (p < 256):
sr=255 ; sg=(255-(p-191)*4) ; sb= (255-(p-191)*4)
return (sr,sg,sb)
for i in range(N):
r=255*i//(N-1)
s=ColorMap(r)
palette[i]=s[0]*2**16+s[1]*2**8+s[2]
# blue to yellow
#for i in range(N):
# j = int((i/N)*255)
# palette[i]=j*2**16+j*2**8+128-j//2
#palette[0] = 0x000088
# grayscale
#for i in range(N):
#j = 128+int(i*(128/N))
# j = int((i/N)*255)
# palette[i]=j*2**16+j*2**8+j
#palette[0] = 0
tile_grid = displayio.TileGrid(pixels, pixel_shader=palette)
group.append(tile_grid)
if f is None:
f = random.random() * 27 + 8 # frequency
if p is None:
p = random.random() * math.pi # phase
if n is None:
n = random.randint(7, 15) # of rotations
init += time.monotonic() - start
# intermediary calculus
start = time.monotonic()
fp = f + p
rot = 3.14 * 2.0 / n
Nn = (N - 1) / n
#row = ulab.array([i for i in range(width)])
row = ulab.linspace(-6.28, 0, num=width//2)
col = ulab.linspace(-6.28, 0, num=height//2)
#x2 = row * row
#y2 = col * col
ky = 0
init_calc += time.monotonic() - start
for y in col:
s_row = time.monotonic()
#y = ky * h4pi - 6.28
#y2 = y**2
atan = ulab.vector.arctan2( col[ky], row )
#atan = ulab.vector.atan( row / y )
dist = ulab.vector.sqrt((row * row) + (y**2)) * fp
#dist = dist * fp
z = ulab.zeros(width//2)
s_inner = time.monotonic()
for i in range(n):
z = z + ulab.vector.cos(ulab.vector.sin(atan + (i * rot)) * dist)
inner += time.monotonic() - s_inner
z = abs(z * Nn)
time_row += time.monotonic() - s_row
s_draw = time.monotonic()
for i, c in enumerate(z):
pixels[ky*width+i] = int(c)
pixels[ky*width+(width-1 -i)] = int(c)
pixels[(height-1-ky)*width+i] = int(c)
pixels[(height-1-ky)*width+(width-1 -i)] = int(c)
draw += time.monotonic() - s_draw
ky += 1
#gc.collect()
#gc.collect()
print("time report :")
print(" init :", init)
print(" init calc :", init_calc)
print(" rows :", time_row-inner)
print(" inner loop:", inner)
print(" draw :", draw)
return group
def mandelbrot_ulab(WIDTH, HEIGHT, N=256, group=None, CENTER=(-0.5, 0), DIAMX=2.3):
"""
mandelbrot()
return a group with drawing of mandelbrot fractal in it.
Parameters :
WIDTH : width of the bitmap
HEIGHT : height of the bitmap
N : number of iterations, and number of colors (default 256)
group : reuse a group instead of creating a new one
CENTER : tuple containing the center coordinates
DIAMX : "zoom" level, from 2.3 to 0.000027
"""
DIAMY = DIAMX*HEIGHT/WIDTH
XMIN=CENTER[0]-DIAMX/2
XMAX=CENTER[0]+DIAMX/2
YMIN=CENTER[1]-DIAMY/2
YMAX=CENTER[1]+DIAMY/2
r1 = ulab.linspace(XMIN, XMAX, num=WIDTH)
r2 = ulab.linspace(YMIN, YMAX, num=HEIGHT)
if group is None:
group = displayio.Group()
elif group:
group.pop()
bitmap = displayio.Bitmap(WIDTH, HEIGHT, N)
def ColorMap(p):
sr = sg = sb = 0
if (p < 64):
sr=0 ; sg=p*4 ; sb=255
elif (p < 128):
sr=(p-64)*4 ; sg=255 ; sb=(255-(p-64)*4)
elif (p < 192):
sr=255 ; sg=255 ;sb = (p-128)*4
elif (p < 256):
sr=255 ; sg=(255-(p-191)*4) ; sb= (255-(p-191)*4)
return (sr,sg,sb)
palette = displayio.Palette(N)
for i in range(N):
r=255*i//(N-1)
s=ColorMap(r)
palette[i]=s[0]*2**16+s[1]*2**8+s[2]
palette[0]=0
palette[1]=0xffffff
tile_grid = displayio.TileGrid(bitmap, pixel_shader=palette)
group.append(tile_grid)
#############################
# Mandelbrot Drawing #
#############################
before = 0
loop = 0
after = 0
print("Start drawing mandelbrot fractal :", CENTER, DIAMX, N)
start = time.monotonic()
for xp in range(WIDTH):
s_before = time.monotonic()
col_z_imag = ulab.array(r2)
x = ulab.ones(HEIGHT)*r1[xp]
x2 = x * x
z2 = col_z_imag * col_z_imag
output = ulab.zeros(HEIGHT, dtype=ulab.int16)
notdone = [True]*HEIGHT
before += time.monotonic() - s_before
s_loop = time.monotonic()
for i in range(N):
z2 = col_z_imag * col_z_imag
x2 = x * x
try:
output[(x2 + z2 ) < 4] = i
except IndexError:
break
#col_z_imag[notdone] = ( ( x * col_z_imag )[notdone] * 2 ) + r2[notdone]
col_z_imag = ( ( x * col_z_imag ) * 2 ) + r2
#x[notdone] = (x2 - z2)[notdone] + r1[xp]
x = (x2 - z2) + r1[xp]
loop += time.monotonic() - s_loop
s_after = time.monotonic()
limit = output >= N-1
if limit.count(True) > 0:
output[limit] = -1
output = output + 1
for yp in range(HEIGHT):
bitmap[xp,yp]= output[yp]
after += time.monotonic() - s_after
print("before :", before)
print("loop :", loop)
print("after :", after)
print("total :", time.monotonic() - start)
return group