wrappers.c

calc大数库

#include <stdio.h>
#include <stdlib.h>
#include "integer.h"
#include "pI.h"
#include "fun.h"
#include "stack.h"
#include "wrappers.h"
#include "calc.h"

/* Free MPI's. Free POLYI's. DO NOT FREE ARRAYS! or VARIABLES!*/

MPI *GCD_W(Stack s)
{
  /* to free or not to free.  That is the question.  I say not! */
  MPI *Aptr = stackPop(s);
  MPI *Bptr = stackPop(s);
  MPI *Result = GCD(Aptr, Bptr);
  FREEMPI(Aptr);
  FREEMPI(Bptr);
  return Result;
}

MPI *LCM_W(Stack s)
{
  /* to free or not to free.  That is the question.  I say not! */
  MPI *Aptr = stackPop(s);
  MPI *Bptr = stackPop(s);
  MPI *Result = LCM(Aptr, Bptr);
  FREEMPI(Aptr);
  FREEMPI(Bptr);
  return Result;
}

/* MPI *LCM_ARRAY(MPI *M[]) */
MPI *LCM_ARRAY_W(Stack s)
{
  MPIA M = stackPop(s);
  MPI *Result;
  Result = LCM_ARRAY(M);
  return Result;
}


/*void SERRET(MPI *P, MPI **Xptr, MPI **Yptr)*/
void SERRET_W(Stack s)
{
  MPI *P=stackPop(s);
  MPI **Xptr=stackPop(s);
  MPI **Yptr=stackPop(s);
  SERRET(P, Xptr, Yptr);
  FREEMPI(P);
  /* Notice I did not free Xptr or Ypr. They are variables */
}

void LAGRANGE_W(Stack s)
{
  POLYI P = stackPop(s);
  MPIA *AA = stackPop(s);
  MPI *M = stackPop(s);
  MPI *ZERO, *TEMP, *ONE, *G0, *G1, *GC, *H, *K, *DIFF;
  MPR *HH;
  POLYI Q,R;
  int d;

  if(DEGREEPI(P)<2){
	printf("P is linear\n");
	DELETEPI(P);
	FREEMPI(M);
	return;
  }
  TEMP=LEADPI(P);
  d=TEMP->S;
  FREEMPI(TEMP);
  if(d <0){
	printf("leading coefficient is negative\n");
	DELETEPI(P);
	FREEMPI(M);
	return;
  }
  ZERO=ZEROI();
  TEMP=VALPI(P, ZERO);
  FREEMPI(ZERO);
  d=TEMP->S;
  FREEMPI(TEMP);
  if(d==0){
	printf("P(0)=0\n");
        DELETEPI(P);
        FREEMPI(M);
	return;
  }
  Q=DERIVPI(P);
  R=GCDPI(P,Q);
  DELETEPI(Q);
  d=DEGREEPI(R);
  DELETEPI(R);
  if(d>0){
	printf("P has a repeated root\n");
        DELETEPI(P);
        FREEMPI(M);
	return;
  }
  ONE=ONEI();
  TEMP=VALPI(P, ONE);
  d=TEMP->S;
  FREEMPI(TEMP);
  FREEMPI(ONE);
  if(d==0){
	printf("P(1)=0\n");
        DELETEPI(P);
        FREEMPI(M);
	return;
  }
/* now to check that P has but one positive root, also >1 */
  ZERO=ZEROI();
  ONE=ONEI();
  G0=STURM_SEQUENCE(P, ZERO, ZERO);
  G1=STURM_SEQUENCE(P, ONE, ZERO);
  HH=CAUCHY(P);
  H=COPYI(HH->N);
  FREEMPR(HH);

  K=VALPI(P, H);
  d=K->S;
  FREEMPI(K);
  if(d==0){
	TEMP=H;
	H=ADD0I(H,ONE);
	FREEMPI(TEMP);
  }
  GC=STURM_SEQUENCE(P, H, ZERO);
  FREEMPI(ZERO);
  FREEMPI(H);
  if(EQUALI(G0,G1)){
	DIFF=SUB0I(G1,GC);
	if(RSV(DIFF,ONE)>0){
		printf("P has ");
		PRINTI(DIFF);
		printf(" roots > 1\n");
		FREEMPI(DIFF);
		FREEMPI(ONE);
		DELETEPI(P);
		FREEMPI(M);
		FREEMPI(G0);
		FREEMPI(G1);
		FREEMPI(GC);
		return;
	}
	if(DIFF->S==0){
		printf("P has no roots > 1\n");
		FREEMPI(DIFF);
		FREEMPI(ONE);
		DELETEPI(P);
		FREEMPI(M);
		FREEMPI(G0);
		FREEMPI(G1);
		FREEMPI(GC);
		return;
	}
  }else{
	printf("a has a root between 0 and 1\n");
	return;
  }
  FREEMPI(G0);
  FREEMPI(G1);
  FREEMPI(GC);
  FREEMPI(ONE);
  FREEMPI(DIFF);
/* now P has exactly one positve root and it's > 1 */

  LAGRANGE(P, AA, M);
  DELETEPI(P);
  FREEMPI(M);
  return;
}

/* void EUCLID(MPI *Aptr, MPI *Bptr, MPIA *Q, MPIA *R, MPIA *S, MPIA *T, MPI **Dptr) */
void EUCLID_W(Stack s)
{
  MPI *Aptr = stackPop(s);
  MPI *Bptr = stackPop(s);
  MPIA *Q = stackPop(s);
  MPIA *R = stackPop(s);
  MPIA *S = stackPop(s);
  MPIA *T = stackPop(s);
  MPI **Dptr = stackPop(s);
  EUCLID(Aptr, Bptr, Q, R, S, T, Dptr);
  FREEMPI(Aptr);
  FREEMPI(Bptr);
}

/*void CONVERGENTS(MPIA A, MPIA *P, MPIA *Q) */
void CONVERGENTS_W(Stack s)
{
  MPIA A = stackPop(s);
  MPIA *P = stackPop(s);
  MPIA *Q = stackPop(s);
  CONVERGENTS(A, P, Q);
}

/* MPI *EUCLIDI(MPI *Pptr, MPI *Qptr, MPI **Hptr, MPI **Kptr) */
MPI *EUCLIDI_W(Stack s)
{
  MPI *P = stackPop(s);
  MPI *Q = stackPop(s);
  MPI **H = stackPop(s);
  MPI **K = stackPop(s);
  MPI *Result = EUCLIDI(P,Q,H,K);
  FREEMPI(P);
  FREEMPI(Q);
  return Result;
} 

/*MPI *JACOB(MPI *M, MPI *N) */
MPI *JACOB_W(Stack s)
{ 
  MPI *M = stackPop(s);
  MPI *N = stackPop(s);
  MPI *Result = JACOB(M, N);
  FREEMPI(M);
  FREEMPI(N);
  return Result;
} 

/* MPI *SQRTMX(MPI *x, MPI *p) */
MPI *SQRTMX_W(Stack s)
{ 
  MPI *x = stackPop(s);
  MPI *p = stackPop(s);
  MPI *Result=SQRTMX(x, p);
  if (Result == NULL)
    rettype=FUNC_FAIL;
  FREEMPI(x);
  FREEMPI(p);
  return Result;
} 

/* MPI *GCD_ARRAY(MPIA M) */
MPI *GCD_ARRAY_W(Stack s)
{ 
  MPIA M = stackPop(s);
  return GCD_ARRAY(M);
} 

/* MPI *GCD_ARRAYVX(MPIA M, MPIA *Y) */
MPI *GCD_ARRAYVX_W(Stack s)
{ 
  MPIA M = stackPop(s);
  MPIA* Y = stackPop(s);
  return GCD_ARRAYVX(M, Y);

} 
/* MPI *CONGRX(MPI *A, MPI *B, MPI *M, MPI **N) */
MPI *CONGRX_W(Stack s)
{ 
  MPI *A= stackPop(s);
  MPI *B= stackPop(s);  
  MPI *M= stackPop(s);
  MPI **N= stackPop(s);
  MPI *Result=CONGRX(A, B, M, N);
  if (Result == NULL)
    rettype = FUNC_FAIL; /* do not print value.  see parse.y */
  FREEMPI(A);
  FREEMPI(B);
  FREEMPI(M);  
  return Result;
}
/* MPI *CHINESEX(MPI *A, MPI *B, MPI *M, MPI *N, MPI **Mptr) */
MPI *CHINESEX_W(Stack s)
{ 
  MPI *A = stackPop(s);
  MPI *B = stackPop(s);
  MPI *M = stackPop(s);
  MPI *N = stackPop(s);
  MPI **Mptr = stackPop(s);
  MPI *Result=CHINESEX(A, B, M, N, Mptr);
  if (Result == NULL) 
    rettype = FUNC_FAIL;
  FREEMPI(A);
  FREEMPI(B);
  FREEMPI(M);
  FREEMPI(N);
  return Result;
} 

/* MPI *CHINESE_ARRAYX(MPIA A, MPIA M, MPI **Mptr) */
MPI *CHINESE_ARRAYX_W(Stack s)
{ 
  MPIA A = stackPop(s);
  MPIA M = stackPop(s);
  MPI **Mptr = stackPop(s);
  MPI *Result=CHINESE_ARRAYX(A, M, Mptr);
  return Result;
} 
/* MPI *BIG_MTHROOTX(MPI *Aptr, MPI *M) */
MPI *BIG_MTHROOTX_W(Stack s)
{ 
  MPI *Aptr = stackPop(s);
  MPI *M = stackPop(s);
  MPI *Result=BIG_MTHROOTX(Aptr, M);
  if (Result == NULL)
    rettype = FUNC_FAIL;
  FREEMPI(Aptr);
  FREEMPI(M);
  return Result;
} 
/* MPI  *FUND_UNITX(MPI *D, MPI **Xptr, MPI **Yptr) */
MPI *FUND_UNITX_W(Stack s)
{ 
  MPI *D = stackPop(s);
  MPI **Xptr = stackPop(s);
  MPI **Yptr = stackPop(s);
  MPI *Result=FUND_UNITX(D, Xptr, Yptr);
  if (Result == NULL)
    rettype = FUNC_FAIL;
  FREEMPI(D);
  return Result;
} 
/* MPI  *PELX(MPI *D, MPI *E, MPI **Xptr, MPI **Yptr) */
MPI *PELX_W(Stack s)
{ 
  MPI *D = stackPop(s);
  MPI *E = stackPop(s);
  MPI **Xptr = stackPop(s);
  MPI **Yptr = stackPop(s);
  MPI *Result=PELX(D, E, Xptr, Yptr);
  if (Result == NULL)
    rettype = FUNC_FAIL;
  FREEMPI(D);
  FREEMPI(E);
  return Result;
} 
/* MPI *SURDX(MPI *D, MPI *T, MPI *U, MPI *V, MPIA *A_ARRAY, MPIA *U_ARRAY, MPIA *V_ARRAY, MPIA *P_ARRAY, MPIA *Q_ARRAY) */
MPI *SURDX_W(Stack s)
{ 
  MPI *D = stackPop(s);
  MPI *T = stackPop(s);
  MPI *U = stackPop(s);
  MPI *V = stackPop(s);
  MPIA *A_ARRAY = stackPop(s);
  MPIA *U_ARRAY = stackPop(s);
  MPIA *V_ARRAY = stackPop(s);
  MPIA *P_ARRAY = stackPop(s);
  MPIA *Q_ARRAY = stackPop(s);

  MPI *Result=SURDX(D, T, U, V, A_ARRAY, U_ARRAY, V_ARRAY, P_ARRAY, Q_ARRAY);
  if (Result == NULL)
    rettype = FUNC_FAIL;
  FREEMPI(D);
  FREEMPI(T);
  FREEMPI(U);
  FREEMPI(V);
  return Result;
} 

/* MPI *PATZX(MPI *D, MPI *N)*/

void PATZ_W(Stack s)
{
	MPI *D = stackPop(s);
	MPI *N = stackPop(s);
	MPI *Result = PATZX(D, N);
	if (Result == NULL)
	    rettype = FUNC_FAIL;
	FREEMPI(Result);
	FREEMPI(D);
	FREEMPI(N);
	return;
}

/* MPI *MPOWERX(MPI *Aptr, MPI *Bptr, MPI *Cptr) */
MPI *MPOWERX_W(Stack s)
{ 
  MPI *Aptr = stackPop(s);
  MPI *Bptr = stackPop(s);
  MPI *Cptr = stackPop(s);
  MPI *Result=MPOWERX(Aptr, Bptr, Cptr);
  if (Result == NULL)
    rettype = FUNC_FAIL;
  FREEMPI(Aptr);
  FREEMPI(Bptr);
  FREEMPI(Cptr);
  return Result;
} 
/* MPI *Nextprime(MPI *N) */
MPI *Nextprime_W(Stack s)
{ 
  MPI *N = stackPop(s);
  MPI *Result=Nextprime(N);
  if (Result == NULL)
    rettype = FUNC_FAIL;
  FREEMPI(N);
  return Result;
} 

/* MPI *INVERSEMX(MPI *A, MPI *M) */
MPI *INVERSEMX_W(Stack s)
{ 
  MPI *A = stackPop(s);
  MPI *M = stackPop(s);
  MPI *Result=INVERSEMX(A, M);
  if (Result == NULL)
    rettype = FUNC_FAIL;
  FREEMPI(A);
  FREEMPI(M);
  return Result;
} 
/* MPI *FACTORX(MPI *N) */
MPI *FACTORX_W(Stack s)
{ 
  MPI *N = stackPop(s);
  MPI *Result=FACTORX(N);
  if (Result == NULL)
    rettype = FUNC_FAIL;
  FREEMPI(N);
  return Result;
} 
/* MPI *DIVISORX(MPI *N) */
MPI *DIVISORX_W(Stack s)
{ 
  MPI *N = stackPop(s);
  MPI *Result=DIVISORX(N);
  if (Result == NULL)
    rettype = FUNC_FAIL;
  FREEMPI(N);
  return Result;
} 
/* MPI *MOBIUSX(MPI *N) */
MPI *MOBIUSX_W(Stack s)
{ 
  MPI *N = stackPop(s);
  MPI *Result=MOBIUSX(N);
  if (Result == NULL)
    rettype = FUNC_FAIL;
  FREEMPI(N);
  return Result;
} 

/* MPI *EULERX(MPI *N) */
MPI *EULERX_W(Stack s)
{ 
  MPI *N = stackPop(s);
  MPI *Result=EULERX(N);
  if (Result == NULL)
    rettype = FUNC_FAIL;
  FREEMPI(N);
  return Result;
} 
  /* MPI *SIGMAX(MPI *N) */
MPI *SIGMAX_W(Stack s)
{ 
  MPI *N = stackPop(s);
  MPI *Result=SIGMAX(N);
  if (Result == NULL)
    rettype = FUNC_FAIL;
  FREEMPI(N);
  return Result;
} 
/* MPI *LPRIMROOTX(MPI *P) */
MPI *LPRIMROOTX_W(Stack s)
{ 
  MPI *N = stackPop(s);
  MPI *Result=LPRIMROOTX(N);
  if (Result == NULL)
    rettype = FUNC_FAIL;
  FREEMPI(N);
  return Result;

} 
/* MPI *ORDERMX(MPI *A, MPI *M*/
MPI *ORDERMX_W(Stack s)
{ 
  MPI *A = stackPop(s);
  MPI *M = stackPop(s);
  MPI *Result=ORDERMX(A,M);
  if (Result == NULL)
    rettype = FUNC_FAIL;
  FREEMPI(A);
  FREEMPI(M);
  return Result;
} 
/* MPI *LUCASX(MPI *N) */
MPI *LUCASX_W(Stack s)
{ 
  MPI *N = stackPop(s);
  MPI *Result=LUCASX(N);
  if (Result == NULL)
    rettype = FUNC_FAIL;
  FREEMPI(N);
  return Result;
} 
/* MPI *LENGTHX(MPI *N) */
MPI *LENGTHX_W(Stack s)
{ 
  MPI *N = stackPop(s);
  MPI *Result=LENGTHX(N);
  FREEMPI(N);
  return Result;
} 
/* MPI *RSAE(MPI *Pptr, MPI *Qptr) */
MPI *RSAE_W(Stack s)
{ 
  MPI *P = stackPop(s);
  MPI *Q = stackPop(s);
  MPI *Result=RSAEX(P, Q);
  if (Result == NULL)
    printf("either p or q is not a prime <= 355142\n");
    rettype = FUNC_FAIL;
  FREEMPI(P);
  FREEMPI(Q);
  return Result;
} 
/* MPI *NEXTPRIMEAPX(MPI *A, MPI *B, MPI *M) */
MPI *NEXTPRIMEAPX_W(Stack s)
{ 
  MPI *A = stackPop(s);
  MPI *B = stackPop(s);
  MPI *M = stackPop(s);
  MPI *Result=NEXTPRIMEAPX(A, B, M);
  if (Result == NULL)
    rettype = FUNC_FAIL;
  FREEMPI(A);
  FREEMPI(B);
  FREEMPI(M);
  return Result;
} 
/* MPI *POLLARD(MPI *Nptr) */
MPI *POLLARD_W(Stack s)
{ 
  MPI *N = stackPop(s);
  MPI *Result=POLLARD(N);
  FREEMPI(N);
  return Result;
} 
/* MPI *EFACTORX(MPI *N, MPI *M, MPI *P) */
MPI *EFACTORX_W(Stack s)
{ 
  MPI *N = stackPop(s);
  MPI *M = stackPop(s);
  MPI *P = stackPop(s);
  MPI *Result=EFACTORX(N, M, P);
  if (Result == NULL)
    rettype = FUNC_FAIL;
  FREEMPI(N);
  FREEMPI(M);
  FREEMPI(P);
  return Result;
} 
/* MPI *PERFECT_POWER(MPI *N) */
MPI *PERFECT_POWER_W(Stack s)
{ 
  MPI *N = stackPop(s);
  MPI *Result=PERFECT_POWER(N);
  FREEMPI(N);
  return Result;
} 

/*MPI *LEASTQNRX(MPI *P) */
MPI *LEASTQNRX_W(Stack s)
{ 
  MPI *P = stackPop(s);
  MPI *Result=LEASTQNRX(P);
  FREEMPI(P);
  if (Result  == NULL)
    rettype = FUNC_FAIL;
  return Result;
} 
MPI* CONTENTPI2_W(Stack s)
{
  POLYI P = stackPop(s);
  MPI *Result = CONTENTPI2(P);
  DELETEPI(P);
  return Result;
}

/* void COLLATZ(MPI *Dptr, MPI *Eptr) */
void COLLATZ_W(Stack s)
{
  MPI *D = stackPop(s);
  MPI *E = stackPop(s);
  COLLATZ(D, E);
  FREEMPI(D);
  FREEMPI(E);

}
/* void MTHROOTX(MPI *Aptr, MPI *Bptr, MPI *M, MPI *R) */
void MTHROOTX_W(Stack s)
{
  MPI *A = stackPop(s);
  MPI *B = stackPop(s);
  MPI *M = stackPop(s);
  MPI *R = stackPop(s);
  MTHROOTX(A, B, M, R);
  FREEMPI(A);
  FREEMPI(B);
  FREEMPI(M);
  FREEMPI(R);
}
/* void MILLERX(MPI *N, MPI *B) */
void MILLERX_W(Stack s)
{
  MPI *N = stackPop(s);
  MPI *B = stackPop(s);
  MILLERX(N, B);
  FREEMPI(N);
  FREEMPI(B);
}
/* void JUGGLER(MPI *Dptr, MPI *Iptr) */
void JUGGLER_W(Stack s)
{
  MPI *D = stackPop(s);
  MPI *I = stackPop(s);
  JUGGLER(D, I);
  FREEMPI(D);
  FREEMPI(I);
}

/* void ENCODE(MPI *Eptr, MPI *Rptr) */
void ENCODE_W(Stack s)
{
  MPI *E = stackPop(s);
  MPI *R = stackPop(s);
  ENCODE(E, R);
  FREEMPI(E);
  FREEMPI(R);
}
/* void DECODEX(MPI *Eptr, MPI *Pptr, MPI *Qptr) */
void DECODEX_W(Stack s)
{
  MPI *E = stackPop(s);
  MPI *P = stackPop(s);
  MPI *Q = stackPop(s);
  DECODEX(E, P, Q);
  FREEMPI(E);
  FREEMPI(P);
  FREEMPI(Q);
    
}
/* void SCHNORRGCD(MPI *N) */
void SCHNORRGCD_W(Stack s)
{
  MPI *N = stackPop(s);
  SCHNORRGCD(N);
  FREEMPI(N);
}

/* void SCHNORRHERMITE(MPI *N) */
void SCHNORRHERMITE_W(Stack s)
{
  MPI *N = stackPop(s);
  SCHNORRHERMITE(N);
  FREEMPI(N);
}

POLYI PRIMITIVEPI_W(Stack s)
{
  POLYI P = stackPop(s);
  POLYI Result=PRIMITIVEPI(P);
  DELETEPI(P);