#! /usr/bin/python3
# Last edited on 2023-06-12 19:43:10 by stolfi

# Compute a vector {v} with one zero coordinate and two distinct
# nonzero coordinates such that the 24bis 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.96, 0.10, 0.10)) 
  # v24 = (0.9619916786846407, -0.19309584426070245, -0.19309584426070245)
  # v24 = (0.9619916786846409, 0.19309584426070248, 0.19309584426070248)
  # v24 = (0.9625359111383264, 0.19173499911220182, 0.19173499911220182)
  # v24 = (0.962671367922476, 0.19139466735291918, 0.19139466735291918)
  # v24 = (0.9626442958158207, 0.19146273754083667, 0.19146273754083667)
  # v24 = (0.9626442958158208, 0.1914627375408367, 0.1914627375408367)
  # v24 = (0.9626334642777093, 0.19148996508002245, 0.19148996508002245)
  # v24 = (0.9626375262849975, 0.19147975478872512, 0.19147975478872512)
  # v24 = (0.9626372554912502, 0.19148043547615207, 0.19148043547615207)
  # v24 = (0.9626372554912502, 0.19148043547615207, 0.19148043547615207)
  # v24 = (0.9626372554912502, 0.19148043547615207, 0.19148043547615207)
  # v24 = (0.9626372473674227, 0.19148045589677187, 0.19148045589677187)
  # v24 = (0.9626372473674228, 0.1914804558967719, 0.1914804558967719)
  # v24 = (0.9626372479090114, 0.19148045453539725, 0.19148045453539725)
  v24 = (0.9626372481798057, 0.19148045385470994, 0.19148045385470994)
  
  u24, mu24 = rn.dir(( +2*v24[1], -v24[0], -v24[0] ))
 
  # Canonical direction from the 48-set:
  # v48 = (0.8079921595509884, 0.5313210595258978, 0.2546499593724839)
  # v48 = (0.8079921595509884, 0.5313210595258978, 0.2546499593724839)
  # v48 = (0.8137599214991793, 0.5470601054920204, 0.19626520613880782)
  # v48 = (0.8166300221207581, 0.5441697897685215, 0.19233992532579747)
  # v48 = (0.8161550179308309, 0.545054945589933, 0.1918491412393611)
  # v48 = (0.8160917532960967, 0.5452531949018349, 0.19155470146003878)
  # v48 = (0.8160917532960967, 0.5452531949018349, 0.19155470146003878)
  # v48 = (0.8160822704576113, 0.5452949656087187, 0.1914761821390236)
  # v48 = (0.816084252279971, 0.5452902763651417, 0.19148108962053728)
  # v48 = (0.816084252279971, 0.5452902763651417, 0.19148108962053728)
  # v48 = (0.816084458920297, 0.5452901738998635, 0.19148050072271733)
  # v48 = (0.8160844589202971, 0.5452901738998636, 0.19148050072271736)
  # v48 = (0.8160844470294966, 0.5452902020353778, 0.19148047127782467)
  # v48 = (0.8160844531474307, 0.5452901977044223, 0.19148045753687468)
  # v48 = (0.8160844537842715, 0.5452901981299458, 0.191480453610889)
  v48 = (0.8160844536250613, 0.545290198023565, 0.19148045459238544)
  
  # dminmax24 =  0.39127202050612364
  # dminmax =  0.37669756731598136
  # dminmax =  0.37717049687973314
  # dminmax =  0.38144354241577444
  # dminmax =  0.38278933470583837
  # dminmax =  0.38292547508167335
  # dminmax =  0.3829254750816734
  # dminmax =  0.38295107903576164
  # dminmax =  0.38295950957745023
  # dminmax =  0.3829605133476847
  # dminmax =  0.38296087095230413
  # dminmax =  0.38296087095230413
  # dminmax =  0.3829608938832653
  # dminmax =  0.38296090517399245
  # dminmax =  0.3829609067884196
  # dminmax =  0.38296090748356526
  # dminmax =  0.38296090748356526
   
  u48, mu48 = rn.dir(( +v48[1], -v48[0], 0 ))
  w48, mw48 = rn.dir(rn.cross3d(u48, v48));
  
  step = 0.00000000087

  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_24bis_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_24bis_48(t24, t48):  
  # Generate all permutations and sign-flips of {t24} and {t48} 
  # where {t24} has {t24[1] = t24[2] != 0} and {t24[0] >> t24[1]},
  # and {t48} has three distinct nonzero coordinates. 
  
  # Enumerate all permutations and sign-flips of {t24}
  L24 = enum24bis(t24)
  
  # Enumerate all permutations and sign-flips of {t48}
  L48 = enum48(t48)
 
  L = L24 + L48;
  
  dmin = compute_dmin_list(L);
  return dmin
  # ----------------------------------------------------------------------
  
def enum24bis(t24):
  assert t24[0] != 0;
  assert t24[1] != 0;
  assert t24[1] == t24[2];
  assert t24[0] > t24[1];
  L = [None]*24 
  k = 0
  v = t24;
  for s0 in range(2):
    for s1 in range(2):
      for s2 in range(2):
        w = v
        for cy in range(3):
          L[k] = w
          k = k + 1
          w = ( w[1], w[2], w[0] )

        v = ( +v[0], +v[1], -v[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()