def ray_trace(x, y, poly):
"""
Determines for some set of x and y coordinates, which of those coordinates is within `poly`. Ray trace is \
generally called as an internal function, see :func:`.poly_clip`
:param x: A 1D numpy array of x coordinates.
:param y: A 1D numpy array of y coordinates.
:param poly: The coordinates of a polygon as a numpy array (i.e. from geo_json['coordinates']
:return: A 1D boolean numpy array, true values are those points that are within `poly`.
"""
@vectorize([bool_(float64, float64)])
def ray(x, y):
# where xy is a coordinate
n = len(poly)
inside = False
p2x = 0.0
p2y = 0.0
xints = 0.0
p1x, p1y = poly[0]
for i in range(n + 1):
p2x, p2y = poly[i % n]
if y > min(p1y, p2y):
if y <= max(p1y, p2y):
if x <= max(p1x, p2x):
if p1y != p2y:
xints = (y - p1y) * (p2x - p1x) / (p2y - p1y) + p1x
if p1x == p2x or x <= xints:
inside = not inside
p1x, p1y = p2x, p2y
return inside
return ray(x, y)
def ray_trace(x, y, poly):
"""
A numba implementation of the ray tracing algorithm.
:param x: A 1D numpy array of x coordinates.
:param y: A 1D numpy array of y coordinates.
:param poly: A shapely polygon.
:return:
"""
poly = np.array(poly.exterior.coords)
@vectorize([bool_(float64, float64)])
def ray(x, y):
# where xy is a coordinate
n = len(poly)
inside = False
p2x = 0.0
p2y = 0.0
xints = 0.0
p1x, p1y = poly[0]
for i in range(n + 1):
p2x, p2y = poly[i % n]
if y > min(p1y, p2y):
if y <= max(p1y, p2y):
if x <= max(p1x, p2x):
if p1y != p2y:
xints = (y - p1y) * (p2x - p1x) / (p2y - p1y) + p1x
if p1x == p2x or x <= xints:
inside = not inside
p1x, p1y = p2x, p2y
return inside
return (ray(x, y))
def test_type_inference(self):
global vector_add
vector_add = vectorize([
bool_(double, int_),
double(double, double),
float_(double, float_),
])(add)
cfunc = jit(func)
self.assertEqual(cfunc(np.dtype(np.float64), np.dtype('i')), int8[:])
self.assertEqual(cfunc(np.dtype(np.float64), np.dtype(np.float64)),
double[:])
self.assertEqual(cfunc(np.dtype(np.float64), np.dtype(np.float32)),
float_[:])
def test_type_inference(self):
"""This is testing numpy ufunc dispatch machinery"""
global vector_add
vector_add = vectorize([
bool_(double, int_),
double(double, double),
float_(double, float_),
])(add)
cfunc = jit(func)
def numba_type_equal(a, b):
self.assertEqual(a.dtype, b.dtype)
self.assertEqual(a.ndim, b.ndim)
numba_type_equal(cfunc(np.dtype(np.float64), np.dtype("i")), bool_[:])
numba_type_equal(cfunc(np.dtype(np.float64), np.dtype(np.float64)),
double[:])
# This is because the double(double, double) matches first
numba_type_equal(cfunc(np.dtype(np.float64), np.dtype(np.float32)),
double[:])
def test_type_inference(self):
"""This is testing numpy ufunc dispatch machinery
"""
global vector_add
vector_add = vectorize([
bool_(double, int_),
double(double, double),
float_(double, float_),
])(add)
cfunc = jit(func)
def numba_type_equal(a, b):
self.assertEqual(a.dtype, b.dtype)
self.assertEqual(a.ndim, b.ndim)
numba_type_equal(cfunc(np.dtype(np.float64), np.dtype('i')), bool_[:])
numba_type_equal(cfunc(np.dtype(np.float64), np.dtype(np.float64)),
double[:])
# This is because the double(double, double) matches first
numba_type_equal(cfunc(np.dtype(np.float64), np.dtype(np.float32)),
double[:])
import numpy as np
from numba import bool_, float32, float64, int32, int64
from .decorators import ndreduce
@ndreduce([bool_(int32), bool_(int64), bool_(float32), bool_(float64)])
def allnan(a):
f = True
for ai in a.flat:
if not np.isnan(ai):
f = False
break
return f
@ndreduce([bool_(int32), bool_(int64), bool_(float32), bool_(float64)])
def anynan(a):
f = False
for ai in a.flat:
if np.isnan(ai):
f = True
break
return f
@ndreduce([int64(int32), int64(int64), int64(float32), int64(float64)])
def count(a):
non_missing = 0
for ai in a.flat:
if not np.isnan(ai):
from numba import double, int64, int8, bool_
from numba.decorators import jit
from app.tool import deepthroat as dt
@jit(bool_(int64, int64, double[:], double[:]), nopython=True)
def contraction_share(v1, v2, high, low):
"""Calculate does v2 shares min 1 pip with volatility contraction
Parameters
----------
candle v1: int
candle v2: int
candle high: double[:]
candle low: double[:]
Returns
-------
True if share False if doesn't
"""
for i in range(v1, v2, -1):
if high[v2] < low[i] and low[v2] > high[i]:
return False
else:
return True
@jit(int64(int64, int64[:], int8[:]), nopython=True)
def prior_bull_wrb(start, dir, wrb):
for i in range(start - 1, 0, -1):
if wrb[i] == 1 and dir[i] == 1:
import numba
from math import sqrt
@numba.jit(numba.bool_(numba.int64), nopython=True)
def is_prime(n):
d = int(sqrt(n))
while d > 1:
if n % d == 0:
return False
else:
d = d-1
return True
q_trans_tr[i] *= f_trans_tr[j]
# Inverts about 1, to take the _infection_ probability
q_trans_tr[i] = 1. - q_trans_tr[i]
# ---------------
# Convergence (consecutive states close to each other) and numerical error checking
# # Convergence check - numpy version
# def check_states_are_close(p_state, p_next, tol):
# return np.amax(np.abs((p_next - p_state))) < tol
# Convergence check - numba version
@nb.njit(
nb.bool_(nb_ncount_t, nb_int_t, nb_p_t[:, :], nb_p_t[:, :], nb_float_t))
def check_states_are_close(num_nodes, num_states, p_state, p_next, tol):
"""
Check if all markov state probabilities from the current and the (already calculated) next step are all close
up to a given tolerance tol. The operation is executed for all nodes and all states. Any entry that exceeds the
tolerance immediately implies a 'False' return.
"""
for i_s in range(num_states):
for i in range(num_nodes):
if abs(p_next[i_s, i] - p_state[i_s, i]) >= tol:
return False
return True
@nb.njit(nb.void(nb_ncount_t, nb_p_t[:, :]))
