char filter(){ fp_t abs = fp_add(fp_add(fp_mul(acc[0], acc[0]), fp_mul(acc[1], acc[1])), fp_mul(acc[2], acc[2])); //////////////////////////////////////////////////////////////////////////////// //idle state filter if (!(fp_cmp(abs, 10486)==1 /*0.32*/ || fp_cmp(abs, 8847)==2 /*0.27*/)) { // if between 0.01 - 0.09 return false; } //////////////////////////////////////////////////////////////////////////////// // def = directional equivalence filter const fp_t def_sensitivity = 2621; //0.08 if (fp_cmp(acc[0], fp_sub(dir_filter_ref[0], def_sensitivity))==2 || fp_cmp(acc[0], fp_add(dir_filter_ref[0], def_sensitivity))== 1 || fp_cmp(acc[1], fp_sub(dir_filter_ref[1], def_sensitivity))==2 || fp_cmp(acc[1], fp_add(dir_filter_ref[1], def_sensitivity))== 1 || fp_cmp(acc[2], fp_sub(dir_filter_ref[2], def_sensitivity))==2 || fp_cmp(acc[2], fp_add(dir_filter_ref[2], def_sensitivity))==1) { dir_filter_ref[0] = acc[0]; dir_filter_ref[1] = acc[1]; dir_filter_ref[2] = acc[2]; return true; } return false; }
void ep_rhs(fp_t rhs, const ep_t p) { fp_t t0; fp_t t1; fp_null(t0); fp_null(t1); TRY { fp_new(t0); fp_new(t1); /* t0 = x1^2. */ fp_sqr(t0, p->x); /* t1 = x1^3. */ fp_mul(t1, t0, p->x); /* t1 = x1^3 + a * x1 + b. */ switch (ep_curve_opt_a()) { case OPT_ZERO: break; case OPT_ONE: fp_add(t1, t1, p->x); break; #if FP_RDC != MONTY case OPT_DIGIT: fp_mul_dig(t0, p->x, ep_curve_get_a()[0]); fp_add(t1, t1, t0); break; #endif default: fp_mul(t0, p->x, ep_curve_get_a()); fp_add(t1, t1, t0); break; } switch (ep_curve_opt_b()) { case OPT_ZERO: break; case OPT_ONE: fp_add_dig(t1, t1, 1); break; #if FP_RDC != MONTY case OPT_DIGIT: fp_add_dig(t1, t1, ep_curve_get_b()[0]); break; #endif default: fp_add(t1, t1, ep_curve_get_b()); break; } fp_copy(rhs, t1); } CATCH_ANY { THROW(ERR_CAUGHT); } FINALLY { fp_free(t0); fp_free(t1); } }
char filter(){ fp_t abs = fp_add(fp_add(fp_mul(acc[0], acc[0]), fp_mul(acc[1], acc[1])), fp_mul(acc[2], acc[2])); //////////////////////////////////////////////////////////////////////////////// //idle state filter if (!(fp_cmp(abs, d2fp(0.32))==1 || fp_cmp(abs, d2fp(0.27))==-1)) { // if between 0.01 - 0.09 return false; } //////////////////////////////////////////////////////////////////////////////// // def = directional equivalence filter fp_t def_sensitivity = d2fp(0.08); if (fp_cmp(acc[0], fp_sub(dir_filter_ref[0], def_sensitivity))==-1 || fp_cmp(acc[0], fp_add(dir_filter_ref[0], def_sensitivity))== 1 || fp_cmp(acc[1], fp_sub(dir_filter_ref[1], def_sensitivity))==-1 || fp_cmp(acc[1], fp_add(dir_filter_ref[1], def_sensitivity))== 1 || fp_cmp(acc[2], fp_sub(dir_filter_ref[2], def_sensitivity))==-1 || fp_cmp(acc[2], fp_add(dir_filter_ref[2], def_sensitivity))==1) { dir_filter_ref[0] = acc[0]; dir_filter_ref[1] = acc[1]; dir_filter_ref[2] = acc[2]; return true; } return false; }
/** * Compute the Miller loop for pairings of type G_2 x G_1 over the bits of a * given parameter. * * @param[out] r - the result. * @param[out] t - the resulting point. * @param[in] q - the first pairing argument in affine coordinates. * @param[in] p - the second pairing argument in affine coordinates. * @param[in] n - the number of pairings to evaluate. * @param[in] a - the loop parameter. */ static void pp_mil_k12(fp12_t r, ep2_t *t, ep2_t *q, ep_t *p, int m, bn_t a) { fp12_t l; ep_t _p[m]; int i, j; if (m == 0) { return; } fp12_null(l); TRY { fp12_new(l); for (j = 0; j < m; j++) { ep_null(_p[j]); ep_new(_p[j]); #if EP_ADD == BASIC ep_neg(_p[j], p[i]); #else fp_add(_p[j]->x, p[j]->x, p[j]->x); fp_add(_p[j]->x, _p[j]->x, p[j]->x); fp_neg(_p[j]->y, p[j]->y); #endif ep2_copy(t[j], q[j]); } fp12_zero(l); /* Precomputing. */ pp_dbl_k12(r, t[0], t[0], _p[0]); if (bn_get_bit(a, bn_bits(a) - 2)) { for (j = 0; j < m; j++) { pp_add_k12(l, t[j], q[j], p[j]); fp12_mul_dxs(r, r, l); } } for (i = bn_bits(a) - 3; i >= 0; i--) { fp12_sqr(r, r); for (j = 0; j < m; j++) { pp_dbl_k12(l, t[j], t[j], _p[j]); fp12_mul_dxs(r, r, l); if (bn_get_bit(a, i)) { pp_add_k12(l, t[j], q[j], p[j]); fp12_mul_dxs(r, r, l); } } } } CATCH_ANY { THROW(ERR_CAUGHT); } FINALLY { fp12_free(l); for (j = 0; j < m; j++) { ep_free(_p[j]); } } }
void fp_add_test() { unsigned bias = 0b01111111; bit16 zero = construct(0b0, 0, 0); bit16 one = construct(0b0, 0b01111111, 0b0000000); bit16 onePointTwoFive = construct(0b0, 0b01111111, 0b0100000); bit16 threePointSevenFive = construct(0b0, 0b10000000, 0b1110000); bit16 twoTotheSeven = construct(0b0, 0b111 + bias, 0b0000000); bit16 twoTotheMinusSeven = construct(0b0, -0b111 + bias, 0b0000000); bit16 minusOnePointTwoFive = construct(0b0, 0b01111111, 0b0100000); bit16 minusThreePointSevenFive = construct(0b0, 0b10000000, 0b1110000); print16(SM_ADD(minusOnePointTwoFive, minusThreePointSevenFive)); printf("1.25 + 3.75 = \n"); print16(fp_add(onePointTwoFive, threePointSevenFive)); printf("0 + 3.75 = \n"); print16(fp_add(zero, threePointSevenFive)); printf("0 + 0 = \n"); print16(fp_add(zero, zero)); printf("2^7 + 1 = \n"); print16(fp_add(twoTotheSeven, 1)); printf("2^7 + 2^-7 = \n"); print16(fp_add(twoTotheSeven, twoTotheMinusSeven)); return; }
int fp2_srt(fp2_t c, fp2_t a) { int r = 0; fp_t t1; fp_t t2; fp_t t3; fp_null(t1); fp_null(t2); fp_null(t3); TRY { fp_new(t1); fp_new(t2); fp_new(t3); /* t1 = a[0]^2 - u^2 * a[1]^2 */ fp_sqr(t1, a[0]); fp_sqr(t2, a[1]); for (int i = -1; i > fp_prime_get_qnr(); i--) { fp_add(t1, t1, t2); } for (int i = 0; i <= fp_prime_get_qnr(); i++) { fp_sub(t1, t1, t2); } fp_add(t1, t1, t2); if (fp_srt(t2, t1)) { /* t1 = (a_0 + sqrt(t1)) / 2 */ fp_add(t1, a[0], t2); fp_set_dig(t3, 2); fp_inv(t3, t3); fp_mul(t1, t1, t3); if (!fp_srt(t3, t1)) { /* t1 = (a_0 - sqrt(t1)) / 2 */ fp_sub(t1, a[0], t2); fp_set_dig(t3, 2); fp_inv(t3, t3); fp_mul(t1, t1, t3); fp_srt(t3, t1); } /* c_0 = sqrt(t1) */ fp_copy(c[0], t3); /* c_1 = a_1 / (2 * sqrt(t1)) */ fp_dbl(t3, t3); fp_inv(t3, t3); fp_mul(c[1], a[1], t3); r = 1; } } CATCH_ANY { THROW(ERR_CAUGHT); } FINALLY { fp_free(t1); fp_free(t2); fp_free(t3); } return r; }
void fp2_norm_low(fp2_t c, fp2_t a) { fp2_t t; bn_t b; fp2_null(t); bn_null(b); TRY { fp2_new(t); bn_new(b); #if FP_PRIME == 158 fp_dbl(t[0], a[0]); fp_dbl(t[0], t[0]); fp_sub(t[0], t[0], a[1]); fp_dbl(t[1], a[1]); fp_dbl(t[1], t[1]); fp_add(c[1], a[0], t[1]); fp_copy(c[0], t[0]); #elif defined(FP_QNRES) /* If p = 3 mod 8, (1 + i) is a QNR/CNR. */ fp_neg(t[0], a[1]); fp_add(c[1], a[0], a[1]); fp_add(c[0], t[0], a[0]); #else switch (fp_prime_get_mod8()) { case 3: /* If p = 3 mod 8, (1 + u) is a QNR/CNR. */ fp_neg(t[0], a[1]); fp_add(c[1], a[0], a[1]); fp_add(c[0], t[0], a[0]); break; case 5: /* If p = 5 mod 8, (u) is a QNR/CNR. */ fp2_mul_art(c, a); break; case 7: /* If p = 7 mod 8, we choose (2^(lg_4(b-1)) + u) as QNR/CNR. */ fp2_mul_art(t, a); fp2_dbl(c, a); fp_prime_back(b, ep_curve_get_b()); for (int i = 1; i < bn_bits(b) / 2; i++) { fp2_dbl(c, c); } fp2_add(c, c, t); break; default: THROW(ERR_NO_VALID); break; } #endif } CATCH_ANY { THROW(ERR_CAUGHT); } FINALLY { fp2_free(t); bn_free(b); } }
static int tfm_rsa_private_calculate(fp_int * in, fp_int * p, fp_int * q, fp_int * dmp1, fp_int * dmq1, fp_int * iqmp, fp_int * out) { fp_int vp, vq, u; fp_init_multi(&vp, &vq, &u, NULL); /* vq = c ^ (d mod (q - 1)) mod q */ /* vp = c ^ (d mod (p - 1)) mod p */ fp_mod(in, p, &u); fp_exptmod(&u, dmp1, p, &vp); fp_mod(in, q, &u); fp_exptmod(&u, dmq1, q, &vq); /* C2 = 1/q mod p (iqmp) */ /* u = (vp - vq)C2 mod p. */ fp_sub(&vp, &vq, &u); if (fp_isneg(&u)) fp_add(&u, p, &u); fp_mul(&u, iqmp, &u); fp_mod(&u, p, &u); /* c ^ d mod n = vq + u q */ fp_mul(&u, q, &u); fp_add(&u, &vq, out); fp_zero_multi(&vp, &vq, &u, NULL); return 0; }
void fp2_mul_basic(fp2_t c, fp2_t a, fp2_t b) { dv_t t0, t1, t2, t3, t4; dv_null(t0); dv_null(t1); dv_null(t2); dv_null(t3); dv_null(t4); TRY { dv_new(t0); dv_new(t1); dv_new(t2); dv_new(t3); dv_new(t4); /* Karatsuba algorithm. */ /* t2 = a_0 + a_1, t1 = b0 + b1. */ fp_add(t2, a[0], a[1]); fp_add(t1, b[0], b[1]); /* t3 = (a_0 + a_1) * (b0 + b1). */ fp_muln_low(t3, t2, t1); /* t0 = a_0 * b0, t4 = a_1 * b1. */ fp_muln_low(t0, a[0], b[0]); fp_muln_low(t4, a[1], b[1]); /* t2 = (a_0 * b0) + (a_1 * b1). */ fp_addc_low(t2, t0, t4); /* t1 = (a_0 * b0) + u^2 * (a_1 * b1). */ fp_subc_low(t1, t0, t4); /* t1 = u^2 * (a_1 * b1). */ for (int i = -1; i > fp_prime_get_qnr(); i--) { fp_subc_low(t1, t1, t4); } /* c_0 = t1 mod p. */ fp_rdc(c[0], t1); /* t4 = t3 - t2. */ fp_subc_low(t4, t3, t2); /* c_1 = t4 mod p. */ fp_rdc(c[1], t4); } CATCH_ANY { THROW(ERR_CAUGHT); } FINALLY { dv_free(t0); dv_free(t1); dv_free(t2); dv_free(t3); dv_free(t4); } }
void fp2_sqr_basic(fp2_t c, fp2_t a) { fp_t t0, t1, t2; fp_null(t0); fp_null(t1); fp_null(t2); TRY { fp_new(t0); fp_new(t1); fp_new(t2); /* t0 = (a_0 + a_1). */ fp_add(t0, a[0], a[1]); /* t1 = (a_0 - a_1). */ fp_sub(t1, a[0], a[1]); /* t1 = a_0 + u^2 * a_1. */ for (int i = -1; i > fp_prime_get_qnr(); i--) { fp_sub(t1, t1, a[1]); } for (int i = 0; i <= fp_prime_get_qnr(); i++) { fp_add(t1, t1, a[1]); } if (fp_prime_get_qnr() == -1) { /* t2 = 2 * a_0. */ fp_dbl(t2, a[0]); /* c_1 = 2 * a_0 * a_1. */ fp_mul(c[1], t2, a[1]); /* c_0 = a_0^2 + a_1^2 * u^2. */ fp_mul(c[0], t0, t1); } else { /* c_1 = a_0 * a_1. */ fp_mul(c[1], a[0], a[1]); /* c_0 = a_0^2 + a_1^2 * u^2. */ fp_mul(c[0], t0, t1); for (int i = -1; i > fp_prime_get_qnr(); i--) { fp_add(c[0], c[0], c[1]); } for (int i = 0; i <= fp_prime_get_qnr(); i++) { fp_sub(c[0], c[0], c[1]); } /* c_1 = 2 * a_0 * a_1. */ fp_dbl(c[1], c[1]); } /* c = c_0 + c_1 * u. */ } CATCH_ANY { THROW(ERR_CAUGHT); } FINALLY { fp_free(t0); fp_free(t1); fp_free(t2); } }
void fp2_inv(fp2_t c, fp2_t a) { fp_t t0, t1; fp_null(t0); fp_null(t1); TRY { fp_new(t0); fp_new(t1); /* t0 = a_0^2, t1 = a_1^2. */ fp_sqr(t0, a[0]); fp_sqr(t1, a[1]); /* t1 = 1/(a_0^2 + a_1^2). */ #ifndef FP_QNRES if (fp_prime_get_qnr() != -1) { if (fp_prime_get_qnr() == -2) { fp_dbl(t1, t1); fp_add(t0, t0, t1); } else { if (fp_prime_get_qnr() < 0) { fp_mul_dig(t1, t1, -fp_prime_get_qnr()); fp_add(t0, t0, t1); } else { fp_mul_dig(t1, t1, fp_prime_get_qnr()); fp_sub(t0, t0, t1); } } } else { fp_add(t0, t0, t1); } #else fp_add(t0, t0, t1); #endif fp_inv(t1, t0); /* c_0 = a_0/(a_0^2 + a_1^2). */ fp_mul(c[0], a[0], t1); /* c_1 = - a_1/(a_0^2 + a_1^2). */ fp_mul(c[1], a[1], t1); fp_neg(c[1], c[1]); } CATCH_ANY { THROW(ERR_CAUGHT); } FINALLY { fp_free(t0); fp_free(t1); } }
void fp2_mul_nor_basic(fp2_t c, fp2_t a) { fp2_t t; bn_t b; fp2_null(t); bn_null(b); TRY { fp2_new(t); bn_new(b); #ifdef FP_QNRES /* If p = 3 mod 8, (1 + i) is a QNR/CNR. */ fp_neg(t[0], a[1]); fp_add(c[1], a[0], a[1]); fp_add(c[0], t[0], a[0]); #else switch (fp_prime_get_mod8()) { case 3: /* If p = 3 mod 8, (1 + u) is a QNR/CNR. */ fp_neg(t[0], a[1]); fp_add(c[1], a[0], a[1]); fp_add(c[0], t[0], a[0]); break; case 1: case 5: /* If p = 5 mod 8, (u) is a QNR/CNR. */ fp2_mul_art(c, a); break; case 7: /* If p = 7 mod 8, we choose (4 + u) is a QNR/CNR. */ fp2_mul_art(t, a); fp2_dbl(c, a); fp2_dbl(c, c); fp2_add(c, c, t); break; default: THROW(ERR_NO_VALID); } #endif } CATCH_ANY { THROW(ERR_CAUGHT); } FINALLY { fp2_free(t); bn_free(b); } }
void fp2_mul_art(fp2_t c, fp2_t a) { fp_t t; fp_null(t); TRY { fp_new(t); #ifdef FP_QNRES /* (a_0 + a_1 * i) * i = -a_1 + a_0 * i. */ fp_copy(t, a[0]); fp_neg(c[0], a[1]); fp_copy(c[1], t); #else /* (a_0 + a_1 * u) * u = (a_1 * u^2) + a_0 * u. */ fp_copy(t, a[0]); fp_neg(c[0], a[1]); for (int i = -1; i > fp_prime_get_qnr(); i--) { fp_sub(c[0], c[0], a[1]); } for (int i = 1; i <= fp_prime_get_qnr() + 1; i++) { fp_add(c[0], c[0], a[1]); } fp_copy(c[1], t); #endif } CATCH_ANY { THROW(ERR_CAUGHT); } FINALLY { fp_free(t); } }
//Called at the end of the gesture, //Returns the id of the recognized gesture or -1 if none. char input_end(){ fp_t prob; char recognized = -1; // which gesture has been recognized fp_t recogprob = -1; // probability of this gesture fp_t tmpgesture; char i, j; started = false; for (i = 0; i < 2; i++){ prob = 0; // add probabilities for (j = 0; j < 8; j++){ prob = fp_add(prob, s[j]); } if (fp_cmp(prob, recogprob)==1) { recogprob = prob; recognized = i; } } //printf("m->prob = %.30f\n", fp2d(recogprob)); UARTSendArray("p=", 2); UARTSendInt(recogprob); //dir_filter_ref[0] = 0; //reset for next time return recognized; }
//Performs the next iteration of the HMM forward algorithm fp_t forward_proc_inc(char o){ fp_t ord = 0; fp_t sum; char k,l; if (started == false){ for (l = 0; l < 8; l++){ f[l] = b[(o<<3) + l]; // pi*b //f[l] = b[o][l]; } for (l = 1; l < 8; l++){ f[l] = 0; } return 0; }else{ for (k = 0; k < 8; k++){ sum = 0; for (l = 0; l < 8; l++){ //sum = fp_add(sum, fp_mul(s[l], a[(l<<3) + k])); sum = fp_add(sum, fp_mul(s[l], b[(l<<3) +k])); } f[k] = fp_mul(sum, b[(o<<3)+k]); //f[k] = fp_mul(sum, b[o][k]); ord |= f[k]; } } return ord; }
/* d = a + b (mod c) */ int fp_addmod(fp_int *a, fp_int *b, fp_int *c, fp_int *d) { fp_int tmp; fp_zero(&tmp); fp_add(a, b, &tmp); return fp_mod(&tmp, c, d); }
fp_t forward_proc_inc2(unsigned char o){ fp_t ord = 0; fp_t sum; unsigned char k,l; if (started == false){ for (l = 0; l < 8; l++){ f2[l] = fp_mul(pi2[l],b2[(o<<3) + l]); // pi*b //f[l] = b[o][l]; } return 0; }else{ for (k = 0; k < 8; k++){ sum = 0; for (l = 0; l < 8; l++){ sum = fp_add(sum, fp_mul(s2[l], a2[(l<<3) + k])); //sum = fp_add(sum, fp_mul(s2[l], b2[(l<<3) +k])); } f2[k] = fp_mul(sum, b2[(o<<3)+k]); //f[k] = fp_mul(sum, b2[o][k]); ord |= f2[k]; } } return ord; }
/* add */ static int add(void *a, void *b, void *c) { LTC_ARGCHK(a != NULL); LTC_ARGCHK(b != NULL); LTC_ARGCHK(c != NULL); fp_add(a, b, c); return CRYPT_OK; }
fixed SynthController::ProcessSample() { const fixed noise = noiseGenerator_.ProcessSample(); const fixed osc = oscillator_.ProcessSample(); const fixed value=fp_add(noise,osc); const fixed envValue =envelope_.GetScaledValue(); return fp_mul(value, envValue); }
/* Evaluates the following polynomial at x = a: * * coefs[0] x^(n-1) + coefs[1] x^(n-1) + ... + coefs[n-1] * * using the Horner scheme. This changes the order of evaluation to: * * coefs[n-1] + (coefs[n-2] + (... + coefs[n-1] * x) * x) * x * * which greatly reduces the number of required multiplies. */ fp_t fp_poly(fp_t coefs[], size_t n, fp_t a) { size_t i; fp_t out; out = coefs[0]; for(i = 1; i < n; ++i) { out = fp_mul(a, out); out = fp_add(coefs[i], out); } return out; }
unsigned char derive_group2(){ fp_t a, b, c, d; fp_t minDist = 0x7fff; //0x7fff; char minGroup=0; fp_t *ref; char i; for (i = 0; i < 14; i++){ ref = quantizerMap2[i]; a = fp_sub(ref[0], acc[0]); b = fp_sub(ref[1], acc[1]); c = fp_sub(ref[2], acc[2]); d = fp_add(fp_add(fp_mul(a,a), fp_mul(b,b)), fp_mul(c,c)); if (fp_cmp(d, minDist) == 2){ minDist = d; minGroup = i; } } /* UARTSendArray("group=", 6); */ /* UARTSendInt(minGroup); */ return minGroup; }
//Called at the end of the gesture, //Returns the id of the recognized gesture or -1 if none. char input_end(){ fp_t prob, prob2; char recognized; // which gesture has been recognized char j; started = false; prob = 0; prob2 = 0; // add probabilities for (j = 0; j < 8; j++){ prob = fp_add(prob, s[j]); prob2 = fp_add(prob2, s2[j]); } if (fp_cmp(prob, prob2)==1) { recognized = 0; } else { recognized = 1; } //printf("\np = %d %d\n", prob, prob2); return recognized; }
int main() { int count = 0; int errors = 0; for (int i = 0; i < numbers_cnt; i++) { uint32_t v = v_add(numbers[i], 0x4B00U<<16); uint32_t fp = fp_add(numbers[i], 0x4B00U<<16, 0, 1); if (v != fp && errors < 10) { printf("flr: %08x => v %08x | fp %08x\n", numbers[i], v, fp); } errors += fp != v; count += 1; } printf("flr: errors: %d tests: %d\n", errors, count); return errors != 0; }
/* c = a mod b, 0 <= c < b */ int fp_mod(fp_int *a, fp_int *b, fp_int *c) { fp_int t; int err; fp_zero(&t); if ((err = fp_div(a, b, NULL, &t)) != FP_OKAY) { return err; } if (t.sign != b->sign) { fp_add(&t, b, c); } else { fp_copy(&t, c); } return FP_OKAY; }
void set_filter(int channel, filterType_t type, fixed param1,fixed param2,int mix,bool bassyMapping) { filter_t* flt=&filter[channel]; if(flt->type!=type) //reset only on filter type change (maybe no reset would make interresting bugs) { flt->height[0]=0; //idle state flt->height[1]=0; //idle state flt->speed[0]=0; //paused (to avoid having it goind crazy) flt->speed[1]=0; //paused (to avoid having it goind crazy) flt->hipdelay[0]=0 ; flt->hipdelay[1]=0 ; flt->type=type; } flt->dirt=fp_mul(i2fp(100),i2fp(1)-param1)+fp_mul(i2fp(5000),param1) ; flt->mix =fp_mul(i2fp(mix),fp_inv_255) ; if (param1 != flt->parm1) { flt->parm1=param1; //adjust parm to get the most of the parameters, as the fx are more useful with near-limit parameters. if (bassyMapping) { static const fixed fpFreqDivider = fl2fp(1/22050.0f); static const fixed fpZeroSix = fl2fp(0.6f); static const fixed fpThreeOne = fl2fp(3.1f); fixed power = fp_add(fpZeroSix,fp_mul(param1,fpThreeOne)); fixed frequency = fl2fp(pow(10.0f,fp2fl(power))) ; frequency=fp_mul(frequency,fpFreqDivider); flt->freq=frequency; } else { flt->freq=fp_mul(param1,param1); //0 - .5 - 1 => 0 - .25 - 1 } } if (param2 != flt->parm2) { flt->parm2=param2; flt->reso=i2fp(1)-param2 ; flt->reso=fp_sub(fl2fp(1.f),fp_mul(flt->reso,fp_mul(flt->reso,flt->reso))); //0 - .5 - 1 => 0 - .93 - 1 } }
int main() { if (fp_add (1, 1) != 2) fail ("fp_add 1+1"); if (fp_sub (3, 2) != 1) fail ("fp_sub 3-2"); if (fp_mul (2, 3) != 6) fail ("fp_mul 2*3"); if (fp_div (3, 2) != 1.5) fail ("fp_div 3/2"); if (fp_neg (1) != -1) fail ("fp_neg 1"); if (dp_add (1, 1) != 2) fail ("dp_add 1+1"); if (dp_sub (3, 2) != 1) fail ("dp_sub 3-2"); if (dp_mul (2, 3) != 6) fail ("dp_mul 2*3"); if (dp_div (3, 2) != 1.5) fail ("dp_div 3/2"); if (dp_neg (1) != -1) fail ("dp_neg 1"); if (fp_to_dp (1.5) != 1.5) fail ("fp_to_dp 1.5"); if (dp_to_fp (1.5) != 1.5) fail ("dp_to_fp 1.5"); if (floatsisf (1) != 1) fail ("floatsisf 1"); if (floatsidf (1) != 1) fail ("floatsidf 1"); if (fixsfsi (1.42) != 1) fail ("fixsfsi 1.42"); if (fixunssfsi (1.42) != 1) fail ("fixunssfsi 1.42"); if (fixdfsi (1.42) != 1) fail ("fixdfsi 1.42"); if (fixunsdfsi (1.42) != 1) fail ("fixunsdfsi 1.42"); if (eqsf2 (1, 1) == 0) fail ("eqsf2 1==1"); if (eqsf2 (1, 2) != 0) fail ("eqsf2 1==2"); if (nesf2 (1, 2) == 0) fail ("nesf2 1!=1"); if (nesf2 (1, 1) != 0) fail ("nesf2 1!=1"); if (gtsf2 (2, 1) == 0) fail ("gtsf2 2>1"); if (gtsf2 (1, 1) != 0) fail ("gtsf2 1>1"); if (gtsf2 (0, 1) != 0) fail ("gtsf2 0>1"); if (gesf2 (2, 1) == 0) fail ("gesf2 2>=1"); if (gesf2 (1, 1) == 0) fail ("gesf2 1>=1"); if (gesf2 (0, 1) != 0) fail ("gesf2 0>=1"); if (ltsf2 (1, 2) == 0) fail ("ltsf2 1<2"); if (ltsf2 (1, 1) != 0) fail ("ltsf2 1<1"); if (ltsf2 (1, 0) != 0) fail ("ltsf2 1<0"); if (lesf2 (1, 2) == 0) fail ("lesf2 1<=2"); if (lesf2 (1, 1) == 0) fail ("lesf2 1<=1"); if (lesf2 (1, 0) != 0) fail ("lesf2 1<=0"); if (fail_count != 0) abort (); exit (0); }
/* Computes log(x) and stores the result in out. * The current method of computation is as follows: * 1) Separate x into the form y * 10^n, where 1 <= y < 10. * 2) Approximate log(y) using a 5/5 Pade approximant. * 3) Compute log(10^n) via n * log(10). * 4) Since log(ab) = log(a) + log(b), compute final result by: * log(y) + n log(10). */ fp_t fp_log(fp_t x) { fp_t num, div, tmp, p10; /* Extract the fractional part of x. */ tmp = x; tmp.expt = 0x7f; /* Compute the quotient approximation of frac(x) */ num = fp_poly(QUOT_NUMERATOR, sizeof QUOT_NUMERATOR / sizeof QUOT_NUMERATOR[0], tmp); div = fp_poly(QUOT_DENOMINATOR, sizeof QUOT_DENOMINATOR / sizeof QUOT_DENOMINATOR[0], tmp); /* Compute the quotient. */ tmp = fp_div(num, div); p10 = fp_fromint(x.expt - 0x7f); p10 = fp_mul(p10, FP_LOG10); tmp = fp_add(tmp, p10); return tmp; }
int ed_affine_is_valid(const fp_t x, const fp_t y) { fp_t tmpFP0; fp_t tmpFP1; fp_t tmpFP2; fp_null(tmpFP0); fp_null(tmpFP1); fp_null(tmpFP2); int r = 0; TRY { fp_new(tmpFP0); fp_new(tmpFP1); fp_new(tmpFP2); // a * X^2 + Y^2 - 1 - d * X^2 * Y^2 =?= 0 fp_sqr(tmpFP0, x); fp_mul(tmpFP0, core_get()->ed_a, tmpFP0); fp_sqr(tmpFP1, y); fp_add(tmpFP1, tmpFP0, tmpFP1); fp_sub_dig(tmpFP1, tmpFP1, 1); fp_sqr(tmpFP0, x); fp_mul(tmpFP0, core_get()->ed_d, tmpFP0); fp_sqr(tmpFP2, y); fp_mul(tmpFP2, tmpFP0, tmpFP2); fp_sub(tmpFP0, tmpFP1, tmpFP2); r = fp_is_zero(tmpFP0); } CATCH_ANY { THROW(ERR_CAUGHT); } FINALLY { fp_free(tmpFP0); fp_free(tmpFP1); fp_free(tmpFP2); } return r; }
void pp_dbl_k2_basic(fp2_t l, ep_t r, ep_t p, ep_t q) { fp_t s; ep_t t; fp_null(s); ep_null(t); TRY { fp_new(s); ep_new(t); ep_copy(t, p); ep_dbl_slp_basic(r, s, p); fp_add(l[0], t->x, q->x); fp_mul(l[0], l[0], s); fp_sub(l[0], t->y, l[0]); fp_copy(l[1], q->y); } CATCH_ANY { THROW(ERR_CAUGHT); } FINALLY { fp_free(s); ep_free(t); } }
void fp_rdcs_low(dig_t *c, dig_t *a, dig_t *m) { align dig_t q[2 * FP_DIGS], _q[2 * FP_DIGS]; align dig_t _r[2 * FP_DIGS], r[2 * FP_DIGS], t[2 * FP_DIGS]; int *sform, len; int first, i, j, b0, d0, b1, d1; dig_t carry; sform = fp_prime_get_sps(&len); SPLIT(b0, d0, FP_BITS, FP_DIG_LOG); first = (d0) + (b0 == 0 ? 0 : 1); /* q = floor(a/b^k) */ dv_zero(q, 2 * FP_DIGS); bn_rshd_low(q, a, 2 * FP_DIGS, d0); if (b0 > 0) { bn_rshb_low(q, q, 2 * FP_DIGS, b0); } /* r = a - qb^k. */ dv_copy(r, a, first); if (b0 > 0) { r[first - 1] &= MASK(b0); } carry = 0; while (!fp_is_zero(q)) { dv_zero(_q, 2 * FP_DIGS); for (i = len - 1; i > 0; i--) { j = (sform[i] < 0 ? -sform[i] : sform[i]); SPLIT(b1, d1, j, FP_DIG_LOG); dv_zero(t, 2 * FP_DIGS); bn_lshd_low(t, q, FP_DIGS, d1); if (b1 > 0) { bn_lshb_low(t, t, 2 * FP_DIGS, b1); } if (sform[i] > 0) { bn_subn_low(_q, _q, t, 2 * FP_DIGS); } else { bn_addn_low(_q, _q, t, 2 * FP_DIGS); } } if (sform[0] > 0) { bn_subn_low(_q, _q, q, 2 * FP_DIGS); } else { bn_addn_low(_q, _q, q, 2 * FP_DIGS); } bn_rshd_low(q, _q, 2 * FP_DIGS, d0); if (b0 > 0) { bn_rshb_low(q, q, 2 * FP_DIGS, b0); } dv_copy(_r, _q, first); if (b0 > 0) { _r[first - 1] &= MASK(b0); } fp_add(r, r, _r); } while (fp_cmpn_low(r, m) != CMP_LT) { fp_subn_low(r, r, m); } fp_copy(c, r); }