void
check_limb (void)
{
  int        i;
  mp_limb_t  limb;
  mpz_t      z;
  char       *s;

  check_one ("0", "%Md", CNST_LIMB(0));
  check_one ("1", "%Md", CNST_LIMB(1));

  /* "i" many 1 bits, tested against mpz_get_str in decimal and hex */
  limb = 1;
  mpz_init_set_ui (z, 1L);
  for (i = 1; i <= GMP_LIMB_BITS; i++)
    {
      s = mpz_get_str (NULL, 10, z);
      check_one (s, "%Mu", limb);
      (*__gmp_free_func) (s, strlen (s) + 1);

      s = mpz_get_str (NULL, 16, z);
      check_one (s, "%Mx", limb);
      (*__gmp_free_func) (s, strlen (s) + 1);

      s = mpz_get_str (NULL, -16, z);
      check_one (s, "%MX", limb);
      (*__gmp_free_func) (s, strlen (s) + 1);

      limb = 2*limb + 1;
      mpz_mul_2exp (z, z, 1L);
      mpz_add_ui (z, z, 1L);
    }

  mpz_clear (z);
}
Example #2
0
char *dd_MLGetStrForNumber(mytype x)
{
  /* This is to make a string of rational expression for GMP rational number x.
     It does nothing (return NULL) if x is double.  */
     
  char *sd=NULL,*sn=NULL,*st=NULL;
#if defined GMPRATIONAL
  mpz_t zn,zd;
  int len;

  mpz_init(zn); mpz_init(zd);
  mpq_canonicalize(x);
  mpq_get_num(zn,x);
  mpq_get_den(zd,x);
  if (mpz_sgn(zn)==0){
    st=(char *)malloc(2);
    strcpy(st," 0");
  } else if (mpz_cmp_ui(zd,1U)==0){
    st=mpz_get_str(st,10,zn);
  } else {
    sn=mpz_get_str(sn,10,zn);sd=mpz_get_str(sd,10,zd);
    len=strlen(sn)+strlen(sd)+2;
    st=(char *)malloc(len);
    strcpy(st,sn);
    strcat(st,"/");strcat(st,sd);
  }
  mpz_clear(zn); mpz_clear(zd);
  if (sd!=NULL) free(sd);
  if (sn!=NULL) free(sn);
#else
  /* do nothing */
#endif
  /* printf("String for Number =%s\n",st);  */
  return st;
}
Example #3
0
void sharecalc()
{
	char buf[1024];

	if(np<n){
		fprintf(stderr,"Could not read enough shares, unable to compute.\n");
		exit(1);
	}

	/*calculate*/

	/*printf("Key-Matrix:\n");printm(kmatrix);
	printf("Hash-Matrix:\n");printm(hmatrix);*/

	solve(kmatrix);
	solve(hmatrix);

	/*output result*/
	str2bin(key,mpz_get_str(buf,16,kmatrix[0][n]),16);
	str2bin(hashv,mpz_get_str(buf,16,hmatrix[0][n]),16);
	/*printf("Using key: %s\n",key_prints(0,key));
	printf("Expected Hash: %s\n",key_prints(0,hashv));*/
	/*printf("Key-Matrix:\n");printm(kmatrix);
	printf("Hash-Matrix:\n");printm(hmatrix);*/
}
Example #4
0
/*
===============
SV_RSAGenMsg

Generate an encrypted RSA message
===============
*/
int SV_RSAGenMsg( const char *pubkey, char *cleartext, char *encrypted ) {
	struct        rsa_public_key public_key;
	mpz_t         message;
	unsigned char buffer[ RSA_KEY_LENGTH / 8 - 11 ];
	int           retval;

	Com_RandomBytes( buffer, RSA_KEY_LENGTH / 8 - 11 );

	nettle_mpz_init_set_str_256_u( message, RSA_KEY_LENGTH / 8 - 11, buffer );
	mpz_get_str( cleartext, 16, message );
	rsa_public_key_init( &public_key );
	mpz_set_ui( public_key.e, RSA_PUBLIC_EXPONENT );
	retval = mpz_set_str( public_key.n, pubkey, 16 ) + 1;
	
	if ( retval ) {
		rsa_public_key_prepare( &public_key );
		retval = rsa_encrypt( &public_key, NULL, qnettle_random, RSA_KEY_LENGTH / 8 - 11, buffer, message );
	}

	rsa_public_key_clear( &public_key );
	mpz_get_str( encrypted, 16, message );
	mpz_clear( message );

	return retval;
}
Example #5
0
/***
 *  get Public and Private keys and save them in .txt
 */
void getPublicPrivatekey(mpz_t p, mpz_t q,mpz_t n ,mpz_t phi , mpz_t e, mpz_t d)
{
    mpz_init(p);
    mpz_init(q); 
    mpz_init(n);
    mpz_init(phi);
    mpz_init(d);
    int seed=rand();
    getNumberPremier(p,seed+1);
    getNumberPremier(q,seed+2);
    int e_int=65537;   
    mpz_set_ui(e,e_int);

    mpz_mul(n,p,q);                     //n=p*q
    mpz_sub_ui(p, p, 1);                //p=p-1
    mpz_sub_ui(q, q, 1);                //q=q-1
    mpz_mul(phi, p, q);                 //phi=(p-1)*(q-1)
    mpz_invert(d, e, phi);              //calcul d

    char *str_d=malloc(KEY_LENGTH/4*sizeof(char));
    char *str_n=malloc(KEY_LENGTH/2*sizeof(char));

    mpz_get_str (str_n, 16, n);
    mpz_get_str (str_d, 16, d);

    WriteF(str_n,"publicKey_Modulo");
    WriteF(str_d,"privateKey_d");

    free(str_n);
    free(str_d);

    printf("\nClé ==>==>==>==>==> Gagné\n");
}
Example #6
0
// sign a hash using ECDSA, hash must be a string in base used during initialisation.
// private key and a generator point are required for it to work (look SetDomain 
// and SetKeys)
void ECDSA::Sign( char *hash, char *&r, char *&s )
{
	mpz_t z,k,rr,ss,t,u;
	ECPoint kG;

	mpz_init_set_str(z, hash, m_base);
	mpz_inits(k, rr, ss, t, u, NULL);

	do 
	{
		mpz_urandomm(k, m_st, ecc->m_n);
		ecc->MultiplePoint(k, ecc->m_G, kG);
		mpz_set(rr, kG.x);
		mpz_mod(rr, rr, ecc->m_n);
	} while (!mpz_cmp_ui(rr, 0));

	do 
	{
		mpz_set(t,z);
		mpz_addmul(t,rr,ecc->m_dA);
		mpz_set(u,k);
		mpz_invert(u,u,ecc->m_n);
		mpz_mul(ss, t, u);
		mpz_mod(ss, ss, ecc->m_n);
	} while (!mpz_cmp_ui(ss, 0));

	mpz_get_str(r, m_base, rr);
	mpz_get_str(s, m_base, ss);

	mpz_clears(z,k,rr,ss,t,u,NULL);

	return;
}
Example #7
0
/******************************************************************************
 PYTHON BINDINGS
 ******************************************************************************/
static PyObject * _ecdsa_sign(PyObject *self, PyObject *args) {
    char * msg, * d, * k, * p, * a, * b, * q, * gx, * gy;

    if (!PyArg_ParseTuple(args, "sssssssss", &msg, &d, &k, &p, &a, &b, &q, &gx, &gy)) {
        return NULL;
    }

    mpz_t privKey, nonce;
    CurveZZ_p * curve = buildCurveZZ_p(p, a, b, q, gx, gy, 10);
    Sig sig;

    mpz_init_set_str(privKey, d, 10);
    mpz_init_set_str(nonce, k, 10);

    signZZ_p(&sig, msg, privKey, nonce, curve);
    destroyCurveZZ_p(curve);

    char * resultR = mpz_get_str(NULL, 10, sig.r);
    char * resultS = mpz_get_str(NULL, 10, sig.s);
    mpz_clears(sig.r, sig.s, privKey, NULL);

    PyObject * ret = Py_BuildValue("ss", resultR, resultS);
    free(resultR);
    free(resultS);
    return ret;
}
Example #8
0
/* MakeSpanCaseSpecification : return an ident in the format suitable for
	Case specifications from a SpanListList */
Ptrchar MakeSpanCaseSpecification (PtrSpanListList list, Bits width)
{
    int CaseSpecLength = CASE_SPEC_STR_LEN;
    Ptrchar buildStr = NEW_ARRAY (char, CaseSpecLength);

    *buildStr = '\0';
    /* FOR_EACH (list, true, ...) */
    while (list && true)
    {
        PtrSpanList subList = CAR (list);

        /* FOR_EACH (subList, true, ...) */
        while (subList && true)
        {
            mpz_get_str (EndOfString (buildStr), 10, FilterRangeFromMP_INT (CAR (subList).lowerBound, width, 0));
            if (mpz_cmp (CAR (subList).lowerBound, CAR (subList).upperBound) != 0)
            {
                strcat (buildStr, "..");
                mpz_get_str (EndOfString (buildStr), 10, FilterRangeFromMP_INT (CAR (subList).upperBound, width, 0));
            }
            if (CDR (subList))
                strcat (buildStr, ",");
            if (strlen (buildStr) > CaseSpecLength / 2)
            {
                CaseSpecLength *= 2;
                buildStr = EXTEND_ARRAY (buildStr, char, CaseSpecLength);
            }
            subList = CDR (subList);
        }
        if (CDR (list))
            strcat (buildStr, ";");
        list = CDR (list);
    }
Example #9
0
obj rational_to_string_obj( obj a, unsigned radix )
{
    mpq_t v;
    size_t sz;
    obj str, str2;
    int len;

    OBJ_TO_MPQ(v, a);
    sz = mpz_sizeinbase(mpq_numref(v), radix) + 2;
    if(mpz_sgn(mpq_numref(v))<0)
        sz++;
    sz += mpz_sizeinbase(mpq_denref(v), radix);
    str = bvec_alloc(sz, string_class);

    if(!mpz_get_str(PTR_TO_DATAPTR(str), radix, mpq_numref(v)))
        return FALSE_OBJ;
    len = strlen(PTR_TO_DATAPTR(str));
    ((char *)PTR_TO_DATAPTR(str))[len++]='/';
    if(!mpz_get_str(PTR_TO_DATAPTR(str) + len, radix, mpq_denref(v)))
        return FALSE_OBJ;

    if(strlen(PTR_TO_DATAPTR(str)) == sz - 1)
        return str;
    str2 = bvec_alloc(sz - 1, string_class);
    strcpy(PTR_TO_DATAPTR(str2), PTR_TO_DATAPTR(str));
    return str2;
}
static char *
rw_serialize_priv (const dckey *key)
{
  const rw_priv *sk = k2priv (key);
  size_t buflen = (strlen (rabin_1.name)
		   + sizeof (rwak_ppref) + sizeof (rwak_qpref) + 3
		   + mpz_sizeinbase (sk->p, 16)
		   + mpz_sizeinbase (sk->q, 16));
  char *buf = malloc (buflen);
  char *p = buf;

  if (!buf)
    return NULL;

  strcpy (p, rabin_1.name);
  strcat (p, rwak_ppref);
  strcat (p, "0x");
  p += strlen (p);
  mpz_get_str (p, 16, sk->p);
  strcat (p, rwak_qpref);
  strcat (p, "0x");
  p += strlen (p);
  mpz_get_str (p, 16, sk->q);

  p += strlen (p) + 1;
  assert (p == buf + buflen);

  return buf;
}
Example #11
0
void ecc_doubling(ecc_jcb_t *ROP, ecc_jcb_t *P, ecc_curve *curve)
{
    mpz_t alfa, alfa1, alfa2, beta, x3_2, y3_2, y2, z3_2;
    if((strcmp(mpz_get_str(NULL, 10, P->x), "0") == 0) && (strcmp(mpz_get_str(NULL, 10, P->y), "0") == 0) && (strcmp(mpz_get_str(NULL, 10, P->z), "0") == 0))
    {
        ecc_cp_jcb(ROP, P);
    }
    else
    {
        mpz_inits(alfa, alfa1, alfa2, beta, x3_2, y3_2, z3_2, y2, NULL);
        // alfa = 3*(x1)**2 + a * (z1**4)
        fp_mul_mpz(alfa1, P->x, P->x, curve->p);
        fp_mul_mpz(alfa2, P->z, P->z, curve->p);
        fp_mul_mpz(alfa2, alfa2, alfa2, curve->p);
        fp_mul_si(alfa1, alfa1, 3, curve->p);
        fp_mul_mpz(alfa2, alfa2, curve->a, curve->p);
        fp_add_mpz(alfa, alfa1, alfa2, curve->p);

        // y2 = y1**2
        fp_mul_mpz(y2, P->y, P->y, curve->p);
        // beta = 4*x1*(y1**2)
        fp_mul_mpz(beta, y2, P->x, curve->p);
        fp_mul_si(beta, beta, 4, curve->p);
        
        mpz_set(ROP->z, P->z);
        
        // z3 = y1*z1
        fp_mul_mpz(ROP->z, P->z, P->y, curve->p);
        
        // z3 = 2*y1*z1
        fp_mul_si(ROP->z, ROP->z, 2, curve->p);
        
        mpz_init_set(x3_2, beta);
        
        // x3_2 = 2*beta
        fp_mul_si(x3_2, x3_2, 2, curve->p);
        mpz_set(ROP->x, alfa);
        
        // x3 = alfa**2 - 2*beta
        fp_mul_mpz(ROP->x, ROP->x, ROP->x, curve->p);
        fp_sub_mpz(ROP->x, ROP->x, x3_2, curve->p);
        
        mpz_init_set(y3_2, P->y);
        mpz_set(ROP->y, beta);
        
        // y3 = alfa(beta -x3) 
        fp_sub_mpz(ROP->y, ROP->y, ROP->x, curve->p);
        fp_mul_mpz(ROP->y, ROP->y, alfa, curve->p);
        
        // y3_2 = 8*y1**4
        fp_mul_mpz(y3_2, y2, y2, curve->p);
        fp_mul_si(y3_2, y3_2, 8, curve->p);
        
        // y3 = alfa(beta -x3) - 8*y1**4
        fp_sub_mpz(ROP->y, ROP->y, y3_2, curve->p);
        
        mpz_clears(alfa, alfa1, alfa2, beta, x3_2, y3_2, z3_2, y2, NULL);
    }
}
Example #12
0
void share(char*fn)
{
	int i;
	mpz_t x,k,t,e;
	byte rnd[16];
	char buf[1024];
	FILE *f;

	f=fopen(fn,"w+");
	if(f==NULL){
		fprintf(stderr,"Unable to open file %s.\n",fn);
		return;
	}

	/*generate random x*/
	mpz_init(x);
	for(i=0;i<16;i++)rnd[i]=randbyte();
	setbin(x,rnd,16);

	/*calculate k*/
	mpz_init(k);
	mpz_init(t);
	mpz_init(e);
	for(i=0;i<n;i++){
		/*k=k + kvec[i]*x^i*/
		mpz_powm(t,x,e,p);
		mpz_mul(t,t,kvec[i]);
		mpz_add(k,k,t);
		mpz_mod(k,k,p);
		/*incr e so that it matches the next i*/
		mpz_add_ui(e,e,1);
	}

	fprintf(f,"%s\n",mpz_get_str(buf,16,p));
	fprintf(f,"%s\n",mpz_get_str(buf,16,x));
	fprintf(f,"%s\n",mpz_get_str(buf,16,k));

	mpz_set_ui(e,0);
	mpz_set_ui(k,0);
	for(i=0;i<n;i++){
		/*k=k + hvec[i]*x^i*/
		mpz_powm(t,x,e,p);
		mpz_mul(t,t,hvec[i]);
		mpz_add(k,k,t);
		mpz_mod(k,k,p);
		/*incr e so that it matches the next i*/
		mpz_add_ui(e,e,1);
	}

	fprintf(f,"%s\n",mpz_get_str(buf,16,k));

	fclose(f);

	mpz_clear(x);
	mpz_clear(k);
	mpz_clear(t);
	mpz_clear(e);
}
Example #13
0
/*Output error message when two numbers does not match*/
void test_unmatch(FILE *stream, const char *where, mpz_srcptr a, mpz_srcptr b)
{
	char buf[MAX_INFO_SIZE+1];
	char stra[MAX_INFO_SIZE+1],strb[MAX_INFO_SIZE+1];
	mpz_get_str(stra,10,a);
	mpz_get_str(strb,10,b);
	strcpy(buf,"Expected is ");
	strncat(buf,stra,MAX_INFO_SIZE-strlen(buf));
	strcat(buf,", but got ");
	strncat(buf,strb,MAX_INFO_SIZE-strlen(buf));
	test_error(stream,where,buf);
}
Example #14
0
void display(std::ostream & out, __mpz_struct const * v) {
    size_t sz = mpz_sizeinbase(v, 10) + 2;
    if (sz < 1024) {
        char buffer[1024];
        mpz_get_str(buffer, 10, v);
        out << buffer;
    } else {
        std::unique_ptr<char> buffer(new char[sz]);
        mpz_get_str(buffer.get(), 10, v);
        out << buffer.get();
    }
}
Example #15
0
File: gmp.c Project: manish05/TCR
int main() {
  big a,b,c;
  mpz_init_set_str(a,"123456789123456789123",10);
  mpz_init_set_str(b,"98123981239457",10);
  mpz_init(c);
  mpz_mul(c,a,b);
  printf("%s * %s = %s\n",mpz_get_str(NULL,10,a),mpz_get_str(NULL,10,b),mpz_get_str(NULL,10,c));
  mpz_clear(a);
  mpz_clear(b);
  mpz_clear(c);
  return 0;
}
Example #16
0
int main() {
    dh_key key_a, key_b;
    mpz_t s;

    key_a = new_NIST_dh_key();
    key_b = new_NIST_dh_key();

    dh_session_key(key_a, &s, key_b.public);
    printf("(B**a)%%p: %s\n\n", mpz_get_str(NULL, 16, s));

    dh_session_key(key_b, &s, key_a.public);
    printf("(A**b)%%p: %s\n", mpz_get_str(NULL, 16, s));
}
Example #17
0
int main(int argc, char* argv[]) {

    int count = 0;

    mpz_t n;
    mpz_t d;
    mpz_t n1;
    mpz_t d1;

    mpz_init_set_ui(n, 1);
    mpz_init_set_ui(d, 1);
    mpz_init_set_ui(n1, 3);
    mpz_init_set_ui(d1, 2);

    for(int i = 2; i <= 1000; i++) {
        mpz_t n2;
        mpz_t d2;

        mpz_init(n2);
        mpz_init(d2);

        mpz_mul_ui(n2, n1, 2);
        mpz_add(n2, n2, n);

        mpz_mul_ui(d2, d1, 2);
        mpz_add(d2, d2, d);

        char n_digits[1024] = { '\0' };
        char d_digits[1024] = { '\0' };

        mpz_get_str(n_digits, 10, n2);
        mpz_get_str(d_digits, 10, d2);

        int nlen = strlen(n_digits);
        int dlen = strlen(d_digits);

        if(nlen > dlen) {
            count++;
        }

        mpz_set(n, n1);
        mpz_set(n1, n2);

        mpz_set(d, d1);
        mpz_set(d1, d2);
    }

    printf("%i", count);

    return 0;
}
Example #18
0
void QtGMP::fac()
{
    QString s("");
    mpz_t aa,bb;
    char *str=0;
    mpz_init(bb);
    mpz_init_set_str(aa,qPrintable(this->lineEdit2->text()),10);

    mpz_fac_ui(bb,mpz_get_ui(aa));
    // gmp_printf("B!:\t%Zd\nA!:\t%Zd\n\n\n",aa,bb);
    s.sprintf("B:\t%s\nB!:\t%s\n",mpz_get_str(str,10,aa),mpz_get_str(str,10,bb));
    this->textEdit->setText(s);
    mpz_clears(aa,bb,'\0');
}
Example #19
0
void QtGMP::nprime()
{
    QString s("");
    mpz_t aa,bb;
    char *str=0;
    mpz_init(bb);
    mpz_init_set_str(aa,qPrintable(this->lineEdit1->text()),10);

    mpz_nextprime(bb,aa);
    //gmp_printf("A:\t%Zd\nNextPrime(A):\t%Zd\n\n\n",aa,bb);
    s.sprintf("A:\t%s\nNextPrime(A):\t%s\n",mpz_get_str(str,10,aa),mpz_get_str(str,10,bb));
    this->textEdit->setText(s);
    mpz_clears(aa,bb,'\0');
}
Example #20
0
void QtGMP::powAB()
{
    QString s("");
    mpz_t aa,bb,cc;
    char *str=0;
    mpz_init(cc);
    mpz_init_set_str(aa,qPrintable(this->lineEdit1->text()),10);
    mpz_init_set_str(bb,qPrintable(this->lineEdit2->text()),10);
    mpz_pow_ui(cc,aa,mpz_get_ui(bb));
    // gmp_printf("A:\t%Zd\n\B:\t%ZdnA^B:\t%Zd\n\n\n",aa,bb,cc);
    s.sprintf("A:\t%s\nB:\t%s\nA^B:\t%s\n",mpz_get_str(str,10,aa),mpz_get_str(str,10,bb),mpz_get_str(str,10,cc));
    this->textEdit->setText(s);
    mpz_clears(aa,bb,cc,'\0');
}
Example #21
0
File: rsa.c Project: indrabagus/RSA
int 
rsa_createkey(PRSAKEY pkey){
    /* inisialisasi variabel helper */
    unsigned long int k_int = 65537;
    PPRIVATEATTRIB prsaattrib = create_private_attrib();
    if(prsaattrib==0x00)
        return -1;


    /* pick two random prime number (p and q ) */
    mpz_urandomb(prsaattrib->p,prsaattrib->hrandstate,PRIMESIZE);
    mpz_nextprime(prsaattrib->p,prsaattrib->p);
    //gmp_randseed_ui(prsaattrib->hrandstate,GetTickCount());
    mpz_urandomb(prsaattrib->q,prsaattrib->hrandstate,PRIMESIZE);
    mpz_nextprime(prsaattrib->q,prsaattrib->q);
    /* calculate n = (p * q) */
    mpz_mul(prsaattrib->n,prsaattrib->q,prsaattrib->p);
    /* calculate z = (p-1) * ( q - 1) */
    mpz_sub_ui(prsaattrib->pminus,prsaattrib->p,(unsigned int)1);
    mpz_sub_ui(prsaattrib->qminus,prsaattrib->q,(unsigned int)1);
    mpz_mul(prsaattrib->z,prsaattrib->pminus,prsaattrib->qminus);
    /* choose k, such that k is co-prime to z, i.e z is not divisible by k 
       or in other word gcd(k,z) = 1 */
    while(1){
        mpz_gcd_ui(prsaattrib->gcd,prsaattrib->z,k_int);
        if(mpz_cmp_ui(prsaattrib->gcd,(unsigned long)1) == 0)
            break;
        k_int +=1;
    }
    mpz_set_ui(prsaattrib->k,k_int);

    /* calculate j for ( k * j ) mod z = 1 */
    if(mpz_invert(prsaattrib->j,prsaattrib->k,prsaattrib->z) == 0){
        /* cannot find j (multiplicative inverse) */
        destroy_private_attrib(prsaattrib);
        return -1;
    }

    /* then we have public key = [n,k] */ 
    mpz_get_str(pkey->public_key.strkey_k,16,prsaattrib->k);
    mpz_get_str(pkey->public_key.strkey_n,16,prsaattrib->n);
    /* and private key [n,j] */
    mpz_get_str(pkey->private_key.strkey_j,16,prsaattrib->j);
    mpz_get_str(pkey->private_key.strkey_n,16,prsaattrib->n);
    /* clean up everything */
    destroy_private_attrib(prsaattrib);
    
    return 0;
}
Example #22
0
void QtGMP::lcm()
{
    //QApplication::aboutQt();
    QString s("");
    mpz_t aa,bb,cc;
    char *str=0;
    mpz_init(cc);
    mpz_init_set_str(aa,qPrintable(this->lineEdit1->text()),10);
    mpz_init_set_str(bb,qPrintable(this->lineEdit2->text()),10);
    mpz_lcm(cc,aa,bb);
    //  gmp_printf("A:\t%Zd\nB:\t%Zd\nLCM(A,B):\t%Zd\n\n\n",aa,bb,cc);
    s.sprintf("A:\t%s\nB:\t%s\nLCM(A,B):\t%s\n",mpz_get_str(str,10,aa),mpz_get_str(str,10,bb),mpz_get_str(str,10,cc));
    this->textEdit->setText(s);
    mpz_clears(aa,bb,cc,'\0');
}
Example #23
0
char *
mpc_get_str (mpc_t op)
{
  char *return_value;
  mpz_t temp_op;
  mpz_t temp1;
  mpz_t temp2;

  if (op.precision == 0)
    return_value = mpz_get_str (NULL, 10, op.object);
  else
    {
      mpz_init (temp_op);
      mpz_abs (temp_op, op.object);
      
      mpz_init_set (temp1, temp_op);
      mpz_init_set_ui (temp2, 1);

      power_of_ten (temp2, op.precision);
      mpz_tdiv_q (temp1, temp1, temp2);

      return_value = concatinate_free (mpz_get_str (NULL, 10, temp1), ".", true, false);

      mpz_mul (temp1, temp1, temp2);
      mpz_sub (temp1, temp_op, temp1);

      mpz_abs (temp1, temp1);

      mpz_tdiv_q_ui (temp2, temp2, 10);

      while (mpz_cmp (temp2, temp1) > 0)
	{
	  return_value = concatinate_free (return_value, "0", true, false);
	  mpz_tdiv_q_ui (temp2, temp2, 10);
	}

      return_value = concatinate_free (return_value, mpz_get_str (NULL, 10, temp1), true, true);

      if (mpz_sgn (op.object) < 0)
	return_value = concatinate_free ("-", return_value, false, true);

      mpz_clear (temp1);
      mpz_clear (temp2);
      mpz_clear (temp_op);
    }

  return return_value;
}
static int gmp2bn(mpz_t g, BIGNUM *bn)
	{
	if(((sizeof(bn->d[0]) * 8) == GMP_NUMB_BITS) &&
			(BN_BITS2 == GMP_NUMB_BITS))
		{
		/* The common case */
		int s = (g->_mp_size >= 0) ? g->_mp_size : -g->_mp_size;
		BN_zero(bn);
		if(bn_expand2 (bn, s) == NULL)
			return 0;
		bn->top = s;
		TINYCLR_SSL_MEMCPY(&bn->d[0], &g->_mp_d[0], s * sizeof(bn->d[0]));
		bn_correct_top(bn);
		bn->neg = g->_mp_size >= 0 ? 0 : 1;
		return 1;
		}
	else
		{
		int toret;
		char *tmpchar = OPENSSL_malloc(mpz_sizeinbase(g, 16) + 10);
		if(!tmpchar) return 0;
		mpz_get_str(tmpchar, 16, g);
		toret = BN_hex2bn(&bn, tmpchar);
		OPENSSL_free(tmpchar);
		return toret;
		}
	}
Example #25
0
int main(void) {

	unsigned int maxsum = 0;

	mpz_t num;
	mpz_init(num);

	char numstr[200] = "";

	for (unsigned int base = 51; base < 100; ++base) {
		if (base % 10 == 0) {
			continue;
		}
		for (unsigned int exp = 70; exp <= 100; ++exp) {

			mpz_ui_pow_ui(num, base, exp);
			mpz_get_str(numstr, 10, num);

			unsigned int sum = 0;

			for (char* digit = numstr; *digit; ++digit) {
				sum += *digit - '0';
			}
			if (sum > maxsum) {
				maxsum = sum;
			}
		}
	}

	printf("%u\n", maxsum);

	return 0;
}
Example #26
0
int main(int argc, char **argv)
{
    mpz_t counter;
    mpz_t triangleValue;
    unsigned int factors;
    unsigned int previousFactors = 0;
    mpz_init_set_ui(counter, 1);
    mpz_init(triangleValue);
    mpz_init_set_ui(previousTriangleCounter, 0);
    
    while (1) 
    {
        nextTriangle(triangleValue);
        factors = factorCount(triangleValue);
        if (previousFactors < factors)
        {
            previousFactors = factors;
            printf("Number %s has triangle %s and %d factors\n", mpz_get_str(NULL, 10, counter), mpz_get_str(NULL, 10, triangleValue), factors);
        }
        if (factors >= STOP_COUNT)
            break;
        mpz_add_ui(counter, counter, 1);
    }
    return 0;
}
Example #27
0
static void
dump (const char *label, const mpz_t x)
{
  char *buf = mpz_get_str (NULL, 16, x);
  fprintf (stderr, "%s: %s\n", label, buf);
  testfree (buf);
}
Example #28
0
int main() {


	unsigned long long a,b;
	mpz_t a2, b3, v, sum;

	mpz_init(a2);
	mpz_init(b3);
	mpz_init(v);
	mpz_init_set_ui(sum, 0);

	for (b = 1; b < sqrt(MAX); b++) {
		mpz_ui_pow_ui(b3, b, 3);			
		for (a = 1; a < b	; a++) {
			mpz_ui_pow_ui(a2, a, 2);		
			mpz_add(v, a2, b3);
      if (!mpz_divisible_ui_p(v, a)) {
				continue;
      }
			mpz_div_ui(v, v, a);
			if (mpz_perfect_square_p(v)) {
				mpz_add(sum, sum, v);
				printf("%s %llu %llu\n",  mpz_get_str(NULL, 10, v), a, b);
			}


    }

  }



 	
	return(0);
}
Example #29
0
/* write one */
static int write_radix(void *a, char *b, int radix)
{
   LTC_ARGCHK(a != NULL);
   LTC_ARGCHK(b != NULL);
   mpz_get_str(b, radix, a);
   return CRYPT_OK;
}
Example #30
0
		// stolen from boost.multiprecision
		std::string str(std::ios_base::fmtflags f = std::ios_base::fmtflags(0)) const
		{
			int base = 10;
			if((f & std::ios_base::oct) == std::ios_base::oct)
				base = 8;
			else if((f & std::ios_base::hex) == std::ios_base::hex)
				base = 16;
			//
			// sanity check, bases 8 and 16 are only available for positive numbers:
			//
			if((base != 10) && (mpz_sgn(m_data) < 0))
				BOOST_THROW_EXCEPTION(std::runtime_error("Formatted output in bases 8 or 16 is only available for positive numbers"));
			void *(*alloc_func_ptr) (size_t);
			void *(*realloc_func_ptr) (void *, size_t, size_t);
			void (*free_func_ptr) (void *, size_t);
			const char* ps = mpz_get_str (0, base, m_data);
			std::string s = ps;
			mp_get_memory_functions(&alloc_func_ptr, &realloc_func_ptr, &free_func_ptr);
			(*free_func_ptr)((void*)ps, std::strlen(ps) + 1);

			if((base != 10) && (f & std::ios_base::showbase))
			{
				int pos = s[0] == '-' ? 1 : 0;
				const char* pp = base == 8 ? "0" : "0x";
				s.insert(pos, pp);
			}
			if((f & std::ios_base::showpos) && (s[0] != '-'))
				s.insert(0, 1, '+');

			return s;
		}