from hgeom import *

# def test_bcc_neighbors_3():b
#
#    for bcc in [
#          BCC3([10, 10, 10], [-50, -50, -50], [50, 50, 50]),
#          BCC3([11, 11, 11], [-55, -55, -55], [55, 55, 55]),
#    ]:
#       cen0 = np.array([[0.0, 0.0, 0.0]])
#       kcen = bcc.keys(cen0)
#       # print(kcen)
#       cen = bcc.vals(kcen)
#       allkeys = np.arange(len(bcc), dtype="u8")
#       allcens = bcc[allkeys]
#       # print(len(allcens))
#       diff = allcens - cen
#       d = np.linalg.norm(diff[:, :3], axis=1)
#
#       for rad in range(1, 5):
#          nb = bcc.neighbors_3(kcen, rad, extrahalf=0, sphere=0).astype("i8")
#          assert np.all(np.diff(nb) > 0)
#          wnb = set(nb)
#          assert len(nb) == len(set(nb)) == (1 + 2 * rad)**3 + 8 * rad**3
#          wd10 = set(np.where(d < 10.1 * rad)[0])
#          # wd15 = set(np.where(d < 15.1 * rad)[0])
#          # print(rad, len(nb), len(wd15 - wnb), len(wnb - wd15))
#          assert wd10.issubset(wnb)
#          cart = bcc[nb.astype("u8")]
#          uvals = np.arange(-10 * rad, 10.01 * rad, 5)
#          # print(np.unique(cart[:, 0]))
#          assert np.all(np.unique(cart[:, 0]) == uvals)
#          assert np.all(np.unique(cart[:, 1]) == uvals)
#          assert np.all(np.unique(cart[:, 2]) == uvals)
#
#          # print(cart)
#          com = np.mean(cart, axis=0)
#          cerr = np.linalg.norm(com - cen)
#          assert abs(cerr) < 0.001
#          dis = np.linalg.norm(cart - com, axis=1)
#          assert np.allclose(np.max(dis), np.sqrt(3) * rad * 10)
#
# def test_bcc_neighbors_3_exhalf():
#    for bcc in [
#          BCC3([10, 10, 10], [-50, -50, -50], [50, 50, 50]),
#          BCC3([11, 11, 11], [-55, -55, -55], [55, 55, 55]),
#    ]:
#       cen0 = np.array([[0.0, 0.0, 0.0]])
#       kcen = bcc.keys(cen0)
#       # print(kcen)
#       cen = bcc.vals(kcen)
#       allkeys = np.arange(len(bcc), dtype="u8")
#       allcens = bcc[allkeys]
#       # print(len(allcens))
#       diff = allcens - cen
#       d = np.linalg.norm(diff[:, :3], axis=1)
#
#       for rad in range(1, 5):
#          nb = bcc.neighbors_3(kcen, rad, extrahalf=1, sphere=0)
#          cart = bcc[nb]
#          # print(np.unique(cart[:, 0]))
#          assert len(nb) == len(set(nb)) == (1 + 2 * rad)**3 + (2 * rad + 2)**3
#          wnb = set(nb)
#          wd10 = set(np.where(d < 10.1 * rad)[0])
#          # wd15 = set(np.where(d < 15.1 * rad)[0])
#          # print(rad, len(nb), len(wd15 - wnb), len(wnb - wd15))
#          assert wd10.issubset(wnb)
#
#          uvals = np.arange(-10 * rad - 5, 10.01 * rad + 5, 5)
#          assert np.all(np.unique(cart[:, 0]) == uvals)
#          assert np.all(np.unique(cart[:, 1]) == uvals)
#          assert np.all(np.unique(cart[:, 2]) == uvals)
#
#          # print(cart)
#          com = np.mean(cart, axis=0)
#          cerr = np.linalg.norm(com - cen)
#          assert abs(cerr) < 0.001
#          dis = np.linalg.norm(cart - com, axis=1)
#          assert np.allclose(np.max(dis), np.sqrt(3) * (rad * 10 + 5))
#
# def test_bcc_neighbors_3_sphere():
#
#    for bcc in [
#          BCC3([10, 10, 10], [-50, -50, -50], [50, 50, 50]),
#          BCC3([11, 11, 11], [-55, -55, -55], [55, 55, 55]),
#    ]:
#       cen0 = np.array([[0.0, 0.0, 0.0]])
#       kcen = bcc.keys(cen0)
#       cen = bcc.vals(kcen)
#       allkeys = np.arange(len(bcc), dtype="u8")
#       allcens = bcc[allkeys]
#       diff = allcens - cen
#       d = np.linalg.norm(diff[:, :3], axis=1)
#       ntrim = np.array([0, 8, 5 * 8 + 12, 23 * 8 + 3 * 12, 57 * 8 + 3 * 12])
#       radius = [14.142135623730, 24.494897427831, 34.641016151377, 44.721359549995]
#
#       for rad in range(1, 5):
#          nbns = bcc.neighbors_3(kcen, rad, extrahalf=0, sphere=0).astype("i8")
#          nb = bcc.neighbors_3(kcen, rad, extrahalf=0, sphere=1).astype("i8")
#          cart = bcc[nb.astype("u8")]
#
#          # from hgeom.io.io import dump_pdb_from_points
#
#          # cart2 = bcc[nbns.astype("u8")]
#          # nbnse = bcc.neighbors_3(kcen, rad, extrahalf=1, sphere=0)
#          # nbe = bcc.neighbors_3(kcen, rad, extrahalf=1, sphere=1)
#          # carte = bcc[nbe]
#          # cart2e = bcc[nbnse]
#          # dump_pdb_from_points("bcc_%i.pdb" % rad, cart2)
#          # dump_pdb_from_points("bcc_%i_sph.pdb" % rad, cart)
#          # dump_pdb_from_points("bcc_%iex.pdb" % rad, cart2e)
#          # dump_pdb_from_points("bcc_%iex_sph.pdb" % rad, carte)
#
#          assert np.all(np.diff(nb) > 0)
#          wnb = set(nb)
#          # print("Npts", rad, (len(nbns) - len(nb) - ntrim[rad]) / 8)
#          assert len(nb) == (1 + 2 * rad)**3 + 8 * rad**3 - ntrim[rad]
#          wd10 = set(np.where(d < 10.1 * rad)[0])
#          # wd15 = set(np.where(d < 15.1 * rad)[0])
#          # print(rad, len(nb), len(wd15 - wnb), len(wnb - wd15))
#          assert wd10.issubset(wnb)
#
#          uvals = np.arange(-10 * rad, 10.01 * rad, 5)
#          # print(np.unique(cart[:, 0]))
#          assert np.all(np.unique(cart[:, 0]) == uvals)
#          assert np.all(np.unique(cart[:, 1]) == uvals)
#          assert np.all(np.unique(cart[:, 2]) == uvals)
#
#          # print(cart)
#          com = np.mean(cart, axis=0)
#          cerr = np.linalg.norm(com - cen)
#          assert abs(cerr) < 0.001
#          dis = np.linalg.norm(cart - com, axis=1)
#          # print(rad * 10, np.max(dis), np.sqrt(2) * rad * 10)
#          assert rad * 10 < np.max(dis) < np.sqrt(2) * rad * 10 + 0.01
#          assert np.allclose(radius[rad - 1], np.max(dis))
#
# def test_bcc_neighbors_3_exhalf_sphere():
#
#    for bcc in [
#          BCC3([10, 10, 10], [-50, -50, -50], [50, 50, 50]),
#          BCC3([11, 11, 11], [-55, -55, -55], [55, 55, 55]),
#    ]:
#       cen0 = np.array([[0.0, 0.0, 0.0]])
#       kcen = bcc.keys(cen0)
#       cen = bcc.vals(kcen)
#       allkeys = np.arange(len(bcc), dtype="u8")
#       allcens = bcc[allkeys]
#       diff = allcens - cen
#       d = np.linalg.norm(diff[:, :3], axis=1)
#
#       ntrim = np.array([0, 4 * 8, 11 * 8, 36 * 8 + 3 * 12, 79 * 8 + 3 * 12])
#       radius = [17.320508075688775, 30.0, 38.40572873934304, 50.0]
#       for rad in range(1, 5):
#          nbns = bcc.neighbors_3(kcen, rad, extrahalf=1, sphere=0).astype("i8")
#          nb = bcc.neighbors_3(kcen, rad, extrahalf=1, sphere=1).astype("i8")
#          # print(len(nbns), len(nb))
#          cart = bcc[nb.astype("u8")]
#          # cart2 = bcc[nbns.astype("u8")]
#          assert np.all(np.diff(nb) > 0)
#          wnb = set(nb)
#          # print("Npts", rad, (len(nbns) - len(nb) - ntrim[rad]) / 8)
#
#          assert len(nb) == (1 + 2 * rad)**3 + (2 * rad + 2)**3 - ntrim[rad]
#
#          wd10 = set(np.where(d < 10.1 * rad)[0])
#          # wd15 = set(np.where(d < 15.1 * rad)[0])
#          # print(rad, len(nb), len(wd15 - wnb), len(wnb - wd15))
#          assert wd10.issubset(wnb)
#
#          uvals = np.arange(-10 * rad - 5, 10.01 * rad + 5, 5)
#          # print(np.unique(cart[:, 0]))
#          assert np.all(np.unique(cart[:, 0]) == uvals)
#          assert np.all(np.unique(cart[:, 1]) == uvals)
#          assert np.all(np.unique(cart[:, 2]) == uvals)
#
#          # print(cart)
#          com = np.mean(cart, axis=0)
#          cerr = np.linalg.norm(com - cen)
#          assert abs(cerr) < 0.001
#          dis = np.linalg.norm(cart - com, axis=1)
#          # print(rad * 10, np.max(dis), np.sqrt(2) * rad * 10)
#          assert rad * 10 + 5 < np.max(dis) < np.sqrt(2) * (rad * 10 + 5.01)
#          assert np.allclose(radius[rad - 1], np.max(dis))

#def test_bcc_neighbors_6_3():
#
#   cen0 = np.array([[0.0, 0.0, 0.0, 0.5, 0.5, 0.5]])
#   for bcc in [
#         BCC6(
#            [10, 10, 10, 4, 4, 4],
#            [-50, -50, -50, -20, -20, -20],
#            [50, 50, 50, 20, 20, 20],
#         ),
#         BCC6(
#            [11, 11, 11, 5, 5, 5],
#            [-55, -55, -55, -25, -25, -25],
#            [55, 55, 55, 25, 25, 25],
#         ),
#   ]:
#      kcen = bcc.keys(cen0)
#      cen = bcc.vals(kcen)
#      assert np.all(cen == 0)
#      allcens = bcc[np.arange(len(bcc), dtype="u8")]
#      diff = allcens - cen
#      d1 = np.linalg.norm(diff[:, :3], axis=1)
#      d2 = np.linalg.norm(diff[:, 3:], axis=1)
#
#      for rad in range(1, 5):
#         nb = bcc.neighbors_6_3(kcen, rad, extrahalf=0, oddlast3=0, sphere=0)
#         diff = np.diff(nb.astype("i8"))
#         # print(diff)
#         assert np.all(diff > 0)
#         wnb = set(nb)
#         assert len(nb) == len(set(nb)) == ((1 + 2 * rad)**3 + (2 * rad)**3)
#
#         wd = set(np.where((d1 < 10.1 * rad + 5) * (d2 < 1))[0])
#         assert len(wd - wnb) == 0
#
#         cart = bcc[nb]
#         uvals = np.arange(-10 * rad, 10.01 * rad, 5)
#         assert np.all(np.unique(cart[:, 0]) == uvals)
#         assert np.all(np.unique(cart[:, 1]) == uvals)
#         assert np.all(np.unique(cart[:, 2]) == uvals)
#         # assert np.all(np.unique(cart[:, 3]) == [-5, 0, 5])
#         # assert np.all(np.unique(cart[:, 4]) == [-5, 0, 5])
#         # assert np.all(np.unique(cart[:, 5]) == [-5, 0, 5])
#         # print(cart)
#         com = np.mean(cart, axis=0)
#         cerr = np.linalg.norm(com[:3] - cen[0, :3])
#         assert abs(cerr) < 0.001
#         # dis = np.linalg.norm(cart - com, axis=1)
#         # assert np.allclose(np.max(dis), np.sqrt(3) * rad * 10)
#
#def test_bcc_neighbors_6_3_extrahalf():
#
#   cen0 = np.array([[0.0, 0.0, 0.0, 0.5, 0.5, 0.5]])
#   for bcc in [
#         BCC6(
#            [10, 10, 10, 4, 4, 4],
#            [-50, -50, -50, -20, -20, -20],
#            [50, 50, 50, 20, 20, 20],
#         ),
#         BCC6(
#            [11, 11, 11, 5, 5, 5],
#            [-55, -55, -55, -25, -25, -25],
#            [55, 55, 55, 25, 25, 25],
#         ),
#   ]:
#      kcen = bcc.keys(cen0)
#      cen = bcc.vals(kcen)
#      assert np.all(cen == 0)
#      allcens = bcc[np.arange(len(bcc), dtype="u8")]
#      diff = allcens - cen
#      d1 = np.linalg.norm(diff[:, :3], axis=1)
#      d2 = np.linalg.norm(diff[:, 3:], axis=1)
#
#      for rad in range(1, 5):
#         w = 2 * rad + 1
#         nb = bcc.neighbors_6_3(kcen, rad, extrahalf=1, oddlast3=0, sphere=0)
#         diff = np.diff(nb.astype("i8"))
#         # print(diff)
#         assert np.all(diff > 0)
#         wnb = set(nb)
#         assert len(nb) == len(set(nb)) == w**3 + (w + 1)**3
#
#         wd = set(np.where((d1 < 10.1 * rad + 5) * (d2 < 1))[0])
#         assert len(wd - wnb) == 0
#
#         cart = bcc[nb]
#         uvals = np.arange(-5 - 10 * rad, 10 * rad + 5.1, 5)
#         assert np.all(np.unique(cart[:, 0]) == uvals)
#         assert np.all(np.unique(cart[:, 1]) == uvals)
#         assert np.all(np.unique(cart[:, 2]) == uvals)
#         assert list(np.unique(cart[:, 3])) in [[-5, 0], [0, 5]]
#         assert list(np.unique(cart[:, 4])) in [[-5, 0], [0, 5]]
#         assert list(np.unique(cart[:, 5])) in [[-5, 0], [0, 5]]
#         com = np.mean(cart, axis=0)
#         cerr = np.linalg.norm(com[:3] - cen[0, :3])
#         assert abs(cerr) < 0.001
#         # dis = np.linalg.norm(cart - com, axis=1)
#         # assert np.allclose(np.max(dis), np.sqrt(3) * rad * 10)
#
#def test_bcc_neighbors_6_3_oddlast3():
#
#   cen0 = np.array([[0.0, 0.0, 0.0, 0.5, 0.5, 0.5]])
#   for bcc in [
#         BCC6(
#            [10, 10, 10, 4, 4, 4],
#            [-50, -50, -50, -20, -20, -20],
#            [50, 50, 50, 20, 20, 20],
#         ),
#         BCC6(
#            [11, 11, 11, 5, 5, 5],
#            [-55, -55, -55, -25, -25, -25],
#            [55, 55, 55, 25, 25, 25],
#         ),
#   ]:
#      kcen = bcc.keys(cen0)
#      cen = bcc.vals(kcen)
#      assert np.all(cen == 0)
#      allcens = bcc[np.arange(len(bcc), dtype="u8")]
#      diff = allcens - cen
#      d1 = np.linalg.norm(diff[:, :3], axis=1)
#      d2 = np.linalg.norm(diff[:, 3:], axis=1)
#
#      for rad in range(1, 5):
#         w = 2 * rad + 1
#         nb = bcc.neighbors_6_3(kcen, rad, extrahalf=0, oddlast3=1, sphere=0)
#         wnb = set(nb)
#         diff = np.diff(nb.astype("i8"))
#         # print(diff)
#         assert np.all(diff > 0)
#
#         assert len(nb) == w**3 + (w - 1)**3 * 8
#
#         wd = set(np.where((d1 < 10.1 * rad + 5) * (d2 < 9))[0])
#         # print(len(wd), len(wnb))
#         assert len(wd - wnb) == 0
#         vol_sph = 4 / 3 * np.pi
#         vol_cube = 8
#         cube_out_of_sphere = (vol_cube - vol_sph) / vol_cube
#         # print(len(wnb - wd) / len(wnb))
#         assert len(wnb - wd) < len(wnb) * cube_out_of_sphere
#
#         cart = bcc[nb]
#         uvals = np.arange(-10 * rad, 10.01 * rad, 5)
#         assert np.all(np.unique(cart[:, 0]) == uvals)
#         assert np.all(np.unique(cart[:, 1]) == uvals)
#         assert np.all(np.unique(cart[:, 2]) == uvals)
#         # print(np.unique(cart[:, 3]))
#         assert np.all(np.unique(cart[:, 3]) == [-5, 0, 5])
#         assert np.all(np.unique(cart[:, 4]) == [-5, 0, 5])
#         assert np.all(np.unique(cart[:, 5]) == [-5, 0, 5])
#         # print(cart)
#         com = np.mean(cart, axis=0)
#         cerr = np.linalg.norm(com - cen)
#         assert abs(cerr) < 0.001
#         dis = np.linalg.norm(cart - com, axis=1)
#         assert np.allclose(np.max(dis), np.sqrt(3) * rad * 10)
#
#def test_bcc_neighbors_6_3_oddlast3_extrahalf():
#   radius = [
#      0,
#      27.386127875258307,
#      44.15880433163923,
#      61.237243569579455,
#      78.4219357067906,
#   ]
#   cen0 = np.array([[0.0, 0.0, 0.0, 0.5, 0.5, 0.5]])
#   for bcc in [
#         BCC6(
#            [10, 10, 10, 4, 4, 4],
#            [-50, -50, -50, -20, -20, -20],
#            [50, 50, 50, 20, 20, 20],
#         ),
#         BCC6(
#            [11, 11, 11, 5, 5, 5],
#            [-55, -55, -55, -25, -25, -25],
#            [55, 55, 55, 25, 25, 25],
#         ),
#   ]:
#      kcen = bcc.keys(cen0)
#      cen = bcc.vals(kcen)
#      assert np.all(cen == 0)
#      allcens = bcc[np.arange(len(bcc), dtype="u8")]
#      diff = allcens - cen
#      d1 = np.linalg.norm(diff[:, :3], axis=1)
#      d2 = np.linalg.norm(diff[:, 3:], axis=1)
#
#      for rad in range(1, 5):
#         w = 2 * rad + 1
#         nb = bcc.neighbors_6_3(kcen, rad, extrahalf=1, oddlast3=1, sphere=0)
#         wnb = set(nb)
#         diff = np.diff(nb.astype("i8"))
#         # print(diff)
#         assert np.all(diff > 0)
#
#         assert len(nb) == w**3 + (w + 1)**3 * 8
#
#         wd = set(np.where((d1 < 10.1 * rad + 9) * (d2 < 9))[0])
#         # print(len(wd), len(wnb))
#         assert len(wd - wnb) == 0
#         assert len(wnb - wd) < len(wnb) * 0.6
#
#         cart = bcc[nb]
#         uvals = np.arange(-5 - 10 * rad, 5.01 + 10 * rad, 5)
#         assert np.all(np.unique(cart[:, 0]) == uvals)
#         assert np.all(np.unique(cart[:, 1]) == uvals)
#         assert np.all(np.unique(cart[:, 2]) == uvals)
#         # print(np.unique(cart[:, 3]))
#         assert np.all(np.unique(cart[:, 3]) == [-5, 0, 5])
#         assert np.all(np.unique(cart[:, 4]) == [-5, 0, 5])
#         assert np.all(np.unique(cart[:, 5]) == [-5, 0, 5])
#         # print(cart)
#         com = np.mean(cart, axis=0)
#         cerr = np.linalg.norm(com - cen)
#         assert abs(cerr) < 0.001
#         dis = np.linalg.norm(cart - com, axis=1)
#         # assert np.allclose(np.max(dis), np.sqrt(3) * rad * 10)
#         # print(rad * 10 + 10, np.max(dis), np.sqrt(3) * (rad * 10 + 10.01))
#         assert rad * 10 + 10 < np.max(dis) < np.sqrt(3) * (rad * 10 + 10.01)
#         assert np.allclose(radius[rad], np.max(dis))
#
#def test_bcc_neighbors_6_3_oddlast3_sphere():
#   ntrim = np.array([0, 8, 12 * 8 + 12, 72 * 8 + 3 * 12, 190 * 8 + 3 * 12])
#   radius = [
#      0,
#      14.142135623730951,
#      24.49489742783178,
#      34.64101615137755,
#      44.721359549995796,
#   ]
#
#   cen0 = np.array([[0.0, 0.0, 0.0, 0.5, 0.5, 0.5]])
#   for bcc in [
#         BCC6(
#            [10, 10, 10, 4, 4, 4],
#            [-50, -50, -50, -20, -20, -20],
#            [50, 50, 50, 20, 20, 20],
#         ),
#         BCC6(
#            [11, 11, 11, 5, 5, 5],
#            [-55, -55, -55, -25, -25, -25],
#            [55, 55, 55, 25, 25, 25],
#         ),
#   ]:
#      kcen = bcc.keys(cen0)
#      cen = bcc.vals(kcen)
#      assert np.all(cen == 0)
#      allcens = bcc[np.arange(len(bcc), dtype="u8")]
#      diff = allcens - cen
#      d1 = np.linalg.norm(diff[:, :3], axis=1)
#      d2 = np.linalg.norm(diff[:, 3:], axis=1)
#
#      for rad in range(1, 5):
#         w = 2 * rad + 1
#         nb = bcc.neighbors_6_3(kcen, rad, extrahalf=0, oddlast3=1, sphere=1)
#         nbns = bcc.neighbors_6_3(kcen, rad, extrahalf=0, oddlast3=1, sphere=0)
#         assert len(nb) < len(nbns)
#         wnb = set(nb)
#         diff = np.diff(nb.astype("i8"))
#         # print(diff)
#         assert np.all(diff > 0)
#
#         print(
#            "test_bcc_neighbors_6_3_oddlast3_sphere",
#            rad,
#            len(nb),
#            len(nbns) - len(nb),
#         )
#         assert len(nbns) == w**3 + (w - 1)**3 * 8
#         assert len(nb) == w**3 + (w - 1)**3 * 8 - ntrim[rad]
#
#         wd = set(np.where((d1 < 10.1 * rad + 5) * (d2 < 9))[0])
#         # print(len(wd), len(wnb))
#         assert len(wd - wnb) == 0
#         vol_sph = 4 / 3 * np.pi
#         vol_cube = 8
#         cube_out_of_sphere = (vol_cube - vol_sph) / vol_cube
#         # print(len(wnb - wd) / len(wnb))
#         assert len(wnb - wd) < len(wnb) * cube_out_of_sphere
#
#         cart = bcc[nb]
#         uvals = np.arange(-10 * rad, 10.01 * rad, 5)
#         assert np.all(np.unique(cart[:, 0]) == uvals)
#         assert np.all(np.unique(cart[:, 1]) == uvals)
#         assert np.all(np.unique(cart[:, 2]) == uvals)
#         # print(np.unique(cart[:, 3]))
#         assert np.all(np.unique(cart[:, 3]) == [-5, 0, 5])
#         assert np.all(np.unique(cart[:, 4]) == [-5, 0, 5])
#         assert np.all(np.unique(cart[:, 5]) == [-5, 0, 5])
#         # print(cart)
#         com = np.mean(cart, axis=0)
#         cerr = np.linalg.norm(com - cen)
#         assert abs(cerr) < 0.001
#         dis = np.linalg.norm(cart - com, axis=1)
#         assert rad * 10 < np.max(dis) < np.sqrt(2) * rad * 10 + 0.01
#         assert np.allclose(radius[rad], np.max(dis))
#
#def test_bcc_neighbors_6_3_oddlast3_sphere_extrahalf():
#   ntrim = np.array([0, 4 * 8 * 8, 81 * 8, 239 * 8 + 3 * 12, 471 * 8 + 3 * 12])
#   radius = [
#      0,
#      18.708286933869708,
#      30.822070014844883,
#      39.370039370059054,
#      50.49752469181039,
#   ]
#   cen0 = np.array([[0.0, 0.0, 0.0, 0.5, 0.5, 0.5]])
#   for bcc in [
#         BCC6(
#            [10, 10, 10, 4, 4, 4],
#            [-50, -50, -50, -20, -20, -20],
#            [50, 50, 50, 20, 20, 20],
#         ),
#         BCC6(
#            [11, 11, 11, 5, 5, 5],
#            [-55, -55, -55, -25, -25, -25],
#            [55, 55, 55, 25, 25, 25],
#         ),
#   ]:
#      kcen = bcc.keys(cen0)
#      cen = bcc.vals(kcen)
#      assert np.all(cen == 0)
#      allcens = bcc[np.arange(len(bcc), dtype="u8")]
#      diff = allcens - cen
#      d1 = np.linalg.norm(diff[:, :3], axis=1)
#      d2 = np.linalg.norm(diff[:, 3:], axis=1)
#
#      for rad in range(1, 5):
#         w = 2 * rad + 1
#         nb = bcc.neighbors_6_3(kcen, rad, extrahalf=1, oddlast3=1, sphere=1)
#         nbns = bcc.neighbors_6_3(kcen, rad, extrahalf=1, oddlast3=1, sphere=0)
#         cart = bcc[nb]
#         cart2 = bcc[nbns]
#         assert len(nb) < len(nbns)
#         wnb = set(nb)
#         diff = np.diff(nb.astype("i8"))
#         assert np.all(diff > 0)
#
#         assert len(nbns) == w**3 + (w + 1)**3 * 8
#         assert len(nb) == w**3 + (w + 1)**3 * 8 - ntrim[rad]
#
#         wd = set(np.where((d1 < 10.1 * rad + 9) * (d2 < 9))[0])
#         # print(len(wd), len(wnb))
#         assert len(wd - wnb) == 0
#         vol_sph = 4 / 3 * np.pi
#         vol_cube = 8
#         cube_out_of_sphere = (vol_cube - vol_sph) / vol_cube
#         # print(len(wnb - wd) / len(wnb))
#         assert len(wnb - wd) < len(wnb) * cube_out_of_sphere
#
#         uvals = np.arange(-5 - 10 * rad, 5 + 10.01 * rad, 5)
#         assert np.all(np.unique(cart[:, 0]) == uvals)
#         assert np.all(np.unique(cart[:, 1]) == uvals)
#         assert np.all(np.unique(cart[:, 2]) == uvals)
#         # print(np.unique(cart[:, 3]))
#         assert np.all(np.unique(cart[:, 3]) == [-5, 0, 5])
#         assert np.all(np.unique(cart[:, 4]) == [-5, 0, 5])
#         assert np.all(np.unique(cart[:, 5]) == [-5, 0, 5])
#         # print(cart)
#         com = np.mean(cart, axis=0)
#         # print(com)
#         cerr = np.linalg.norm(com - cen)
#         assert abs(cerr) < 0.001
#         dis = np.linalg.norm(cart - com, axis=1)
#         assert 5 + rad * 10 < np.max(dis) < np.sqrt(2) * (rad * 10 + 5.01)
#         print(np.max(dis))
#         # assert np.allclose(radius[rad], np.max(dis))

# def test_bcc_neighbor_radius():
#    # no bounts checking
#    bcc = BCC6([10, 10, 10, 10, 10, 10], [-1, -1, -1, -1, -1, -1], [1, 1, 1, 1, 1, 1])
#    kcen = bcc.keys(np.zeros(6).reshape(1, 6))
#    cen = bcc.vals(kcen)
#    for r, e, s, c in [
#       (1, 0, 10, 12 + 1),
#       (1, 1, 17, 27 + 1),
#       (2, 0, 26, 48 + 1),
#       (2, 1, 37, 75 + 1),
#       (3, 0, 50, 108 + 1),
#       (3, 1, 65, 147 + 1),
#       (4, 0, 82, 192 + 1),
#       (4, 1, 101, 243 + 1),
#       (5, 0, 122, 300 + 1),
#       (5, 1, 145, 363 + 1),
#       (6, 0, 170, 432 + 1),
#       (6, 1, 197, 507 + 1),
#    ]:
#       s0 = bcc.neighbor_sphere_radius_square_cut(radius=r, extrahalf=e)
#       c0 = bcc.neighbor_radius_square_cut(radius=r, extrahalf=e)
#       assert s0 == s
#       assert c0 == c
#       ks, ds = bcc.neighbors_6_3_dist(kcen, r, extrahalf=e, oddlast3=1, sphere=1)
#       kc, dc = bcc.neighbors_6_3_dist(kcen, r, extrahalf=e, oddlast3=1, sphere=0)
#       print(s, np.max(ds))
#       if r > 1:
#          assert s * 0.9 < np.max(ds)
#       assert np.max(ds) < s
#       assert c * 0.9 < np.max(dc) < c

if __name__ == "__main__":
   # test_bcc_neighbors_3()
   # test_bcc_neighbors_3_sphere()
   # test_bcc_neighbors_3_exhalf_sphere()
   # test_bcc_neighbors_6_3()
   # test_bcc_neighbors_6_3_extrahalf()
   # test_bcc_neighbors_6_3_oddlast3()
   # test_bcc_neighbors_6_3_oddlast3_extrahalf()
   # test_bcc_neighbors_6_3_oddlast3_sphere()
   # test_bcc_neighbors_6_3_oddlast3_sphere_extrahalf()
   # test_bcc_neighbor_radius()
   pass
