#! /usr/bin/python3
# Last edited on 2023-06-12 18:45:07 by stolfi

# Compute a vector {v} with one zero coordinate and two distinct
# nonzero coordinates such that the 24 sign-flips and 
# permutations are as separated as possible.

from math import inf, sqrt
import rn

def main():

  # Guessed canonical direction of the 24-set
  # v24, mv24 = rn.dir((0.90, 0.20, 0.0)) 
  # v24 = (0.9641361193819173, 0.26540825779010224, 0.0)
  # v24 = (0.9614339663074333, 0.27503586753432235, 0.0)
  # v24 = (0.9608819728103407, 0.276958181551128, 0.0)
  # v24 = (0.9608819728103407, 0.276958181551128, 0.0)
  # v24 = (0.9609650170213813, 0.2766699045091394, 0.0)
  # v24 = (0.9609650170213814, 0.2766699045091395, 0.0)
  # v24 = (0.9609650170213814, 0.2766699045091395, 0.0)
  # v24 = (0.9609647403509963, 0.27667086547401815, 0.0)
  # v24 = (0.960964685016804, 0.27667105766696065, 0.0)
  # v24 = (0.96096467118325, 0.27667110571519454, 0.0)
  # v24 = (0.9609646739499609, 0.2766710961055478, 0.0)
  # v24 = (0.960964673949961, 0.27667109610554785, 0.0)
  # v24 = (0.9609646731199477, 0.2766710989884419, 0.0)
  # v24 = (0.9609646731199477, 0.2766710989884419, 0.0)
  v24 = (0.9609646731199477, 0.2766710989884419, 0.0)
  
  u24 = ( +v24[1], -v24[0], 0 )
 
  # Canonical direction from the 48-set:
  # v48 = ( 0.8259425910240683, 0.5208409981408336, 0.21573940527430036) 
  # v48 = ( 0.8175660520420548, 0.5311182921334452, 0.2224839551734472)
  # v48 = (0.8116037677506779, 0.5272449925484872, 0.25161884270747503)
  # v48 = (0.8078969692509772, 0.5319917070465634, 0.2535494245877301)
  # v48 = (0.8079596841911822, 0.5314343376006695, 0.25451658794786386)
  # v48 = (0.8079933650615609, 0.5313367984902758, 0.2546132922425675)
  # v48 = (0.8079958436697409, 0.5313144915208511, 0.2546519737060039)
  # v48 = (0.807994160372788, 0.5313193687783281, 0.2546471385358031)
  # v48 = (0.8079924232012415, 0.5313206201180534, 0.2546500396362683)
  # v48 = (0.8079922459816258, 0.5313209823156012, 0.25464984622958764)
  # v48 = (0.8079921697612784, 0.5313210518779802, 0.2546499429329178)
  # v48 = (0.8079921621392427, 0.5313210588342172, 0.2546499526032508)
  # v48 = (0.8079921621392429, 0.5313210588342173, 0.25464995260325085)
  # v48 = (0.8079921592143238, 0.5313210605013483, 0.2546499584054506)
  # v48 = (0.8079921595509884, 0.5313210595258978, 0.2546499593724839)
  v48 = (0.8079921595509884, 0.5313210595258978, 0.2546499593724839)
  
  # dminmax =  0.3753439577325772
  # dminmax =  0.3864848938127032
  # dminmax =  0.3901889637395869
  # dminmax =  0.391052469490853
  # dminmax =  0.39125146856468646
  # dminmax =  0.3912598848940449
  # dminmax =  0.3912692139702046
  # dminmax =  0.39127128722697735
  # dminmax =  0.39127189448346816
  # dminmax =  0.39127199581332556
  # dminmax =  0.3912720164290957
  # dminmax =  0.39127201642909576
  # dminmax =  0.39127202011655526
  # dminmax =  0.39127202050612364
  # dminmax =  0.39127202050612364
   
  u48, mu48 = rn.dir(( +v48[1], -v48[0], 0 ))
  w48, mw48 = rn.dir(rn.cross3d(u48, v48));
  
  step = 0.000000001

  dminmax = 0
  tminmax24 = None
  tminmax48 = None
  for ku48 in range(-10,11):
    for kw48 in range(-10,11):
      for ku24 in range(-10,11):
        # print("  k = ", ku48, kw48, ku24)
        t24, mt24 = rn.dir(rn.mix(1, v24, step*ku24, u24))
        t48, mt48 = rn.dir(rn.mix(1, rn.mix(1, v48, step*ku48, u48), step*kw48, w48))
        dmin = compute_dmin_24_48(t24, t48)
        # print("dmin = ", dmin)
        if abs(dmin) > abs(dminmax):
          dminmax = dmin
          tminmax24 = t24
          tminmax48 = t48

  print("")
  print("dminmax = ", dminmax)
  print("tminmax24 = ", tminmax24)
  print("tminmax48 = ", tminmax48)
  return 0;
  # ----------------------------------------------------------------------
  
def compute_dmin_24_48(t24, t48):  
  # Generate all permutations and sign-flips of {t24} and {t48} 
  # where {t24} has {t24[2] = 0} and {t24[0] != t24y},
  # and {t48} has three distinct nonzero coordinates. 
  
  # Enumerate all permutations and sign-flips of {t24}
  L24 = enum24(t24)
  
  # Enumerate all permutations and sign-flips of {t48}
  L48 = enum48(t48)
 
  L = L24 + L48;
  
  dmin = compute_dmin_list(L);
  return dmin
  # ----------------------------------------------------------------------
  
def enum24(t24):
  assert t24[0] != 0;
  assert t24[1] != 0;
  assert t24[2] == 0;
  assert t24[0] != t24[1];
  L = [None]*24 
  k = 0
  v = t24;
  for s0 in range(2):
    for s1 in range(2):
      w = v
      for eo in range(2):
        for cy in range(3):
          L[k] = w
          k = k + 1
          w = ( w[1], w[2], w[0] )
        w = ( w[1], w[0], w[2] )
      v = ( +v[0], -v[1], +v[2] )
    v = ( -v[0], +v[1], +v[2] )
  assert k == 24;
  return L;
  # ----------------------------------------------------------------------
  
def enum48(t48):
  assert t48[0] != 0;
  assert t48[1] != 0;
  assert t48[2] != 0;
  assert t48[0] != t48[1];
  assert t48[0] != t48[2];
  assert t48[1] != t48[2];

  L = [None]*48 
  k = 0
  w = t48;
  for eo in range(2):
    for cy in range(3):
      for s0 in range(2):
        for s1 in range(2):
          for s2 in range(2):
            L[k] = w
            k = k + 1
            w = ( +w[0], +w[1], -w[2] )
          w = ( +w[0], -w[1], +w[2] )
        w = ( -w[0], +w[1], +w[2] )
      w = ( w[1], w[2], w[0] )
    w = ( w[1], w[0], w[2] )

  assert k == 48
  return L
  # ----------------------------------------------------------------------
  
def compute_dmin_list(L):
  n = len(L);
  umin = None
  vmin = None
  dmin = +inf
  for k in range(n):
    for j in range(k):
      d = rn.dist(L[j], L[k])
      if d < dmin:
        dmin = d
        umin = L[j]
        vmin = L[k]
  # print("")
  # print("dmin = ", dmin)
  # print("umin = ", umin)
  # print("vmin = ", vmin)

  return dmin
  # ----------------------------------------------------------------------

main()