static void check_different_precisions(void) { /* check reuse when real and imaginary part have different precisions. */ mpc_t z, expected, got; int res; mpc_init2(z, 128); mpc_init2(expected, 128); mpc_init2(got, 128); /* change precision of one part */ mpfr_set_prec (mpc_imagref (z), 32); mpfr_set_prec (mpc_imagref (expected), 32); mpfr_set_prec (mpc_imagref (got), 32); mpfr_set_str (mpc_realref (z), "0x100000000fp-32", 16, GMP_RNDN); mpfr_set_str (mpc_imagref (z), "-1", 2, GMP_RNDN); mpfr_set_str (mpc_realref (expected), "+1", 2, GMP_RNDN); mpfr_set_str (mpc_imagref (expected), "0x100000000fp-32", 16, GMP_RNDN); mpc_set (got, z, MPC_RNDNN); res = mpc_mul_i (got, got, +1, MPC_RNDNN); if (MPC_INEX_RE(res) != 0 || MPC_INEX_IM(res) >=0) { printf("Wrong inexact flag for mpc_mul_i(z, z, n)\n" " got (re=%2d, im=%2d)\nexpected (re= 0, im=-1)\n", MPC_INEX_RE(res), MPC_INEX_IM(res)); exit(1); } if (mpc_cmp(got, expected) != 0) { printf ("Error for mpc_mul_i(z, z, n) for\n"); MPC_OUT (z); printf ("n=+1\n"); MPC_OUT (expected); MPC_OUT (got); exit (1); } mpc_neg (expected, expected, MPC_RNDNN); mpc_set (got, z, MPC_RNDNN); mpc_mul_i (got, got, -1, MPC_RNDNN); if (mpc_cmp(got, expected) != 0) { printf ("Error for mpc_mul_i(z, z, n) for\n"); MPC_OUT (z); printf ("n=-1\n"); MPC_OUT (expected); MPC_OUT (got); exit (1); } mpc_clear (z); mpc_clear (expected); mpc_clear (got); }
static PyObject * _GMPy_MPC_Minus(PyObject *x, CTXT_Object *context) { MPC_Object *result; CHECK_CONTEXT(context); if (!(result = GMPy_MPC_New(0, 0, context))) { return NULL; } result->rc = mpc_neg(result->c, MPC(x), GET_MPC_ROUND(context)); GMPY_MPC_CLEANUP(result, context, "minus()"); return (PyObject*)result; }
static void pure_real_argument (void) { /* cosh(x -i*0) = cosh(x) +i*0 if x<0 */ /* cosh(x -i*0) = cosh(x) -i*0 if x>0 */ /* cosh(x +i*0) = cosh(x) -i*0 if x<0 */ /* cosh(x -i*0) = cosh(x) +i*0 if x>0 */ mpc_t u; mpc_t z; mpc_t cosh_z; mpc_init2 (z, 2); mpc_init2 (u, 100); mpc_init2 (cosh_z, 100); /* cosh(1 +i*0) = cosh(1) +i*0 */ mpc_set_ui_ui (z, 1, 0, MPC_RNDNN); mpfr_cosh (MPC_RE (u), MPC_RE (z), GMP_RNDN); mpfr_set_ui (MPC_IM (u), 0, GMP_RNDN); mpc_cosh (cosh_z, z, MPC_RNDNN); if (mpc_cmp (cosh_z, u) != 0 || mpfr_signbit (MPC_IM (cosh_z))) TEST_FAILED ("mpc_cosh", z, cosh_z, u, MPC_RNDNN); /* cosh(1 -i*0) = cosh(1) -i*0 */ mpc_conj (z, z, MPC_RNDNN); mpc_conj (u, u, MPC_RNDNN); mpc_cosh (cosh_z, z, MPC_RNDNN); if (mpc_cmp (cosh_z, u) != 0 || !mpfr_signbit (MPC_IM (cosh_z))) TEST_FAILED ("mpc_cosh", z, cosh_z, u, MPC_RNDNN); /* cosh(-1 +i*0) = cosh(1) -i*0 */ mpc_neg (z, z, MPC_RNDNN); mpc_cosh (cosh_z, z, MPC_RNDNN); if (mpc_cmp (cosh_z, u) != 0 || !mpfr_signbit (MPC_IM (cosh_z))) TEST_FAILED ("mpc_cosh", z, cosh_z, u, MPC_RNDNN); /* cosh(-1 -i*0) = cosh(1) +i*0 */ mpc_conj (z, z, MPC_RNDNN); mpc_conj (u, u, MPC_RNDNN); mpc_cosh (cosh_z, z, MPC_RNDNN); if (mpc_cmp (cosh_z, u) != 0 || mpfr_signbit (MPC_IM (cosh_z))) TEST_FAILED ("mpc_cosh", z, cosh_z, u, MPC_RNDNN); mpc_clear (cosh_z); mpc_clear (z); mpc_clear (u); }
static void pure_imaginary_argument (void) { /* cosh(+0 +i*y) = cos y +i*0*sin y */ /* cosh(-0 +i*y) = cos y -i*0*sin y */ mpc_t u; mpc_t z; mpc_t cosh_z; mpc_init2 (z, 2); mpc_init2 (u, 100); mpc_init2 (cosh_z, 100); /* cosh(+0 +i) = cos(1) + i*0 */ mpc_set_ui_ui (z, 0, 1, MPC_RNDNN); mpfr_cos (MPC_RE (u), MPC_IM (z), GMP_RNDN); mpfr_set_ui (MPC_IM (u), 0, GMP_RNDN); mpc_cosh (cosh_z, z, MPC_RNDNN); if (mpc_cmp (cosh_z, u) != 0 || mpfr_signbit (MPC_IM (cosh_z))) TEST_FAILED ("mpc_cosh", z, cosh_z, u, MPC_RNDNN); /* cosh(+0 -i) = cos(1) - i*0 */ mpc_conj (z, z, MPC_RNDNN); mpc_conj (u, u, MPC_RNDNN); mpc_cosh (cosh_z, z, MPC_RNDNN); if (mpc_cmp (cosh_z, u) != 0 || !mpfr_signbit (MPC_IM (cosh_z))) TEST_FAILED ("mpc_cosh", z, cosh_z, u, MPC_RNDNN); /* cosh(-0 +i) = cos(1) - i*0 */ mpc_neg (z, z, MPC_RNDNN); mpc_cosh (cosh_z, z, MPC_RNDNN); if (mpc_cmp (cosh_z, u) != 0 || !mpfr_signbit (MPC_IM (cosh_z))) TEST_FAILED ("mpc_cosh", z, cosh_z, u, MPC_RNDNN); /* cosh(-0 -i) = cos(1) + i*0 */ mpc_conj (z, z, MPC_RNDNN); mpc_conj (u, u, MPC_RNDNN); mpc_cosh (cosh_z, z, MPC_RNDNN); if (mpc_cmp (cosh_z, u) != 0 || mpfr_signbit (MPC_IM (cosh_z))) TEST_FAILED ("mpc_cosh", z, cosh_z, u, MPC_RNDNN); mpc_clear (cosh_z); mpc_clear (z); mpc_clear (u); }
SEXP R_mpc_neg(SEXP e1) { /* Garbage collector will be confused if we just call * mpc_neg(*z, *z, ...) */ mpc_t *z = (mpc_t *)malloc(sizeof(mpc_t)); if (Rf_inherits(e1, "mpc")) { mpc_t *z1 = (mpc_t *)R_ExternalPtrAddr(e1); mpc_init2(*z, mpc_get_prec(*z1)); mpc_neg(*z, *z1, Rmpc_get_rounding()); } else { Rf_error("Invalid operands for mpc negation."); } SEXP retVal = PROTECT(R_MakeExternalPtr((void *)z, Rf_install("mpc ptr"), R_NilValue)); Rf_setAttrib(retVal, R_ClassSymbol, Rf_mkString("mpc")); R_RegisterCFinalizerEx(retVal, mpcFinalizer, TRUE); UNPROTECT(1); return retVal; }
mpcomplex mpcomplex::neg() const{ mpc_t negativeValue; mpc_init3( negativeValue , mpc_prec, default_rnd ); mpc_neg(negativeValue, mpc_val , default_rnd ); return mpcomplex( negativeValue ); }
// See Cohen; my D is -D in his notation. size_t pbc_hilbert(mpz_t **arr, int D) { int a, b; int t; int B = (int)floor(sqrt((double) D / 3.0)); mpc_t alpha; mpc_t j; mpf_t sqrtD; mpf_t f0; darray_t Pz; mpc_t z0, z1, z2; double d = 1.0; int h = 1; int jcount = 1; // Compute required precision. b = D % 2; for (;;) { t = (b*b + D) / 4; a = b; if (a <= 1) { a = 1; goto step535_4; } step535_3: if (!(t % a)) { jcount++; if ((a == b) || (a*a == t) || !b) { d += 1.0 / ((double) a); h++; } else { d += 2.0 / ((double) a); h+=2; } } step535_4: a++; if (a * a <= t) { goto step535_3; } else { b += 2; if (b > B) break; } } //printf("modulus: %f\n", exp(3.14159265358979 * sqrt(D)) * d * 0.5); d *= sqrt(D) * 3.14159265358979 / log(2); precision_init((int)(d + 34)); pbc_info("class number %d, %d bit precision", h, (int) d + 34); darray_init(Pz); mpc_init(alpha); mpc_init(j); mpc_init(z0); mpc_init(z1); mpc_init(z2); mpf_init(sqrtD); mpf_init(f0); mpf_sqrt_ui(sqrtD, D); b = D % 2; h = 0; for (;;) { t = (b*b + D) / 4; if (b > 1) { a = b; } else { a = 1; } step3: if (t % a) { step4: a++; if (a * a <= t) goto step3; } else { // a, b, t/a are coeffs of an appropriate primitive reduced positive // definite form. // Compute j((-b + sqrt{-D})/(2a)). h++; pbc_info("[%d/%d] a b c = %d %d %d", h, jcount, a, b, t/a); mpf_set_ui(f0, 1); mpf_div_ui(f0, f0, 2 * a); mpf_mul(mpc_im(alpha), sqrtD, f0); mpf_mul_ui(f0, f0, b); mpf_neg(mpc_re(alpha), f0); compute_j(j, alpha); if (0) { int i; for (i=Pz->count - 1; i>=0; i--) { printf("P %d = ", i); mpc_out_str(stdout, 10, 4, Pz->item[i]); printf("\n"); } } if (a == b || a * a == t || !b) { // P *= X - j int i, n; mpc_ptr p0; p0 = (mpc_ptr) pbc_malloc(sizeof(mpc_t)); mpc_init(p0); mpc_neg(p0, j); n = Pz->count; if (n) { mpc_set(z1, Pz->item[0]); mpc_add(Pz->item[0], z1, p0); for (i=1; i<n; i++) { mpc_mul(z0, z1, p0); mpc_set(z1, Pz->item[i]); mpc_add(Pz->item[i], z1, z0); } mpc_mul(p0, p0, z1); } darray_append(Pz, p0); } else { // P *= X^2 - 2 Re(j) X + |j|^2 int i, n; mpc_ptr p0, p1; p0 = (mpc_ptr) pbc_malloc(sizeof(mpc_t)); p1 = (mpc_ptr) pbc_malloc(sizeof(mpc_t)); mpc_init(p0); mpc_init(p1); // p1 = - 2 Re(j) mpf_mul_ui(f0, mpc_re(j), 2); mpf_neg(f0, f0); mpf_set(mpc_re(p1), f0); // p0 = |j|^2 mpf_mul(f0, mpc_re(j), mpc_re(j)); mpf_mul(mpc_re(p0), mpc_im(j), mpc_im(j)); mpf_add(mpc_re(p0), mpc_re(p0), f0); n = Pz->count; if (!n) { } else if (n == 1) { mpc_set(z1, Pz->item[0]); mpc_add(Pz->item[0], z1, p1); mpc_mul(p1, z1, p1); mpc_add(p1, p1, p0); mpc_mul(p0, p0, z1); } else { mpc_set(z2, Pz->item[0]); mpc_set(z1, Pz->item[1]); mpc_add(Pz->item[0], z2, p1); mpc_mul(z0, z2, p1); mpc_add(Pz->item[1], z1, z0); mpc_add(Pz->item[1], Pz->item[1], p0); for (i=2; i<n; i++) { mpc_mul(z0, z1, p1); mpc_mul(alpha, z2, p0); mpc_set(z2, z1); mpc_set(z1, Pz->item[i]); mpc_add(alpha, alpha, z0); mpc_add(Pz->item[i], z1, alpha); } mpc_mul(z0, z2, p0); mpc_mul(p1, p1, z1); mpc_add(p1, p1, z0); mpc_mul(p0, p0, z1); } darray_append(Pz, p1); darray_append(Pz, p0); } goto step4; } b+=2; if (b > B) break; } // Round polynomial and assign. int k = 0; { *arr = pbc_malloc(sizeof(mpz_t) * (Pz->count + 1)); int i; for (i=Pz->count - 1; i>=0; i--) { if (mpf_sgn(mpc_re(Pz->item[i])) < 0) { mpf_set_d(f0, -0.5); } else { mpf_set_d(f0, 0.5); } mpf_add(f0, f0, mpc_re(Pz->item[i])); mpz_init((*arr)[k]); mpz_set_f((*arr)[k], f0); k++; mpc_clear(Pz->item[i]); pbc_free(Pz->item[i]); } mpz_init((*arr)[k]); mpz_set_ui((*arr)[k], 1); k++; } darray_clear(Pz); mpc_clear(z0); mpc_clear(z1); mpc_clear(z2); mpf_clear(f0); mpf_clear(sqrtD); mpc_clear(alpha); mpc_clear(j); precision_clear(); return k; }
void Lib_Mpcr_Neg(MpcrPtr f, MpcrPtr g, long rnd) { mpc_neg( (mpc_ptr) f, (mpc_ptr) g, (mpc_rnd_t) rnd); }