def pascals_triangle(n: int = None, **kwargs: dict) -> npNdArray:
"""Pascal's Triangle
Returns a numpy array of the nth row of Pascal's Triangle.
n=4 => triangle: [1, 4, 6, 4, 1]
=> weighted: [0.0625, 0.25, 0.375, 0.25, 0.0625]
=> inverse weighted: [0.9375, 0.75, 0.625, 0.75, 0.9375]
"""
n = int(npFabs(n)) if n is not None else 0
# Calculation
triangle = npArray([combination(n=n, r=i) for i in range(0, n + 1)])
triangle_sum = npSum(triangle)
triangle_weights = triangle / triangle_sum
inverse_weights = 1 - triangle_weights
weighted = kwargs.pop("weighted", False)
inverse = kwargs.pop("inverse", False)
if weighted and inverse:
return inverse_weights
if weighted:
return triangle_weights
if inverse:
return None
return triangle
def fibonacci(n: int = 2, **kwargs: dict) -> npNdArray:
"""Fibonacci Sequence as a numpy array"""
n = int(npFabs(n)) if n >= 0 else 2
zero = kwargs.pop("zero", False)
if zero:
a, b = 0, 1
else:
n -= 1
a, b = 1, 1
result = npArray([a])
for _ in range(0, n):
a, b = b, a + b
result = npAppend(result, a)
weighted = kwargs.pop("weighted", False)
if weighted:
fib_sum = npSum(result)
if fib_sum > 0:
return result / fib_sum
else:
return result
else:
return result
def getChat(self):
frame = ImageGrab.grab(self.coords)
frame.convert()
frame_gray: cv2 = cvtColor(npArray(frame), COLOR_RGB2GRAY)
imwrite(f'img_fgr.jpg', frame_gray)
# chat = frame_gray
# _, chat = cv2.threshold(frame_gray,i*10,255,cv2.THRESH_BINARY)
# _, chat = cv2.threshold(frame_gray,i*10,255,cv2.THRESH_BINARY+cv2.THRESH_OTSU)
# chat = cv2.adaptiveThreshold(frame_gray, 255, cv2.ADAPTIVE_THRESH_MEAN_C, cv2.THRESH_BINARY, 11, 2)
# for i in range(25):
# _, chat = cv2.threshold(frame_gray,i*10,255,cv2.THRESH_BINARY)
# chat = cv2.bitwise_not(chat)
# cv2.imwrite(f'img{i}.jpg', chat)
if np.mean(frame_gray[:10, :10]) < 122:
frame_gray = bitwise_not(frame_gray)
padding = 20
frame_gray = copyMakeBorder(frame_gray, padding, padding, padding,
padding, BORDER_REPLICATE)
imwrite(f'img_fgr2.jpg', frame_gray)
# _, chat = cv2.threshold(frame_gray, 80, 255, cv2.THRESH_BINARY)
# chat = cv2.ximgproc.niBlackThreshold(frame_gray, 255, cv2.THRESH_BINARY, 9, 0, cv2.ximgproc.BINARIZATION_SAUVOLA)
# _, chat = cv2.threshold(frame_gray, 50, 255, 0)
# cv2.imwrite(f'imgx1.jpg', chat)
# chat = cv2.ximgproc.thinning(chat, thinningType=cv2.ximgproc.THINNING_GUOHALL)
# cv2.imwrite(f'imgx2.jpg', chat)
return frame_gray
def findParabola(p0,p1,p2):
# Always of the form y = a * x^2 + b * x + c
fcoeffs = lambda x,y : (x*x , x , 1, y)
# Map points to arrays of coeffecients (variable array, solution array)
arr0 = fcoeffs(p0.x,p0.y)
arr1 = fcoeffs(p1.x,p1.y)
arr2 = fcoeffs(p2.x,p2.y)
# Solve system of equations
from numpy import array as npArray
from numpy.linalg import solve
# Varaible arrary
arrV = npArray([
arr0[0:-1],
arr1[0:-1],
arr2[0:-1]
])
# Solution array ... = arrS
arrS = npArray([arr0[3],arr1[3],arr2[3]])
coeff = solve(arrV,arrS)
# Give the parameters needed to construct parabola (a,b,c) for y=ax^2+bx+c
return coeff
def copyGrid(grid, elementGennerator=None):
"""
Returns an empty Sudoku grid.
Parameters:
- elementGennerator (function) (optional=None): Is is used to generate initial values of the grid's elements.
If it's not given, all grid's elements will be "None".
"""
return npArray([[
(0 if elementGennerator is None else elementGennerator(i, j))
for j in range(len(grid))
] for i in range(len(grid))])
def _concatArrays(arrs): """ Mimics MATLAB array flattening behaviour. @arrs [[int], [int]] Arbitrary 2D array. @returns [int] All arrays, flattened. """ flattened = [] [ flattened.extend(arrs[i]) for i in range(len(arrs)) ] return npArray(flattened)
def encodePuzzle(grid):
"""
Returns chromosome of Sudoku puzzle. The chromosome of a puzzle is
defined as an array of 81 numbers that is divided into nine sub block.
Parameters:
- grid: Sudoku puzzle
"""
chromosome = [[] for i in range(DIGIT_NUMBER)]
for j in range(DIGIT_NUMBER):
for i in range(DIGIT_NUMBER):
chromosome[int(i / BLOCK_NUMBER) +
int(j / BLOCK_NUMBER) * BLOCK_NUMBER].append(grid[j][i])
return npArray(chromosome)
def _plot(self,
df,
mas: bool = True,
constants: bool = False,
**kwargs) -> None:
if constants:
chart_lines = npAppend(npArange(-5, 6, 1), npArange(-100, 110, 10))
df.ta.constants(True,
chart_lines) # Adding the constants for the charts
df.ta.constants(False, npArray(
[-60, -40, 40,
60])) # Removing some constants from the DataFrame
if self.verbose: print(f"[i] {df.ticker} constants added.")
if ta.Imports["matplotlib"]:
_exchange = kwargs.pop("exchange", "NYSE")
_time = ta.get_time(_exchange, to_string=True)
_kind = kwargs.pop("plot_kind", None)
_figsize = kwargs.pop("figsize", (16, 10))
_colors = kwargs.pop("figsize",
["black", "green", "orange", "red", "maroon"])
_grid = kwargs.pop("grid", True)
_alpha = kwargs.pop("alpha", 1)
_last = kwargs.pop("last", 252)
_title = kwargs.pop("title",
f"{df.ticker} {_time} [{self.ds_name}]")
col = kwargs.pop("close", "close")
if mas:
# df.ta.strategy(self.strategy, append=True)
price = df[[col, "SMA_10", "SMA_20", "SMA_50", "SMA_200"]]
else:
price = df[col]
if _kind is None:
price.tail(_last).plot(figsize=_figsize,
color=_colors,
linewidth=2,
title=_title,
grid=_grid,
alpha=_alpha)
else:
print(f"[X] Plot kind not implemented")
return
def decodePuzzle(chromosome):
"""
Returns Sudoku puzzle of chromosome.
Parameters:
- chromosome: Chromosome.
"""
grid = zerosLike(chromosome)
i = 0
for a, b in sameColumnIndexes(0, 0, BLOCK_NUMBER):
row = list(
getCellsFromIndexes(chromosome, sameRowIndexes(a, b,
BLOCK_NUMBER)))
grid[i] = npArray(row)
i += 1
return grid
def dailySeizureDistributionComparison(request):
from matplotlib.backends.backend_agg import FigureCanvasAgg as FigureCanvas
from matplotlib.figure import Figure
from matplotlib.dates import DateFormatter
from datetime import timedelta
from numpy import array as npArray
import seaborn as sns
sns.set(style="darkgrid", palette="Set2")
seizureFrequency = Seizure.objects.getSeizuresPerNight()
fig = Figure(facecolor="white", figsize=(12, 6))
ax = fig.add_subplot(111)
duration = []
time = []
for day in seizureFrequency:
duration.append([dayI.duration for dayI in day])
time.append([dayI.time for dayI in day])
plots = []
labels = []
for setI in range(len(duration)):
p, = ax.plot(npArray(time[setI]) - timedelta(days=setI, hours=-2),
duration[setI],
marker='o')
plots.append(p)
labels.append("%s" % time[setI][0].strftime("%d-%m-%Y"))
fig.legend(plots, labels, 'upper right', bbox_to_anchor=(1.01, 1))
fig.autofmt_xdate()
ax.grid(True)
ax.set_xlabel("Time of sampling interval [h]")
ax.set_ylabel("Seizure duration [s]")
canvas = FigureCanvas(fig)
response = HttpResponse(content_type='image/png')
canvas.print_png(response)
return response
def linreg(close, length=None, offset=None, **kwargs):
"""Indicator: Linear Regression"""
# Validate arguments
length = int(length) if length and length > 0 else 14
close = verify_series(close, length)
offset = get_offset(offset)
angle = kwargs.pop("angle", False)
intercept = kwargs.pop("intercept", False)
degrees = kwargs.pop("degrees", False)
r = kwargs.pop("r", False)
slope = kwargs.pop("slope", False)
tsf = kwargs.pop("tsf", False)
if close is None: return
# Calculate Result
x = range(1, length + 1) # [1, 2, ..., n] from 1 to n keeps Sum(xy) low
x_sum = 0.5 * length * (length + 1)
x2_sum = x_sum * (2 * length + 1) / 3
divisor = length * x2_sum - x_sum * x_sum
def linear_regression(series):
y_sum = series.sum()
xy_sum = (x * series).sum()
m = (length * xy_sum - x_sum * y_sum) / divisor
if slope:
return m
b = (y_sum * x2_sum - x_sum * xy_sum) / divisor
if intercept:
return b
if angle:
theta = npAtan(m)
if degrees:
theta *= 180 / npPi
return theta
if r:
y2_sum = (series * series).sum()
rn = length * xy_sum - x_sum * y_sum
rd = (divisor * (length * y2_sum - y_sum * y_sum)) ** 0.5
return rn / rd
return m * length + b if tsf else m * (length - 1) + b
linreg_ = [linear_regression(_) for _ in sliding_window_view(npArray(close), length)]
linreg = Series([npNaN] * (length - 1) + linreg_, index=close.index)
# Offset
if offset != 0:
linreg = linreg.shift(offset)
# Handle fills
if "fillna" in kwargs:
linreg.fillna(kwargs["fillna"], inplace=True)
if "fill_method" in kwargs:
linreg.fillna(method=kwargs["fill_method"], inplace=True)
# Name and Categorize it
linreg.name = f"LR"
if slope: linreg.name += "m"
if intercept: linreg.name += "b"
if angle: linreg.name += "a"
if r: linreg.name += "r"
linreg.name += f"_{length}"
linreg.category = "overlap"
return linreg
def linreg(close, length=None, offset=None, **kwargs):
"""Indicator: Linear Regression"""
# Validate arguments
length = int(length) if length and length > 0 else 14
close = verify_series(close, length)
offset = get_offset(offset)
angle = kwargs.pop("angle", False)
intercept = kwargs.pop("intercept", False)
degrees = kwargs.pop("degrees", False)
r = kwargs.pop("r", False)
slope = kwargs.pop("slope", False)
tsf = kwargs.pop("tsf", False)
if close is None: return
# Calculate Result
x = range(1, length + 1) # [1, 2, ..., n] from 1 to n keeps Sum(xy) low
x_sum = 0.5 * length * (length + 1)
x2_sum = x_sum * (2 * length + 1) / 3
divisor = length * x2_sum - x_sum * x_sum
def linear_regression(series):
y_sum = series.sum()
xy_sum = (x * series).sum()
m = (length * xy_sum - x_sum * y_sum) / divisor
if slope:
return m
b = (y_sum * x2_sum - x_sum * xy_sum) / divisor
if intercept:
return b
if angle:
theta = npAtan(m)
if degrees:
theta *= 180 / npPi
return theta
if r:
y2_sum = (series * series).sum()
rn = length * xy_sum - x_sum * y_sum
rd = (divisor * (length * y2_sum - y_sum * y_sum)) ** 0.5
return rn / rd
return m * length + b if tsf else m * (length - 1) + b
def rolling_window(array, length):
"""https://github.com/twopirllc/pandas-ta/issues/285"""
strides = array.strides + (array.strides[-1],)
shape = array.shape[:-1] + (array.shape[-1] - length + 1, length)
return as_strided(array, shape=shape, strides=strides)
if npVersion >= "1.20.0":
from numpy.lib.stride_tricks import sliding_window_view
linreg_ = [linear_regression(_) for _ in sliding_window_view(npArray(close), length)]
else:
from numpy.lib.stride_tricks import as_strided
linreg_ = [linear_regression(_) for _ in rolling_window(npArray(close), length)]
linreg = Series([npNaN] * (length - 1) + linreg_, index=close.index)
# Offset
if offset != 0:
linreg = linreg.shift(offset)
# Handle fills
if "fillna" in kwargs:
linreg.fillna(kwargs["fillna"], inplace=True)
if "fill_method" in kwargs:
linreg.fillna(method=kwargs["fill_method"], inplace=True)
# Name and Categorize it
linreg.name = f"LR"
if slope: linreg.name += "m"
if intercept: linreg.name += "b"
if angle: linreg.name += "a"
if r: linreg.name += "r"
linreg.name += f"_{length}"
linreg.category = "overlap"
return linreg
def tos_stdevall(close,
length=None,
stds=None,
ddof=None,
offset=None,
**kwargs):
"""Indicator: TD Ameritrade's Think or Swim Standard Deviation All"""
# Validate Arguments
stds = stds if isinstance(stds, list) and len(stds) > 0 else [1, 2, 3]
if min(stds) <= 0: return
if not all(i < j for i, j in zip(stds, stds[1:])):
stds = stds[::-1]
ddof = int(ddof) if ddof and ddof >= 0 and ddof < length else 1
offset = get_offset(offset)
if length is None:
length = close.size
_props = f"STDEVALL"
else:
length = int(length) if length and length > 2 else 30
close = close.iloc[-length:]
_props = f"STDEVALL_{length}"
close = verify_series(close, length)
if close is None: return
# Calculate Result
if isinstance(close.index, DatetimeIndex):
close_ = npArray(close)
np_index = npArange(length)
m, b = npPolyfit(np_index, close_, 1)
lr_ = m * np_index + b
else:
m, b = npPolyfit(close.index, close, 1)
lr_ = m * close.index + b
lr = Series(lr_, index=close.index)
stdevall = stdev(Series(close), length=length, ddof=ddof)
# std = npStd(close, ddof=ddof)
# Name and Categorize it
df = DataFrame({f"{_props}_LR": lr}, index=close.index)
for i in stds:
df[f"{_props}_L_{i}"] = lr - i * stdevall.iloc[-1]
df[f"{_props}_U_{i}"] = lr + i * stdevall.iloc[-1]
df[f"{_props}_L_{i}"].name = df[f"{_props}_U_{i}"].name = f"{_props}"
df[f"{_props}_L_{i}"].category = df[
f"{_props}_U_{i}"].category = "statistics"
# Offset
if offset != 0:
df = df.shift(offset)
# Handle fills
if "fillna" in kwargs:
df.fillna(kwargs["fillna"], inplace=True)
if "fill_method" in kwargs:
df.fillna(method=kwargs["fill_method"], inplace=True)
# Prepare DataFrame to return
df.name = f"{_props}"
df.category = "statistics"
return df
y2_sum = sum(series ** 2)
rn = length * xy_sum - x_sum * y_sum
rd = (divisor * (length * y2_sum - y_sum * y_sum)) ** 0.5
return rn / rd
return m * length + b if tsf else m * (length - 1) + b
<<<<<<< HEAD
values = [
linear_regression(each)
for each in np.lib.stride_tricks.sliding_window_view(np.array(close), length)
]
linreg = pd.Series([np.NaN] * (length - 1) + values)
linreg.index = close.index
=======
linreg_ = [linear_regression(_) for _ in sliding_window_view(npArray(close), length)]
linreg = Series([npNaN] * (length - 1) + linreg_, index=close.index)
>>>>>>> b2f2cc83a16376c1eb0a11aebed52186d7eab121
# Offset
if offset != 0:
linreg = linreg.shift(offset)
# Handle fills
if "fillna" in kwargs:
linreg.fillna(kwargs["fillna"], inplace=True)
if "fill_method" in kwargs:
linreg.fillna(method=kwargs["fill_method"], inplace=True)
# Name and Categorize it
linreg.name = f"LR"
