ABC гипотеза

 
 package main
 
 import (
 	"math"
 	"math/big"
 	"strconv"
 	"fmt"
 )
 
 func factors(nn *big.Int) map[string]int64{
     n := big.NewInt(0).Set(nn)
     factors := make(map[string]int64)
     i := big.NewInt(2)
     mod := big.NewInt(0)
     div := big.NewInt(0)
     
     for {
 	ii := big.NewInt(0).Mul(i,i)
 	if ii.Cmp(n) == 1 { break }
 	div.DivMod(n, i, mod)
 	if mod.Cmp(big.NewInt(0)) > 0  {
 	  i.Add(i, big.NewInt(1))
 	} else {
             n.Div(n,i)
             factors[big.NewInt(0).Set(i).String()] = 1
 	}
     }
     if n.Cmp(big.NewInt(1)) == 1 {
        factors[n.String()] = 1
     }
 
     return factors
 }
 
 
 func gcd(a *big.Int, b *big.Int) *big.Int {
   aa, bb, mod, div := big.NewInt(0), big.NewInt(0), big.NewInt(0), big.NewInt(0)
   aa.Set(a)
   bb.Set(b)
   for{
     if bb.Cmp(big.NewInt(0)) == 0 {break}
     div.DivMod(aa, bb, mod)
     aa.Set(bb)
     bb.Set(mod)
   }
   return aa
 }
 
 
 func nod(a int64, b int64)(int64){
     for {
       if b == 0 {break}
       a, b = b, a%b
     }
     return a
 }
 
 
 func rad(a map[string]int64,b  map[string]int64,c  map[string]int64)  (*big.Int){
     r := big.NewInt(1)
     kk := big.NewInt(0)
     for k,_ := range a{
 	kk.SetString(k, 0)
         r.Mul(r,kk)
     }
     for k,_ := range b{
 	kk.SetString(k, 0)
         r.Mul(r,kk)
     }
     for k,_ := range c{
 	kk.SetString(k, 0)
         r.Mul(r,kk)
     }
     return r    
 }
 
 
 
 func quality(a *big.Int,b *big.Int,c *big.Int) (float64){
   apf := factors(a)
   cpf := factors(c)
   bpf := factors(b)
   q := float64(0)
   if len(apf) == 0 || len(cpf) == 0 || len(bpf) == 0 {
     return q
   } 
   
   r := rad(apf, bpf, cpf)
   mlr := get_log(r)
  
   if mlr > 0 {
     q = get_log(c) 
     q /= mlr    
   }
 
   return q
 }
 
 func get_log(n *big.Int) (z float64){
    if n.Cmp(big.NewInt(1000000000)) == 1 {
       l1 := len(fmt.Sprintf("%b", n)) - 1 
       l2 := float64(l1)*math.Log(2)
       return l2
   }else {
       l1 := fmt.Sprintf("%d", n)
       l2, _ := strconv.ParseFloat(l1, 64)
       l3 := math.Log(l2)
       return l3
   }
 } 
 
 
 func setABC(count int64) {
   var i,j,k int64
   for i=1; i < count+1; i +=1 {
     for j=i+1; j < count+1; j +=1 {
       for k=j+1; k < count+1; k +=1 {
 	if nod(i,j) == 1 && nod(i,k) == 1 && nod(j,k) == 1  {
 	  ABC = append(ABC, i)
 	  ABC = append(ABC, j)
 	  ABC = append(ABC, k)
 	}
       }
     }
   }
 
   println("count=", count, "len=", len(ABC)/3)
 }
 
 func getABC(count int64) (int64,int64,int64){
   
   var c,i,A,B,C int64
   
   c = count*3 
   for i=0; i < int64(len(ABC)); i +=1 {
     if i == c {
       A = ABC[i]
       B = ABC[i+1]
       C = ABC[i+2]
       break
     }
     
   }
   return A,B, C
 }
 
 var ABC []int64
 
 func main() {
 
     ABC = make([]int64, 0)
     setABC(300)
     n := int64(2)
     var i int64;
     mod, div := big.NewInt(0), big.NewInt(0)
     
     for i=0; i < int64(len(ABC))/3; i+=1 {
 	A,B,C := getABC(i)
 	BB := big.NewInt(B)
 	B *= -1
 	t := int64(0)
 	t2 := C/2
 	tt := make([]int64, 0)
 	for{
 	      if t >= t2 {break}
 	      div1 := big.NewInt(A)
 	      div2 := big.NewInt(0).Exp(big.NewInt(t), big.NewInt(n), nil)
 	      div1.Mul(div1, div2)
 	      div.DivMod(div1, big.NewInt(C), mod)
 	      if mod.Cmp(BB) == 0 {
 		tt = append(tt, t)
 	      }
 	      t += 1
 	}
 	
 	if len(tt) > 0 {
 	    ttt  := make([]float64, 0)
 	    tttu := make([]int64, 0)
 	    for _, t := range tt{
 	      t1 := float64(t)/float64(C)
 	      ttt = append(ttt, t1)
 	      ttf := int64(1)
 	      tf := strconv.FormatFloat(t1, 'f', -10, 64)
 	      if len(tf) < 4 { 
 		ttf, _ = strconv.ParseInt(tf[2:3], 10, 64)
 		ttf *= 10
 	      } else {
 		ttf, _ = strconv.ParseInt(tf[2:4], 10, 64)
 	      }
 	      tttu = append(tttu, ttf)
 	    }
 	    
 	    count := int64(0)
 	    
 	    for _, t := range ttt{
 	        t01 := int64(float64(t)*float64(100))
 		t02 := C * tttu[count]
 		t03 := t01 - t02
 		a01 := big.NewInt(t03)
 		a0  := big.NewInt(0).Exp(a01, big.NewInt(n), nil)
 		b01  := big.NewInt(-B) 
 		b02  := big.NewInt(0).Exp(big.NewInt(100), big.NewInt(n), nil)
 		b0   := big.NewInt(0).Mul(b01, b02) 
 		c0   := big.NewInt(0).Add(a0, b0) 
 		gcd0 := gcd(a0,b0)
 		gcd0  = gcd(gcd0,c0)
 		a0.Div(a0, gcd0)
 		b0.Div(b0, gcd0)
 		c0.Div(c0, gcd0)
 		a := big.NewInt(0).Abs(a0)
 		if big.NewInt(0).Abs(b0).Cmp(a) == -1 { a = big.NewInt(0).Abs(b0)}
 		if big.NewInt(0).Abs(c0).Cmp(a) == -1 { a = big.NewInt(0).Abs(c0)}
 		c := big.NewInt(0).Abs(a0)
 		if big.NewInt(0).Abs(b0).Cmp(c) == 1 { c = big.NewInt(0).Abs(b0)}
 		if big.NewInt(0).Abs(c0).Cmp(c) == 1 { c = big.NewInt(0).Abs(c0)}
 		b := big.NewInt(0).Sub(c, a)
 		if gcd(a,b).Cmp(big.NewInt(1)) == 0 && gcd(a,c).Cmp(big.NewInt(1)) == 0 && gcd(b,c).Cmp(big.NewInt(1)) == 0 { 
 		  q  := quality(a,b,c)
 		  if q > 1.0 {
 		    println("a=", a.String(), "b=", b.String(), "c=", c.String(),  q)
 		  }
 		}
 	      }
 	  }
      }
 }