def test_hash_reversability_3d_valid(self):
assert pm.deinterleave3(pm.interleave(100, 30, 50)) == (100, 30, 50)
if getattr(sys, 'maxint', 0) and sys.maxint <= 2 ** 31 - 1:
max_v = 0xff
else:
max_v = 0xffff
for i in range(100):
p1 = (random.randint(0, max_v), random.randint(0, max_v), random.randint(0, max_v))
print(p1, pm.deinterleave3(pm.interleave(*p1)))
assert p1 == pm.deinterleave3(pm.interleave(*p1))
def to_zcurve(prctls):
""" A mapping from R^n -> R based on the Morton z-curve """
dim = len(prctls)
SCALE = morton_scale(dim)
int_prctls = [int(math.floor(p * SCALE)) for p in prctls]
m1 = pymorton.interleave(*int_prctls)
int_prctls_back = pymorton.deinterleave2(
m1) if dim == 2 else pymorton.deinterleave3(m1)
assert all(i1 == i2 for i1, i2 in zip(int_prctls, int_prctls_back))
m2 = pymorton.interleave(*[SCALE - 1 for _ in range(dim)])
return m1 / m2
def test_pymorton(self):
# Test standard hashing
assert (pm.interleave(100, 50) == pm.interleave2(100, 50))
assert (pm.interleave(10, 50, 40) == pm.interleave3(10, 50, 40))
assert ((100, 30) == pm.deinterleave2(pm.interleave(100, 30)))
assert (pm.deinterleave2(pm.interleave(100, 30)) == (100, 30))
assert (pm.deinterleave3(pm.interleave(100, 30, 50)) == (100, 30, 50))
# Test geo-hashing
lat, lng = 40.712014, -74.008164
latlng_morton = pm.interleave_latlng(lat, lng)
assert('03023211232311330231120312032231' == \
latlng_morton)
assert(pm.deinterleave_latlng(latlng_morton) == \
(40.712013971060514, -74.00816400535405))
def test_pymorton(self):
# Test standard hashing
assert(pm.interleave(100, 50) == pm.interleave2(100, 50))
assert(pm.interleave(10, 50, 40) == pm.interleave3(10, 50, 40))
assert((100, 30) == pm.deinterleave2(pm.interleave(100, 30)))
assert(pm.deinterleave2(pm.interleave(100,30)) == (100, 30))
assert(pm.deinterleave3(pm.interleave(100, 30, 50)) == (100, 30, 50))
# Test geo-hashing
lat, lng = 40.712014, -74.008164
latlng_morton = pm.interleave_latlng(lat, lng)
assert('03023211232311330231120312032231' == \
latlng_morton)
assert(pm.deinterleave_latlng(latlng_morton) == \
(40.712013971060514, -74.00816400535405))
def create_agent_id_embedding_dic(self):
z_order_dic = {}
agent_embedding_dic = {}
for agent_id in self.agent_dic:
position = traci.junction.getPosition(agent_id)
unique_Z_ID = pm.interleave(int(position[0]), int(position[1]))
if self.config.Constants['Analysis_Mode']:
try:
assert (unique_Z_ID not in z_order_dic)
except Exception as e:
breakpoint()
z_order_dic[unique_Z_ID] = agent_id
sorted_z_vals = list(z_order_dic)
sorted_z_vals.sort()
ID_size = len(format(len(sorted_z_vals) - 1, 'b'))
for index in range(0, len(sorted_z_vals)):
z_val = sorted_z_vals[index]
agent_id = z_order_dic[z_val]
agent_id_embedding = [0] * ID_size
index_bin = format(index, 'b')
for i in range(len(index_bin)):
agent_id_embedding[-i - 1] = int(index_bin[-i - 1])
agent_embedding_dic[agent_id] = torch.tensor(
agent_id_embedding,
dtype=torch.float,
device=self.config.device)
return agent_embedding_dic, ID_size
def from_cube(self, prctls: List[float]) -> float:
"""
Inverse of space filling curve I^n -> I
"""
dim = len(prctls)
SAFE = False # relic
SCALE = self.morton_scale(dim)
int_prctls = [int(math.floor(p * SCALE)) for p in prctls]
m1 = pymorton.interleave(*int_prctls)
if SAFE:
int_prctls_back = pymorton.deinterleave2(
m1) if dim == 2 else pymorton.deinterleave3(m1)
assert all(i1 == i2 for i1, i2 in zip(int_prctls, int_prctls_back))
m2 = pymorton.interleave(*[SCALE - 1 for _ in range(dim)])
zpercentile = m1 / m2
return zpercentile
def to_zcurve(self, prctls: List[float] ):
""" A mapping from R^n -> R based on the Morton z-curve """
SAFE = False
dim = len(prctls)
if dim==1:
return self.to_zscores(prctls)[0]
else:
SCALE = self.morton_scale(dim)
int_prctls = [ int(math.floor(p*SCALE)) for p in prctls ]
m1 = pymorton.interleave(*int_prctls)
if SAFE:
int_prctls_back = pymorton.deinterleave2(m1) if dim==2 else pymorton.deinterleave3(m1)
assert all( i1==i2 for i1,i2 in zip(int_prctls, int_prctls_back))
m2 = pymorton.interleave(*[ SCALE-1 for _ in range(dim) ])
zpercentile = m1/m2
return StatsConventions.norminv(zpercentile)
def morton_distance_dask(geoseries):
bounds = geoseries.bounds.to_numpy()
total_bounds = geoseries.total_bounds
x_coords, y_coords = _continuous_to_discrete_coords(
bounds, level=16, total_bounds=total_bounds)
ddf = from_geopandas(geoseries, npartitions=1)
result = ddf.morton_distance().compute()
expected = []
for i in range(len(x_coords)):
x = int(x_coords[i])
y = int(y_coords[i])
expected.append(interleave(x, y))
assert list(result) == expected
assert isinstance(result, pd.Series)
assert_index_equal(ddf.index.compute(), result.index)
def morton_large(dim):
SCALE = ZCurveHelper.morton_scale(dim=dim)
return pymorton.interleave(*[SCALE - 1 for _ in range(dim)])
def test_hash_ordinality_3d(self):
assert pm.interleave(10, 25, 50) < pm.interleave(10, 25, 100)
def test_hash_ordinality_2d(self):
assert pm.interleave(10, 25) < pm.interleave(10, 50)
def test_hash_reversability_3d_valid(self):
assert pm.deinterleave3(pm.interleave(100, 30, 50)) == (100, 30, 50)
def test_hash_reversability_2d_valid(self):
assert (100, 30) == pm.deinterleave2(pm.interleave(100, 30))
def test_hashing_3d_valid(self):
assert pm.interleave(10, 50, 40) == pm.interleave3(10, 50, 40)
def test_hashing_2d_valid(self):
assert pm.interleave(100, 50) == pm.interleave2(100, 50)
def morton_large(dim):
SCALE = ZCurveConventions.morton_scale(dim=dim)
return pymorton.interleave(*[SCALE - 1 for _ in range(dim)])
