void check_one (const char *name, mpz_srcptr x, double y, int cmp, int cmpabs) { int got; got = mpz_cmp_d (x, y); if (SGN(got) != cmp) { unsigned i; printf ("mpz_cmp_d wrong (from %s)\n", name); printf (" got %d\n", got); printf (" want %d\n", cmp); fail: printf (" x="); mpz_out_str (stdout, 10, x); printf ("\n y %g\n", y); printf (" x=0x"); mpz_out_str (stdout, -16, x); printf ("\n y %g\n", y); printf (" y"); for (i = 0; i < sizeof(y); i++) printf (" %02X", (unsigned) ((unsigned char *) &y)[i]); printf ("\n"); abort (); } got = mpz_cmpabs_d (x, y); if (SGN(got) != cmpabs) { printf ("mpz_cmpabs_d wrong\n"); printf (" got %d\n", got); printf (" want %d\n", cmpabs); goto fail; } }
void testmain (int argc, char **argv) { unsigned i; mpz_t a, b, res, ref; mpz_init (a); mpz_init (b); mpz_init (res); mpz_init (ref); for (i = 0; i < COUNT; i++) { mini_random_op3 (OP_MUL, MAXBITS, a, b, ref); if (mpz_sgn(ref) == 0) /* my_mpz_mul requires a != 0, b != 0 */ continue; my_mpz_mul (res, a, b); if (mpz_cmp (res, ref)) { fprintf (stderr, "my_mpz_mul failed:\n"); dump ("a", a); dump ("b", b); dump ("r", res); dump ("ref", ref); abort (); } /* The following test exploits a side-effect of my_mpz_mul: res points to a buffer with at least an+bn limbs, and the limbs above the result are zeroed. */ if (mpz_size (b) > 0 && mpz_getlimbn (res, mpz_size(a)) != mpz_limbs_read (res) [mpz_size(a)]) { fprintf (stderr, "getlimbn - limbs_read differ.\n"); abort (); } if ((i % 4 == 0) && mpz_size (res) > 1) { mpz_realloc2 (res, 1); if (mpz_cmp_ui (res, 0)) { fprintf (stderr, "mpz_realloc2 did not clear res.\n"); abort (); } mpz_limbs_finish (ref, 0); if (mpz_cmp_d (ref, 0)) { fprintf (stderr, "mpz_limbs_finish did not clear res.\n"); abort (); } } } mpz_clear (a); mpz_clear (b); mpz_clear (res); mpz_clear (ref); }
/* * Function: compute_bbp_first_sum_gmp * -------------------- * Computes the first summand in the BBP formula using GNU GMP. * * d: digit to be calculated * base: the base * c: a fixed positive integer * p: a simple polynomial like x or x^2 * start_at_0: start the summation at k=0, if true, at k=1, otherwise. Most * instances of the BBP formula, such as pi, have you start at 0. * But some, such as log(2), have you start at 1. * * returns: the value of the first sum */ void compute_bbp_first_sum_gmp(mpf_t sum, unsigned long int d, int base, long int c, void (*p)(mpz_t, mpz_t), bool start_at_0) { mpf_set_d(sum, 0.0); signed long int k_start = start_at_0 ? 0 : 1; mpz_t k; mpz_init_set_si(k, k_start); double upper = floor((double) d / (double) c); while (mpz_cmp_d(k, upper) <= 0) { mpz_t poly_result; mpz_init(poly_result); (*p)(poly_result, k); mpz_t num; mpz_init(num); mpz_t exponent; mpz_init_set(exponent, k); mpz_mul_si(exponent, exponent, c); mpz_mul_si(exponent, exponent, -1); mpz_add_ui(exponent, exponent, d); modular_pow_gmp(num, base, exponent, poly_result); mpf_t num_float; mpf_init(num_float); mpf_set_z(num_float, num); mpz_clear(num); mpz_clear(exponent); mpf_t denom; mpf_init_set_d(denom, mpz_get_d(poly_result)); mpz_clear(poly_result); mpf_t quotient; mpf_init(quotient); mpf_div(quotient, num_float, denom); mpf_clear(num_float); mpf_clear(denom); mpf_add(sum, sum, quotient); mpf_clear(quotient); mod_one_gmp(sum, sum); mpz_add_ui(k, k, 1); } mpz_clear(k); mod_one_gmp(sum, sum); }
/* Input: p is the initial generator (sigma), if 0, generate it at random. N is the number to factor B1 is the stage 1 bound B2 is the stage 2 bound B1done is the stage 1 limit to which supplied residue has already been computed k is the number of blocks for stage 2 verbose is the verbosity level Output: f is the factor found, p is the residue at end of stage 1 Return value: non-zero iff a factor is found (1 for stage 1, 2 for stage 2) */ int pm1 (mpz_t f, mpz_t p, mpz_t N, mpz_t go, double *B1done, double B1, mpz_t B2min_parm, mpz_t B2_parm, double B2scale, unsigned long k, const int S, int verbose, int repr, int use_ntt, FILE *os, FILE *es, char *chkfilename, char *TreeFilename, double maxmem, gmp_randstate_t rng, int (*stop_asap)(void)) { int youpi = ECM_NO_FACTOR_FOUND; int base2 = 0; int Nbits, smallbase; int po2 = 0; /* Whether we should use power-of-2 poly degree */ long st; mpmod_t modulus; mpres_t x; mpz_t B2min, B2; /* Local B2, B2min to avoid changing caller's values */ unsigned long dF; root_params_t root_params; faststage2_param_t faststage2_params; /* If stage2_variant != 0, we use the new fast stage 2 */ const int stage2_variant = (S == 1 || S == ECM_DEFAULT_S); set_verbose (verbose); ECM_STDOUT = (os == NULL) ? stdout : os; ECM_STDERR = (es == NULL) ? stdout : es; /* if n is even, return 2 */ if (mpz_divisible_2exp_p (N, 1)) { mpz_set_ui (f, 2); return ECM_FACTOR_FOUND_STEP1; } st = cputime (); if (mpz_cmp_ui (p, 0) == 0) pm1_random_seed (p, N, rng); mpz_init_set (B2min, B2min_parm); mpz_init_set (B2, B2_parm); /* Set default B2. See ecm.c for comments */ if (ECM_IS_DEFAULT_B2(B2)) { if (stage2_variant == 0) mpz_set_d (B2, B2scale * pow (B1 * PM1_COST, DEFAULT_B2_EXPONENT)); else mpz_set_d (B2, B2scale * pow (B1 * PM1FS2_COST, PM1FS2_DEFAULT_B2_EXPONENT)); } /* set B2min */ if (mpz_sgn (B2min) < 0) mpz_set_d (B2min, B1); if (repr != ECM_MOD_DEFAULT && repr != ECM_MOD_NOBASE2) { if (repr == ECM_MOD_MODMULN) mpmod_init_MODMULN (modulus, N); else if (repr == ECM_MOD_REDC) mpmod_init_REDC (modulus, N); else if (abs (repr) > 16) { if (mpmod_init_BASE2 (modulus, repr, N) == ECM_ERROR) return ECM_ERROR; } else mpmod_init_MPZ (modulus, N); } else /* automatic choice */ { /* Find a good arithmetic for this number */ Nbits = mpz_sizeinbase (N, 2); base2 = (repr == 0) ? isbase2 (N, BASE2_THRESHOLD) : 0; smallbase = mpz_fits_uint_p (p); /* TODO: make dependent on Nbits and base2 */ if (base2) { mpmod_init_BASE2 (modulus, base2, N); } else if (mpz_size (N) <= 2 * POWM_THRESHOLD && smallbase && B1 <= 1e6) /* Below POWM_THRESHOLD, mpz_powm uses MODMULN reduction, too, but without special code for small bases which makes our MODMULN faster. Above POWM_THRESHOLD mpz_powm uses faster mod reduction, at about 2*POWM_THRESHOLD it catches up with our smallbase-MODMULN and then is faster until REDC takes over. */ { outputf (OUTPUT_VERBOSE, "Using MODMULN\n"); mpmod_init_MODMULN (modulus, N); } else if (Nbits > 50000 || (Nbits > 3500 && smallbase)) { outputf (OUTPUT_VERBOSE, "Using REDC\n"); mpmod_init_REDC (modulus, N); } else { outputf (OUTPUT_VERBOSE, "Using mpz_powm\n"); mpmod_init_MPZ (modulus, N); } } /* Determine parameters (polynomial degree etc.) */ if (stage2_variant != 0) { long P_ntt, P_nontt; const unsigned long lmax = 1UL<<28; /* An upper bound */ unsigned long lmax_NTT, lmax_noNTT; faststage2_param_t params_ntt, params_nontt, *better_params; mpz_init (faststage2_params.m_1); faststage2_params.l = 0; mpz_init (params_ntt.m_1); params_ntt.l = 0; mpz_init (params_nontt.m_1); params_nontt.l = 0; /* Find out what the longest transform length is we can do at all. If no maxmem is given, the non-NTT can theoretically do any length. */ lmax_NTT = 0; if (use_ntt) { unsigned long t; /* See what transform length the NTT can handle (due to limited primes and limited memory) */ t = mpzspm_max_len (N); lmax_NTT = MIN (lmax, t); if (maxmem != 0.) { t = pm1fs2_maxlen (double_to_size (maxmem), N, use_ntt); lmax_NTT = MIN (lmax_NTT, t); } outputf (OUTPUT_DEVVERBOSE, "NTT can handle lmax <= %lu\n", lmax_NTT); /* FIXME: if both ntt and no-ntt are tried, but finally ntt is preferred, the last B2 bound computed is that of no-ntt, which is thus wrong */ P_ntt = choose_P (B2min, B2, lmax_NTT, k, ¶ms_ntt, B2min, B2, 1, ECM_PM1); if (P_ntt != ECM_ERROR) outputf (OUTPUT_DEVVERBOSE, "Parameters for NTT: P=%lu, l=%lu\n", params_ntt.P, params_ntt.l); } else P_ntt = 0; /* or GCC complains about uninitialized var */ /* See what transform length the non-NTT code can handle */ lmax_noNTT = lmax; if (maxmem != 0.) { unsigned long t; t = pm1fs2_maxlen (double_to_size (maxmem), N, 0); lmax_noNTT = MIN (lmax_noNTT, t); outputf (OUTPUT_DEVVERBOSE, "non-NTT can handle lmax <= %lu\n", lmax_noNTT); } if (use_ntt != 2) P_nontt = choose_P (B2min, B2, lmax_noNTT, k, ¶ms_nontt, B2min, B2, 0, ECM_PM1); else P_nontt = ECM_ERROR; if (P_nontt != ECM_ERROR) outputf (OUTPUT_DEVVERBOSE, "Parameters for non-NTT: P=%lu, l=%lu\n", params_nontt.P, params_nontt.l); if (((!use_ntt || P_ntt == ECM_ERROR) && P_nontt == ECM_ERROR) || (use_ntt == 2 && P_ntt == ECM_ERROR)) { outputf (OUTPUT_ERROR, "Error: cannot choose suitable P value for your stage 2 " "parameters.\nTry a shorter B2min,B2 interval.\n"); mpz_clear (faststage2_params.m_1); mpz_clear (params_ntt.m_1); mpz_clear (params_nontt.m_1); return ECM_ERROR; } /* Now decide wether to take NTT or non-NTT. How to choose the better one is not an easy question. It will depend on the speed ratio between NTT/non-NTT code, their difference in memory use and available memory. For now, we choose the one that uses a longer transform length. FIXME: Write something not brain-dead here */ if (use_ntt == 0 || P_ntt == ECM_ERROR || (use_ntt == 1 && params_nontt.l > params_ntt.l)) { better_params = ¶ms_nontt; use_ntt = 0; } else { better_params = ¶ms_ntt; use_ntt = 1; } faststage2_params.P = better_params->P; faststage2_params.s_1 = better_params->s_1; faststage2_params.s_2 = better_params->s_2; faststage2_params.l = better_params->l; mpz_set (faststage2_params.m_1, better_params->m_1); mpz_clear (params_ntt.m_1); mpz_clear (params_nontt.m_1); if (maxmem != 0.) outputf (OUTPUT_VERBOSE, "Using lmax = %lu with%s NTT which takes " "about %luMB of memory\n", faststage2_params.l, (use_ntt) ? "" : "out", pm1fs2_memory_use (faststage2_params.l, N, use_ntt)/1048576); } else { mpz_init (root_params.i0); root_params.d2 = 0; /* Enable automatic choice of d2 */ if (use_ntt || (modulus->repr == ECM_MOD_BASE2 && modulus->Fermat > 0)) po2 = 1; if (bestD (&root_params, &k, &dF, B2min, B2, po2, use_ntt, maxmem, (TreeFilename != NULL), modulus) == ECM_ERROR) { youpi = ECM_ERROR; goto clear_and_exit; } root_params.S = S; /* Set default degree for Brent-Suyama extension */ if (root_params.S == ECM_DEFAULT_S) { if (modulus->repr == ECM_MOD_BASE2 && modulus->Fermat > 0) { /* For Fermat numbers, default is 2 (no Brent-Suyama) */ root_params.S = 2; } else { mpz_t t; mpz_init (t); mpz_sub (t, B2, B2min); if (mpz_cmp_d (t, 3.5e5) < 0) /* B1 < 50000 */ root_params.S = -4; /* Dickson polys give a slightly better chance of success */ else if (mpz_cmp_d (t, 1.1e7) < 0) /* B1 < 500000 */ root_params.S = -6; else if (mpz_cmp_d (t, 1.25e8) < 0) /* B1 < 3000000 */ root_params.S = 12; /* but for S>6, S-th powers are faster thanks to invtrick */ else if (mpz_cmp_d (t, 7.e9) < 0) /* B1 < 50000000 */ root_params.S = 24; else if (mpz_cmp_d (t, 1.9e10) < 0) /* B1 < 100000000 */ root_params.S = 48; else if (mpz_cmp_d (t, 5.e11) < 0) /* B1 < 1000000000 */ root_params.S = 60; else root_params.S = 120; mpz_clear (t); } } /* We need Suyama's power even and at least 2 for P-1 stage 2 to work correctly */ if (root_params.S & 1) root_params.S *= 2; /* FIXME: Is this what the user would expect? */ } /* Print B1, B2, polynomial and x0 */ print_B1_B2_poly (OUTPUT_NORMAL, ECM_PM1, B1, *B1done, B2min_parm, B2min, B2, (stage2_variant == 0) ? root_params.S : 1, p, 0, NULL); /* If we do a stage 2, print its parameters */ if (mpz_cmp (B2, B2min) >= 0) { if (stage2_variant != 0) outputf (OUTPUT_VERBOSE, "P = %lu, l = %lu, s_1 = %lu, k = s_2 = %lu, " "m_1 = %Zd\n", faststage2_params.P, faststage2_params.l, faststage2_params.s_1,faststage2_params.s_2, faststage2_params.m_1); else outputf (OUTPUT_VERBOSE, "dF=%lu, k=%lu, d=%lu, d2=%lu, i0=%Zd\n", dF, k, root_params.d1, root_params.d2, root_params.i0); } if (test_verbose (OUTPUT_VERBOSE)) { if (mpz_sgn (B2min_parm) >= 0) { outputf (OUTPUT_VERBOSE, "Can't compute success probabilities for B1 <> B2min\n"); } else { rhoinit (256, 10); print_prob (B1, B2, dF, k, (stage2_variant == 0) ? root_params.S : 1, go); } } mpres_init (x, modulus); mpres_set_z (x, p, modulus); st = cputime (); if (B1 > *B1done) youpi = pm1_stage1 (f, x, modulus, B1, B1done, go, stop_asap, chkfilename); st = elltime (st, cputime ()); outputf (OUTPUT_NORMAL, "Step 1 took %ldms\n", st); if (test_verbose (OUTPUT_RESVERBOSE)) { mpz_t tx; mpz_init (tx); mpres_get_z (tx, x, modulus); outputf (OUTPUT_RESVERBOSE, "x=%Zd\n", tx); mpz_clear (tx); } if (stop_asap != NULL && (*stop_asap) ()) goto clear_and_exit; if (youpi == ECM_NO_FACTOR_FOUND && mpz_cmp (B2, B2min) >= 0) { if (stage2_variant != 0) { if (use_ntt) youpi = pm1fs2_ntt (f, x, modulus, &faststage2_params); else youpi = pm1fs2 (f, x, modulus, &faststage2_params); } else youpi = stage2 (f, &x, modulus, dF, k, &root_params, ECM_PM1, use_ntt, TreeFilename, stop_asap); } if (test_verbose (OUTPUT_VERBOSE)) { if (mpz_sgn (B2min_parm) < 0) rhoinit (1, 0); /* Free memory of rhotable */ } clear_and_exit: mpres_get_z (p, x, modulus); mpres_clear (x, modulus); mpmod_clear (modulus); if (stage2_variant != 0) mpz_clear (faststage2_params.m_1); else mpz_clear (root_params.i0); mpz_clear (B2); mpz_clear (B2min); return youpi; }
static int _compf(CBIGINT *a, double f, bool invert) { return mpz_cmp_d(a->n, f); }
static int _equalf(CBIGINT *a, double f, bool invert) { return mpz_cmp_d(a->n, f) == 0; }
void testmain (int argc, char **argv) { unsigned i; mpz_t x; for (i = 0; values[i].s; i++) { char *s; mpz_init_set_d (x, values[i].d); s = mpz_get_str (NULL, 16, x); if (strcmp (s, values[i].s) != 0) { fprintf (stderr, "mpz_set_d failed:\n" "d = %.20g\n" "s = %s\n" "r = %s\n", values[i].d, s, values[i].s); abort (); } testfree (s); mpz_clear (x); } mpz_init (x); for (i = 0; i < COUNT; i++) { /* Use volatile, to avoid extended precision in floating point registers, e.g., on m68k and 80387. */ volatile double d, f; unsigned long m; int e; mini_rrandomb (x, GMP_LIMB_BITS); m = mpz_get_ui (x); mini_urandomb (x, 8); e = mpz_get_ui (x) - 100; d = ldexp ((double) m, e); mpz_set_d (x, d); f = mpz_get_d (x); if (f != floor (d)) { fprintf (stderr, "mpz_set_d/mpz_get_d failed:\n"); goto dumperror; } if ((f == d) ? (mpz_cmp_d (x, d) != 0) : (mpz_cmp_d (x, d) >= 0)) { fprintf (stderr, "mpz_cmp_d (x, d) failed:\n"); goto dumperror; } f = d + 1.0; if (f > d && ! (mpz_cmp_d (x, f) < 0)) { fprintf (stderr, "mpz_cmp_d (x, f) failed:\n"); goto dumperror; } d = - d; mpz_set_d (x, d); f = mpz_get_d (x); if (f != ceil (d)) { fprintf (stderr, "mpz_set_d/mpz_get_d failed:\n"); dumperror: dump ("x", x); fprintf (stderr, "m = %lx, e = %i\n", m, e); fprintf (stderr, "d = %.15g\n", d); fprintf (stderr, "f = %.15g\n", f); fprintf (stderr, "f - d = %.5g\n", f - d); abort (); } if ((f == d) ? (mpz_cmp_d (x, d) != 0) : (mpz_cmp_d (x, d) <= 0)) { fprintf (stderr, "mpz_cmp_d (x, d) failed:\n"); goto dumperror; } f = d - 1.0; if (f < d && ! (mpz_cmp_d (x, f) > 0)) { fprintf (stderr, "mpz_cmp_d (x, f) failed:\n"); goto dumperror; } } mpz_clear (x); }
int32_t Integer::operator != (const float l) const { return mpz_cmp_d((mpz_srcptr)&gmp_rep, (float) l) != 0; }
int32_t Integer::operator != (const double l) const { return mpz_cmp_d((mpz_srcptr)&gmp_rep, l) != 0; }
float check_contraction(int fil,int stickers,int lane, float c0, mpz_t states,gsl_rng *r,FILE *fp){ int newlane=lane-1; int ret=0; mpz_t newstates; mpz_init(newstates); float domega=0; // clock_t t3 = clock(); count_isl_single(&newstates,fil,stickers,newlane); // clock_t t4 = clock(); // printf("contraction time: %f\n",(double)(t4-t3)/CLOCKS_PER_SEC); float curv1=1.0/lane; float curv2=1.0/newlane; float k=10000.0; if (mpz_cmp_d(newstates,0.0)){ domega=k*(curv2*curv2 - curv1*curv1 -2.0*c0*(curv2-curv1))-mpzln(newstates)+mpzln(states); //fprintf(fp,"curvature: %f entropy: %f\n",k*(curv2*curv2 - curv1*curv1 -2.0*c0*(curv2-curv1)),-mpzln(newstates)+mpzln(states)); }else{ domega=VERYBIG; } // fprintf(fp, "current domega for contraction=%f\n",domega); // if (domega<0){ // ret=ret-1; // // //fprintf(fp,"contraction - domega=%f\n",domega); // } // // // /*if it's positive, we calculate the probability of acceptance // * and test for it*/ // else{ // double prob=exp(-1.0*domega); // double fromthehat=gsl_rng_uniform(r); // //printf("metropolising: rng=%f, prob=%f\n",fromthehat,prob); // if (fromthehat<prob){ // ret=ret-1; // // //fprintf(fp,"contraction - domega=%f\n",domega); // }else{ // //fprintf(fp,"no contraction - domega=%f\n",domega); // } // } // // // newlane=lane+1; // count_isl_single(&newstates,fil,stickers,newlane); // // curv2=1.0/newlane; // domega=k*(curv2*curv2 - curv1*curv1 -2.0*c0*(curv2-curv1))-mpzln(newstates)+mpzln(states); // if (domega<0){ // ret=ret+1; // // //fprintf(fp,"expansion - domega=%f\n",domega); // } // // // /*if it's positive, we calculate the probability of acceptance // * and test for it*/ // else{ // double prob=exp(-1.0*domega); // double fromthehat=gsl_rng_uniform(r); // //printf("metropolising: rng=%f, prob=%f\n",fromthehat,prob); // if (fromthehat<prob){ // // ret=ret+1; // //fprintf(fp,"expansion - domega=%f\n",domega); // }else{ // //fprintf(fp,"no expansion - domega=%f\n",domega); // } // } // mpz_clear(newstates); return domega; }
void simulation_single(){ const int num_lanes=2; int lane_size=100; const gsl_rng_type * T; gsl_rng_env_setup(); T = gsl_rng_default; gsl_rng *r; r = gsl_rng_alloc (T); unsigned long int seed; seed=gen_seed(); gsl_rng_set(r,seed); int fil_length=150; int stickers=1; //glue-related! //int stickers=0; mpz_t states; mpz_t newstates; mpz_t deltastates; mpz_init(states); mpz_init(newstates); mpz_init(deltastates); const float timesteps=5000; int my_rank; MPI_Comm_rank(MPI_COMM_WORLD,&my_rank); char* filename[60]; sprintf(filename,"./output_single_filament_compact/run%d.txt",my_rank); // sprintf(filename,"./output_single_filament_glue_%.2f/run%d.txt",kstick,my_rank); printf("%s\n",filename); FILE *fp = fopen(filename, "w"); if (fp == NULL) { printf("Error"); return; } float mu=6.0; float glue=1.0; float koff=1.0; float i; int j,k; float kstick=0.01; float kunstick=0.01; float stick_energy=3.0; int type=0; float nextoff=gsl_ran_exponential(r,1.0/koff); float nextstick=gsl_ran_exponential(r,1.0/((fil_length-lane_size-stickers)*kstick)); float nextunstick=gsl_ran_exponential(r,1.0/(stickers*kunstick)); //glue-related! // float nextstick=VERYBIG; // float nextunstick=VERYBIG; float peroverlap=kstick; double domega; float c0=1.0/lane_size; int att_depol=0; int acc_depol=0; int att_stick=0; int acc_stick=0; int att_unstick=0; int acc_unstick=0; int att_contr=0; int acc_contr=0; int att_expan=0; int acc_expan=0; int att_special=0; int acc_special=0; float eta=0.2; float fraction=0.0; float delta=0.0; clock_t t1 = clock(); //printf("before first count: %f fil_length: %d\n",kstick,fil_length); count_isl_single(&states,fil_length,stickers,lane_size); gmp_printf("states= %Zd\n",states); int currpar=0; for (i=0;i<timesteps;i=i+0.01){ fraction=fraction+0.01*delta; //printf("%f %f %d\n",fraction,delta,currpar); // if ((int)(fraction*20)%2!=currpar){ // fprintf(fp, "fraction=%f delta=%f\n",fraction,delta); // // } // currpar=(int)(fraction*20)%2; if (fabs(fraction)>1.0){ //fprintf(fp,"event occurring - i=%f delta=%f fraction=%f\n",i,delta,fraction); if (fraction>0){ delta=check_contraction(fil_length,stickers,lane_size+1,c0,states,r,fp); if (delta>VERYBIG/10){ delta=0; fraction=0; //fprintf(fp,"delta too big! delta is now %f\n",delta); }else{ lane_size++; } } else{ delta=check_contraction(fil_length,stickers,lane_size-1,c0,states,r,fp); if (delta>VERYBIG/10){ delta=0; fraction=0; //fprintf(fp,"delta too big! delta is now %f\n",delta); }else{ lane_size--; } } fraction=0; nextstick=i+gsl_ran_exponential(r,1.0/((fil_length-lane_size-stickers)*kstick)); } if (stickers==0){ nextunstick=VERYBIG; } if (fil_length-lane_size-stickers<=0){ nextstick=VERYBIG; } //fprintf(fp, "fraction=%f delta=%f\n",fraction,delta); //printf("%f %f %f %f %d %d %d %d %d %d %d %d %d %d %d %d %d\n", i,nextoff,nextstick,nextunstick,fil_length,stickers,lane_size,att_depol,acc_depol,att_stick,acc_stick,att_unstick,acc_unstick,att_contr,acc_contr,att_expan,acc_expan); if (fil_length==0){ break; } if ((int)(i*100)%(int)timesteps==0){ clock_t t2 = clock(); printf("%d percent %f\n",(int)(i*100)/(int)timesteps,(double)(t2-t1)/CLOCKS_PER_SEC); } //fprintf(fp,"i=%f\n",i); if ((int)(i*100)%50==0){ fprintf(fp, "%f %f %f %f %d %d %d %d %d %d %d %d %d %d %d %f %f %f %f\n", i,nextoff,nextstick,nextunstick,fil_length,stickers,lane_size,att_depol,acc_depol,att_stick,acc_stick,att_unstick,acc_unstick,att_special,acc_special,((fil_length-lane_size-stickers)*kstick),(stickers*kunstick),delta,fraction); //gmp_fprintf(fp,"states= %Zd\n",states); } if (i>=nextoff){ type=1;} if (i>=nextstick){ type=2; } if (i>=nextunstick){ type=3; } if (type==1){ int done=0; att_depol=att_depol+1; int newlength=fil_length-1; // clock_t t3 = clock(); count_isl_single(&newstates,newlength,stickers,lane_size); // clock_t t4 = clock(); // printf("depol time: %f\n",(double)(t4-t3)/CLOCKS_PER_SEC); if (mpz_cmp_d(newstates,0.0)){ domega=-mu+glue-mpzln(newstates)+mpzln(states); //glue-related! // domega=-mu+glue+peroverlap-mpzln(newstates)+mpzln(states); if (domega<0){ acc_depol++; fil_length=newlength; mpz_set(states,newstates); done=1; // fprintf(fp,"depol - domega=%f\n",domega); } /*if it's positive, we calculate the probability of acceptance * and test for it*/ else{ double prob=exp(-1.0*domega); double fromthehat=gsl_rng_uniform(r); //printf("metropolising: rng=%f, prob=%f\n",fromthehat,prob); if (fromthehat<prob){ fil_length=newlength; acc_depol++; mpz_set(states,newstates); done=1; // fprintf(fp,"depol - domega=%f\n",domega); }else{ // fprintf(fp,"removal not accepted - domega=%f\n",domega); } } } if (done==0){ att_special++; // clock_t t3 = clock(); count_isl_single(&newstates,newlength,stickers-1,lane_size); // clock_t t4 = clock(); // printf("special depol time: %f\n",(double)(t4-t3)/CLOCKS_PER_SEC); domega=stick_energy-mu+glue-mpzln(newstates)+mpzln(states); if (domega<0){ fil_length=newlength; stickers=stickers-1; acc_depol++; acc_special++; mpz_set(states,newstates); //fprintf(fp,"depol and removal - domega=%f\n",domega); } else{ double prob=exp(-1.0*domega); double fromthehat=gsl_rng_uniform(r); //printf("metropolising: rng=%f, prob=%f\n",fromthehat,prob); if (fromthehat<prob){ fil_length=newlength; stickers=stickers-1; acc_depol++; acc_special++; mpz_set(states,newstates); //fprintf(fp,"depol and removal - domega=%f\n",domega); }else{ // fprintf(fp,"depol w/unstick not accepted - domega=%f\n",domega); } } } att_contr++; att_expan++; delta=check_contraction(fil_length,stickers,lane_size,c0,states,r,fp); delta=delta/eta; // if (delta==-1){ // acc_contr++; // } // if (delta==+1){ // acc_expan++; // } // lane_size=lane_size+delta; nextoff=i+gsl_ran_exponential(r,1.0/koff); nextstick=i+gsl_ran_exponential(r,1.0/((fil_length-lane_size-stickers)*kstick)); type=0; } if (type==2){ att_stick++; int newstickers=stickers+1; // clock_t t3 = clock(); count_isl_single(&newstates,fil_length,newstickers,lane_size); // clock_t t4 = clock(); // printf("new sticker time: %f\n",(double)(t4-t3)/CLOCKS_PER_SEC); domega=-stick_energy-mpzln(newstates)+mpzln(states); if (domega<0){ stickers=newstickers; acc_stick++; mpz_set(states,newstates); // fprintf(fp,"added sticker - domega=%f\n",domega); } /*if it's positive, we calculate the probability of acceptance * and test for it*/ else{ double prob=exp(-1.0*domega); double fromthehat=gsl_rng_uniform(r); //printf("metropolising: rng=%f, prob=%f\n",fromthehat,prob); if (fromthehat<prob){ stickers=newstickers; acc_stick++; mpz_set(states,newstates); // fprintf(fp,"added sticker - domega=%f\n",domega); }else{ // fprintf(fp,"addition sticker rejected - domega=%f\n",domega); } } att_contr++; att_expan++; delta=check_contraction(fil_length,stickers,lane_size,c0,states,r,fp); delta=delta/eta; // if (delta==-1){ // acc_contr++; // } // if (delta==+1){ // acc_expan++; // } // lane_size=lane_size+delta; nextstick=i+gsl_ran_exponential(r,1.0/((fil_length-lane_size-stickers)*kstick)); nextunstick=i+gsl_ran_exponential(r,1.0/(stickers*kunstick)); type=0; } if (type==3){ att_unstick++; int newstickers=stickers-1; // clock_t t3 = clock(); count_isl_single(&newstates,fil_length,newstickers,lane_size); // clock_t t4 = clock(); // printf("remove sticker time: %f\n",(double)(t4-t3)/CLOCKS_PER_SEC); domega=stick_energy-mpzln(newstates)+mpzln(states); if (domega<0){ acc_unstick++; stickers=newstickers; mpz_set(states,newstates); //fprintf(fp,"removal - domega=%f\n",domega); } /*if it's positive, we calculate the probability of acceptance * and test for it*/ else{ double prob=exp(-1.0*domega); double fromthehat=gsl_rng_uniform(r); //printf("metropolising: rng=%f, prob=%f\n",fromthehat,prob); if (fromthehat<prob){ stickers=newstickers; acc_unstick++; mpz_set(states,newstates); //fprintf(fp,"removal - domega=%f\n",domega); }else{ // fprintf(fp,"removal of sticker not accepted - domega=%f\n",domega); } } att_contr++; att_expan++; delta=check_contraction(fil_length,stickers,lane_size,c0,states,r,fp); delta=delta/eta; // if (delta==-1){ // acc_contr++; // } // if (delta==+1){ // acc_expan++; // } // lane_size=lane_size+delta; nextunstick=i+gsl_ran_exponential(r,1.0/(stickers*kunstick)); nextstick=i+gsl_ran_exponential(r,1.0/((fil_length-lane_size-stickers)*kstick)); type=0; } } mpz_clear(states); mpz_clear(newstates); mpz_clear(deltastates); gsl_rng_free (r); fclose(fp); }
void simulation_single(float kstick){ const int num_lanes=2; int lane_size=1000; const gsl_rng_type * T; gsl_rng_env_setup(); T = gsl_rng_default; gsl_rng *r; r = gsl_rng_alloc (T); unsigned long int seed; seed=gen_seed(); gsl_rng_set(r,seed); int fil_length=1500; int stickers=1; //glue-related! //int stickers=0; mpz_t states; mpz_t newstates; mpz_t deltastates; mpz_init(states); mpz_init(newstates); mpz_init(deltastates); float timesteps=50000; int my_rank; MPI_Comm_rank(MPI_COMM_WORLD,&my_rank); char* filename[60]; sprintf(filename,"./output_single_filament_strong_%.2f/run%d.txt",kstick,my_rank); // sprintf(filename,"./output_single_filament_glue_%.2f/run%d.txt",kstick,my_rank); printf("%s\n",filename); FILE *fp = fopen(filename, "w"); if (fp == NULL) { printf("Error"); return; } float mu=6.0; float glue=1.0; float koff=1.0; float i; int j,k; //float kstick=0.05; float kunstick=kstick; float stick_energy=8.0; int type=0; int delta=0; float nextoff=gsl_ran_exponential(r,1.0/koff); float nextstick=gsl_ran_exponential(r,1.0/kstick); float nextunstick=gsl_ran_exponential(r,1.0/kunstick); //glue-related! // float nextstick=VERYBIG; // float nextunstick=VERYBIG; float peroverlap=kstick; double domega; float c0=1.0/lane_size; int att_depol=0; int acc_depol=0; int att_stick=0; int acc_stick=0; int att_unstick=0; int acc_unstick=0; int att_contr=0; int acc_contr=0; int att_expan=0; int acc_expan=0; count_isl_single(&states,fil_length,stickers,lane_size); for (i=0;i<timesteps;i=i+0.01){ if (fil_length==0){ break; } if ((int)(i*100)%(int)timesteps==0){ printf("%d\%\n",(int)(i*100)/timesteps); } if ((int)(i*100)%50==0){ fprintf(fp, "%f %f %f %f %d %d %d %d %d %d %d %d %d %d %d %d %d\n", i,nextoff,nextstick,nextunstick,fil_length,stickers,lane_size,att_depol,acc_depol,att_stick,acc_stick,att_unstick,acc_unstick,att_contr,acc_contr,att_expan,acc_expan); } if (i>=nextoff){ type=1;} if (i>=nextstick){ type=2; } if (i>=nextunstick){ type=3; } if (type==1){ att_depol=att_depol+1; int newlength=fil_length-1; count_isl_single(&newstates,newlength,stickers,lane_size); if (!mpz_cmp_d(newstates,0.0)){ count_isl_single(&newstates,newlength,stickers-1,lane_size); domega=stick_energy-mu+glue-mpzln(newstates)+mpzln(states); if (domega<0){ fil_length=newlength; stickers=stickers-1; acc_depol++; mpz_set(states,newstates); //fprintf(fp,"depol and removal - domega=%f\n",domega); } else{ double prob=exp(-1.0*domega); double fromthehat=gsl_rng_uniform(r); //printf("metropolising: rng=%f, prob=%f\n",fromthehat,prob); if (fromthehat<prob){ fil_length=newlength; stickers=stickers-1; acc_depol++; mpz_set(states,newstates); //fprintf(fp,"depol and removal - domega=%f\n",domega); }else{ //fprintf(fp,"depol w/unstick not accepted - domega=%f\n",domega); } } }else{ domega=-mu+glue-mpzln(newstates)+mpzln(states); //glue-related! // domega=-mu+glue+peroverlap-mpzln(newstates)+mpzln(states); if (domega<0){ acc_depol++; fil_length=newlength; mpz_set(states,newstates); //fprintf(fp,"depol - domega=%f\n",domega); } /*if it's positive, we calculate the probability of acceptance * and test for it*/ else{ double prob=exp(-1.0*domega); double fromthehat=gsl_rng_uniform(r); //printf("metropolising: rng=%f, prob=%f\n",fromthehat,prob); if (fromthehat<prob){ fil_length=newlength; acc_depol++; mpz_set(states,newstates); //fprintf(fp,"depol - domega=%f\n",domega); }else{ //fprintf(fp,"removal not accepted - domega=%f\n",domega); } } } att_contr++; att_expan++; delta=check_contraction(fil_length,stickers,lane_size,c0,states,r,fp); if (delta==-1){ acc_contr++; } if (delta==+1){ acc_expan++; } lane_size=lane_size+delta; nextoff=i+gsl_ran_exponential(r,1.0/koff); type=0; } if (type==2){ att_stick++; int newstickers=stickers+1; count_isl_single(&newstates,fil_length,newstickers,lane_size); domega=-stick_energy-mpzln(newstates)+mpzln(states); if (domega<0){ stickers=newstickers; acc_stick++; mpz_set(states,newstates); //fprintf(fp,"added sticker - domega=%f\n",domega); } /*if it's positive, we calculate the probability of acceptance * and test for it*/ else{ double prob=exp(-1.0*domega); double fromthehat=gsl_rng_uniform(r); //printf("metropolising: rng=%f, prob=%f\n",fromthehat,prob); if (fromthehat<prob){ stickers=newstickers; acc_stick++; mpz_set(states,newstates); //fprintf(fp,"added sticker - domega=%f\n",domega); }else{ //fprintf(fp,"addition sticker rejected - domega=%f\n",domega); } } delta=check_contraction(fil_length,stickers,lane_size,c0,states,r,fp); if (delta==-1){ acc_contr++; } if (delta==+1){ acc_expan++; } lane_size=lane_size+delta; nextstick=i+gsl_ran_exponential(r,1.0/kstick); type=0; } if (type==3){ att_unstick++; int newstickers=stickers-1; count_isl_single(&newstates,fil_length,newstickers,lane_size); domega=stick_energy-mpzln(newstates)+mpzln(states); if (domega<0){ acc_unstick++; stickers=newstickers; mpz_set(states,newstates); //fprintf(fp,"removal - domega=%f\n",domega); } /*if it's positive, we calculate the probability of acceptance * and test for it*/ else{ double prob=exp(-1.0*domega); double fromthehat=gsl_rng_uniform(r); //printf("metropolising: rng=%f, prob=%f\n",fromthehat,prob); if (fromthehat<prob){ stickers=newstickers; acc_unstick++; mpz_set(states,newstates); //fprintf(fp,"removal - domega=%f\n",domega); }else{ //fprintf(fp,"removal of sticker not accepted - domega=%f\n",domega); } } delta=check_contraction(fil_length,stickers,lane_size,c0,states,r,fp); if (delta==-1){ acc_contr++; } if (delta==+1){ acc_expan++; } lane_size=lane_size+delta; nextunstick=i+gsl_ran_exponential(r,1.0/kunstick); type=0; } }