fun.h

calc大数库

unsigned long LENGTHDR(unsigned int d, MPR *Mptr);
unsigned long LENGTHI(MPI *Mptr);
unsigned long LENGTHR(MPR *Mptr);
unsigned long MINUSm(USL a, USL m);
unsigned long MINUSm(USL a, USL m);
unsigned long MOD0_(MPI *Aptr, unsigned long b);
unsigned long MODINT0_(MPI *Aptr, unsigned long b, MPI **Qptr);
unsigned long MOD_(MPI *Aptr, unsigned long b);
unsigned long MULT32(USL x, USL y);
unsigned long MULTm(USL a, USL b, USL m);
unsigned long MULTm(USL a, USL b, USL m);
unsigned long POWER_m(USL a, USL y, USL m);
unsigned long POWERm(USL a, MPI *Bptr, USL m);
unsigned long RANDOMm(USL x);
unsigned long RUSSm(USL a, USL b, USL c, USL p);
unsigned long RUSSm(USL a, USL b, USL c, USL p);
unsigned long RUSSm(USL a, USL b, USL c, USL p);
unsigned long SQRTm(USL x, USL p);
unsigned long SUBm(USL a, USL b, USL m);
unsigned long SUBm(USL a, USL b, USL m);
void *calloc1(size_t m, size_t n);
void *malloc1(size_t nbytes);
void *realloc1(void *ptr, size_t nbytes, long mbytes);
void ADD_CUBICR(MPR *X1, MPR *Y1, MPR *X2, MPR *Y2, MPR **Xptr, MPR **Yptr, MPR *A1, MPR *A2, MPR *A3, MPR *A4, MPR *A6);
void ADD_CUBICRX();
void *ADD_MULT_ROWI0(USI p, USI q, MPI *Aptr, MPMATI *Mptr);
void BASIS_UPDATE(USI i, USI m, MPMATI **Cptr, MPMATI **Lptr, MPMATI *B1ptr, MPI *D[]);
void COLLATZ(MPI *Dptr, MPI *Eptr);
void CONT_FRAC(MPI *Aptr, MPI *Bptr, MPI *Zptr, MPI **Xptr, MPI **Yptr);
void CSWAP_UPDATE(USI k, USI m, MPI *S, MPMATI **Cptr, MPI *D[]);
void DECODE(MPI *Dptr, MPI *Rptr);
void DECODEX(MPI *Eptr, MPI *Pptr, MPI *Qptr);
void DUMPMPI(MPI *Mptr, char *name);
void EXZPOWER(MPI *X, MPI *Z, USI k, MPI *P, MPI *Q, MPI **Aptr, MPI **Cptr, MPI *N);
void ADD_ELLIPTIC_Q(MPR *X1, MPR *Y1, MPR *X2, MPR *Y2, MPR **Xptr, MPR **Yptr, MPR *A, MPR *B);
void ENCODE(MPI *Eptr, MPI *Rptr);
void EXP_UPDATE(MPI *Q, USL base[], USI FBASE, USI exponents[]);
void EXTGCDX();
void FFlush(FILE *f);
void FIB_MIN();
void FINCKE_POHSTX();
void FREEMATR(MPMATR *Mptr);
void FINCKE_POHST(MPMATR *Q, MPR *C, USI filename);
void FIND(unsigned int k, MPI *A1ptr, MPI *B1ptr, unsigned long R[]);
void FPRINTDR(FILE *outfile, unsigned int d, MPR *Mptr);
void FPRINTI(FILE *outfile, MPI *Mptr);
void FPRINTMATI(FILE *outfile, USI i1, USI i2, USI j1, USI j2, MPMATI *Mptr);
void FPRINTMATR(FILE *outfile, USI i1, USI i2, USI j1, USI j2, MPMATR *Mptr);
void FPRINTR(FILE *outfile, MPR *Aptr);
void FREEMATI(MPMATI *Mptr);
void FREEMPI(MPI *Mptr);
void FREEMPIBANK();
void FREEMPR(MPR *Mptr);
void Flush();
void GetReturn();
void HERMITE();
void IMPROVEPX();
void INITMPIBANK();
void INTSETI(int *Aptr, unsigned long n, int m);
void INTSETL(long *Aptr, unsigned long n, long m);
void INTSETUI(unsigned int *Aptr, unsigned long n, unsigned int m);
void INTSETUL(unsigned long *Aptr, unsigned long n, unsigned long m);
void JUGGLER(MPI *Dptr, MPI *Iptr);
void LUCAS_MIN();
void MAXELTI1(MPMATI *Mptr, USI *iptr, USI *jptr);
void MILLERX(MPI *N, MPI *B);
void MINELTI1(MPMATI *Mptr, USI *iptr, USI *jptr);
void MLLL();
void MTHROOT(MPI *Aptr, MPI *Bptr, unsigned int m, unsigned int r);
void MTHROOTX(MPI *Aptr, MPI *Bptr, MPI *M, MPI *R);
MPR *MULTR3(MPR *A, MPR *B, MPR *C);
void MULTXM(MPI *a, MPI *b, MPI *c, MPI *d, MPI **eptr, MPI **fptr, MPI *x, MPI *p);
void MULTXm(USL a, USL b, USL c, USL d, USL *eptr, USL *fptr, USL x, USL p);
void NEXT(int k, MPI *A1ptr, MPI *B1ptr, unsigned long R[]);
void PELL(MPI *Dptr, MPI *Eptr);
void POWER_CUBICRX();
void POWER_CUBICR(MPR *X1, MPR *Y1, MPR **Xptr, MPR **Yptr, MPR *A1, MPR *A2, MPR *A3, MPR *A4, MPR *A6, unsigned int n);
void POWERXM(MPI *a, MPI *b, MPI *n, MPI **eptr, MPI **fptr, MPI *x, MPI *p);
void POWERXm(USL a, USL b, USL n, USL *eptr, USL *fptr, USL x, USL p);
void PRINT_DEFECT();
void PRINTDR(unsigned int d, MPR *Mptr);
void PRINTI(MPI *Mptr);
void PRINTIA(MPIA Mptr);
void PRINTMATI(USI i1, USI i2, USI j1, USI j2, MPMATI *Mptr);
void PRINTMATR(USI i1, USI i2, USI j1, USI j2, MPMATR *Mptr);
void PRINTR(MPR *Aptr);
void PRINTW1(USI n, USI r);
void PRINTW2(USI n, USI r, USI m);
void PRINTWW();
void QERATOSTHENES(MPI *N, USL base[], USL soln[], USI FBASE);
void QSORTMPI0(MPI *A[], USI m, USI n);
void QSORTMPI(MPI *A[], USI m, USI n);
void QSORTMPIX();
void QSORTMATIX();
void QSORTMATI(MPMATI *Mptr, USI r, USI s);
void REDUCTION(USI **M1, USI **M2, USI m, USI n, int SCAN[]);
void REDUCTION1(USL **M1, USL **M2, USI m, USI n, USI m1bitcols, USI m2bitcols, int INDEX[], USI CTR[]);
void RODI(MPMATI *Aptr, USI *T, USI j);
void RODIP(MPMATI *Aptr, MPMATI *Pptr, USI *T, USI j);
int SIGNI(MPI *I);
void SCHNORRGCD(MPI *N);
void SERRET(MPI *P, MPI **Xptr, MPI **Yptr);
void SHALLIT();
void SHORTESTTTX();
void SHORTESTTT(MPMATI *AA, MPI *BOUND);
void SMITH();
void SORTI(USI *T, USI nz);
void SPRINTDR(char *buffer, unsigned int d, MPR *Mptr);
void SPRINTI(char *buffer, MPI *Mptr);
void SPRINTR(char *buffer, MPR *Aptr);
void STEP7(USI i, USI k, MPMATI **Lptr, MPI *D[]);
void STEP8(USI k, MPMATI **B1ptr, MPMATI **Lptr, MPMATI **Eptr, USI i);
void STEP80(USI k, MPMATI **B1ptr, MPMATI **Lptr);
void SelOpt();
void TryAgain();
void ZEROTESTI(USI i, MPMATI *Mptr, USI *p, USI *q);
void clean_symtab();
void clearscreen();
void doit(FILE *f, char *valstr, MPI *Eptr, MPI *Rptr);
void fpecatch();
void ifree2(USL **pa, USI row, USI col);
void init();
void print_array(USL **M, int rows, int cols);
void sfree(void *ptr, size_t nbytes, char *errorfile, int errorline);
void undoit(FILE *f, char *unencstr, MPI *Dptr, MPI *Rptr);
void warning(char *s, char *t);
void yyerror();
MPMATI *LLLGCD(MPMATI *DD, MPI **Aptr, USI m, USI m1, USI n1);
void REDUCE(USI k, USI l, MPMATI **Lptr, MPMATI **Bptr, MPI *D[], MPI *A[]);
void SWAP1(USI i, USI k, MPMATI **Lptr, MPI *D[]);
void SWAP2(USI k, MPMATI **B1ptr, MPMATI **Lptr, MPI *A[]);
void LLLGCDX();
void JACOBIGCDX();
MPMATI *JACOBIGCD(MPMATI *DD, MPI **Aptr, USI m);
USI COLSEEKI0(MPMATI *A, USI i, USI j);
void SCHNORRHERMITE(MPI *N);
MPMATI *BASIS_REDUCTION000(MPMATI *Bptr, USI m1, USI n1, MPI *N);
unsigned int STEP4000(USI k, USI l, MPMATI **Lptr, MPMATI **Bptr, MPI *D[], MPI *N);
void STEP8000(USI k, MPMATI **B1ptr, MPMATI **Lptr, MPI *N);
MPMATI *LLLHERMITE1(MPMATI *DD, MPMATI **Aptr, USI *rank, USI m1, USI n1);
void REDUCE1(USI k, USI l, MPMATI **Lptr, MPMATI **Bptr, MPI *D[], MPMATI **Aptr, USI *col1, USI *col2);
void SWAP21(USI k, MPMATI **Bptr, MPMATI **Lptr, MPMATI **Aptr);
void LLLHERMITE1X();
void LLLMINUS(MPMATI **Aptr, MPMATI **Pptr, MPMATI **Lptr, USI j);
MPMATI *SCALAR_ROWI(USI p, MPI *Aptr, MPMATI *Mptr);
void GCD4();
void GCD5();
void GCD6();
MPMATI *SHORTESTT0(MPMATI *AA, MPI **XX[]);
void LLLGCDMINUS(MPMATI **Pptr, MPMATI **Lptr, USI j);
MPI *PERFECT_POWER(MPI *N);
void CONVERGENTS(MPIA A, MPIA *P, MPIA *Q);
void LAGRANGE(POLYI P, MPIA *AA, MPI *M);
MPI *SUMI(MPI *A[], USL n);
MPI *EFACTORX(MPI *N, MPI *M, MPI *P);
void AXB();
void AXB1();
MPMATI *TRANSPOSEI(MPMATI *Mptr);
unsigned int PIVOTI(MPMATI *Mptr, USI *rptr, USI *cptr, USI r, USI s);
MPI *RANDOMI(MPI *X, MPI *P, MPI *T);
void RANDOM_MATRIX(MPI *M, MPI *N, MPI *X, MPI *P, MPI *T);
MPMATI *RANDOM_MATRIXA(USI m, USI n, MPI *X, MPI *P, MPI *T);
MPMATI *RANDOM_MATRIXA3(USI m, USI n, MPI *X, MPI *P, MPI *T);
MPMATI *JCOLSMATI(MPMATI *Mptr, MPMATI *Nptr);
void TESTAXB();
MPI *HALFMOD(MPI *Aptr, MPI *Pptr);
MPI *THREEI();
MPI *CHANGEL(long n);
void CHANGELX(MPI *M);
void FERMAT_QUOTIENT(MPI *N);
MPMATI *LLLGCD0(MPMATI *DD, MPI **Aptr, USI m, USI m1, USI n1);
MPR *MPI_TO_MPR(MPI *N);
void LLLGCD0X();
void GCD10();
void GCD11();
void GCD33();
MPI *ABS_NEAREST_INTR(MPR *Aptr);
MPMATI *LLLGCD0M(MPMATI *DD, MPI **Aptr, USI m, USI m1, USI n1);
void SHORTEST(MPMATI *AA, MPI *I[], USI filename, USI number);
MPI *EFACTOR(MPI *N, USI m, USI p);
void SLVECTORX();
MPR *SLVECTOR(MPMATR *A, MPR *C, MPR **VALUE);
void GCD_CONJ();
MPMATI *LLLGCDL(MPMATI *DD, MPI **Aptr, USI m, USI m1, USI n1, MPMATR**LMATRIX);
MPI ***SHORTESTX(MPMATI *AA, MPI *I[], USI *counter);
void GCD3();
void GCDCONJECTURE4();
void GCDCONJECTURE5();
void GCDCONJECTURE6();
void GCDCONJECTURE7();
void GCDCONJECTUREM();
void ABS_NEAREST_INTRX();
MPI *GEN_COLLATZ(MPI *Aptr, USL d, MPI *m[], MPI *X[]);
void P_CYCLE(MPI *Aptr, USL d, MPI *m[], MPI *X[], USI c);
unsigned int IS_CYCLE(MPI *Aptr, USL d, MPI *m[], MPI *X[], MPI *Z[], USI c);
void CYCLE(USL d, MPI *m[], MPI *X[], USL INFINITY, USL RANGE);
void CYCLEX();
MPI *MULTM3(MPI *A, MPI *B, MPI *C, MPI *M);
MPI *MULTABCM(MPI *A, MPI *B, MPI *C, MPI *M);
void POWER_CUBICM(MPI *X1, MPI *Y1, MPI **Xptr, MPI **Yptr, MPI *A1, MPI *A2, MPI *A3, MPI *A4, MPI *A6, unsigned int n, MPI *MODULUS);
void ADD_CUBICM(MPI *X1, MPI *Y1, MPI *X2, MPI *Y2, MPI **Xptr, MPI **Yptr, MPI *A1, MPI *A2, MPI *A3, MPI *A4, MPI *A6, MPI *MODULUS);
void ADD_CUBICMX();
void POWER_CUBICMX();
void ORDER_CUBICMX();
unsigned int ORDER_CUBICM(MPI *X1, MPI *Y1, MPI *A1, MPI *A2, MPI *A3, MPI *A4, MPI *A6, MPI *MODULUS);
void ORDER_CUBICRX();
unsigned int ORDER_CUBICR(MPR *X1, MPR *Y1, MPR *A1, MPR *A2, MPR *A3, MPR *A4, MPR *A6);
MPI *LEASTQNR(MPI *P);
MPI *LEASTQNRX(MPI *P);
void EUCLID(MPI *Aptr, MPI *Bptr, MPIA *Q, MPIA *R, MPIA *S, MPIA *T, MPI **Dptr);

void readme();

MPIA BUILDMPIA();
void ADD_TO_MPIA(MPIA MA, MPI *V, USL n);
void FREEMPIA(MPIA MA);
void MPIA_INSERT(MPIA MA, MPI *V, USL n);
void CORNACCHIA(MPI *A, MPI *B, MPI *M);
int COMPARE_DIGITS(MPI *M, MPI *N, MPI *U, MPI *V, USL b);
MPI *SQROOT1(MPI *A, MPI *P, USL n);
MPI *SQROOT2(MPI *A, USL n);
MPI *SQROOT3(MPI *A, MPI *P, USL n, MPI**EXPONENT);
MPI *SQROOT(MPI *A, MPI *N, MPIA *SOL, MPI **MODULUS, USI *l);
unsigned int SURD(MPI *D, MPI *T, MPI *U, MPI *V, MPIA *AA_SURD, MPIA *U_SURD, MPIA *V_SURD, MPIA *P_SURD, MPIA *Q_SURD, USI surd_flag);
MPI *SURDX(MPI *D, MPI *T, MPI *U, MPI *V, MPIA *AA_SURD, MPIA *U_ARRAY,MPIA *V_ARRAY, MPIA *P_ARRAY, MPIA *Q_ARRAY);
void PATZ(MPI *D, MPI *N);
MPI *PATZX(MPI *D, MPI *N);
MPI *CORNACCHIAX(MPI *A, MPI *B, MPI *M);
MPI *SQROOTX(MPI *A, MPI *N, MPIA *Y, MPI **M, USI *l);
MPI *QUADRATIC(MPI *A, MPI *B, MPI *C, MPI *N, MPIA *SOL);
MPI *QUADRATICX(MPI *A, MPI *B, MPI *C, MPI *N, MPIA *SOL);
void GAUSS(MPI *A, MPI *B, MPI *C, MPI *N, MPI **alpha, MPI **gamma, MPI **M);
void BINARYFORM(MPI *A, MPI *B, MPI *C, MPI *N, MPIA *FSX1, MPIA *FSY1, USI *N1, USI FLAG, USI verb);
void BINARYFORM1(MPI *A, MPI *B, MPI *C, MPI *N, MPI *VERB);
MPI *HALFMODX(MPI *Aptr, MPI *Pptr);

void LOG(MPI *A, MPI *B, MPI *D, MPI *R, MPIA *M, MPI **L);
MPI *LOGX(MPI *A, MPI *B, MPI *D, MPI *R, MPIA *M, MPI **L);
MPI *CEILINGI(MPI *A, MPI *B);
MPI *CEILINGIX(MPI *A, MPI *B);
void TESTLOG1(MPI *A, MPI *B, MPI *D, MPI *R);
void TESTLOG(MPI *A, MPI *B, MPI *D, MPI *M, MPI *N);
MPI *TESTLOGX(MPI *A, MPI *B, MPI *D, MPI *M, MPI *N);
MPI *PRIME_GENERATOR(MPI *M, MPI *N);
MPI *PRIME_GENERATORX(MPI *M, MPI *N);
USI SIGN_COUNT(MPIA A);
MPI *STURM_SEQUENCE(POLYI P, MPI *B, MPI *E);
POLYI PRIMITIVEPI_(POLYI P);
void NEXTPHI(USL p, USL *gptr, MPIA *b, MPIA *coef);
int NOTYET(USL n, USL i, USL *qptr);
int LPF(USL n);
POLYI CYCLOTOMIC(MPI *N);
unsigned int SQUAREFREE_TEST1000(USL n);
unsigned int PERIOD(MPI *D, MPI *U, MPI *V);
unsigned int CHECK_UVARRAYS(MPI *U, MPI *Y);
USI POS(MPI *D);
MPI *POSX(MPI *D);
USI NEG(MPI *D, MPI *FLAG, MPI *TABLE_FLAG);
MPI *NEGX(MPI *D, MPI *FLAG);
MPI *NEARINT(MPI *M, MPI *N);
MPI *NEARINTX(MPI *M, MPI *N);
USI REDUCE_NEG(MPI *A, MPI *B, MPI *C);
MPI *REDUCE_NEGX(MPI *A, MPI *B, MPI *C);
MPI *REDUCE_POSX(MPI *A, MPI *B, MPI *C);
USI REDUCE_POS(MPI *A, MPI *B, MPI *C);
USI CYCLE_PERIOD(MPI *D, MPI *U, MPI *V, USI i, int sign);
USI POS0(MPI *D);
MPI *POS0X(MPI *D);
MPI *TABLENEGX(MPI *M, MPI *N);
USL TABLENEG(MPI *M, MPI *N);
USL TABLEPOS(MPI *M, MPI *N);
USI POS1(MPI *D, int *norm);
MPI *TABLEPOSX(MPI *M, MPI *N);
USL POSITIVITY(MPI *A, MPI *B, MPI *C, MPI *D);
USL NPROD(USL l,USL m);
MPI *REFINE(MPI *A, MPI *B, MPI *C, MPI *D);
USL RANEY(MPI *P, MPI *B, MPI *Q, MPI *R);
USL DAVISON(USL l, USL m, USL n);
MPI *DAVISONX(MPI *L, MPI *M, MPI *N);
USL RANEY1(MPI *P, MPI *Q, MPI *R, MPI *S);
MPI *RANEY1X(MPI *P, MPI *Q, MPI *R, MPI *S);
MPI *UNIMODULARX(MPI *P, MPI *Q, MPI *R, MPI *S);
USL UNIMODULAR(MPI *P, MPI *Q, MPI *R, MPI *S);
MPI *MAXMPI(MPI *I, MPI *J);
MPI *MINMPI(MPI *I, MPI *J);
void MULT_PADIC(MPIA A, MPIA B, MPI *P, MPIA *PROD, USI m, USI n, USI *l);
int RSV_PADIC(MPIA A, MPIA B, USI m, USI n);
void SUB_PADIC(MPIA A, MPIA B, MPI *P, MPIA *DIFF, USI m, USI n, USI *l);
void BASE_PADIC(MPI *B, MPI *N, MPIA *BASE, USI *j);
void TWOADICSQRT(MPI *A, USI n, MPIA *DIGITS);
MPI *TWOADICSQRTX(MPI *A, MPI *N, MPIA *DIGITS);
void PADICSQRT(MPI *A, USI n, MPI *P, MPIA *DIGITS);
MPI *PADICSQRTX(MPI *A, MPI *N, MPI *P, MPIA *DIGITS);
MPI *SIGMAK(USI k, MPI *N);
MPI *SIGMAKX(MPI *K, MPI *N);
MPI *TAU(USI n);
MPI *TAUX(MPI *N);
MPI *TAU_PRIMEPOWERX(MPI *N, MPI *P);
MPI *TAU_PRIMEPOWER(USI n, USI p);
MPI *TAU_COMPOSITEX(MPI *N);
MPI *TAU_COMPOSITE(USI n);
USI REDUCE_NEG0(MPI *A, MPI *B, MPI *C, MPI **AA, MPI **BB, MPI **CC, MPI **alpha, MPI **beta, MPI **gamma, MPI **delta, USI print_flag);
USI REP_DEFINITE(MPI *A, MPI *B, MPI *C, MPI *M, USI print_flag);
MPI *REP_DEFINITEX(MPI *A, MPI *B, MPI *C, MPI *M, MPI *PRINT_FLAG);
void AUTOMORPH(MPI *A, MPI *B, MPI *D, MPI *T, MPI *U, MPI *X, MPI *Y, MPI **XX, MPI **YY);
void POWERD(MPI *A, MPI *B, MPI *D, MPI *N, MPI **AA, MPI **BB);
MPI *EUCLIDI1(MPI *M, MPI *N);
MPI *CFRACN(MPI *N);
MPI  *CFRAC_PERIOD(MPI *D);
#endif