wrappers.c

calc大数库

  return Result;
}

/* MPI *CORNACCHIAX(MPI *A, MPI *B, MPI *M) */
void CORNACCHIA_W(Stack S)
{
	MPI *A = stackPop(S);
	MPI *B = stackPop(S);
	MPI *M = stackPop(S);
	
	MPI *Result = CORNACCHIAX(A, B, M);
	if (Result  == NULL)
	    rettype = FUNC_FAIL;
	FREEMPI(Result);
	FREEMPI(A);
	FREEMPI(B);
	FREEMPI(M);
	return;
}

MPI *SQROOT_W(Stack S)
{
	MPI *Tmp;
	USI ll;

	MPI *A = stackPop(S);
	MPI *N = stackPop(S);
	MPIA *Y = stackPop(S);
	MPI **M = stackPop(S);
	MPI **L = stackPop(S);
	MPI *R = SQROOTX(A, N, Y, M, &ll);
	FREEMPI(A);
	FREEMPI(N);
	if (R == NULL)
            rettype = FUNC_FAIL;
	else{
		*L = CHANGE((USL)ll);
		if(EQMINUSONEI(R)){
			Tmp = R;
			R = ZEROI();
			FREEMPI(Tmp);
		}
	}
	return (R);
}

MPI *QUADRATIC_W(Stack S)
{
	MPI *A, *B, *C, *N, *R;
	MPIA *Y;

	A = stackPop(S);
	B = stackPop(S);
	C = stackPop(S);
	N = stackPop(S);
	Y = stackPop(S);
	R = QUADRATICX(A, B, C, N, Y);
	FREEMPI(A);
	FREEMPI(B);
	FREEMPI(C);
	FREEMPI(N);
	if (R == NULL){
	    R = ZEROI();
            rettype = FUNC_FAIL;
	}
	return (R);
}
/*
void BINARYFORM_W(Stack S)
{
	MPI *A, *B, *C, *N;

	A = stackPop(S);
	B = stackPop(S);
	C = stackPop(S);
	N = stackPop(S);
	BINARYFORM(A, B, C, N);
	FREEMPI(A);
	FREEMPI(B);
	FREEMPI(C);
	FREEMPI(N);
	return;
}
*/
void GAUSS_W(Stack S)
{
	MPI *A, *B, *C, *N, **alpha, **gamma, **M;
	A = stackPop(S);
        B = stackPop(S);
        C = stackPop(S);
        N = stackPop(S);
        alpha = stackPop(S);
        gamma = stackPop(S);
	
        M = stackPop(S);
	GAUSS(A, B, C, N, alpha, gamma, M);
	FREEMPI(A);
	FREEMPI(B);
	FREEMPI(C);
	FREEMPI(N);
	return;
}

void BINFORM_W(Stack S)
{
	MPI *A, *B, *C, *N, *V;

	A = stackPop(S);
	B = stackPop(S);
	C = stackPop(S);
	N = stackPop(S);
	V = stackPop(S);
	BINARYFORM1(A, B, C, N, V);
	FREEMPI(A);
	FREEMPI(B);
	FREEMPI(C);
	FREEMPI(N);
	FREEMPI(V);
	return;
}

MPI *HALFMOD_W(Stack S)
{
	MPI *A, *B, *R;

	A = stackPop(S);
	B = stackPop(S);
	R = HALFMODX(A, B);
	FREEMPI(A);
	FREEMPI(B);
	if (R == NULL){
            rettype = FUNC_FAIL;
	}
	return (R);
}

/* MPI *LOGX(MPI *A, MPI *B, MPI *D, MPI *R, MPIA *M, MPI **L) */
void LOG_W(Stack s)
{
	MPI *A = stackPop(s);
	MPI *B = stackPop(s);
	MPI *D = stackPop(s);
	MPI *R = stackPop(s);
	MPIA *M = stackPop(s);
	MPI **L = stackPop(s);
	MPI *Z;

	Z = LOGX(A, B, D, R, M, L);
	if (Z == NULL)
            rettype = FUNC_FAIL;
	else
		FREEMPI(Z);
	FREEMPI(A);
	FREEMPI(B);
	FREEMPI(D);
	FREEMPI(R);
}

/* MPI *CEILINGIX(MPI *A, MPI *B) */
MPI *CEILINGI_W(Stack s)
{
	MPI *A = stackPop(s);
	MPI *B = stackPop(s);

	MPI *Z = CEILINGIX(A,B);
	if (Z == NULL)
            rettype = FUNC_FAIL;
	FREEMPI(A);
	FREEMPI(B);
	return(Z);
}

/*void TESTLOG1(MPI *A, MPI *B, MPI *D, MPI *R)*/
void TESTLOG1_W(Stack s)
{
	MPI *A = stackPop(s);
	MPI *B = stackPop(s);
	MPI *D = stackPop(s);
	MPI *R = stackPop(s);

	TESTLOG1(A, B, D, R);
	FREEMPI(A);
	FREEMPI(B);
	FREEMPI(D);
	FREEMPI(R);
}

/*void TESTLOGX(MPI *A, MPI *B, MPI *D, MPI *M, MPI *N)*/
void TESTLOG_W(Stack s)
{
	MPI *A = stackPop(s);
	MPI *B = stackPop(s);
	MPI *D = stackPop(s);
	MPI *M = stackPop(s);
	MPI *N = stackPop(s);
	MPI *Z;

	Z = TESTLOGX(A, B, D, M, N);
	if (Z == NULL)
            rettype = FUNC_FAIL;
	else
		FREEMPI(Z);

	FREEMPI(A);
	FREEMPI(B);
	FREEMPI(D);
	FREEMPI(M);
	FREEMPI(N);
}

/* MPI *SUBRESULTANT(POLYI P, POLY Q) */
MPI *SUBRESULTANT_W(Stack s)
{ 
	  MPI *Result;
          POLYI P = stackPop(s);
	  POLYI Q = stackPop(s);
          if(DEGREEPI(P)<=0){
	      printf("First argument is a constant\n");
              rettype = FUNC_FAIL;
	  }
          if(DEGREEPI(Q)<=0){
	      printf("Second argument is a constant\n");
              rettype = FUNC_FAIL;
	  }
	  Result=SUBRESULTANT(P, Q);
	  DELETEPI(P);
	  DELETEPI(Q);
	  return Result;
} 


/* MPI *DISCRIMINANTPI(POLYI Pptr)*/
MPI *DISCRIMINANTPI_W(Stack s){
	  MPI *Result;
          POLYI P = stackPop(s);
          if(DEGREEPI(P)<=1){
	      printf("argument has form aX+b\n");
              rettype = FUNC_FAIL;
	  }
          Result=DISCRIMINANTPI(P);
          DELETEPI(P);
          return Result;
}

/* POLYI DERIVPI(POLYI Pptr) */
POLYI DERIVPI_W(Stack s){
	POLYI Result;
        POLYI P = stackPop(s);
	Result = DERIVPI(P);
        DELETEPI(P);
        return Result;
}

/* MPI *PRIME_GENERATORX(MPI *M, MPI *N) */
MPI *PRIME_GENERATOR_W(Stack s){
	MPI *Result;

	MPI *M = stackPop(s);
	MPI *N = stackPop(s);
	Result = PRIME_GENERATORX(M, N);
	if (Result == NULL){
		FREEMPI(M);
		FREEMPI(N);
                rettype = FUNC_FAIL;
	}
	FREEMPI(M);
	FREEMPI(N);
	return(Result);
}

/* POLYI GCDPI(POLYI Pptr, POLYI Qptr) */
POLYI GCDPI_W(Stack s){
	POLYI Result;
        POLYI P = stackPop(s);
        POLYI Q = stackPop(s);
	Result = GCDPI(P, Q);
        DELETEPI(P);
        DELETEPI(Q);
        return Result;
}


/* MPI *STURM_SEQUENCE(POLYI P, MPI *B, MPI *E)*/
MPI *STURM_SEQUENCE_W(Stack s){
	MPI *Result, *TEMP;
	POLYI R, Q;
	int d;
	POLYI P = stackPop(s);
	MPI *B = stackPop(s);
	MPI *E = stackPop(s);

	Q = DERIVPI(P); 
	R = GCDPI(P,Q);
	d = DEGREEPI(R);
	DELETEPI(Q);
	DELETEPI(R);
	if(d){
		printf("P has a multiple root\n");
                rettype = FUNC_FAIL;
		DELETEPI(P);
		FREEMPI(B);
		FREEMPI(E);
		return NULL;
	}else if(DEGREEPI(P) <2){
		printf("P is linear\n");
                rettype = FUNC_FAIL;
		DELETEPI(P);
		FREEMPI(B);
		FREEMPI(E);
		return NULL;
	}else{
		TEMP=VALPI(P, B);
		d = TEMP->S;
		FREEMPI(TEMP);
		if(d==0){
			printf("P(b)=0\n");
			rettype = FUNC_FAIL;
			DELETEPI(P);
			FREEMPI(B);
			FREEMPI(E);
			return NULL;
		}else{
			Result = STURM_SEQUENCE(P, B, E);
			DELETEPI(P);
			FREEMPI(B);
			FREEMPI(E);
			return Result;
		}
	}
}

POLYI CYCLOTOMIC_W(Stack s){
	POLYI P;
	MPI *N = stackPop(s);
	P = CYCLOTOMIC(N);
	if(P==NULL){
		rettype=FUNC_FAIL;
	}
	FREEMPI(N);
	return(P);
}

MPI *POS_W(Stack s){
	MPI *P;
	MPI *D = stackPop(s);
	P = POSX(D);
	if(P==NULL)
		rettype=FUNC_FAIL;
	FREEMPI(D);
	return(P);
}

MPI *NEG_W(Stack s){
	MPI *H;
	MPI *D = stackPop(s);
	MPI *FLAG = stackPop(s);
	H = NEGX(D, FLAG);
	if(H==NULL)
		rettype=FUNC_FAIL;
	FREEMPI(D);
	FREEMPI(FLAG);
	return(H);
}

MPI *NEARINT_W(Stack s){
	MPI *A, *B, *R;

	A = stackPop(s);
	B = stackPop(s);
	R = NEARINTX(A, B);
	FREEMPI(A);
	FREEMPI(B);
	if (R == NULL){
            rettype = FUNC_FAIL;
	}
	return (R);
}

MPI *REDUCE_NEG_W(Stack s){
	MPI *A, *B, *C, *I;
	A = stackPop(s);
	B = stackPop(s);
	C = stackPop(s);
	I = REDUCE_NEGX(A, B, C);
	FREEMPI(A);
	FREEMPI(B);
	FREEMPI(C);
	if (I == NULL){
            rettype = FUNC_FAIL;
	}
	return(I);
}

MPI *REDUCE_POS_W(Stack s){
	MPI *I;
        MPI *A = stackPop(s);
        MPI *B = stackPop(s);
        MPI *C = stackPop(s);
        I = REDUCE_POSX(A, B, C);
        FREEMPI(A);
        FREEMPI(B);
        FREEMPI(C);
        if (I == NULL){
            rettype = FUNC_FAIL;
        }
        return(I);
}

MPI *POS0_W(Stack s){
	MPI *P;
	MPI *D = stackPop(s);
	P = POS0X(D);
	if(P==NULL)
		rettype=FUNC_FAIL;
	FREEMPI(D);
	return(P);
}

MPI *TABLENEG_W(Stack s){
	MPI *P;
	MPI *M = stackPop(s);
	MPI *N = stackPop(s);
	P = TABLENEGX(M, N);
	if (P == NULL)
		rettype=FUNC_FAIL;
	FREEMPI(M);
	FREEMPI(N);
	return(P);
}

MPI *TABLEPOS_W(Stack s){
	MPI *P;
	MPI *M = stackPop(s);
	MPI *N = stackPop(s);
	P = TABLEPOSX(M, N);
	if (P == NULL)
		rettype=FUNC_FAIL;
	FREEMPI(M);
	FREEMPI(N);
	return(P);
}

MPI *DAVISON_W(Stack s){
	MPI *T;
	MPI *L = stackPop(s);
	MPI *M = stackPop(s);
	MPI *N = stackPop(s);
	T = DAVISONX(L, M, N);
	if (T == NULL)
		rettype=FUNC_FAIL;
	FREEMPI(L);
	FREEMPI(M);
	FREEMPI(N);
	return(T);
}

MPI *RANEY1_W(Stack s){
	MPI *T;
	MPI *P = stackPop(s);
	MPI *Q = stackPop(s);
	MPI *R = stackPop(s);
	MPI *S = stackPop(s);
	T = RANEY1X(P, Q, R, S);
	if (T == NULL)
		rettype=FUNC_FAIL;
	FREEMPI(P);
	FREEMPI(Q);
	FREEMPI(R);
	FREEMPI(S);
	return(T);
}

MPI *UNIMODULAR_W(Stack s){
	MPI *T;
	MPI *P = stackPop(s);
	MPI *Q = stackPop(s);
	MPI *R = stackPop(s);
	MPI *S = stackPop(s);
	T = UNIMODULARX(P, Q, R, S);
	if (T == NULL)
		rettype=FUNC_FAIL;
	FREEMPI(P);
	FREEMPI(Q);
	FREEMPI(R);
	FREEMPI(S);
	return(T);
}

void TWOADICSQRT_W(Stack s){
	MPI *T;
	MPI *A = stackPop(s);
	MPI *N = stackPop(s);
	MPIA *DIGITS = stackPop(s);
	T = TWOADICSQRTX(A, N, DIGITS);
	if (T == NULL)
		rettype=FUNC_FAIL;
	FREEMPI(A);
	FREEMPI(N);
	FREEMPI(T);
}

void PADICSQRT_W(Stack s){
	MPI *T;
	MPI *A = stackPop(s);
	MPI *N = stackPop(s);
	MPI *P = stackPop(s);
	MPIA *DIGITS = stackPop(s);
	T = PADICSQRTX(A, N, P, DIGITS);
	if (T == NULL)
		rettype=FUNC_FAIL;
	FREEMPI(A);
	FREEMPI(N);
	FREEMPI(P);
	FREEMPI(T);
}
 
MPI *SIGMAK_W(Stack s){
	MPI *T;
	MPI *K = stackPop(s);
	MPI *N = stackPop(s);
	T = SIGMAKX(K, N);	
	if (T == NULL)
		rettype=FUNC_FAIL;
	FREEMPI(K);
	FREEMPI(N);
	return(T);
}

MPI *TAU_W(Stack s){
	MPI *T;
	MPI *N = stackPop(s);
	T = TAUX(N);	
	if (T == NULL)
		rettype=FUNC_FAIL;
	FREEMPI(N);
	return(T);
}

MPI *TAU_PRIMEPOWER_W(Stack s){
	MPI *T;
	MPI *N = stackPop(s);
	MPI *P = stackPop(s);
	T = TAU_PRIMEPOWERX(N, P);	
	if (T == NULL)
		rettype=FUNC_FAIL;
	FREEMPI(N);
	FREEMPI(P);
	return(T);
}

MPI *TAU_COMPOSITE_W(Stack s){
	MPI *T;
	MPI *N = stackPop(s);
	T = TAU_COMPOSITEX(N);	
	if (T == NULL)
		rettype=FUNC_FAIL;
	FREEMPI(N);
	return(T);
}

MPI *REP_DEFINITE_W(Stack s){
	MPI *A, *B, *C, *M, *PRINT_FLAG, *I;
	A = stackPop(s);
	B = stackPop(s);
	C = stackPop(s);
	M = stackPop(s);
	PRINT_FLAG = stackPop(s);
	I = REP_DEFINITEX(A, B, C, M, PRINT_FLAG);
	FREEMPI(A);
	FREEMPI(B);
	FREEMPI(C);
	FREEMPI(M);
	FREEMPI(PRINT_FLAG);
	if (I == NULL){
            rettype = FUNC_FAIL;
	}
	return(I);
}

void POWERD_W(Stack s)
{
  MPI *A=stackPop(s);
  MPI *B=stackPop(s);
  MPI *D=stackPop(s);
  MPI *N=stackPop(s);
  MPI **AA=stackPop(s);
  MPI **BB=stackPop(s);
  POWERD(A, B, D, N, AA, BB);
  FREEMPI(A);
  FREEMPI(B);
  FREEMPI(D);
  FREEMPI(N);
}

MPI *EUCLIDI1_W(Stack s)
{
  MPI *Aptr = stackPop(s);
  MPI *Bptr = stackPop(s);
  MPI *Result;
  if(Aptr->S <= 0){
      Result = ZEROI();
      printf("A <= 0\n");
  }else if(Bptr->S <= 0){
      Result = ZEROI();
      printf("B <= 0\n");
  }else{
      Result = EUCLIDI1(Aptr, Bptr);
  }
  FREEMPI(Aptr);
  FREEMPI(Bptr);
  return Result;
}

MPI *CFRACN_W(Stack s)
{
  MPI *TEMP1, *TEMP2;
  MPI *N=stackPop(s);
  if(N->S<0){
    printf("n < 0\n");
    FREEMPI(N);
    return(ZEROI());
  }else{
     MPI *M = CFRACN(N);
     printf ("the  continued fraction expansion of sqrt(2^");
     TEMP1 = MULT_I(N, 2);
     TEMP2 = ADD0_I(TEMP1, 1);
     PRINTI(TEMP2);
     FREEMPI(TEMP1);
     FREEMPI(TEMP2);
     printf(") has period-length ");
     PRINTI(M);
     FREEMPI(N);
     printf("\n");
     return(M);
  }
}

MPI *CFRAC_PERIOD_W(Stack s)
{
  USI t;
  MPI *P, *X, *Y;
  MPI *D=stackPop(s);
  X= BIG_MTHROOT(D, 2);
  Y = MULTI(X, X);
  t = EQUALI(D, Y);
  FREEMPI(X);
  FREEMPI(Y);
  if(t){
     printf("D is a square\n");
     FREEMPI(D);
     return(ZEROI());
  }
  P = CFRAC_PERIOD(D);
  FREEMPI(D);
  return(P);
}