可计算代数数论（2012-12-09 20:56、2013-03-23 21:39、2013-06-23 20:27、2013-06-23 20:32、2014-05-16 17:49）

本文合并了《欧拉φ函数（1736-1760）的程序计算》、《高斯整数环Z[i]、整数环Z等UFD的算术基本定理的C++程序实现》、《一元三次方程的实根、椭圆曲线j不变量的C++程序计算》、《C++解代数题》、《代数数论中的程序计算问题（2014-4-28,4-30,5-2,5-12）》这几篇日志而成。
整数有很多性质，其中这整数的带余除法大家都知道：
两个整数a和b，如果b不为零，一定有一个整数q和一个非负整数r使得 a=qb+r, 其中0≤r<|b|。
gap> a:=8;;b:=3;;q:=EuclideanQuotient(a,b);r:=EuclideanRemainder(a,b);qr:=QuotientRemainder(Integers,a,b);
2
2
[ 2, 2 ]
gap> a:=8;;b:=3;;q:=EuclideanQuotient(GaussianIntegers,a,b);r:=EuclideanRemainder(GaussianIntegers,a,b);qr:=QuotientRemainder(GaussianIntegers,a,b);
3
-1
[ 3, -1 ]
gap> for n in [1..10] do Print(Norm(1+E(n)),",");od;
2,0,1,2,1,3,1,2,1,5,
gap> Norm(1+E(3));
1
gap> Norm(1+E(4));
2
gap> Factors(GaussianIntegers,2);
[ 1-E(4), 1+E(4) ]
gap> for i  in [5,13,17,29] do L:=Factors(GaussianIntegers,i);Print(i,",",L,"\n");od;
5,[ 2-E(4), 2+E(4) ]
13,[ 3-2*E(4), 3+2*E(4) ]
17,[ 4-E(4), 4+E(4) ]
29,[ 5-2*E(4), 5+2*E(4) ]
//5 = (2 + i) × (2 − i),
//13 = (2 + 3i) × (2 − 3i),
//17 = (4 + i) × (4 − i),
//29 = (2 + 5i) × (2 − 5i), ...
gap> for n in [2..10] do R:=DefaultRingByGenerators([ 2, E(n) ]);Print(R,",");od;
Integers,CF(3),GaussianIntegers,CF(5),CF(3),CF(7),CF(8),CF(9),CF(5),
gap> Gcd(10,15);
5
gap> Gcd(200,300,50,35);
5
gap> Gcd(18-E(4),-29+3*E(4));
3+4*E(4)
gap> Gcd(GaussianIntegers,[18-E(4),-29+3*E(4)]);
3+4*E(4)
gap> Gcd(GaussianIntegers,[10,15]);
5
>> maple('with(GaussInt);')

ans =

[GIbasis, GIchrem, GIdivisor, GIfacpoly, GIfacset, GIfactor, GIfactors, GIgcd, GIgcdex, GIhermite, GIissqr, GIlcm, GImcmbine, GInearest, GInodiv, GInorm, GInormal, GIorder, GIphi, GIprime, GIquadres, GIquo, GIrem, GIroots, GIsieve, GIsmith, GIsqrfree, GIsqrt, GIunitnormal]

>> maple('GaussInt[GIfactor](2);')

ans =

``(-i)*``(1+i)^2

>> maple('GaussInt[GIfactors](2);')

ans =

[-i, [[1+i, 2]]]

>> maple('GaussInt[GIfactor](5+7*i);')

ans =

``(i)*``(1+i)*``(1-6*i)
>> maple('GaussInt[GIfactors](5+7*i);')

ans =

[i, [[1+i, 1], [1-6*i, 1]]]
totient(1)=1
totient(2)=1
totient(3)=2
totient(4)=2
totient(5)=4
totient(6)=2
totient(7)=6
totient(8)=4
totient(9)=6
totient(10)=4
totient(11)=10
totient(12)=4
totient(13)=12
totient(14)=6
totient(15)=8
totient(16)=8
totient(17)=16
totient(18)=6
totient(19)=18
totient(20)=8
totient(21)=12
totient(22)=10
totient(23)=22
totient(24)=8
totient(25)=20
totient(26)=12
totient(27)=18
totient(28)=12
totient(29)=28
totient(30)=8
totient(31)=30
totient(32)=16
totient(33)=20
totient(34)=16
totient(35)=24
totient(36)=12
totient(37)=36
totient(38)=18
totient(39)=24
totient(40)=16
totient(41)=40
totient(42)=12
totient(43)=42
totient(44)=20
totient(45)=24
totient(46)=22
totient(47)=46
totient(48)=16
totient(49)=42
totient(50)=20
totient(51)=32
totient(52)=24
totient(53)=52
totient(54)=18
totient(55)=40
totient(56)=24
totient(57)=36
totient(58)=28
totient(59)=58
totient(60)=16
totient(61)=60
totient(62)=30
totient(63)=36
totient(64)=32
totient(65)=48
totient(66)=20
totient(67)=66
totient(68)=32
totient(69)=44
totient(70)=24
totient(71)=70
totient(72)=24
totient(73)=72
totient(74)=36
totient(75)=40
totient(76)=36
totient(77)=60
totient(78)=24
totient(79)=78
totient(80)=32
totient(81)=54
totient(82)=40
totient(83)=82
totient(84)=24
totient(85)=64
totient(86)=42
totient(87)=56
totient(88)=40
totient(89)=88
totient(90)=24
totient(91)=72
totient(92)=44
totient(93)=60
totient(94)=46
totient(95)=72
totient(96)=32
totient(97)=96
totient(98)=42
totient(99)=60
totient(100)=40
#include "stdafx.h"
#include<math.h>
extern "C" _declspec(dllexport)int __stdcall factorial(int value);//阶乘（小整数版）
extern "C" _declspec(dllexport)int __stdcall nlcb(int *a, int n);//求n个数的最大公约数，有问题
int __stdcall factorial(int value)
{
 if(value == 0||value == 1)
  return (1);
 else
  return (value * factorial(value-1));
}
int __stdcall nlcb(int *a, int n)
{
 int product=1;
 for(int i=0;i<n;i++)
 {
  product*=a[i];
  a[i]=abs(a[i]);
 }
 if(product<0)
  return -nlcb(a,n);
 
 int min=a[1];
 int i,flag;
 for(i=2;i<n;i++)
  if(a[i]<min)
   min=a[i];
 for(;;min--)
 {
  flag=1;
  for(i=1;i<=n;i++)
   if(a[i]%min)
   {
    flag=0;
    break;
   }
   if(flag)
    return min;
 }
}
//求2个数的最大公约数
int __stdcall GCD(int a, int b)
{
 //int Arr3[3]={12,32,16};
 //int ret3=nlcb(&Arr3[0],3);
#if 0
 int Arr[2]={0};
 Arr[0]=a;
 Arr[1]=b;
 int ret=nlcb(Arr,2);//有问题
 return ret;
#else
 if(a*b<0)
  return -GCD(abs(a),abs(b));
 int temp=0;
 if(a<b)
 {
  temp=a;
  a=b;
  b=temp;
 }
 if(a%b==0)
  return b;
 else
  return GCD(a%b,b);
 return 0;
#endif
}
int __stdcall Iscoprime(int a, int b)
{
 int ret=0;
 if(GCD(a,b)==1)
  ret=1;
 return ret;
}
int __stdcall totient(int num)
{
 int count=0;
#if 1
 if(num==1)
  return 1;
 for(int i=1;i<=num-1;i++)
#else
 for(int i=1;i<num;i++)
#endif
 {
    count+=Iscoprime(num,i);
 }
 return count;
}
int main(int argc, char* argv[])
{ 
 int ret=GCD(12,32);
 int ret1=GCD(-12,32);
 int ret2=GCD(12,-32);
 for(int i=1;i<=100;i++)
  printf("totient(%d)=%d\n",i,totient(i));
 getchar();
 return 0;
}
用公式φ(n)=n∏[k=1->r](1-1/p_k)
φ(42)=φ(2·3·7)=42(1/2)(2/3)(6/7)=12
φ(360)=φ(2^3·3^2·5)=360(1/2)(2/3)(4/5)=96，即在1到359这359和自然数当中，与360互素的有96个。
事实上，φ(m_1m_2)=φ(m_1)φ(m_2)，其中m_1与m_2互素。
摘录自维基百科：
单位的n次根以乘法构成n阶循环群。它的生成元是n次本原单位根。n次本原单位根是e^(2piki/n)，其中k和n互质。n次本原单位根数目为欧拉函数φ(n)。
规定：φ(1)=1----1次单位根有1个：1
1是1次本原单位根，是2,3,4……次非本原单位根
φ(2)=1----2次单位根有2个：+1和-1，只有-1是本原根
-1是2次本原单位根，是4,6,8，……次非本原单位根
φ(3)=2----3次单位根有3个：1,cos(2pi/3)+isin(2pi/3),cos(-2pi/3)+isin(-2pi/3)，除1外都是本原根
φ(4)=2----4次单位根有4个：+1,i,-1,-i，其中+i和-i是本原根。
5次本原单位根有4个：((usqrt(5)-1)/4)+uisqrt((5+usqrt(5))/8)，u,v∈{-1,1}
6次本原单位根有2个：cos(pii/3)+isin(pii/3),cos(-pii/3)+isin(-pii/3)
--注意观察2,3,6次本原根的关系
7次本原单位根有6个：
8次本原单位根有4个：cos(pii/4)+isin(pii/4),cos(5pii/4)+isin(5pii/4),cos(-pii/4)+isin(-pii/4),cos(3pii/4)+isin(3pii/4)
--注意观察2,4,8次本原根的关系
高斯注意到，如果n次本原单位根能仅用平方根表示出来，那么正n边形就能用尺规作图构造出来。如果单位根需要3次，4次，或更高次根式，那么正n边形就不能用尺规作图构造出来。
以下问题的一般化为：求一个高斯整数的高斯素因子（高斯整数环的算术基本定理）
/*
问题描述：
求一个整数的高斯素因子。
解题思路：
高斯整数a+bi是素数当且仅当：
1)a、b中有一个是零，另一个数的绝对值是形如4n+3的素数；
2)a、b均不为零，而a^2+b^2为素数；
于是只要将每个分解素因子，对于每个素因子P,如果该素因子形如4n+3，则必定能分解成(a+bj)(a-bj)=a^2+b^2，枚举解决。
*/
#include <iostream>
#include <cmath>
using namespace std;
int f[65537], p[65537], size;
int pri[1000], top;
int n;
struct point
{
    int a;
    int b;
    char oper;
}s[10000];
int num;
//筛选素数
void init()
{
    f[1] = 1;
    int i, j;
    for(i = 2; i <= 65536; i++)
    {
        if(!f[i])
        {
            p[ size++ ] = i;
            for(j = i+i; j <= 65536; j += i)
                f[j] = 1;
        }
    }
}
//素因子分解
void Flip(int key)
{
    int i;
    top = 0;
    for(i = 0; i < size; i++)
    {
        if(key % p[i] == 0)
        {
            pri[ top++ ] = p[i];
            key /= p[i];
            while(key % p[i] == 0){
                pri[ top++ ] = p[i];
                key /= p[i];
            }
        }
    }
    if(key - 1)
        pri[ top++ ] = key;
}
//高斯素数分解
void Part(int prime)
{
    int i;
    if(prime == 2)
    {
        s[ num ].a = 1; s[ num ].b = 1; s[ num++ ].oper = '+';
        s[ num ].a = 1; s[ num ].b = 1; s[ num++ ].oper = '-';
    }else if( (prime - 1) % 4 == 0)
    {
        for(i = 1; ;i++)
        {
            int u = int(sqrt(prime - i*i*1.0) + 1e-5);
            if(u*u + i*i == prime)
            {
                s[ num ].a = i; s[ num ].b = u; s[ num++ ].oper = '+';
                s[ num ].a = i; s[ num ].b = u; s[ num++ ].oper = '-';
                break;
            }
        }
    }else
    {
        s[ num ].a = prime; s[ num++ ].b = 0;
    }
}
int cmp(const void *a, const void *b)
{
    point *c = (point *)a;
    point *d = (point *)b;
    if(c->a != d->a)
        return c->a - d->a;
    if(c->b != d->b)
        return c->b - d->b;
    return c->oper == '-' ? 1 : -1;
}
void Print(int key)
{
    printf("%d", s[key].a );
   
    if(s[key].b == 0)
        return;
    if(s[key].b == 1)
    {
        printf("%cj", s[key].oper);
    }else
    {
        printf("%c%dj", s[key].oper, s[key].b);
    }
}
int main()
{
    init();
    int i, cas = 1;
    while(scanf("%d", &n) != EOF)
    {
        num = 0;
        Flip(n);
        for(i = 0; i < top; i++)
        {
            Part(pri[i]);
        }
        qsort(s, num, sizeof(point), cmp);
        printf("Case #%d: ", cas++);
        Print(0);
        for(i = 1; i < num; i++)
        {
            if(s[i].a == s[i-1].a
                && s[i].b == s[i-1].b
                && s[i].oper == s[i-1].oper)
                continue;
            if(i)
                printf(", ");
            Print(i);
        }
        puts("");
    }
}

#include<iostream>
#include<complex>
#include<cstdlib>
using namespace std;
bool is_prime(long p)
{
 if( p<2 ) return false;
 for(int i=2; i*i<=p; i++)
  if ( p%i==0 )
   return false;
 return true;
}
bool is_4n_plus_3( long a ) { return a%4 == 3 ; }
bool is_gausian_prime( std::complex<long> z ) // a + bi
{
 const long a = std::abs( z.real() ) ;
 const long b = std::abs( z.imag() ) ;
 if( a == 0 ) return is_prime(b) && is_4n_plus_3(b) ;
 else if( b == 0 ) return is_prime(a) && is_4n_plus_3(a) ;
 else return is_prime( a*a + b*b ) ;
}
/*
 自然数集与整数集一一对应：当n为偶数时，对应到n/2； n为奇数时对应到1-(n+1)/2
 0,1,-1,……
 有限多个可数集的笛卡尔积是可数的。
 Z[i]可数：按范数升序和幅角主值升序排列
 0,1,i,-1,-i,1+i,-1+i,-1-i,1-i,……
高斯整數和普通整數相像，也是惟一分解 (Unique Factorization) 的。除去因子的次序、單位 + 1、 - 1 、 + i 、 - i 及相伴元以外的分解是惟一的。在高斯整數的世界中，型如 4k-1 的素數 (如 3、7、11、19、23、......) 仍為素數，但其他的則可進一步分解成其他高斯素數：
2 = (1+i) (1-i) 5 = (2+i) (2-i) 13 = (2+3i) (2-3i)
17 = (4+i) (4-i) 29 = (5+2i) (5-2i) 37 = (6+i) (6-i)
現在我們知道在實軸 (Real Axis) 及虛軸 (Imaginary Axis) 上存在無限多個高斯素數，因為虛軸上的高斯素數不過是實軸的高斯素數的相伴元。但在複平面 (Complex Plane) 上別的直線又如何呢？例如所有型如 (1 + ki) 的高斯素數是否均存有無限多個呢？仍是存疑。

某些素数并非高斯素数，如2=(1+i)(1-i)及5=(2+i)(2-i)。
4除余3的素数都是高斯素数，4除余1者则否，因为后者能表示成两个平方数之和：
p=a^2+b^2=(a+bi)(a-bi)
若某个高斯整数的范数是素数，该高斯整数是高斯素数。
A complex number a + bj where a and b are integers is a Gaussian prime if the factors are 1, -1, -a - bj and a + bj only.
The following are Gaussian primes: 1 + j, 1 - j, 1 + 2j, 1 - 2j, 3 and 7.
The Gaussian prime factors of 5 are:
    1 + 2j and 1 - 2j, or
    2 + j and 2 - j, or
    -1 - 2j and -1 + 2j, or
    -2 - j and -2 + j.
求证范数小于100，1/4正平面(0<=θ<π/2)上所有“高斯素数”
1+1I   1+2I   2+1I   3   2+3I   3+2I   1+4I   4+1I   2+5I   5+2I   1+6I   6+1I 
4+5I   5+4I   7   2+7I   7+2I   5+6I   6+5I   3+8I   8+3I   5+8I   8+5I   4+9I   9+4I
高斯素数是指除了单位{1,-1,i,-i}及其自身与单位的乘积，不能被其他高斯整数除尽。
找高斯素数我觉得也不很难，只要得出正平面(0<=θ<π/2)上的高斯素数，然后乘上单位
{-1,i,-i}就能得出其他三个平面上的高斯素数。可以看出高斯素数是关于原点对称的。
*/

class gint
{
public:
 gint(long a,long b)
 {
  m_a=a;
  m_b=b;
 }
 static bool IsPrime(gint N)
 {
  return is_gausian_prime(complex<long>(N.m_a,N.m_b));
 }
 friend ostream& operator<< (ostream& os,gint& N);
public:
 long m_a;
 long m_b;
};
ostream& operator<< (ostream& os,gint& N)
{
 string strDes=(gint::IsPrime(N)?"是高斯素数":"不是高斯素数");
 if(N.m_a!=0 && N.m_b>0)
  cout<<N.m_a<<"+"<<N.m_b<<"i"<<strDes;
 if(N.m_a!=0 && N.m_b<0)
  cout<<N.m_a<<N.m_b<<"i"<<strDes;
 if(/*N.m_a!=0 && */N.m_b==0)
  cout<<N.m_a<<strDes;
 if(N.m_a==0 && N.m_b!=0)
  cout<<N.m_b<<"i"<<strDes;
 return os;
}
unsigned int Primes[]={2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97,101,103,
107,109,113,127,131,137,139,149,151,157,163,167,173,179,181,191,193,197,199,211,223,227,229,233,239,241,251,257,263,269,271,277,281,283,293,307,311,313,317,331,
337,347,349,353,359,367,373,379,383,389,397,401,409,419,421,431,433,439,443,449,457,461,463,467,479,487,491,499,503,509,521,523,541,547,557,563,569,571,577,587,
593,599,601,607,613,617,619,631,641,643,647,653,659,661,673,677,683,691,701,709,719,727,733,739,743,751,757,761,769,773,787,797,809,811,821,823,827,829,839,853,
857,859,863,877,881,883,887,907,911,919,929,937,941,947,953,967,971,977,983,991,997};
int main(void)
{
 for(int i=0;i<sizeof(Primes)/sizeof(unsigned int);i++)
  cout<<gint(Primes[i],0)<<endl;
 cout<<gint(1,0)<<endl;
 cout<<gint(-1,0)<<endl;
 cout<<gint(0,1)<<endl;
 cout<<gint(0,-1)<<endl;
 cout<<gint(1,1)<<endl;
 cout<<gint(1,-1)<<endl;
 cout<<gint(4,3)<<endl;
 cout<<gint(5,4)<<endl;
 //cout<<int_max()(3,4)<<endl;
    cin.get();
    return 0;
}

/*
前20以内+8
20~60 +9
60~100 +8
100~140 +9
140~180 +8
180~220 +9
=>第100个质数为449【实际上Primes[99]=541】
1000以内有质数216个【实际上有168个】
质概率P(n)=1.0625/5(n->∞)
*/
#include "stdafx.h"
#include<vector>
#include<iostream>
#include<cmath>
#include<algorithm>
using namespace std;
unsigned int Primes[]={2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97,101,103,
107,109,113,127,131,137,139,149,151,157,163,167,173,179,181,191,193,197,199,211,223,227,229,233,239,241,251,257,263,269,271,277,281,283,293,307,311,313,317,331,
337,347,349,353,359,367,373,379,383,389,397,401,409,419,421,431,433,439,443,449,457,461,463,467,479,487,491,499,503,509,521,523,541,547,557,563,569,571,577,587,
593,599,601,607,613,617,619,631,641,643,647,653,659,661,673,677,683,691,701,709,719,727,733,739,743,751,757,761,769,773,787,797,809,811,821,823,827,829,839,853,
857,859,863,877,881,883,887,907,911,919,929,937,941,947,953,967,971,977,983,991,997};
//unsigned int Primes[]={2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97,101,103,107
//,109,113,127,131,137,139,149,151,157,163,167,173,179,181,191,193,197,199,211,223
//,227,229,233,239,241,251,257,263,269,271,277,281,283,293,307,311,313,317,331,337
//,347,349,353,359,367,373,379,383,389,397,401,409,419,421,431,433,439,443,449,457
//,461,463,467,479,487,491,499,503,509,521,523,541,547,557,563,569,571,577,587,593
//,599,601,607,613,617,619,631,641,643,647,653,659,661,673,677,683,691,701,709,719
//,727,733,739,743,751,757,761,769,773,787,797,809,811,821,823,827,829,839,853,857
//,859,863,877,881,883,887,907,911,919,929,937,941,947,953,967,971,977,983,991,997};
namespace math
{
 typedef unsigned long DWORD; 
 //函数decomp_integer对n分解素因数，分解后的素数存入facArr数组，并返回因子的个数  
 int decomp_integer( DWORD n, DWORD facArr[]) 
 { 
  DWORD fac;      //n的可能的一个因子  
  int count; 
  if (n<4)        //4以内的数，不需要分解  
  {    
   facArr[0]=n; return 1;   
  } 
  count=0; 
  //下面的while循环为2试出n，直到2不是n的因子为止  
  while ( (n & 1)==0) // 这里判断偶数用 （n &1）==0，这比(n % 2)==0更快  
  { 
   facArr[count++]=2;  n/=2; 
  } 
  fac=3;  //用3到sqrt(n)之间的奇数试除  
  while (fac*fac<=n) // fac*fac <= n  
  { 
   while (n % fac==0) 
   { 
    facArr[count++]=fac; 
    n /= fac; 
   } 
   fac+=2; 
  } 
  if (n==1) 
   return count; 
  facArr[count++]=n; 
  return count; 
 }
 void UFD(unsigned int N,vector<unsigned int> &vecMP,vector<unsigned int> &vecP,vector<unsigned int> &vecA)
 {
  DWORD facArray[32]; 
  int count=decomp_integer(N,facArray);
  for(int i=0;i<count;i++) 
   vecMP.push_back(facArray[i]);
  vecP.insert(vecP.end(),vecMP.begin(), vecMP.end());
  vecP.erase(unique(vecP.begin(),vecP.end()),vecP.end());
  vecA.resize(vecP.size());
  for(int i=0;i<vecP.size();i++)
  {
   vecA[i]=std::count(vecMP.begin(), vecMP.end(),vecP[i]);
  }
 }
/*
EulerPhi(1)=1
EulerPhi(2)=1
EulerPhi(3)=2
EulerPhi(4)=2
EulerPhi(5)=4
EulerPhi(6)=2
EulerPhi(7)=6
EulerPhi(8)=4
EulerPhi(9)=6
EulerPhi(10)=4
EulerPhi(11)=10
EulerPhi(12)=4
*/
/*
定义：给定正整数M，不大于M并与M互素的正整数的个数记作φ(M)，称φ(M)为欧拉函数。
φ(1)=1，φ(2)=1，φ(3)=2，φ(p)=p-1（p设为素数）
M=12=2^2?3，则φ(M)=12(1-1/2)(1-1/3)=4。
若a和b是任意两个互素的正整数，则φ(ab)=φ(a)?φ(b)。
*/
 unsigned int EulerPhi(unsigned int N)
 {
  if(N==1)
   return 1;
  vector<unsigned int> vecMP,vecP,vecA;
  math::UFD(N,vecMP,vecP,vecA);
  unsigned int ret=N;
  for(int i=0;i<vecP.size();i++)
  {
     ret=ret*(vecP[i]-1)/vecP[i];
  }
  return ret;
 }
}
bool IsPrime(unsigned int N)
{
 for(int i=2;i<=sqrt((float)N);i++)
  if(N%i==0)
   return false;
 //else
 // continue;
 return true;
}

int main(void)
{
 //for(int i=2;i<50000;i++)
 // if(IsPrime(i))
 //  printf("%d,",i);
 //printf("%d\n",sizeof(Primes)/sizeof(unsigned int));
 //printf("Primes[99]=%d\n",Primes[99]);
 unsigned int N=300;//72;
 vector<unsigned int> vecMP,vecP,vecA;
 math::UFD(N,vecMP,vecP,vecA);
 system("pause");
 return 0;
}

按定义计算N次剩余符号（N=2,3,4）

问题1：对于有理整数、高斯整数、爱森斯坦整数，N(p)=?
问题2：jacobi4(3,7)=-1<=>x^4=3(mod7)在Z上无解时，J4(3,7)是-1,i,-i中哪一个？
对任意的(α,π)=1，有α^(φ(π))≡1(mod π)，

当π是奇素数时4|φ(π)，
所以，(α^(φ(π)/4-1)-1)(α^(φ(π)/4-1)-i)(α^(φ(π)/4-1)+1)(α^(φ(π)/4-1)+i)≡0(mod π)。
进而推出

(α,π)_4≡α^(φ(π)/4)≡1,i,-1,-i(mod π)有且仅有一种情形成立。

由于0,1,i,-1,-i本身对乘法是封闭的，所以Z[i]中的四次剩余特征可直接定义为

(α,π)_4=1，α是模π的四次剩余，即(α,π)_4≡α^(φ(π)/4)≡1(mod π)，
(α,π)_4=i，α是模π的四次非剩余，且(α,π)_4≡α^(φ(π)/4)≡i(mod π)，
(α,π)_4=-1，α是模π的四次非剩余，且(α,π)_4≡α^(φ(π)/4)≡-1(mod π)，

(α,π)_4=-i，α是模π的四次非剩余，且(α,π)_4≡α^(φ(π)/4)≡-i(mod π)，

(α,π)_4=0，π|α。
三次、四次互反律
Reciprocity Laws - From Euler to Eisenstein - F. Lemmermeyer (Springer, 2000)
http://www.docin.com/p-102193376.html#documentinfo
10.1.1.192.1338 Reciprocity laws, from Euler to Eisenstein （2007）（数论图书评论)http://www.docin.com/p-478399430.html
互反律：从欧拉到爱森斯坦
三次互反律
对Z中三次剩余的讨论，导致对O_Q(sqrt(-3))=Z[e^(2pii/3)]=Z[-1/2+sqrt(-3)/2]中三次剩余特征的研究。
设p是正有理素数，a∈Z，(a,p)=1，我们考虑Z中的三次同余方程x^3≡a(mod p)，x∈Z。----（1）
当p=3或p≡2(mod 3)时，Z中模p的三次剩余特征
(a|p)_(3,Z)≡a^(p-1)/(3,p-1)≡a^(p-1) ≡1(mod p)，----（2）
所以，这时方程（1）总有唯一解。
例如：
jacobi3(13,17)=1
jacobi3(5,17)=1
jacobi3(1,5)=1
jacobi3(2,5)=1
jacobi3(3,5)=1
jacobi3(4,5)=1
jacobi3(7,5)=1
jacobi3(8,5)=1
jacobi3(-3,2)=1
jacobi3(-3,5)=1
jacobi3(5,2)=1
jacobi3(5,3)=1
jacobi3(5,11)=1
jacobi3(5,17)=1
jacobi3(-7,2)=1
jacobi3(-7,3)=1
jacobi3(-7,5)=1
jacobi3(-7,11)=1
jacobi3(-7,17)=1
jacobi3(-11,2)=1
jacobi3(-11,3)=1
jacobi3(-11,5)=1
jacobi3(13,2)=1
jacobi3(13,3)=1
jacobi3(13,5)=1
jacobi3(13,11)=1
jacobi3(13,17)=1
jacobi3(17,2)=1
jacobi3(17,3)=1
jacobi3(17,5)=1
jacobi3(17,11)=1
当p≡1(mod 3)时，同余方程（1）有解的充要条件是
(a|p)_(3,Z)≡a^((p-1)/3)≡1(mod p)，----（3）
另一方面，p≡1(mod 3)在Z[-1/2+sqrt(-3)/2]中是分裂的。
同余方程（1）和Z[-1/2+sqrt(-3)/2]中的同余方程χ^3≡a(mod π_0)，x∈Z[-1/2+sqrt(-3)/2]，同时有解或无解。这样，当p≡1(mod 3)时，Z中模p的三次剩余特征就归结为讨论Z[-1/2+sqrt(-3)/2]中的三次剩余特征。
例如：
jacobi3(-3,7)=-1
jacobi3(-3,11)=1
jacobi3(-3,13)=-1
jacobi3(-3,17)=1
jacobi3(5,7)=-1
jacobi3(5,13)=1
jacobi3(-7,13)=-1
jacobi3(-11,7)=-1
jacobi3(-11,13)=-1
jacobi3(-11,17)=1
jacobi3(13,7)=1
jacobi3(17,7)=-1
jacobi3(17,13)=-1

四次互反律
1825年，高斯研究了有理整数Z中的四次剩余问题。设p∈N是有理素数，a∈Z，p!|a。如果同余方程x^4≡a(mod p)，x∈Z，----（1）有解，就称a是模p的四次剩余；如果无解，就称a是模p的四次非剩余。p=2的情形是显然的，所以下面假定p>=3。
a是模p的四次剩余的充要条件是四次剩余特征
(a|p)_(4,Z)≡a^((p-1)/(4,p-1))≡1(mod p)。----(2)

当p≡3(mod 4)时显有(a|p)_(4,Z)≡(a|p)(mod p)。----(3)
----四次剩余特征和二次剩余特征的联系（20140429举例）
所以,a是模p的四次剩余的充要条件是它是模p的二次剩余。
例如：
jacobi4(-3,7)=1=jacobi(-3,7)=1
jacobi4(-3,11)=-1=jacobi(-3,11)=-1
jacobi4(5,11)=1=jacobi(5,11)=1
jacobi(5,3)=-1=jacobi4(5,3)=-1
jacobi(5,7)=-1=jacobi4(5,7)=-1

当p≡1(mod 4)时, (a|p)_(4,Z)≡a^((p-1)/4)(mod p)。----(4)
所以有,
[(a|p)_(4,Z)]^2≡(a|p) ≡±1(mod p)。----(5)
当a是模p的四次剩余时一定也是二次剩余，当a是模p的二次非剩余时，一定也是四次非剩余。但当a是模p的二次剩余时，即a^((p-1)/2)≡1(mod p)----(6)时，a不一定是四次剩余。
例如：
jacobi4(1,5)=1=>jacobi(1,5)=1
jacobi4(13,17)=1=>jacobi(13,17)=1
jacobi(5,17)=-1=>jacobi4(5,17)=-1
jacobi(-3,5)=-1=>jacobi4(-3,5)=-1
jacobi(-3,17)=-1=>jacobi4(-3,17)=-1
jacobi(5,17)=-1=>jacobi4(5,17)=-1
jacobi(-3,13)=1时，jacobi4(-3,13)=-1
jacobi(-11,5)=1时，jacobi4(-11,5)=-1
jacobi(4,5)=1时，jacobi4(4,5)=-1
jacobi(1,5)=1时，jacobi4(1,5)=1
jacobi(13,17)=1时，jacobi4(13,17)=1
双二次互反律的特殊情形——
1.高斯素数π,σ都是4n+3型的有理素数p,q∈{3,7,11,……}
N(π)=p^2
N(σ)=q^2
[(p^2-1)/4][(q^2-1)/4]=[(4n+4)(4n+2)/4][(4m+4)(4m+2)/4]=(n+1)(m+1)(4n+2)(4m+2)∈2Z
(π/σ)_4(σ/π)_4=(-1)^[(p^2-1)/4][(q^2-1)/4]=1
例如：
(有问题：jacobi4(3,7)=-1<=>jacobi4(7,3)=1
jacobi4(3,11)=1<=>jacobi4(11,3)=-1
jacobi4(7,11)=-1<=>jacobi4(11,7)=1）
2.高斯素数π,σ都是-4n-3型的本原奇素数p,q∈{-3,-7,-11,……}
N(π)=p^2
N(σ)=q^2
[(p^2-1)/4][(q^2-1)/4]=[(-4n-2)(-4n-4)/4][(-4m-4)(-4m-2)/4]=(n+1)(m+1)(4n+2)(4m+2)∈2Z
(π/σ)_4(σ/π)_4=(-1)^[(p^2-1)/4][(q^2-1)/4]=1
例如：
(jacobi4(-3,-7)=-1<=>jacobi4(-7,-3)=-1
J4(-3,-7)、J4(-7,-3)=i或-i中的哪一个？）
二次互反律：对奇素数p，q，(p/q)*(q/p)=(-1)^((p-1)/2*(q-1)/2)
(p/q)*(q/p)=(-1)^((p-1)/2*(q-1)/2)=(-1)^[(4n+2)(4m+2)/4]=(-1)^(4nm+1+2m+2n)=-1
例如：
jacobi(3,7)=-1<=>jacobi(7,3)=1
jacobi(3,11)=1<=>jacobi(11,3)=-1
jacobi(7,11)=-1<=>jacobi(11,7)=1
对奇素数-p，-q，
(p/q)*(q/p)=(-1)^((p-1)/2*(q-1)/2)=(-1)^[(-4n-4)(-4m-4)/4]=1
例如：
jacobi(-3,-7)=-1<=>jacobi(-7,-3)=-1
/*
> jacobi(13,17)
1
> jacobi(5,17)
-1
> jacobi(1,5)
1
> jacobi(2,5)
-1
> jacobi(3,5)
-1
> jacobi(4,5)
1
> jacobi(7,5)
-1
> jacobi(8,5)
-1

c:\>javac jacobiN.java
c:\>java jacobiN
jacobi(13,17)=1
jacobi(5,17)=-1
jacobi(1,5)=1
jacobi(2,5)=-1
jacobi(3,5)=-1
jacobi(4,5)=1
jacobi(7,5)=-1
jacobi(8,5)=-1
jacobi4(13,17)=1
jacobi4(5,17)=-1
jacobi4(1,5)=1
jacobi4(2,5)=-1
jacobi4(3,5)=-1
jacobi4(4,5)=-1
jacobi4(7,5)=-1
jacobi4(8,5)=-1

jacobi3(13,17)=1
jacobi3(5,17)=1
jacobi3(1,5)=1
jacobi3(2,5)=1
jacobi3(3,5)=1
jacobi3(4,5)=1
jacobi3(7,5)=1
jacobi3(8,5)=1
*/

public class jacobiN{
 
/*
按定义计算二次剩余和二次非剩余
x=8,(13/17)=1
x=无解,(5/17)=-1
*/
public static int Legendre(int a,int p)
{
 if(a%p==0)
  return 0;//a是p的倍数
 for(int i=1;i<p;i++)
 {
    if((i*i-a)%p==0)
    {
     return 1;//a是p的二次剩余
    }
 }
    return -1;//a是p的二次非剩余
}

public static int Gauss(int a,int p)
{
 if(a%p==0)
  return 0;//a是p的倍数
 for(int i=1;i<p;i++)
 {
           if((i*i*i*i-a)%p==0)
    {
     return 1;//a是p的四次剩余
    }
 }
    return -1;//a是p的四次非剩余
}

public static int Eisenstein(int a,int p)
{
 if(a%p==0)
  return 0;//a是p的倍数
 for(int i=1;i<p;i++)
 {
           if((i*i*i-a)%p==0)
    {
     return 1;//a是p的三次剩余
    }
 }
    return -1;//a是p的三次非剩余
} 

 public static void main(String args[]){
  jacobiN j1=new jacobiN();
                {
                    int a[]={13,5};
                    int p=17;
                    for(int i=0;i<2;i++)
                    {
                         int ret=Legendre(a[i],p);
                         System.out.printf("jacobi(%d,%d)=%d\n",a[i],p,ret);
                    }
                 }
                {
                    int a[]={1,2,3,4,7,8};
                    int p=5;
                    for(int i=0;i<6;i++)
                    {
                         int ret=Legendre(a[i],p);
                         System.out.printf("jacobi(%d,%d)=%d\n",a[i],p,ret);
                    }
                 }
                {
                    int a[]={13,5};
                    int p=17;
                    for(int i=0;i<2;i++)
                    {
                         int ret=Gauss(a[i],p);
                         System.out.printf("jacobi4(%d,%d)=%d\n",a[i],p,ret);
                    }
                 }
                {
                    int a[]={1,2,3,4,7,8};
                    int p=5;
                    for(int i=0;i<6;i++)
                    {
                         int ret=Gauss(a[i],p);
                         System.out.printf("jacobi4(%d,%d)=%d\n",a[i],p,ret);
                    }
                 }
                {
                    int a[]={13,5};
                    int p=17;
                    for(int i=0;i<2;i++)
                    {
                         int ret=Eisenstein(a[i],p);
                         System.out.printf("jacobi3(%d,%d)=%d\n",a[i],p,ret);
                    }
                 }
                {
                    int a[]={1,2,3,4,7,8};
                    int p[]={5};
                    for(int i=0;i<6;i++)
                    for(int j=0;j<1;j++)
                    {
                         int ret=Eisenstein(a[i],p[j]);
                         System.out.printf("jacobi3(%d,%d)=%d\n",a[i],p[j],ret);
                    }
                 }
 }
 
}

高斯和及欧拉数http://www.docin.com/p-276938834.html
论文摘要：本文研究了广义k次高斯和的均值及欧拉数的一些同余式问题。通过研究广义二次高斯和的四次均值，得到与Weil估计相联系的一个有趣的等式。根据这一恒等式，我们解决了广义二次高斯和的高次均值方面的一个公开问题。利用剩余系和特征和的性质，我们还给出了广义k次高斯和的一些准确的均值公式，从而部分解决了广义k次高斯和高次均值方面的一个公开问题。最后，利用欧拉数、伯努利数及其多项式之间的关系和性质，我们对欧拉数的两个猜想也作了深入研究，建立了欧拉数及伯努利数模一个奇素数幂的一些精确的同余式。从而对目前国内外在这方面所得到的一些结果给出了一个更为简单的证明。  
关键词：高斯和，均值，Weil估计，欧拉数，伯努利数，同余
目录 
引言
1高斯和
1.1特征的定义及基本性质 
1.2高斯和的定义及基本性质
2广义k次高斯和的均值问题
2.1引言 
2.2广义二次高斯和的均值
2.3广义k次高斯和的均值
2.4待解决的问题
3欧拉数的同余式问题
3.1引言
3.2欧拉数的两个猜想
3.3欧拉数的一些有趣的同余式
3.4待解决的问题
引言 

高斯和除了在证明著名的二次互反律、三次互反律、四次互反律等方面是有用的工具外，在代数编码、椭圆曲线等应用方面也发挥着重要的作用（见文[2]和[49]）。欧拉数及相关的伯努利数出现在数学的许多不同分支中，在数论中尤为重要，它们与数论中的p-adic分析理论，Dirichlet L-函数理论和分圆域上的理想类群理论紧密联系在一起（见文[27]和[34]和[10]）。本文从张文鹏教授提出的广义k次高斯和高次均值方面的两个公开问题及加拿大数学家R.K.Guy在文[12]的问题B45中对欧拉数提出的两个猜想出发，得到本文后两章所包含的广义k次高斯和的高次均值公式和欧拉数、伯努利数模奇素数幂的一些精确的同余式。
第一章 高斯和
1.1特征的定义及基本性质
如果有限域F_p上的一个复值函数χ满足：
……则称χ为有限域F_p上的乘法特征。
从乘法特征的定义可知，勒让德符号(a|p)是有限域F_p上的一个乘法特征。
另一个特征的例子是平凡特征，即对所有a∈F_p^*，χ(a)=1。这个特征叫做乘法主特征，记为χ_0。
显然，F_p上的乘法特征把乘群的各类间的乘法运算，具体表示为复数间的乘法运算，这给我们研究问题时带来了方便。为了便于讨论，我们把有限域F_p上的乘法特征的定义域加以扩展为：如果χ=χ_0是乘法主特征，那么χ(0)=1；如果χ≠χ_0，那么χ(0)=0。
定义1.1.2设m是正整数，……
以这种方式定义的χ叫做模m的Dirichlet特征。
由以上定义可知，勒让德符号(a|p)是模p的一个Dirichlet特征。为研究Dirichlet特征的性质，我们考虑一个更一般的问题。
定义1.1.3设G是一个群，如果G上的一个复值函数f满足：
……
则称f为G的一个特征。
显然，每一个群G至少有一个特征，它就是在G上取值恒等于1的函数。这个特征称为主特征。下面一个命题告诉我们：如果G是群并且有有限阶n>1，那么它还有另外的特征。
命题1.1.5阶为n的有限Abel群有且仅有n个不同的特征。
现令G是一个阶为n的有限Abel群，G的主特征用f_1表示，其余n-1个特征用f_2,…f_n表示，称为非主特征。
1.2高斯和的定义及基本性质
在给出经典的二次高斯和的定义及基本性质之前，我们先考虑著名的三角和公式。
命题1.2.1设k是正整数，那么
∑[m=0->k-1]e^(2piimn/k)=k(k|n)或0(k!|n)。
定义1.2.1：令p是一个奇素数，ζ=e^(2pii/p)。则g_a=∑[t=0->p-1](t|p)ζ^(at)叫做二次高斯和，其中(t|p)是勒让德符号。
命题1.2.2 g_a=(a|p)g_1。
命题1.2.3 g^2 =((-1)^((p-1)/2)))p。
命题1.2.4
g_1=sqrt(p)，p≡1(mod4)；
g_1=isqrt(p)，p≡3(mod4)。
【
20140512二次高斯和的程序计算数据：
p=3时，g_0=0,g_1=sqrt(3)i,g_2=-sqrt(3)i
g^2=((-1)^1)3=-3
p=5时，g_0=0,g_1=sqrt(5)，g_2=-sqrt(5)，g_3=-sqrt(5)，g_4=sqrt(5)
g^2=((-1)^2)5=5
p=7时，g_0=0,g_1=sqrt(7)i，g_2=sqrt(7)i，g_3=-sqrt(7)i，g_4=sqrt(7)i，g_5=-sqrt(7)i，g_6=-sqrt(7)i
g^2=((-1)^3)7=-7
p=11时，g_0=0,g_1=sqrt(11)i，g_2=-sqrt(11)i，g_3=sqrt(11)i，g_4=sqrt(11)i，g_5=sqrt(11)i，g_6=-sqrt(11)i，g_7=-sqrt(11)i，g_8=-sqrt(11)i，
g_9=sqrt(11)i，g_10=-sqrt(11)i
g^2=((-1)^5)11=-11
p=13时，g_0=0,g_1=sqrt(13)
g^2=((-1)^6)13=13
p=17时，g_0=0,g_1=sqrt(17),g_5=-sqrt(17),g_13=sqrt(17)
(5/17)=-1
(13/17)=1
g^2=((-1)^8)17=17
#include <iostream>
#include <complex>
using namespace std;

int Legendre(int t,int p)
{
 if(t%p==0)
  return 0;//t是p的倍数
 int ret=-1;
 for(int i=1;i<p;i++)
 {
  if((i*i-t)%p==0)
  {
   return 1;
  }
 }
 return -1;//t是p的二次非剩余
}

complex<double> Zeta(int p)
{
 const double pi=3.14159265358979323846;//4*atan2((double)1,1);//
 complex<double> z=std::exp(complex<double>(0,2*pi/p));
 return z;
}

complex<double> gauss(int a,int p)
{
 complex<double> z(0,0);
 for(int t=0;t<p;t++)
 {
  complex<double> z1=std::pow(Zeta(p),a*t);
  z+=complex<double>(Legendre(t,p),0)*z1;
 }
 return z;
}

int main(int argc, char* argv[])
{

#if 1
 int primes[12]={2,3,5,7,11,13,17,19,23,29,31,37};
 for(int i=0;i<12;i++)
 {
  int p=primes[i];
        for(int a=0;a<p;a++)
  {
   cout<<"gauss(a="<<a<<",p="<<p<<")="<<gauss(a,p)<<endl;
  }
 }
#endif

 system("pause");
 return 0;
}
】
关于四次高斯和的六次均值http://www.docin.com/p-716077328.html
目录
摘要
第一章引言
第二章基础知识
2.1Dirichlet特征的基本性质
2.2Gauss和的基本性质
第三章四次高斯和的六次均值
3.1简述及主要结果
3.2四次高斯和的均值公式

第2章基础知识
§2.1Dirichlet特征的基本性质
定义2.1.1设g是模m的原根，(a,m)=1。我们把使g^e≡a(modm)成立的e称为是a以原根g为底对模m的指标，记作e=ind_(m,g)a=ind_(m)a。
指标e对模φ(m)是唯一确定的，且有ind_(m,g)ab= ind_(m,g)a+ ind_(m,g)b(modφ(m))。
定义2.1.3……称为是模m的积性特征（简称模m的特征）或Dirichlet特征。
显见，两个模m的特征的乘积仍然是模m的特征。
χ(a)全取实值的特征称为实特征，不然，称为复特征。
χ(-1)=1的特征χ叫做偶特征，χ(-1)=-1的特征χ叫做奇特征。
(a,m)=1时，χ(a)=1；(a,m)≠1时，χ(a)=0。
称为是模m的主特征，记作χ_0(a)=χ_0(a,m)。
定义2.15：使(χ(a,m))^d=1,(a,m)=1成立的最小正整数d称为模m的积性特征χ(a,m)的阶。
由性质2.1.4知模m的积性特征的阶一定是φ(m)的除数。
§2.2Guass和的基本性质
定义2.2.1设m>=3为整数，我们把G(n,χ)=∑[a=1->m] χ(a)e(na/m)称为关于特征χ的Gauss和。
特别地，记τ(x)=G(1,x)= =∑[a=1->m] χ(a)e(a/m)，其中e(y)=e^(2piiy)，χ表示模m的Dirichlet特征。
显然，若χ是模p的二次特征，我们容易得到
τ(χ)=sqrt(p)，p≡1(mod4)；
τ(χ)=isqrt(p)，p≡3(mod4)。
定义2.2.2：我们把J(χ_1,χ_2)=∑[m,nmodp,m+n≡1(modp)] χ_1(n)χ_2(n)称为关于特征χ_1,χ_2的Jacobi和。

/*
(2,1)|(5,0),(5,0)=(2,1)*(2,-1)
gcd((5,0),(2,1))=(2,1)
simple_gcd((5,0),(2,1))=(2,1)
extended_gcd((5,0),(2,1))=(2,1),x=(0,0),y=(1,0)
gcd((7,5),(18,5))=(0,-1)
simple_gcd((7,5),(18,5))=(0,-1)
extended_gcd((7,5),(18,5))=(0,-1),x=(-1,-9),y=(-1,4)
gcd((112,1),(-57,79))=(4,7)
simple_gcd((112,1),(-57,79))=(4,7)
extended_gcd((112,1),(-57,79))=(4,7),x=(-1,-6),y=(5,-5)

*/
#if 1
 std::complex<float> af(5,0);
 std::complex<float> bf(2,1);
 std::complex<float> cf=af/bf;
    std::complex<long> a(5,0);
    std::complex<long> b(2,1);
 std::complex<long> c=Div(a,b);//不要写a/b;
 std::complex<long> cb=c*b;
 if(a==cb)
 {
  cout<<b<<"|"<<a<<","<<a<<"="<<b<<"*"<<c<<endl;
 }
 std::complex<long> q,r;
 bool bret=divide(a,b,q,r);

 {
  std::complex<long> a[]={std::complex<long>(5,0),std::complex<long>(7,5),std::complex<long>(112,1)};
  std::complex<long> b[]={std::complex<long>(2,1),std::complex<long>(18,5),std::complex<long>(-57,79)};
  for(int i=0;i<3;i++)
  {
   //cout<<"abs:"<<abs(a[i])<<","<<abs(b[i])<<endl;
   //cout<<"Norm:"<<Norm(a[i])<<","<<Norm(b[i])<<endl;
   std::complex<long> ret=gcd(a[i],b[i]);
   cout<<"gcd("<<a[i]<<","<<b[i]<<")="<<ret<<endl;
   std::complex<long> ret1=simple_gcd(a[i],b[i]);
   cout<<"simple_gcd("<<a[i]<<","<<b[i]<<")="<<ret1<<endl;
   std::complex<long> x,y;
   std::complex<long> ret2=extended_gcd(a[i],b[i],x,y);
   cout<<"extended_gcd("<<a[i]<<","<<b[i]<<")="<<ret2<<",x="<<x<<",y="<<y<<endl;
  }
 }

#endif
std::complex<long> Div(const std::complex<long> &a,const std::complex<long> &b)
{
 std::complex<float> af(a.real(),a.imag());
 std::complex<float> bf(b.real(),b.imag());
 std::complex<float> cf=af/bf;
 long cr=cf.real()>0?(long)(cf.real()+0.5):(long)(cf.real()-0.5);
 long ci=cf.imag()>0?(long)(cf.imag()+0.5):(long)(cf.imag()-0.5);
 std::complex<long> c(cr,ci);
 return c;
}

bool divide(const std::complex<long>& a, const std::complex<long>& b,std::complex<long>& q, std::complex<long>& r)
{
  //long qr = floor((a/b).real() + 0.5);
  //long qi = floor((a/b).imag() + 0.5);
  //q = std::complex<long>(qr,qi);
  q=Div(a,b);
  r = a - q*b;
  bool bret=(r==std::complex<long>(0,0));
  return bret;
}

long Norm(const std::complex<long>& a)
{
 return (a.real()*a.real()+a.imag()*a.imag());
}

std::complex<long> gcd(const std::complex<long>& a, const std::complex<long>& b)
{
 std::complex<long> x = a, y = b;
 //if(abs(x)<abs(y) )
 if(Norm(x)<Norm(y) )
 {
  std::swap(x,y);
 }
 while ( y != std::complex<long>(0,0) ) {
  std::complex<long> q,r;
  bool ret=divide(x,y,q,r);
  x = y;
  y = r;
 }
 return x;
}

std::complex<long> simple_gcd(const std::complex<long>& a, const std::complex<long>& b)
{

  std::complex<long> aa = a, bb = b;

  //if ( abs(aa) < abs(bb) )
  if(Norm(aa)<Norm(bb) )
  {
      std::swap(aa,bb);
   }

  //while ( abs(bb) != 0)
  while(bb != std::complex<long>(0,0))
   {
      std::complex<long> qq, rr;
      bool bret=divide (aa, bb, qq, rr);
      aa = bb;
      bb = rr;
   }

  return aa;
}

std::complex<long> extended_gcd(const std::complex<long>& a, const std::complex<long>& b,std::complex<long>& x, std::complex<long>& y)
{
 std::complex<long> aa = a, bb = b;
 bool swapped = false;
 //if( abs(aa) < abs(bb) )
 if(Norm(aa)<Norm(bb) )
 {
  std::swap(aa,bb);
  swapped = true;
 }
 std::complex<long> xx = 0, lx = 1, yy = 1, ly = 0;
 do
 {
  std::complex<long> qq, rr;
  bool bret=divide (aa, bb, qq, rr);
  aa = bb; bb = rr;

  std::complex<long> tx = lx - qq*xx;
  lx = xx; xx = tx;

  std::complex<long> ty = ly - qq*yy;
  ly = yy; yy = ty;
 }while (bb != std::complex<long>(0,0));

 x = lx;
 y = ly;
 if (swapped)
 {
  std::swap(x,y);
 }

 return aa;
}

在高斯整数环（The ring of Gaussian integers）Z[i]={a+bi|a,b∈Z}——环(Z[i],+,·)中2+3i生成的理想((2+3i))由以下元素组成：

(2+3i)(a+bi)=(2a-3b)+(3a+2b)i,a,b∈Z。

但由2+3i生成的子环<2+3i>是由以下元素组成：

(2+3i)f(2+3i),f(x)∈Z[x]

(2+3i)f(2+3i)=(2+3i)(2c+d+3ci),c,d∈Z。

<2+3i>{<}((2+3i))

子环<2+3i>不是理想

在环(Z[i],+,·)中，它的子环Z就不是理想。

求7+5i和18+5i的最大公因数：

1=(9-i)(7+5i)+(-4-i)(18+5i)。

求112+i和-57+79i的最大公因数：

(112+i,-57+79i)=4+7i。

求a=1734+1938i的素因子分解式。

a=i(1+i)^3·3·(1+2i)^2·(2+3i)·(1+4i)·(1-4i)

在复数域C、高斯整数环Z[i]内的整数相除结果：
'(4+8j)/(7+9j)=0.76923+0.1538j
'(471+643j)/(9+11j)=56+3j
算式解析
(4+8i)/(7+9i)
ans = 0.769230769230769 + 0.153846153846154i
(471+643i)/(9+11i)
ans = 56 + 3i

/*
第1个偶素数:(1,1)
第2个偶素数:(-1,1)
第3个偶素数:(-1,-1)
第4个偶素数:(1,-1)
*/
#if 1
 static std::complex<long> k[4]={std::complex<long>(1,0),std::complex<long>(0,1),std::complex<long>(-1,0),std::complex<long>(0,-1)};
 std::complex<long> evenP(1,1);
 for(int i=0;i<4;i++)
 {
    std::complex<long> kP=k[i]*evenP;
    cout<<"第"<<(i+1)<<"个偶素数:"<<kP<<endl;
 }
#endif
Z[i]是可数集，每一个高斯整数a+bi存在一个固定的编号f_1234(a,b)；而下面这里的编号是f_14(a,b)，不是f_1234(a,b)。
下面考虑第一、四象限内a，b∈[0,9]的高斯整数，二、三象限内的高斯整数是这些高斯整数对应的相伴数。
第1-134个高斯合数:(0,0),(0,1),(0,-1),(0,2),(0,-2),(0,4),(0,-4),(0,5),(0,-5),(0,6),(0,-6),(0,8),(0,-8),(0,9),(0,-9),(1,0),(1,3),(1,-3),(1,5),(1,-5),(1,7),(1,-7),(1,8),(1,-8),(1,9),(1,-9),(2,0),(2,2),(2,-2),(2,4),(2,-4),(2,6),(2,-6),(2,8),(2,-8),(2,9),(2,-9),(3,1),

(3,-1),(3,3),(3,-3),(3,4),(3,-4),(3,5),(3,-5),(3,6),(3,-6),(3,7),(3,-7),(3,9),(3,-9),(4,0),(4,2),(4,-2),(4,3),(4,-3),

(4,4),(4,-4),(4,6),(4,-6),(4,7),(4,-7),(4,8),(4,-8),(5,0),(5,1),(5,-1),(5,3),(5,-3),(5,5),(5,-5),(5,7),(5,-7),(5,9),(5,-9),(6,0),(6,2),(6,-2),(6,3),(6,-3),(6,4),(6,-4),(6,6),(6,-6),(6,7),(6,-7),(6,8),(6,-8),(6,9),(6,-9),(7,1),(7,-1),(7,3),(7,-3),(7,4),(7,-4),(7,5),(7,-5),(7,6),(7,-6),(7,7),(7,-7),(7,9),(7,-9),(8,0),(8,1),(8,-1),(8,2),(8,-2),(8,4),(8,-4),(8,6),(8,-6),(8,8),(8,-8),(8,9),(8,-9),(9,0),(9,1),(9,-1),(9,2),(9,-2),(9,3),(9,-3),(9,5),(9,-5),(9,6),(9,-6),(9,7),(9,-7),(9,8),(9,-8),(9,9),(9,-9)
第1-56个高斯素数:(0,3),(0,-3),(0,7),(0,-7),(1,4),(1,1),(1,-1),(1,2),(1,-2),(1,-4),(1,6),(1,-6),(2,1),(2,-1),(2,3),(2,-3),(2,5),(2,-5),(2,7),(2,-7),(3,0),(3,2),(3,-2),(3,8),(3,-8),(4,1),(4,-1),(4,5),(4,-5),(4,9),(4,-9),(5,2),(5,-2),(5,4),(5,-4),(5,6),(5,-6),(5,8),(5,-8),(6,1),(6,-1),(6,5),(6,-5),(7,0),(7,2),(7,-2),(7,8),(7,-8),(8,3),(8,-3),(8,5),(8,-5),(8,7),(8,-7),(9,4),(9,-4)
第1-23个奇本原数:(1,0),(1,4),(1,-4),(1,8),(1,-8),(3,2),(3,-2),(3,6),(3,-6),(5,0),(5,4),(5,-4),(5,8),(5,-8),(7,2),(7,-2),(7,6),(7,-6),(9,0),(9,4),(9,-4),(9,8),(9,-8)
一四象限
第1个本原奇素数:(1,4)
第2个本原奇素数:(1,-4)
第3个本原奇素数:(3,2)
第4个本原奇素数:(3,-2)
第5个本原奇素数:(5,4)
第6个本原奇素数:(5,-4)
第7个本原奇素数:(5,8)
第8个本原奇素数:(5,-8)
第9个本原奇素数:(7,2)
第10个本原奇素数:(7,-2)
第11个本原奇素数:(9,4)
第12个本原奇素数:(9,-4)
一二三四象限

第1个本原奇素数:(-1,2)
第2个本原奇素数:(-1,-2)
第3个本原奇素数:(1,4)
第4个本原奇素数:(1,-4)
第5个本原奇素数:(-1,6)
第6个本原奇素数:(-1,-6)
第7个本原奇素数:(-3,0)
第8个本原奇素数:(3,2)
第9个本原奇素数:(3,-2)
第10个本原奇素数:(-3,8)
第11个本原奇素数:(-3,-8)
第12个本原奇素数:(-5,2)
第13个本原奇素数:(-5,-2)
第14个本原奇素数:(5,4)
第15个本原奇素数:(5,-4)
第16个本原奇素数:(-5,6)
第17个本原奇素数:(-5,-6)
第18个本原奇素数:(5,8)
第19个本原奇素数:(5,-8)
第20个本原奇素数:(-7,0)
第21个本原奇素数:(7,2)
第22个本原奇素数:(7,-2)
第23个本原奇素数:(-7,8)
第24个本原奇素数:(-7,-8)
第25个本原奇素数:(9,4)
第26个本原奇素数:(9,-4)
命题2.1：设p是一个正奇素数，则
p是分歧的<=>p|d，
p是分裂的<=>(d/p)=+1，
p是惯性的<=>(d/p)=-1。
类似地，
p=2是分歧的<=>d≡0 mod4，
p=2是分裂的<=>d≡1 mod8，
p=2是惯性的<=>d≡5 mod8。
这个分解定律可以简单地表示为克罗内克符号(d/p)。
判别式为d的二次数域k=Q(sqrt(d))
①(d/p)=+1,若p在Q(sqrt(d))中是分裂的
②(d/p)=0,若p在Q(sqrt(d))中是分歧的
③(d/p)=-1,若p在Q(sqrt(d))中是惯性的
对于奇素数p!|d，这个符号与勒让德符号是相符的。

§3.3 Z[i]中的算术
§3.3A Z[i]中的整除
Z[i]的分式域是Q(i)。
~α=r-si称为α=r+si在域Q(i)中的共轭数，当α∈Q时，~α=α。
整环Z[i]中仅有四个单位元素，也称为单位数：1，i，-1，-i。
定义1：设α=r+si∈Q(i)，我们把T(α)=T_i(α)=α+~α=2r称为α在域Q(i)中的迹；把N(α)=N_i(α)=α~α=r^2+s^2称为α在域Q(i)中的范数。
对定义1要注意的是当α等于有理数r时，它在Q(i)中的迹和范数分别是2r和r^2。
§3.3B Z[i]中的剩余系
定理8：设0≠μ=a+bi∈Z[i]，那么，模μ的一个完全剩余系的元素个数R(μ)=N(μ)，以及
x_m,n=m+ni，m=0,1,…,N(μ)/(a,b)-1，n=0,1,…,(a,b)-1，
是模μ的一个完全剩余系。----(a,b)是最大公约数
例5：求模2+3i的完全剩余系、既约剩余系。
N(2+3i)=13，所以2+3i是素数。因此完全剩余系是0,1,…,12；既约剩余系是1,2，…，12，φ(2+3i)=12。
例6：求模3+6i的完全剩余系和既约剩余系。
3+6i=3(1+2i),3,1+2i都是素数，它们是互素的。
3+6i的完全剩余系是：m+ni,m=0,1,…,14,n=0,1,2。
3的既约剩余系是：m_1+n_1i，0<=m_1,n_1<=2，m_1+n_1≠0。
1+2i的既约剩余系是：m_2,m_2=1,…,4。
因此，3+6i的既约剩余系：6m_2+(-5)(m_1+n_1i)，φ(3+6i)=φ(3)φ(1+2i)=20。

定义1：设α∈Z[i]，若2!|N_i(α), 则称α为偶整数；若2|N_i(α), 则称α为奇整数。——这个说反了吧
Z[i]是Euclid整环，仅有的偶素数就是1+i及其相伴数。
设β是奇整数，它的四个相伴数是β，iβ，-β，-iβ。
定义2：一个奇整数β∈Z[i]称为是Z[i]中的本原数，如果满足β≡1(mod(1+i)^3)。
一个偶整数α≠0称为是Z[i]中的本原数，如果它的表示式α=(1+i)^kβ中的奇整数β是本原数；0也看作是Z[i]中的本原数。

由定义立即推出：本原数的乘积一定是本原数；非零的本原数乘非本原数一定是非本原数；不同的本原数是互不相伴的。
这样Z[i]中的全体本原数就给出了Z[i]的一个代表集合，把它记作Z_0[i]。
下面的定理对判断奇本原数是有用的。
定理1：设β=a+bi∈Z[i]，那么它是奇本原数的充要条件是2|b,a+b≡1(mod 4)。
本原偶素数是1+i，奇素数π=a+bi有两种情形。一是π和有理素数q≡3(mod 4)相伴，这时由定理1知，π=-q，是Z[i]中的本原奇素数；一种是N(π)=p,p≡1(mod 4)是有理素数，因此满足p=a^2+b^2，由定理1知恰好给出一对共轭的本原奇素数（不相伴）：π=a+bi，~π=a-bi。
例如，p=17给出本原奇素数1±4i，p=5给出本原奇素数-1±2i。

由于对任一奇整数β∈Z[i]必有β≡1(mod(1+i))，
所以同余方程ξ^n≡β(mod(1+i))总有解。因而我们在Z[i]中只要讨论以奇素数为模的二次、四次剩余特征。为简单起见在本节中记
(α,π)_2=(α,π)_(2,Z[i])，
(α,π)_4=(α,π)_(4,Z[i])，
并约定模π一定是本原奇素数。
对任意的(α,β)=1，有α^(φ(π))≡1(mod π)，
由于π是奇素数，因此，
(α,π)_2≡α^(φ(π)/2)≡±1(mod π)有且仅有一种情形成立。由于0,1,-1本身对乘法是封闭的，所以Z[i]中的二次剩余特征可直接定义为
(α,π)_2=1，α是模π的二次剩余，
(α,π)_2=-1，α是模π的二次非剩余，
(α,π)_2=0，π|α。

复数9 + 11i乘以56 + 3i的积为复数471 + 643i
复数9 + 11ω乘以56 + 3ω的积为复数471 + 610ω
'以下是计算高斯整数乘积和艾森斯坦整数乘积的vbs代码
function eMul(z1,z2)
z3e = array(0,0)
'或dim z3e(2)
z3e(0)=z1(0)*z2(0)-z1(1)*z2(1)
z3e(1)=z1(0)*z2(1)+z1(1)*z2(0)-z1(1)*z2(1)
eMul=z3e
end function

function eStr(z)
s=z(0) & " + " & z(1) & "ω"
eStr=s
end function

function gMul(z1,z2)
z3 = array(0,0)
'或dim z3(2)
z3(0)=z1(0)*z2(0)-z1(1)*z2(1)
z3(1)=z1(0)*z2(1)+z1(1)*z2(0)
gMul=z3
end function

function gStr(z)
s=z(0) & " + " & z(1) & "i"
gStr=s
end function

function MulStr(z1,z2,z3)
s="复数" & z1 & "乘以" & z2 & "的积为复数" & z3
MulStr=s
end function

z1=array(9,11)
z2=array(56,3)
z3=gMul(z1,z2)
z3e=eMul(z1,z2)
'MsgBox z3(0) & " + " & z3(1) & "i"
sg=MulStr(gStr(z1),gStr(z2),gStr(z3))
se=MulStr(eStr(z1),eStr(z2),eStr(z3e))
MsgBox sg
MsgBox se

my_date1=date
my_date2 = DatePart("yyyy",my_date1) & "-" & Right("0" & DatePart("m",my_date1), 2) & "-" & Right("0" & DatePart("d",my_date1),2)
Const ForAppending = 8
Set objFSO = CreateObject("Scripting.FileSystemObject")
Set objTextFile = objFSO.OpenTextFile(my_date2 & ".txt", ForAppending, True, -1)
objTextFile.WriteLine sg
objTextFile.WriteLine se
objTextFile.Close


整数环、高斯整数环、艾森斯坦整数环、某个代数整数环是可数的。
a+bω的共轭为a+bω^2
a+bω和a+bω^2的范数都为(a+bω)(a+bω^2)=a^-ab+b^2
a+bω的6个相伴元：a+bω,-a-bω，-b+(a-b)ω，b+(b-a)ω，(b-a)-aω，(a-b)+aω，范数都是a^-ab+b^2

1+0ω=(1,0)    1+0ω^2=(1,0)

-1+0ω=(-1,0)    -1+0ω^2=(-1,0)

0+1ω=(-0.5,0.866025)    0+1ω^2=(-0.5,-0.866026)

0+-1ω=(0.5,-0.866025)    0+-1ω^2=(0.5,0.866026)

1+1ω=(0.5,0.866025)    1+1ω^2=(0.5,-0.866026)

1+-1ω=(1.5,-0.866025)    1+-1ω^2=(1.5,0.866026)

4+3ω=(2.5,2.59808)    4+3ω^2=(2.5,-2.59808)

5+4ω=(3,3.4641)    5+4ω^2=(3,-3.4641)

0+0ω=(0,0)    0+0ω^2=(0,0)
复数模不超过6.9282且范数不超过48的艾森斯坦整数共有81个。
应该是：|a|，|b|<=4的艾森斯坦整数共有81个。
第0个艾森斯坦整数是0+0ω=(0,0)不是艾森斯坦素数 复数模：0范数:0
第1个艾森斯坦整数是1+0ω=(1,0)不是艾森斯坦素数 复数模：1范数:1
第2个艾森斯坦整数是1+1ω=(0.5,0.866025)不是艾森斯坦素数 复数模：1范数:1
第3个艾森斯坦整数是0+1ω=(-0.5,0.866025)不是艾森斯坦素数 复数模：1范数:1
第4个艾森斯坦整数是-1+0ω=(-1,0)不是艾森斯坦素数 复数模：1范数:1
第5个艾森斯坦整数是-1+-1ω=(-0.5,-0.866025)不是艾森斯坦素数 复数模：1范数:1
第6个艾森斯坦整数是0+-1ω=(0.5,-0.866025)不是艾森斯坦素数 复数模：1范数:1
第7个艾森斯坦整数是2+1ω=(1.5,0.866025)是艾森斯坦素数 复数模：1.73205范数:3
第8个艾森斯坦整数是1+2ω=(-1.19209e-007,1.73205)是艾森斯坦素数 复数模：1.73205范
数:3
第9个艾森斯坦整数是-1+1ω=(-1.5,0.866025)是艾森斯坦素数 复数模：1.73205范数:3
第10个艾森斯坦整数是-2+-1ω=(-1.5,-0.866025)是艾森斯坦素数 复数模：1.73205范数:3

第11个艾森斯坦整数是-1+-2ω=(1.19209e-007,-1.73205)是艾森斯坦素数 复数模：1.7320
5范数:3
第12个艾森斯坦整数是1+-1ω=(1.5,-0.866025)是艾森斯坦素数 复数模：1.73205范数:3
第13个艾森斯坦整数是2+0ω=(2,0)是艾森斯坦素数 复数模：2范数:4
第14个艾森斯坦整数是2+2ω=(1,1.73205)是艾森斯坦素数 复数模：2范数:4
第15个艾森斯坦整数是0+2ω=(-1,1.73205)是艾森斯坦素数 复数模：2范数:4
第16个艾森斯坦整数是-2+0ω=(-2,0)是艾森斯坦素数 复数模：2范数:4
第17个艾森斯坦整数是-2+-2ω=(-1,-1.73205)是艾森斯坦素数 复数模：2范数:4
第18个艾森斯坦整数是0+-2ω=(1,-1.73205)是艾森斯坦素数 复数模：2范数:4
第19个艾森斯坦整数是3+1ω=(2.5,0.866025)是艾森斯坦素数 复数模：2.64575范数:7
第20个艾森斯坦整数是3+2ω=(2,1.73205)是艾森斯坦素数 复数模：2.64575范数:7
第21个艾森斯坦整数是2+3ω=(0.5,2.59808)是艾森斯坦素数 复数模：2.64575范数:7
第22个艾森斯坦整数是1+3ω=(-0.5,2.59808)是艾森斯坦素数 复数模：2.64575范数:7
第23个艾森斯坦整数是-1+2ω=(-2,1.73205)是艾森斯坦素数 复数模：2.64575范数:7
第24个艾森斯坦整数是-2+1ω=(-2.5,0.866025)是艾森斯坦素数 复数模：2.64575范数:7
第25个艾森斯坦整数是-3+-1ω=(-2.5,-0.866025)是艾森斯坦素数 复数模：2.64575范数:7

第26个艾森斯坦整数是-3+-2ω=(-2,-1.73205)是艾森斯坦素数 复数模：2.64575范数:7
第27个艾森斯坦整数是-2+-3ω=(-0.5,-2.59808)是艾森斯坦素数 复数模：2.64575范数:7
第28个艾森斯坦整数是-1+-3ω=(0.5,-2.59808)是艾森斯坦素数 复数模：2.64575范数:7
第29个艾森斯坦整数是1+-2ω=(2,-1.73205)是艾森斯坦素数 复数模：2.64575范数:7
第30个艾森斯坦整数是2+-1ω=(2.5,-0.866025)是艾森斯坦素数 复数模：2.64575范数:7
第31个艾森斯坦整数是3+0ω=(3,0)不是艾森斯坦素数 复数模：3范数:9
第32个艾森斯坦整数是3+3ω=(1.5,2.59808)不是艾森斯坦素数 复数模：3范数:9
第33个艾森斯坦整数是0+3ω=(-1.5,2.59808)不是艾森斯坦素数 复数模：3范数:9
第34个艾森斯坦整数是-3+0ω=(-3,0)不是艾森斯坦素数 复数模：3范数:9
第35个艾森斯坦整数是-3+-3ω=(-1.5,-2.59808)不是艾森斯坦素数 复数模：3范数:9
第36个艾森斯坦整数是0+-3ω=(1.5,-2.59808)不是艾森斯坦素数 复数模：3范数:9
第37个艾森斯坦整数是4+2ω=(3,1.73205)不是艾森斯坦素数 复数模：3.4641范数:12
第38个艾森斯坦整数是2+4ω=(-2.38419e-007,3.4641)不是艾森斯坦素数 复数模：3.4641
范数:12
第39个艾森斯坦整数是-2+2ω=(-3,1.73205)不是艾森斯坦素数 复数模：3.4641范数:12
第40个艾森斯坦整数是-4+-2ω=(-3,-1.73205)不是艾森斯坦素数 复数模：3.4641范数:12
第41个艾森斯坦整数是-2+-4ω=(2.38419e-007,-3.4641)不是艾森斯坦素数 复数模：3.464
1范数:12
第42个艾森斯坦整数是2+-2ω=(3,-1.73205)不是艾森斯坦素数 复数模：3.4641范数:12
第43个艾森斯坦整数是4+1ω=(3.5,0.866025)是艾森斯坦素数 复数模：3.60555范数:13
第44个艾森斯坦整数是4+3ω=(2.5,2.59808)是艾森斯坦素数 复数模：3.60555范数:13
第45个艾森斯坦整数是3+4ω=(1,3.4641)是艾森斯坦素数 复数模：3.60555范数:13
第46个艾森斯坦整数是1+4ω=(-1,3.4641)是艾森斯坦素数 复数模：3.60555范数:13
第47个艾森斯坦整数是-1+3ω=(-2.5,2.59808)是艾森斯坦素数 复数模：3.60555范数:13
第48个艾森斯坦整数是-3+1ω=(-3.5,0.866025)是艾森斯坦素数 复数模：3.60555范数:13
第49个艾森斯坦整数是-4+-1ω=(-3.5,-0.866025)是艾森斯坦素数 复数模：3.60555范数:1
3
第50个艾森斯坦整数是-4+-3ω=(-2.5,-2.59808)是艾森斯坦素数 复数模：3.60555范数:13

第51个艾森斯坦整数是-3+-4ω=(-1,-3.4641)是艾森斯坦素数 复数模：3.60555范数:13
第52个艾森斯坦整数是-1+-4ω=(1,-3.4641)是艾森斯坦素数 复数模：3.60555范数:13
第53个艾森斯坦整数是1+-3ω=(2.5,-2.59808)是艾森斯坦素数 复数模：3.60555范数:13
第54个艾森斯坦整数是3+-1ω=(3.5,-0.866025)是艾森斯坦素数 复数模：3.60555范数:13
第55个艾森斯坦整数是4+0ω=(4,0)不是艾森斯坦素数 复数模：4范数:16
第56个艾森斯坦整数是4+4ω=(2,3.4641)不是艾森斯坦素数 复数模：4范数:16
第57个艾森斯坦整数是0+4ω=(-2,3.4641)不是艾森斯坦素数 复数模：4范数:16
第58个艾森斯坦整数是-4+0ω=(-4,0)不是艾森斯坦素数 复数模：4范数:16
第59个艾森斯坦整数是-4+-4ω=(-2,-3.4641)不是艾森斯坦素数 复数模：4范数:16
第60个艾森斯坦整数是0+-4ω=(2,-3.4641)不是艾森斯坦素数 复数模：4范数:16
第61个艾森斯坦整数是-2+3ω=(-3.5,2.59808)是艾森斯坦素数 复数模：4.3589范数:19
第62个艾森斯坦整数是-3+2ω=(-4,1.73205)是艾森斯坦素数 复数模：4.3589范数:19
第63个艾森斯坦整数是2+-3ω=(3.5,-2.59808)是艾森斯坦素数 复数模：4.3589范数:19
第64个艾森斯坦整数是3+-2ω=(4,-1.73205)是艾森斯坦素数 复数模：4.3589范数:19
第65个艾森斯坦整数是-1+4ω=(-3,3.4641)不是艾森斯坦素数 复数模：4.58258范数:21
第66个艾森斯坦整数是-4+1ω=(-4.5,0.866025)不是艾森斯坦素数 复数模：4.58258范数:2
1
第67个艾森斯坦整数是1+-4ω=(3,-3.4641)不是艾森斯坦素数 复数模：4.58258范数:21
第68个艾森斯坦整数是4+-1ω=(4.5,-0.866025)不是艾森斯坦素数 复数模：4.58258范数:2
1
第69个艾森斯坦整数是-3+3ω=(-4.5,2.59808)不是艾森斯坦素数 复数模：5.19615范数:27

第70个艾森斯坦整数是3+-3ω=(4.5,-2.59808)不是艾森斯坦素数 复数模：5.19615范数:27

第71个艾森斯坦整数是-2+4ω=(-4,3.4641)不是艾森斯坦素数 复数模：5.2915范数:28
第72个艾森斯坦整数是-4+2ω=(-5,1.73205)不是艾森斯坦素数 复数模：5.2915范数:28
第73个艾森斯坦整数是2+-4ω=(4,-3.4641)不是艾森斯坦素数 复数模：5.2915范数:28
第74个艾森斯坦整数是4+-2ω=(5,-1.73205)不是艾森斯坦素数 复数模：5.2915范数:28
第75个艾森斯坦整数是-3+4ω=(-5,3.4641)是艾森斯坦素数 复数模：6.08276范数:37
第76个艾森斯坦整数是-4+3ω=(-5.5,2.59808)是艾森斯坦素数 复数模：6.08276范数:37
第77个艾森斯坦整数是3+-4ω=(5,-3.4641)是艾森斯坦素数 复数模：6.08276范数:37
第78个艾森斯坦整数是4+-3ω=(5.5,-2.59808)是艾森斯坦素数 复数模：6.08276范数:37
第79个艾森斯坦整数是-4+4ω=(-6,3.4641)不是艾森斯坦素数 复数模：6.9282范数:48
第80个艾森斯坦整数是4+-4ω=(6,-3.4641)不是艾森斯坦素数 复数模：6.9282范数:48
 // 按范数和辐角主值从小到大排列顺序
 bool operator < (const eint &m)const
 {
  int norm1=m_a*m_a+m_b*m_b-m_a*m_b;
  int norm2=m.m_a*m.m_a+m.m_b*m.m_b-m.m_a*m.m_b;
  float arg1=atan2f(m_b,m_a);
  float arg2=atan2f(m.m_b,m.m_a);
  float pi=atan2f(0,-1);
  if(arg1<0)
   arg1+=2*pi;
  if(arg2<0)
   arg2+=2*pi;
  if(norm1!=norm2)
   return norm1<norm2;
  else
   return arg1<arg2;
 }

// 按范数和辐角主值从小到大排列顺序

bool operator < (const gint &m)const 

{

  int norm1=m_a*m_a+m_b*m_b;

  int norm2=m.m_a*m.m_a+m.m_b*m.m_b;

  float arg1=atan2f(m_b,m_a);

  float arg2=atan2f(m.m_b,m.m_a);

  float pi=atan2f(0,-1);

  if(arg1<0)

  arg1+=2*pi;

  if(arg2<0)

  arg2+=2*pi;

  if(norm1!=norm2)

  return norm1<norm2;

  else

           return arg1<arg2;

}

范数不超过36的高斯整数共有169个。
范数不超过100的高斯整数共有441个。
应该是：|a|，|b|<=6,10的高斯整数共有169，441个。

第0个高斯整数是0不是高斯素数

第1个高斯整数是1不是高斯素数

第2个高斯整数是1i不是高斯素数

第3个高斯整数是-1不是高斯素数

第4个高斯整数是-1i不是高斯素数

第5个高斯整数是1+1i是高斯素数

第6个高斯整数是-1+1i是高斯素数

第7个高斯整数是-1-1i是高斯素数

第8个高斯整数是1-1i是高斯素数

第9个高斯整数是2不是高斯素数

第10个高斯整数是2i不是高斯素数

第11个高斯整数是-2不是高斯素数

第12个高斯整数是-2i不是高斯素数

第13个高斯整数是2+1i是高斯素数

第14个高斯整数是1+2i是高斯素数

第15个高斯整数是-1+2i是高斯素数

第16个高斯整数是-2+1i是高斯素数

第17个高斯整数是-2-1i是高斯素数

第18个高斯整数是-1-2i是高斯素数

第19个高斯整数是1-2i是高斯素数

第20个高斯整数是2-1i是高斯素数

第21个高斯整数是2+2i不是高斯素数

第22个高斯整数是-2+2i不是高斯素数

第23个高斯整数是-2-2i不是高斯素数

第24个高斯整数是2-2i不是高斯素数

第25个高斯整数是3是高斯素数

第26个高斯整数是3i是高斯素数

第27个高斯整数是-3是高斯素数

第28个高斯整数是-3i是高斯素数

第29个高斯整数是3+1i不是高斯素数

第30个高斯整数是1+3i不是高斯素数

第31个高斯整数是-1+3i不是高斯素数

第32个高斯整数是-3+1i不是高斯素数

第33个高斯整数是-3-1i不是高斯素数

第34个高斯整数是-1-3i不是高斯素数

第35个高斯整数是1-3i不是高斯素数

第36个高斯整数是3-1i不是高斯素数

第37个高斯整数是3+2i是高斯素数

第38个高斯整数是2+3i是高斯素数

第39个高斯整数是-2+3i是高斯素数

第40个高斯整数是-3+2i是高斯素数

第41个高斯整数是-3-2i是高斯素数

第42个高斯整数是-2-3i是高斯素数

第43个高斯整数是2-3i是高斯素数

第44个高斯整数是3-2i是高斯素数

第45个高斯整数是4不是高斯素数

第46个高斯整数是4i不是高斯素数

第47个高斯整数是-4不是高斯素数

第48个高斯整数是-4i不是高斯素数

第49个高斯整数是4+1i是高斯素数

第50个高斯整数是1+4i是高斯素数

第51个高斯整数是-1+4i是高斯素数

第52个高斯整数是-4+1i是高斯素数

第53个高斯整数是-4-1i是高斯素数

第54个高斯整数是-1-4i是高斯素数

第55个高斯整数是1-4i是高斯素数

第56个高斯整数是4-1i是高斯素数

第57个高斯整数是3+3i不是高斯素数

第58个高斯整数是-3+3i不是高斯素数

第59个高斯整数是-3-3i不是高斯素数

第60个高斯整数是3-3i不是高斯素数

第61个高斯整数是4+2i不是高斯素数

第62个高斯整数是2+4i不是高斯素数

第63个高斯整数是-2+4i不是高斯素数

第64个高斯整数是-4+2i不是高斯素数

第65个高斯整数是-4-2i不是高斯素数

第66个高斯整数是-2-4i不是高斯素数

第67个高斯整数是2-4i不是高斯素数

第68个高斯整数是4-2i不是高斯素数

第69个高斯整数是5不是高斯素数

第70个高斯整数是4+3i不是高斯素数

第71个高斯整数是3+4i不是高斯素数

第72个高斯整数是5i不是高斯素数

第73个高斯整数是-3+4i不是高斯素数

第74个高斯整数是-4+3i不是高斯素数

第75个高斯整数是-5不是高斯素数

第76个高斯整数是-4-3i不是高斯素数

第77个高斯整数是-3-4i不是高斯素数

第78个高斯整数是-5i不是高斯素数

第79个高斯整数是3-4i不是高斯素数

第80个高斯整数是4-3i不是高斯素数

第81个高斯整数是5+1i不是高斯素数

第82个高斯整数是1+5i不是高斯素数

第83个高斯整数是-1+5i不是高斯素数

第84个高斯整数是-5+1i不是高斯素数

第85个高斯整数是-5-1i不是高斯素数

第86个高斯整数是-1-5i不是高斯素数

第87个高斯整数是1-5i不是高斯素数

第88个高斯整数是5-1i不是高斯素数

第89个高斯整数是5+2i是高斯素数

第90个高斯整数是2+5i是高斯素数

第91个高斯整数是-2+5i是高斯素数

第92个高斯整数是-5+2i是高斯素数

第93个高斯整数是-5-2i是高斯素数

第94个高斯整数是-2-5i是高斯素数

第95个高斯整数是2-5i是高斯素数

第96个高斯整数是5-2i是高斯素数

第97个高斯整数是4+4i不是高斯素数

第98个高斯整数是-4+4i不是高斯素数

第99个高斯整数是-4-4i不是高斯素数

第100个高斯整数是4-4i不是高斯素数

第101个高斯整数是5+3i不是高斯素数

第102个高斯整数是3+5i不是高斯素数

第103个高斯整数是-3+5i不是高斯素数

第104个高斯整数是-5+3i不是高斯素数

第105个高斯整数是-5-3i不是高斯素数

第106个高斯整数是-3-5i不是高斯素数

第107个高斯整数是3-5i不是高斯素数

第108个高斯整数是5-3i不是高斯素数

第109个高斯整数是6不是高斯素数

第110个高斯整数是6i不是高斯素数

第111个高斯整数是-6不是高斯素数

第112个高斯整数是-6i不是高斯素数

第113个高斯整数是6+1i是高斯素数

第114个高斯整数是1+6i是高斯素数

第115个高斯整数是-1+6i是高斯素数

第116个高斯整数是-6+1i是高斯素数

第117个高斯整数是-6-1i是高斯素数

第118个高斯整数是-1-6i是高斯素数

第119个高斯整数是1-6i是高斯素数

第120个高斯整数是6-1i是高斯素数

第121个高斯整数是6+2i不是高斯素数

第122个高斯整数是2+6i不是高斯素数

第123个高斯整数是-2+6i不是高斯素数

第124个高斯整数是-6+2i不是高斯素数

第125个高斯整数是-6-2i不是高斯素数

第126个高斯整数是-2-6i不是高斯素数

第127个高斯整数是2-6i不是高斯素数

第128个高斯整数是6-2i不是高斯素数

第129个高斯整数是5+4i是高斯素数

第130个高斯整数是4+5i是高斯素数

第131个高斯整数是-4+5i是高斯素数

第132个高斯整数是-5+4i是高斯素数

第133个高斯整数是-5-4i是高斯素数

第134个高斯整数是-4-5i是高斯素数

第135个高斯整数是4-5i是高斯素数

第136个高斯整数是5-4i是高斯素数

第137个高斯整数是6+3i不是高斯素数

第138个高斯整数是3+6i不是高斯素数

第139个高斯整数是-3+6i不是高斯素数

第140个高斯整数是-6+3i不是高斯素数

第141个高斯整数是-6-3i不是高斯素数

第142个高斯整数是-3-6i不是高斯素数

第143个高斯整数是3-6i不是高斯素数

第144个高斯整数是6-3i不是高斯素数

第145个高斯整数是7是高斯素数

第146个高斯整数是7i是高斯素数

第147个高斯整数是-7是高斯素数

第148个高斯整数是-7i是高斯素数

第149个高斯整数是7+1i不是高斯素数

第150个高斯整数是5+5i不是高斯素数

第151个高斯整数是1+7i不是高斯素数

第152个高斯整数是-1+7i不是高斯素数

第153个高斯整数是-5+5i不是高斯素数

第154个高斯整数是-7+1i不是高斯素数

第155个高斯整数是-7-1i不是高斯素数

第156个高斯整数是-5-5i不是高斯素数

第157个高斯整数是-1-7i不是高斯素数

第158个高斯整数是1-7i不是高斯素数

第159个高斯整数是5-5i不是高斯素数

第160个高斯整数是7-1i不是高斯素数

第161个高斯整数是6+4i不是高斯素数

第162个高斯整数是4+6i不是高斯素数

第163个高斯整数是-4+6i不是高斯素数

第164个高斯整数是-6+4i不是高斯素数

第165个高斯整数是-6-4i不是高斯素数

第166个高斯整数是-4-6i不是高斯素数

第167个高斯整数是4-6i不是高斯素数

第168个高斯整数是6-4i不是高斯素数

第169个高斯整数是7+2i是高斯素数

第170个高斯整数是2+7i是高斯素数

第171个高斯整数是-2+7i是高斯素数

第172个高斯整数是-7+2i是高斯素数

第173个高斯整数是-7-2i是高斯素数

第174个高斯整数是-2-7i是高斯素数

第175个高斯整数是2-7i是高斯素数

第176个高斯整数是7-2i是高斯素数

第177个高斯整数是7+3i不是高斯素数

第178个高斯整数是3+7i不是高斯素数

第179个高斯整数是-3+7i不是高斯素数

第180个高斯整数是-7+3i不是高斯素数

第181个高斯整数是-7-3i不是高斯素数

第182个高斯整数是-3-7i不是高斯素数

第183个高斯整数是3-7i不是高斯素数

第184个高斯整数是7-3i不是高斯素数

第185个高斯整数是6+5i是高斯素数

第186个高斯整数是5+6i是高斯素数

第187个高斯整数是-5+6i是高斯素数

第188个高斯整数是-6+5i是高斯素数

第189个高斯整数是-6-5i是高斯素数

第190个高斯整数是-5-6i是高斯素数

第191个高斯整数是5-6i是高斯素数

第192个高斯整数是6-5i是高斯素数

第193个高斯整数是8不是高斯素数

第194个高斯整数是8i不是高斯素数

第195个高斯整数是-8不是高斯素数

第196个高斯整数是-8i不是高斯素数

第197个高斯整数是8+1i不是高斯素数

第198个高斯整数是7+4i不是高斯素数

第199个高斯整数是4+7i不是高斯素数

第200个高斯整数是1+8i不是高斯素数

第201个高斯整数是-1+8i不是高斯素数

第202个高斯整数是-4+7i不是高斯素数

第203个高斯整数是-7+4i不是高斯素数

第204个高斯整数是-8+1i不是高斯素数

第205个高斯整数是-8-1i不是高斯素数

第206个高斯整数是-7-4i不是高斯素数

第207个高斯整数是-4-7i不是高斯素数

第208个高斯整数是-1-8i不是高斯素数

第209个高斯整数是1-8i不是高斯素数

第210个高斯整数是4-7i不是高斯素数

第211个高斯整数是7-4i不是高斯素数

第212个高斯整数是8-1i不是高斯素数

第213个高斯整数是8+2i不是高斯素数

第214个高斯整数是2+8i不是高斯素数

第215个高斯整数是-2+8i不是高斯素数

第216个高斯整数是-8+2i不是高斯素数

第217个高斯整数是-8-2i不是高斯素数

第218个高斯整数是-2-8i不是高斯素数

第219个高斯整数是2-8i不是高斯素数

第220个高斯整数是8-2i不是高斯素数

第221个高斯整数是6+6i不是高斯素数

第222个高斯整数是-6+6i不是高斯素数

第223个高斯整数是-6-6i不是高斯素数

第224个高斯整数是6-6i不是高斯素数

第225个高斯整数是8+3i是高斯素数

第226个高斯整数是3+8i是高斯素数

第227个高斯整数是-3+8i是高斯素数

第228个高斯整数是-8+3i是高斯素数

第229个高斯整数是-8-3i是高斯素数

第230个高斯整数是-3-8i是高斯素数

第231个高斯整数是3-8i是高斯素数

第232个高斯整数是8-3i是高斯素数

第233个高斯整数是7+5i不是高斯素数

第234个高斯整数是5+7i不是高斯素数

第235个高斯整数是-5+7i不是高斯素数

第236个高斯整数是-7+5i不是高斯素数

第237个高斯整数是-7-5i不是高斯素数

第238个高斯整数是-5-7i不是高斯素数

第239个高斯整数是5-7i不是高斯素数

第240个高斯整数是7-5i不是高斯素数

第241个高斯整数是8+4i不是高斯素数

第242个高斯整数是4+8i不是高斯素数

第243个高斯整数是-4+8i不是高斯素数

第244个高斯整数是-8+4i不是高斯素数

第245个高斯整数是-8-4i不是高斯素数

第246个高斯整数是-4-8i不是高斯素数

第247个高斯整数是4-8i不是高斯素数

第248个高斯整数是8-4i不是高斯素数

第249个高斯整数是9不是高斯素数

第250个高斯整数是9i不是高斯素数

第251个高斯整数是-9不是高斯素数

第252个高斯整数是-9i不是高斯素数

第253个高斯整数是9+1i不是高斯素数

第254个高斯整数是1+9i不是高斯素数

第255个高斯整数是-1+9i不是高斯素数

第256个高斯整数是-9+1i不是高斯素数

第257个高斯整数是-9-1i不是高斯素数

第258个高斯整数是-1-9i不是高斯素数

第259个高斯整数是1-9i不是高斯素数

第260个高斯整数是9-1i不是高斯素数

第261个高斯整数是9+2i不是高斯素数

第262个高斯整数是7+6i不是高斯素数

第263个高斯整数是6+7i不是高斯素数

第264个高斯整数是2+9i不是高斯素数

第265个高斯整数是-2+9i不是高斯素数

第266个高斯整数是-6+7i不是高斯素数

第267个高斯整数是-7+6i不是高斯素数

第268个高斯整数是-9+2i不是高斯素数

第269个高斯整数是-9-2i不是高斯素数

第270个高斯整数是-7-6i不是高斯素数

第271个高斯整数是-6-7i不是高斯素数

第272个高斯整数是-2-9i不是高斯素数

第273个高斯整数是2-9i不是高斯素数

第274个高斯整数是6-7i不是高斯素数

第275个高斯整数是7-6i不是高斯素数

第276个高斯整数是9-2i不是高斯素数

第277个高斯整数是8+5i是高斯素数

第278个高斯整数是5+8i是高斯素数

第279个高斯整数是-5+8i是高斯素数

第280个高斯整数是-8+5i是高斯素数

第281个高斯整数是-8-5i是高斯素数

第282个高斯整数是-5-8i是高斯素数

第283个高斯整数是5-8i是高斯素数

第284个高斯整数是8-5i是高斯素数

第285个高斯整数是9+3i不是高斯素数

第286个高斯整数是3+9i不是高斯素数

第287个高斯整数是-3+9i不是高斯素数

第288个高斯整数是-9+3i不是高斯素数

第289个高斯整数是-9-3i不是高斯素数

第290个高斯整数是-3-9i不是高斯素数

第291个高斯整数是3-9i不是高斯素数

第292个高斯整数是9-3i不是高斯素数

第293个高斯整数是9+4i是高斯素数

第294个高斯整数是4+9i是高斯素数

第295个高斯整数是-4+9i是高斯素数

第296个高斯整数是-9+4i是高斯素数

第297个高斯整数是-9-4i是高斯素数

第298个高斯整数是-4-9i是高斯素数

第299个高斯整数是4-9i是高斯素数

第300个高斯整数是9-4i是高斯素数

第301个高斯整数是7+7i不是高斯素数

第302个高斯整数是-7+7i不是高斯素数

第303个高斯整数是-7-7i不是高斯素数

第304个高斯整数是7-7i不是高斯素数

第305个高斯整数是10不是高斯素数

第306个高斯整数是8+6i不是高斯素数

第307个高斯整数是6+8i不是高斯素数

第308个高斯整数是10i不是高斯素数

第309个高斯整数是-6+8i不是高斯素数

第310个高斯整数是-8+6i不是高斯素数

第311个高斯整数是-10不是高斯素数

第312个高斯整数是-8-6i不是高斯素数

第313个高斯整数是-6-8i不是高斯素数

第314个高斯整数是-10i不是高斯素数

第315个高斯整数是6-8i不是高斯素数

第316个高斯整数是8-6i不是高斯素数

第317个高斯整数是10+1i是高斯素数

第318个高斯整数是1+10i是高斯素数

第319个高斯整数是-1+10i是高斯素数

第320个高斯整数是-10+1i是高斯素数

第321个高斯整数是-10-1i是高斯素数

第322个高斯整数是-1-10i是高斯素数

第323个高斯整数是1-10i是高斯素数

第324个高斯整数是10-1i是高斯素数

第325个高斯整数是10+2i不是高斯素数

第326个高斯整数是2+10i不是高斯素数

第327个高斯整数是-2+10i不是高斯素数

第328个高斯整数是-10+2i不是高斯素数

第329个高斯整数是-10-2i不是高斯素数

第330个高斯整数是-2-10i不是高斯素数

第331个高斯整数是2-10i不是高斯素数

第332个高斯整数是10-2i不是高斯素数

第333个高斯整数是9+5i不是高斯素数

第334个高斯整数是5+9i不是高斯素数

第335个高斯整数是-5+9i不是高斯素数

第336个高斯整数是-9+5i不是高斯素数

第337个高斯整数是-9-5i不是高斯素数

第338个高斯整数是-5-9i不是高斯素数

第339个高斯整数是5-9i不是高斯素数

第340个高斯整数是9-5i不是高斯素数

第341个高斯整数是10+3i是高斯素数

第342个高斯整数是3+10i是高斯素数

第343个高斯整数是-3+10i是高斯素数

第344个高斯整数是-10+3i是高斯素数

第345个高斯整数是-10-3i是高斯素数

第346个高斯整数是-3-10i是高斯素数

第347个高斯整数是3-10i是高斯素数

第348个高斯整数是10-3i是高斯素数

第349个高斯整数是8+7i是高斯素数

第350个高斯整数是7+8i是高斯素数

第351个高斯整数是-7+8i是高斯素数

第352个高斯整数是-8+7i是高斯素数

第353个高斯整数是-8-7i是高斯素数

第354个高斯整数是-7-8i是高斯素数

第355个高斯整数是7-8i是高斯素数

第356个高斯整数是8-7i是高斯素数

第357个高斯整数是10+4i不是高斯素数

第358个高斯整数是4+10i不是高斯素数

第359个高斯整数是-4+10i不是高斯素数

第360个高斯整数是-10+4i不是高斯素数

第361个高斯整数是-10-4i不是高斯素数

第362个高斯整数是-4-10i不是高斯素数

第363个高斯整数是4-10i不是高斯素数

第364个高斯整数是10-4i不是高斯素数

第365个高斯整数是9+6i不是高斯素数

第366个高斯整数是6+9i不是高斯素数

第367个高斯整数是-6+9i不是高斯素数

第368个高斯整数是-9+6i不是高斯素数

第369个高斯整数是-9-6i不是高斯素数

第370个高斯整数是-6-9i不是高斯素数

第371个高斯整数是6-9i不是高斯素数

第372个高斯整数是9-6i不是高斯素数

第373个高斯整数是10+5i不是高斯素数

第374个高斯整数是5+10i不是高斯素数

第375个高斯整数是-5+10i不是高斯素数

第376个高斯整数是-10+5i不是高斯素数

第377个高斯整数是-10-5i不是高斯素数

第378个高斯整数是-5-10i不是高斯素数

第379个高斯整数是5-10i不是高斯素数

第380个高斯整数是10-5i不是高斯素数

第381个高斯整数是8+8i不是高斯素数

第382个高斯整数是-8+8i不是高斯素数

第383个高斯整数是-8-8i不是高斯素数

第384个高斯整数是8-8i不是高斯素数

第385个高斯整数是9+7i不是高斯素数

第386个高斯整数是7+9i不是高斯素数

第387个高斯整数是-7+9i不是高斯素数

第388个高斯整数是-9+7i不是高斯素数

第389个高斯整数是-9-7i不是高斯素数

第390个高斯整数是-7-9i不是高斯素数

第391个高斯整数是7-9i不是高斯素数

第392个高斯整数是9-7i不是高斯素数

第393个高斯整数是10+6i不是高斯素数

第394个高斯整数是6+10i不是高斯素数

第395个高斯整数是-6+10i不是高斯素数

第396个高斯整数是-10+6i不是高斯素数

第397个高斯整数是-10-6i不是高斯素数

第398个高斯整数是-6-10i不是高斯素数

第399个高斯整数是6-10i不是高斯素数

第400个高斯整数是10-6i不是高斯素数

第401个高斯整数是9+8i不是高斯素数

第402个高斯整数是8+9i不是高斯素数

第403个高斯整数是-8+9i不是高斯素数

第404个高斯整数是-9+8i不是高斯素数

第405个高斯整数是-9-8i不是高斯素数

第406个高斯整数是-8-9i不是高斯素数

第407个高斯整数是8-9i不是高斯素数

第408个高斯整数是9-8i不是高斯素数

第409个高斯整数是10+7i是高斯素数

第410个高斯整数是7+10i是高斯素数

第411个高斯整数是-7+10i是高斯素数

第412个高斯整数是-10+7i是高斯素数

第413个高斯整数是-10-7i是高斯素数

第414个高斯整数是-7-10i是高斯素数

第415个高斯整数是7-10i是高斯素数

第416个高斯整数是10-7i是高斯素数

第417个高斯整数是9+9i不是高斯素数

第418个高斯整数是-9+9i不是高斯素数

第419个高斯整数是-9-9i不是高斯素数

第420个高斯整数是9-9i不是高斯素数

第421个高斯整数是10+8i不是高斯素数

第422个高斯整数是8+10i不是高斯素数

第423个高斯整数是-8+10i不是高斯素数

第424个高斯整数是-10+8i不是高斯素数

第425个高斯整数是-10-8i不是高斯素数

第426个高斯整数是-8-10i不是高斯素数

第427个高斯整数是8-10i不是高斯素数

第428个高斯整数是10-8i不是高斯素数

第429个高斯整数是10+9i是高斯素数

第430个高斯整数是9+10i是高斯素数

第431个高斯整数是-9+10i是高斯素数

第432个高斯整数是-10+9i是高斯素数

第433个高斯整数是-10-9i是高斯素数

第434个高斯整数是-9-10i是高斯素数

第435个高斯整数是9-10i是高斯素数

第436个高斯整数是10-9i是高斯素数

第437个高斯整数是10+10i不是高斯素数

第438个高斯整数是-10+10i不是高斯素数

第439个高斯整数是-10-10i不是高斯素数

第440个高斯整数是10-10i不是高斯素数

//求一元三次方程的实根
#include<iostream>
#include<cmath>
#include<complex>
using namespace std;
/*
 x^3+px+q=0：
 x甲=((-q+sqrt(q^2+4p^3/27))/2)^(1/3)+((-q-sqrt(q^2+4p^3/27))/2)^(1/3)
 x乙=(-x甲+sqrt(-3x甲^2-4p))/2
 x丙=(-x甲-sqrt(-3x甲^2-4p))/2
*/
typedef float Real;
struct E3
{
public:
 E3(Real p,Real q):m_p(p),m_q(q){}
 Real DeltOfE3()
 {
  Real ret=m_q*m_q+4*m_p*m_p*m_p/27;
  return ret;
 }
 Real cube(Real a)
 {
  if(a==0)
   return 0;
  if(a>0)
   return expf(1.0*logf(a)/3.0);
  else
   return -expf(1.0*logf(-a)/3.0);
 }
 complex<Real> cube(complex<Real> a)
 {
  return exp(complex<Real>(1.0/3.0,0)*log(a));
 }
 //与牛顿切线法求得的实根值是一致的
 Real xOfE3()
 {
  Real delt=DeltOfE3();
  if(delt>=0)
  {
   Real ret1=cube((-m_q+sqrtf(delt))*0.5);
   Real ret2=cube((-m_q-sqrtf(delt))*0.5);
   return ret1+ret2;
  }
  else
  {
   complex<Real> ret1=cube((-m_q+sqrt(complex<Real>(delt,0)))*complex<Real>(0.5,0));
   complex<Real> ret2=cube((-m_q-sqrt(complex<Real>(delt,0)))*complex<Real>(0.5,0));
   return (ret1+ret2).real();
  }
 }
 //返回true表示有三个实根，返回false表示只有一个实根
 //即初中笔记中的跳板公式
 bool x2x3OfE3(Real &x2,Real &x3)
 {
  Real x1=xOfE3();
  Real delt1=-3*x1*x1-4*m_p;
  if(delt1>=0)
  {
   x2=(-x1+sqrtf(delt1))*0.5;
   x3=(-x1-sqrtf(delt1))*0.5;
   return true;
  }
  else
   return false;//即另外两根为虚根或伪虚根
 }
public:
   Real m_p;
   Real m_q;
};
int main()
{
 {
  E3 E3_1011(1,1);
  Real x=E3_1011.xOfE3();//x^3+x+1=0的一实根为：x = -0.68232781
  Real x2,x3;
  bool ret=E3_1011.x2x3OfE3(x2,x3);
  int a=0;
 }
 {
  //2000.10.30星期二,x^3-0.75x+0.125=0的三实根为：sin50°=x=0.76604444、sin10°=x2=0.17364815、-sin50°-sin10°=x3=-0.93969262
  E3 E3_sin10(-0.75,0.125);
  Real x=E3_sin10.xOfE3();
  Real x2,x3;
  bool ret=E3_sin10.x2x3OfE3(x2,x3);
  int a=0;
 }
 system("pause");
 return 0;
}
#include <iostream>
using namespace std;
typedef double real;
/*
魏尔斯特拉斯方程EC1:y^2+a_1xy+a_3y=x^3+a_2x^2+a_4x+a_6
表示一个椭圆曲线时有一个不为0的不变量△
*/
struct EC1
{
public:
 EC1(real a1,real a3,real a2,real a4,real a6):m_a1(a1),m_a3(a3),m_a2(a2),m_a4(a4),m_a6(a6){}
 real b2OfEC()
 {
  return m_a1*m_a1+4*m_a2;
 }
 real b4OfEC()
 {
  return m_a1*m_a3+2*m_a4;
 }
 real b6OfEC()
 {
  return m_a3*m_a3+4*m_a6;
 }
 real b8OfEC()
 {
  return (b2OfEC()*b6OfEC()-b4OfEC())/4;
 }
 real c4OfEC()
 {
  return b2OfEC()*b2OfEC()-24*b4OfEC();
 }
 real c6OfEC()
 {
  return -b2OfEC()*b2OfEC()*b2OfEC()+36*b2OfEC()*b4OfEC()-216*b6OfEC();
 }
 real DeltOfEC()
 {
  //错误的：
  //return (c4OfEC()*c4OfEC()*c4OfEC()-c6OfEC()*c6OfEC())/35831808;
  //real c4=c4OfEC();
  //real c6=c6OfEC();
  //return (c4*c4*c4-c6*c6)/35831808;
  //正确的：
  real b2=b2OfEC();
  real b4=b4OfEC();
  real b6=b6OfEC();
  real b8=b8OfEC();
  return -b2*b2*b8-8*b4*b4*b4-27*b6*b6+9*b2*b4*b6;
 }
 real jOfEC()
 {
  return c4OfEC()*c4OfEC()*c4OfEC()/DeltOfEC();
 }
public:
 real m_a1;
 real m_a3;
 real m_a2;
 real m_a4;
 real m_a6;
};
/*
复分析中的魏尔斯特拉斯标准型EC2:y^2=4x^3-g_2x+g_3
可以用P（花体）函数参数化：x=P(z),y=P'(z)
*/
struct EC2
{
public:
 EC2(real g2,real g3):m_g2(g2),m_g3(g3){}
 real DeltOfEC()
 {
  return m_g2*m_g2*m_g2-27*m_g3*m_g3;
 }
 real jOfEC()
 {
  return 1728*m_g2*m_g2*m_g2/DeltOfEC();
 }
public:
 real m_g2;
 real m_g3;
};
/*
数论和算术中常用的形式EC3:y^2=x^3+ax+b
*/
struct EC3
{
public:
 EC3(real a,real b):m_a(a),m_b(b){}
 real b2OfEC()
 {
  return 0;
 }
 real b4OfEC()
 {
  return 2*m_a;
 }
 real b6OfEC()
 {
  return 4*m_b;
 }
 real b8OfEC()
 {
  return (b2OfEC()*b6OfEC()-b4OfEC())/4;
 }
 real c4OfEC()
 {
  return b2OfEC()*b2OfEC()-24*b4OfEC();
 }
 real c6OfEC()
 {
  return -b2OfEC()*b2OfEC()*b2OfEC()+36*b2OfEC()*b4OfEC()-216*b6OfEC();
 }
 real DeltOfEC()
 {
  return -16*(4*m_a*m_a*m_a+27*m_b*m_b);//不要把27写成26
 }
 real jOfEC()
 {
  //return c4OfEC()*c4OfEC()*c4OfEC()/DeltOfEC();//正确的
  return -1728*64*m_a*m_a*m_a/DeltOfEC();//加一个负号
 }
public:
 real m_a;
 real m_b;
};
int main()
{
 {
  //j0.DeltOfEC()=-432
  //j0.jOfEC()=0
  //j1728.DeltOfEC()=64
  //j1728.jOfEC()=1728
  EC3 j0(0,-1);
  cout<<"j0.DeltOfEC()="<<j0.DeltOfEC()<<endl;
  cout<<"j0.jOfEC()="<<j0.jOfEC()<<endl;
  EC3 j1728(-1,0);//y^2=x^3-x
  cout<<"j1728.DeltOfEC()="<<j1728.DeltOfEC()<<endl;
  cout<<"j1728.jOfEC()="<<j1728.jOfEC()<<endl;
 }
 {
  //j0.DeltOfEC()=-432
  //j0.jOfEC()=-0
  //j1728.DeltOfEC()=64
  //j1728.jOfEC()=1728
  EC1 j0(0,0,0,0,-1);
  cout<<"j0.DeltOfEC()="<<j0.DeltOfEC()<<endl;
  cout<<"j0.jOfEC()="<<j0.jOfEC()<<endl;
  EC1 j1728(0,0,0,-1,0);//y^2=x^3-x
  cout<<"j1728.DeltOfEC()="<<j1728.DeltOfEC()<<endl;
  cout<<"j1728.jOfEC()="<<j1728.jOfEC()<<endl;
  //jc.DeltOfEC()=-433
  //jc.jOfEC()=-0.00230947
  //jc2.DeltOfEC()=-3.08659e-009
  //jc2.jOfEC()=-0.00230947
  //j(c=1.3365e-006)=-0.00230947
  EC1 jc(-1,0,0,0,1);//y^2-xy=x^3+1
  cout<<"jc.DeltOfEC()="<<jc.DeltOfEC()<<endl;
  cout<<"jc.jOfEC()="<<jc.jOfEC()<<endl;
  real j=-0.00230947;//y^2=x^3-3cx+2c,j=1728*c/(c-1)
  real c=j/(j-1728);
  EC1 jc2(0,0,0,-3*c,2*c);
  cout<<"jc2.DeltOfEC()="<<jc2.DeltOfEC()<<endl;
  cout<<"jc2.jOfEC()="<<jc2.jOfEC()<<endl;
  cout<<"j(c="<<c<<")="<<1728*c/(c-1)<<endl;
 }
 system("pause");
}
10.2椭圆曲线的算术
椭圆曲线上有理点全体构成一个Abel群。也就是说群的元素现在不是数而是点。因此我们必须规定，两个点的和（我们用(+)表示）应该是哪一点?每个点的逆元素是什么？然后再验证它们是否满足Abel群的几条公理。
1.首先我们规定每一点P的反点~P。由于任何椭圆曲线关于x轴对称[按：不一定。]，即如果P(x,y)是椭圆曲线上一点，则(x,-y)也是椭圆曲线上一点，我们称它为P(x,y)的反点，记作~P(x,-y)。
2.现在我们定义两点P_1(x_1,y_1)和P_2(x_2,y_2)的加法运算(+)。如果连接P_1与P_2的直线与椭圆曲线相交于一点P_3，则定义其和为P_3的反点：P_1(+)P_2=~P_3。
3.每一点的逆元素为其反点。
4.零元素为无穷原点。
利用△(E)可以定义椭圆曲线最重要的不变量——j不变量：
j(E)=(c_4)^3/△(E)，
或j(E)=12^3(4a)^3/△(E)，
或j(E)=12^3(g_2)^3/△(E)。
j不变量的重要性在于两Q上椭圆曲线~Q同构当且仅当j不变量相等。
而且，对于每有理数值j，都存在以j为其j不变量的椭圆曲线。
对于Q上的椭圆曲线，还有一个极小魏尔斯特拉斯方程y^2+a_1xy+a_3y=x^3+a_2x^2+a_4x+a_6，其中a_1,a_2,a_3,a_4,a_5均为整数，而且对所有素数p，都是极小的。
极小魏尔斯特拉斯方程的判别式称为极小判别式D(E)。
由于j(E)刻画C上椭圆曲线E的同构类，因此十分重要。每一类我们可以找到形式简单的椭圆曲线为其代表，例如：
1.j=0，可取y^2=x^3-1。
【
椭圆曲线a_4=0,a_6=-1，则x^3-1有一个判别式△=-16(4a_4^3+27a_6^2)=-432，j=0^3/△=0
a_1=0,a_3=0,a_2=0，
b_2=a_1^2+4a_2=0
b_4=a_1a_3+2a_4=0
c_4=b_2^2-24b_4=0
我们可以依据△对椭圆曲线进行分类：
1.△<0，x^3-1只有一个实根，椭圆曲线是一个连通的曲线。
2.△<0，有三个不同的实根。
3.△=0，不是椭圆曲线，或者说它们是有奇点的退化的椭圆曲线。
】
2.j=1728，可取y^2=x^3-x。
3.j≠0,1728时，令c=j/(j-1728)，则可取y^2=x^3-3cx+2c。
j常称为椭圆曲线的模不变量，因为它在模变换下不变，即对于{{a,b},{c,d}}∈SL_2(2)，有j((atau+b)/(ctau+d))=j(tau)。

20130626问题：
系数属于F_3={0,1,2}的二次方程x^2+x+2=0，不可分解，无解。
vector<int> retVec12=FindrootInF3(Polygon2,1,2);//空，即x^2+x+2=0在F_3中无根
设a是是F_3[x]中不可约多项式f(x)=x^2+x+2的一个根，求扩域F_3(a)及x^2+x+2的另外一个根b=(0,1,2,a)？
记-1=2在F_3上的[模]平方根为i，即i是x^2=2∈F_3[x]的一个根，求i和a之间的关系？
解法1：
F_3[a]={m+na|m,n∈F_3}=F_3[i]{m+ni|m,n∈F_3}是f(x)在F_3上的分裂域。
这是因为f(x)=[x-(1+i)][x-(1-i)]，----在C中进行因式分解，这里i是虚数单位
同时，E=F_3[x]/<x^2+x+2>的元素x+<x^2+x+2>是f(x)的根。----这里既用x表示F_3上的未定元，又用x表示E中的陪集代表元，可将陪集x+<x^2+x+2>记作a，于是，E={0,1,2,a,a+1,a+2,2a,2a+1,2a+2}
因为f(x)是2次的，所以f(x)的另一个也在E内。于是f(x)在E中分裂。又因为E只有9个元素，显然E也是f(x)在F_3上的分裂域。E中元素间的加和乘与多项式的运算是一样的。
由于x^2+x+2+<x^2+x+2>=0，因此a^2+a+2=0，
所以a^2=-a-2=2a+1。----这里-1=2,-2=1
由于a(2a+2)=2a^2+2a=2(2a+1)+2a=a+2+2a=2,
所以
x^2+x+2=(x-a)[x-(2a+2)]=(x-a)(x+a+1)
于是，我们已经找到了x^2+x+2在F_3上的两个分裂域，一个是F_3(i)，而另一个则是F_3[x]/<x^2+x+2>。
定理：设F是域，p(x)在F上不可约。如果a是p(x)在F的某个扩域E中的根，那么F(a)同构于F[x]/<p(x)>。而且，如果degp(x)=n，那么F(a)中的元都能惟一地表为如下的形式c_(n-1)a^(n-1)+c_(n-2)a^(n-2)+…+c_1a+c_0，其中c_0,c_1,…,c_(n-1)∈F。
20130622问题：证明在有限域中存在不可分多项式？
20130621问题：设a是F_2[x]中不可约多项式x^3+x+1的一个根，求扩域F_2(a)及x^3+x+1的另外两个根b=b(0,1,a),c=c(0,1,a)？
解答：
F_2(a)={0=O,1=I,a=D,a^2=A,1+a=E,1+a^2=C,a+a^2=B,1+a+a^2=F}，另外两个根为：b=a^2，c=a+a^2。
----加法运算表----
O+O=O O+I=I O+A=A O+B=B O+C=C O+D=D O+E=E O+F=F
I+O=I I+I=O I+A=C I+B=F I+C=A I+D=E I+E=D I+F=B
A+O=A A+I=C A+A=O A+B=D A+C=I A+D=B A+E=F A+F=E
B+O=B B+I=F B+A=D B+B=O B+C=E B+D=A B+E=C B+F=I
C+O=C C+I=A C+A=I C+B=E C+C=O C+D=F C+E=B C+F=D
D+O=D D+I=E D+A=B D+B=A D+C=F D+D=O D+E=I D+F=C
E+O=E E+I=D E+A=F E+B=C E+C=B E+D=I E+E=O E+F=A
F+O=F F+I=B F+A=E F+B=I F+C=D F+D=C F+E=A F+F=O
----乘法运算表----
O*O=O O*I=O O*A=O O*B=O O*C=O O*D=O O*E=O O*F=O
I*O=O I*I=I I*A=A I*B=B I*C=C I*D=D I*E=E I*F=F
A*O=O A*I=A A*A=B A*B=C A*C=D A*D=E A*E=F A*F=I
B*O=O B*I=B B*A=C B*B=D B*C=E B*D=F B*E=I B*F=A
C*O=O C*I=C C*A=D C*B=E C*C=F C*D=I C*E=A C*F=B
D*O=O D*I=D D*A=E D*B=F D*C=I D*D=A D*E=B D*F=C
E*O=O E*I=E E*A=F E*B=I E*C=A E*D=B E*E=C E*F=D
F*O=O F*I=F F*A=I F*B=A F*C=B F*D=C F*E=D F*F=E
----减法运算表----
O-O=O O-I=I O-A=A O-B=B O-C=C O-D=D O-E=E O-F=F
I-O=I I-I=O I-A=C I-B=F I-C=A I-D=E I-E=D I-F=B
A-O=A A-I=C A-A=O A-B=D A-C=I A-D=B A-E=F A-F=E
B-O=B B-I=F B-A=D B-B=O B-C=E B-D=A B-E=C B-F=I
C-O=C C-I=A C-A=I C-B=E C-C=O C-D=F C-E=B C-F=D
D-O=D D-I=E D-A=B D-B=A D-C=F D-D=O D-E=I D-F=C
E-O=E E-I=D E-A=F E-B=C E-C=B E-D=I E-E=O E-F=A
F-O=F F-I=B F-A=E F-B=I F-C=D F-D=C F-E=A F-F=O
关键推导过程：
O*O*O+O+I=I
I*I*I+I+I=I
A*A*A+A+I=O
B*B*B+B+I=O
C*C*C+C+I=D
D*D*D+D+I=O
E*E*E+E+I=B
F*F*F+F+I=A
所以三个根a,b,c为A,B,D
令0=O,1=I,
错误的：a=A,a^2=B,1+a=C=a^3,
错误的：a=B,a^2=D,1+a=F=a^3,
正确的：a=D,a^2=A,1+a=E=aA,1-a=E=>a=-a,1+a^2=C,a+a^2=B,1+a+a^2=F=I+F
错误的：a=C,a^2=F,1+a=A=aE,1-a=A,=>a=-a,1+a^2=B,a+a^2=D,1+a+a^2=E=A+F
即：八元域F_2(a)={O=0,I=1,D=a,A=a^2,E=1+a,C=1+a^2,B=a+a^2,F=1+a+a^2}，
而不是{O=0,I=1,C=a,F=a^2,A=1+a,B=1+a^2,D=a+a^2,E=1+a+a^2}。
F_2的扩域记为F_2(a)=F_2(a=D,b=A=a^2,c=B=a+a^2)
另外两个根为：b=a^2，c=a+a^2。
三根满足关系：
x^3+x+1=x^3-(a+b+c)x^2+(ab-ac-bc)x-abc
D+A+B=O<=>a+b+c=0
DAB=I=-I<=>abc=1=-1
DA-DB-AB=I<=>ab-ac-bc=1
D^3+D=I<=>a^3+a=1
DA(-D-A)=I<=>ab(-a-b)=1
#include <iostream>
#include <vector>
#include <cassert>
using namespace std;
/*
练习作业
1．方程x^2+1=0在有理数域中没有根，问在有限域F_5中有没有根，有几个根？
2．记F=F_2是含2个元素的域，证明多项式x^2+1在多项式环F[x]中可约，而x^2+x+1在多项式环F[x]中不可约。
3．假定F=F_2，α是F[x]中不可约多项式x^2+x+1的一个根，证明F(α)={0，1，α，1+α}是一个含4个元素的域。求多项式x^2+x+1的另一个根。
4．假定F=F_2，求F[x]中所有3次不可约多项式。
在有限域F_2中，5次不可约多项式x^5+x^2+1的[模乘法]阶是31=2^5-1。
F_2中1-5次不可约多项式列表：
1,1+x,x
2,1+x+x^2
3,1+x+x^3,1+x^2+x^3
4,1+x+x^4,1+x+x^2+x^3+x^4,1+x^3+x^4
5,1+x^2+x^5,1+x+x^2+x^3+x^5,1+x^3+x^5,1+x+x^3+x^4+x^5,1+x^2+x^3+x^4+x^5,1+x+x^2+x^4+x^5
*/
【
在F_2中，
x^3+1=(x-1)^3，
x^3+x+1=(x-a)(x-b)(x-c)
x^3+x^2+1=(x-a)(x-b)(x-c)
x^2+1=(x-1)^2，
[
x^2+x+1=(x-a)(x-b)=x^2-(a+b)x+ab，
F_2的扩域记为F_2(a)=F_2(a,b),a(a+1)=a^2+a=a+b=1=-1,ab=1。
b=a^2=(a+1),a^3=1
所以F_2(a)={0,1,a,1+a}
]
】
template <class T> T print(T n); //和定义类时差不多，返回值为T类型，参数n也为T类型
template <class T> T print(T n)
{
 cout<<n<<endl;
 return n;
}
int F_5[5]={0,1,2,3,4};
int Mod(int ret,unsigned int n)
{
 assert(n>0);
 if(ret<0)
 {
  int ret1=ret+(-ret+1)*n;
  return ret1%n;
 }
 return ret%n;
}
int Mod5(int ret)
{
 //while(ret<0)
 //{
 // ret+=5;
 // if(ret>=0)
 //  return ret;
 //}
 //   return ret%5;
 return Mod(ret,5);
}
int AddInF5(int a,int b)
{
 int ret=Mod5(a+b);
 return ret;
}
int MulInF5(int a,int b)
{
 int ret=Mod5(a*b);
 return ret;
}
int AddInvInF5(int a)
{
 static int F_5[5]={0,1,2,3,4};
 for(int i=0;i<5;i++)
 {
  if(AddInF5(F_5[i],Mod5(a))==0)
   return F_5[i];
 }
 return -1;//错误值
}
int MulInvInF5(int a)
{
 static int F_5[5]={0,1,2,3,4};
 for(int i=0;i<5;i++)
 {
  if(MulInF5(F_5[i],Mod5(a))==1)
   return F_5[i];
 }
 return -1;//错误值
}
typedef void(*pFuncVoid)(void);
typedef int(*pFuncInt0)(int x);
int Polygon(int x)
{
 return x*x+1;
}
vector<int> FindrootInF5(pFuncInt0 fun)
{
 vector<int> ret;
 if(fun!=NULL)
 {
  static int F_5[5]={0,1,2,3,4};
  for(int i=0;i<5;i++)
  {
   if(Mod5(fun(F_5[i]))==0)
    ret.push_back(F_5[i]);
  }
 }
 return ret;
}
int main()
{
 vector<int> retVec=FindrootInF5(Polygon);//2,3，即x^2+1=0在F_5中有两根：x_1=2,x_2=3
 //int ret1=(-2)%5;
 //int ret2=(-10)%5;
 //int ret3=Mod5(-2);
 //int ret4=Mod5(-7);
 //int ret5=Mod(-2,5);
 //int ret6=Mod(-7,5);
 system("pause");
 return 0;
}
#include <iostream>
#include <vector>
#include <cassert>
using namespace std;
/*
系数属于F_3={0,1,2}的所有有实际意义的二次方程。
 方程，因式分解，解
 x^2+1=0，不可分解，无解
 x^2+2=0，(x+1)(x+2)，x=1,x=2
 x^2+x+1=0，(x+2)(x+2)，x=1
 x^2+x+2=0，不可分解，无解
 x^2+2x+1=0，(x+1)(x+1)，x=2
 x^2+2x+2=0，不可分解，无解
 在我研究的这个域内没有解的方程称为不可约的。你可以看到系数在0,1,2域中的六个有意义的方程中有三个是不可约的。
*/
/*
系数属于F_2={0,1}的所有有实际意义的三次、二次方程。
 方程，因式分解，解
 x^3+1=0，在F_2中有一根：x_1=1
 x^3+x+1=0，在F_2中无根
 x^3+x^2+1=0，在F_2中无根
 x^3+x^2+x+1=0，在F_2中有一根：x_1=1
 x^2+1=0，在F_2中有一根：x_1=1
 x^2+x+1=0，在F_2中无根
 在我研究的这个域内没有解的方程称为不可约的。你可以看到系数在0,1域中的六个有意义的方程中有三个是不可约的。
*/
int Mod(int ret,unsigned int n)
{
 assert(n>0);
 if(ret<0)
 {
  int ret1=ret+(-ret+1)*n;
  return ret1%n;
 }
 return ret%n;
}
int Mod3(int ret)
{
 return Mod(ret,3);
}
//int AddInF3(int a,int b)
//{
// int ret=Mod3(a+b);
// return ret;
//}
//int MulInF3(int a,int b)
//{
// int ret=Mod3(a*b);
// return ret;
//}
//int AddInvInF3(int a)
//{
// for(int i=0;i<3;i++)
// {
//  if(AddInF3(i,Mod3(a))==0)
//   return i;
// }
// return -1;//错误值
//}
//int MulInvInF3(int a)
//{
// for(int i=0;i<5;i++)
// {
//  if(MulInF3(i,Mod3(a))==1)
//   return i;
// }
// return -1;//错误值
//}
typedef void(*pFuncVoid)(void);
typedef int(*pFuncInt0)(int x);
typedef int(*pFuncInt2)(int x,int a1,int a0);
typedef int(*pFuncInt3)(int x,int a2,int a1,int a0);
int Polygon2(int x,int a1,int a0)
{
 return x*x+a1*x+a0;
}
int Polygon3(int x,int a2,int a1,int a0)
{
 return x*x*x+a2*x*x+a1*x+a0;
}
vector<int> FindrootInF3(pFuncInt2 fun,int a1,int a0)
{
 vector<int> ret;
 if(fun!=NULL)
 {
  for(int i=0;i<3;i++)
  {
   if(Mod3(fun(i,a1,a0))==0)
    ret.push_back(i);
  }
 }
 return ret;
}
//通用的代码
vector<int> FindrootInFp(pFuncInt2 fun,int p,int a1,int a0)
{
 vector<int> ret;
 if(fun!=NULL)
 {
  for(int i=0;i<p;i++)
  {
   if(Mod(fun(i,a1,a0),p)==0)
    ret.push_back(i);
  }
 }
 return ret;
}
vector<int> FindrootInFp(pFuncInt3 fun,int p,int a2,int a1,int a0)
{
 vector<int> ret;
 if(fun!=NULL)
 {
  for(int i=0;i<p;i++)
  {
   if(Mod(fun(i,a2,a1,a0),p)==0)
    ret.push_back(i);
  }
 }
 return ret;
}
int main()
{
 vector<int> retVec01=FindrootInF3(Polygon2,0,1);//空，即x^2+1=0在F_3中无根
 vector<int> retVec02=FindrootInF3(Polygon2,0,2);//1,2，即x^2+2=0在F_3中有两根：x_1=1,x_2=2
 vector<int> retVec11=FindrootInF3(Polygon2,1,1);//1，即x^2+x=1=0在F_3中有一根：x_1=1
 vector<int> retVec12=FindrootInF3(Polygon2,1,2);//空，即x^2+x+2=0在F_3中无根
 vector<int> retVec21=FindrootInF3(Polygon2,2,1);//2，即x^2+2x=1=0在F_3中有一根：x_1=2
 vector<int> retVec22=FindrootInF3(Polygon2,2,2);//空，即x^2+2x+2=0在F_3中无根
 //x^3+1=0，
 //x^3+x+1=0，
 //x^3+x^2+1=0，
 //x^3+x^2+x+1=0，
 //x^2+1=0，
 //x^2+x+1=0，
 vector<int> retVec001=FindrootInFp(Polygon3,2,0,0,1);//1，即x^3+1=0在F_2中有一根：x_1=1
 vector<int> retVec011=FindrootInFp(Polygon3,2,0,1,1);//空，即x^3+x+1=0在F_2中无根
 vector<int> retVec101=FindrootInFp(Polygon3,2,1,0,1);//空，即x^3+1=0在F_2中无根
 vector<int> retVec111=FindrootInFp(Polygon3,2,1,1,1);//1，即x^3+x^2+x+1=0在F_2中有一根：x_1=1
 vector<int> retVec00_01=FindrootInFp(Polygon2,2,0,1);//1，即x^2+1=0在F_2中有一根：x_1=1
 vector<int> retVec00_11=FindrootInFp(Polygon2,2,1,1);//空，即x^2+x+1=0在F_2中无根
 system("pause");
 return 0;
}