comp.h

Go to the documentation of this file.

//
//  comp.h
//
//  Authors: Nicolae Mihalache & François Vigneron
//
//  This software is released under BSD licence, with an attribution clause (see Licence file).
//  Please cite the reference below if you use or distribute this software.
//
//  • [1] R. Anton, N. Mihalache & F. Vigneron. Fast evaluation of real and complex polynomials. 2022.
//        https://hal.archives-ouvertes.fr/hal-03820369
//
//  Copyright 2022 Univ. Paris-Est Créteil & Univ. de Reims Champagne-Ardenne.
//
 
#ifndef comp_h
#define comp_h
 
#include <mpfr.h>
 
#include "ntypes.h"
 
// MARK: data types
 
typedef struct {
    mpfr_t x;  
    mpfr_t y;  
} comp_struct;
 
typedef comp_struct comp[1];
 
typedef comp_struct *comp_ptr;
 
// MARK: macros & functions prototypes
 
#define comp_init(d, prec)      mpfr_init2((d)->x, prec); \
                                mpfr_init2((d)->y, prec);
 
#define comp_initz(d, prec)     mpfr_init2((d)->x, prec); \
                                mpfr_init2((d)->y, prec); \
                                mpfr_set_zero((d)->x, 1); \
                                mpfr_set_zero((d)->y, 1);
 
#define comp_clear(d)           mpfr_clear((d)->x); \
                                mpfr_clear((d)->y);
 
#define comp_zero(d)            (mpfr_zero_p((d)->x) && mpfr_zero_p((d)->y))
 
#define comp_add(d, a, b)       mpfr_add((d)->x, (a)->x, (b)->x, MPFR_RNDN); \
                                mpfr_add((d)->y, (a)->y, (b)->y, MPFR_RNDN);
 
#define comp_set(d, a)          mpfr_set((d)->x, (a)->x, MPFR_RNDN); \
                                mpfr_set((d)->y, (a)->y, MPFR_RNDN);
 
#define comp_setr(d, a)         mpfr_set((d)->x, (a), MPFR_RNDN); \
                                mpfr_set_zero((d)->y, 1);
 
#define comp_neg(d, a)          mpfr_neg((d)->x, (a)->x, MPFR_RNDN); \
                                mpfr_neg((d)->y, (a)->y, MPFR_RNDN);
 
#define comp_addr(d, a, r)      mpfr_add((d)->x, (a)->x, (r), MPFR_RNDN); \
                                mpfr_set((d)->y, (a)->y, MPFR_RNDN);
 
#define comp_amu(d, a, r, buf)  mpfr_mul_ui((buf), (a)->x, (r), MPFR_RNDN); \
                                mpfr_add((d)->x, (d)->x, (buf), MPFR_RNDN); \
                                mpfr_mul_ui((buf), (a)->y, (r), MPFR_RNDN); \
                                mpfr_add((d)->y, (d)->y, (buf), MPFR_RNDN);
 
#define comp_sub(d, a, b)       mpfr_sub((d)->x, (a)->x, (b)->x, MPFR_RNDN); \
                                mpfr_sub((d)->y, (a)->y, (b)->y, MPFR_RNDN);
 
#define comp_subr(d, a, r)      mpfr_sub((d)->x, (a)->x, (r), MPFR_RNDN); \
                                mpfr_set((d)->y, (a)->y, MPFR_RNDN);
 
#define comp_mul(d, a, b, buf1, buf2)   mpfr_mul((buf1), (a)->x, (b)->x, MPFR_RNDN); \
                                        mpfr_mul((buf2), (a)->y, (b)->y, MPFR_RNDN); \
                                        mpfr_sub((buf1), (buf1), (buf2), MPFR_RNDN); \
                                        mpfr_mul((buf2), (a)->x, (b)->y, MPFR_RNDN); \
                                        mpfr_mul((d)->y, (a)->y, (b)->x, MPFR_RNDN); \
                                        mpfr_add((d)->y, (d)->y, (buf2), MPFR_RNDN); \
                                        mpfr_set((d)->x, (buf1), MPFR_RNDN);
 
#define comp_div(d, a, b, b1, b2, b3)   mpfr_sqr((b3), (b)->x, MPFR_RNDN); \
                                        mpfr_sqr((b2), (b)->y, MPFR_RNDN); \
                                        mpfr_add((b3), (b3), (b2), MPFR_RNDN); \
                                        mpfr_mul((b1), (a)->x, (b)->x, MPFR_RNDN); \
                                        mpfr_mul((b2), (a)->y, (b)->y, MPFR_RNDN); \
                                        mpfr_add((b1), (b1), (b2), MPFR_RNDN); \
                                        mpfr_mul((b2), (a)->x, (b)->y, MPFR_RNDN); \
                                        mpfr_mul((d)->y, (a)->y, (b)->x, MPFR_RNDN); \
                                        mpfr_sub((d)->y, (d)->y, (b2), MPFR_RNDN); \
                                        mpfr_div((d)->y, (d)->y, (b3), MPFR_RNDN); \
                                        mpfr_div((d)->x, (b1), (b3), MPFR_RNDN);
 
#define comp_mod(m, a)   mpfr_hypot((m), (a)->x, (a)->y, MPFR_RNDN);
 
#define comp_mulr(d, a, r)      mpfr_mul((d)->x, (a)->x, (r), MPFR_RNDN); \
                                mpfr_mul((d)->y, (a)->y, (r), MPFR_RNDN);
 
#define comp_muli(d, a, i)      mpfr_mul_si((d)->x, (a)->x, (i), MPFR_RNDN); \
                                mpfr_mul_si((d)->y, (a)->y, (i), MPFR_RNDN);
 
#define comp_mulu(d, a, i)      mpfr_mul_ui((d)->x, (a)->x, (i), MPFR_RNDN); \
                                mpfr_mul_ui((d)->y, (a)->y, (i), MPFR_RNDN);
 
#define comp_sqr(d, a, buf)     mpfr_sqr((buf), (a)->y, MPFR_RNDN); \
                                mpfr_mul((d)->y, (a)->x, (a)->y, MPFR_RNDN); \
                                mpfr_mul_2si((d)->y, (d)->y, 1, MPFR_RNDN); \
                                mpfr_sqr((d)->x, (a)->x, MPFR_RNDN); \
                                mpfr_sub((d)->x, (d)->x, (buf), MPFR_RNDN);
 
real_t comp_log2(comp z);
 
real_t real_log2(mpfr_t x);
 
real_t comp_s(comp z);
 
real_t mpfr_s(mpfr_t x);
 
#endif /* comp_h */