go_quad_add ()

void
go_quad_add (GOQuad *res,
             const GOQuad *a,
             const GOQuad *b);

This function adds a and b , storing the result in res .

go_quad_addl ()

void
go_quad_addl (GOQuadl *res,
              const GOQuadl *a,
              const GOQuadl *b);

This function adds a and b , storing the result in res .

go_quad_div ()

void
go_quad_div (GOQuad *res,
             const GOQuad *a,
             const GOQuad *b);

This function divides a and b , storing the result in res .

go_quad_divl ()

void
go_quad_divl (GOQuadl *res,
              const GOQuadl *a,
              const GOQuadl *b);

This function divides a and b , storing the result in res .

go_quad_dot_product ()

void
go_quad_dot_product (GOQuad *res,
                     const GOQuad *a,
                     const GOQuad *b,
                     int n);

go_quad_dot_productl ()

void
go_quad_dot_productl (GOQuadl *res,
                      const GOQuadl *a,
                      const GOQuadl *b,
                      int n);

go_quad_end ()

void
go_quad_end (void *state);

This ends a section of quad precision arithmetic.

go_quad_endl ()

void
go_quad_endl (void *state);

This ends a section of quad precision arithmetic.

go_quad_functional ()

gboolean
go_quad_functional (void);

go_quad_functionall ()

gboolean
go_quad_functionall (void);

go_quad_init ()

void
go_quad_init (GOQuad *res,
              double h);

This stores the value h in res . As an exception, this may be called outside go_quad_start and go_quad_end sections.

go_quad_initl ()

void
go_quad_initl (GOQuadl *res,
               long double h);

This stores the value h in res . As an exception, this may be called outside go_quad_startl and go_quad_endl sections.

go_quad_mul ()

void
go_quad_mul (GOQuad *res,
             const GOQuad *a,
             const GOQuad *b);

This function multiplies a and b , storing the result in res .

go_quad_mul12 ()

void
go_quad_mul12 (GOQuad *res,
               double x,
               double y);

This function multiplies x and y , storing the result in res with full quad precision.

go_quad_mul12l ()

void
go_quad_mul12l (GOQuadl *res,
                long double x,
                long double y);

This function multiplies x and y , storing the result in res with full quad precision.

go_quad_mull ()

void
go_quad_mull (GOQuadl *res,
              const GOQuadl *a,
              const GOQuadl *b);

This function multiplies a and b , storing the result in res .

go_quad_sqrt ()

void
go_quad_sqrt (GOQuad *res,
              const GOQuad *a);

This function takes the square root of a , storing the result in res .

go_quad_sqrtl ()

void
go_quad_sqrtl (GOQuadl *res,
               const GOQuadl *a);

This function takes the square root of a , storing the result in res .

go_quad_start ()

void *
go_quad_start (void);

Initializes GOQuad arithmetic. Any use of GOQuad must occur between calls to go_quad_start() and go_quad_end().

go_quad_startl ()

void *
go_quad_startl (void);

Initializes GOQuadl arithmetic. Any use of GOQuadl must occur between calls to go_quad_startl() and go_quad_endl().

go_quad_sub ()

void
go_quad_sub (GOQuad *res,
             const GOQuad *a,
             const GOQuad *b);

This function subtracts a and b , storing the result in res .

go_quad_subl ()

void
go_quad_subl (GOQuadl *res,
              const GOQuadl *a,
              const GOQuadl *b);

This function subtracts a and b , storing the result in res .

go_quad_value ()

double
go_quad_value (const GOQuad *a);

go_quad_valuel ()

long double
go_quad_valuel (const GOQuadl *a);

go_quad_acos ()

void
go_quad_acos (GOQuad *res,
              const GOQuad *a);

This function computes the arc cosine of a , storing the result in res .

go_quad_acosl ()

void
go_quad_acosl (GOQuadl *res,
               const GOQuadl *a);

This function computes the arc cosine of a , storing the result in res .

go_quad_asin ()

void
go_quad_asin (GOQuad *res,
              const GOQuad *a);

This function computes the arc sine of a , storing the result in res .

go_quad_asinl ()

void
go_quad_asinl (GOQuadl *res,
               const GOQuadl *a);

This function computes the arc sine of a , storing the result in res .

go_quad_atan2 ()

void
go_quad_atan2 (GOQuad *res,
               const GOQuad *y,
               const GOQuad *x);

This function computes polar angle coordinate of the point (x ,y ), storing the result in res .

go_quad_atan2l ()

void
go_quad_atan2l (GOQuadl *res,
                const GOQuadl *y,
                const GOQuadl *x);

This function computes polar angle coordinate of the point (x ,y ), storing the result in res .

go_quad_atan2pi ()

void
go_quad_atan2pi (GOQuad *res,
                 const GOQuad *y,
                 const GOQuad *x);

This function computes polar angle coordinate of the point (x ,y ) divided by pi, storing the result in res .

go_quad_atan2pil ()

void
go_quad_atan2pil (GOQuadl *res,
                  const GOQuadl *y,
                  const GOQuadl *x);

This function computes polar angle coordinate of the point (x ,y ) divided by pi, storing the result in res .

go_quad_constant8 ()

void
go_quad_constant8 (GOQuad *res,
                   const guint8 *data,
                   gsize n,
                   double base,
                   double scale);

This function interprets a vector of digits in a given base as a quad-precision value. It is mostly meant for internal use.

go_quad_constant8l ()

void
go_quad_constant8l (GOQuadl *res,
                    const guint8 *data,
                    gsize n,
                    long double base,
                    long double scale);

This function interprets a vector of digits in a given base as a quad-precision value. It is mostly meant for internal use.

go_quad_cos ()

void
go_quad_cos (GOQuad *res,
             const GOQuad *a);

This function computes the cosine of a , storing the result in res .

go_quad_cosl ()

void
go_quad_cosl (GOQuadl *res,
              const GOQuadl *a);

This function computes the cosine of a , storing the result in res .

go_quad_cospi ()

void
go_quad_cospi (GOQuad *res,
               const GOQuad *a);

This function computes the cosine of a times pi, storing the result in res . This is more accurate than actually doing the multiplication.

go_quad_cospil ()

void
go_quad_cospil (GOQuadl *res,
                const GOQuadl *a);

This function computes the cosine of a times pi, storing the result in res . This is more accurate than actually doing the multiplication.

go_quad_exp ()

void
go_quad_exp (GOQuad *res,
             double *exp2,
             const GOQuad *a);

This function computes the exponential function at a , storing the result in res . If the optional exp2 is supplied, it is used to return a power of 2 by which the result should be scaled. This is useful to represent results much, much bigger than double precision can handle.

go_quad_expl ()

void
go_quad_expl (GOQuadl *res,
              long double *exp2,
              const GOQuadl *a);

This function computes the exponential function at a , storing the result in res . If the optional exp2 is supplied, it is used to return a power of 2 by which the result should be scaled. This is useful to represent results much, much bigger than double precision can handle.

go_quad_expm1 ()

void
go_quad_expm1 (GOQuad *res,
               const GOQuad *a);

This function computes the exponential function at a with 1 subtracted, storing the difference in res .

go_quad_expm1l ()

void
go_quad_expm1l (GOQuadl *res,
                const GOQuadl *a);

This function computes the exponential function at a with 1 subtracted, storing the difference in res .

go_quad_floor ()

void
go_quad_floor (GOQuad *res,
               const GOQuad *a);

This function takes the floor of a , storing the result in res .

go_quad_floorl ()

void
go_quad_floorl (GOQuadl *res,
                const GOQuadl *a);

This function takes the floor of a , storing the result in res .

go_quad_hypot ()

void
go_quad_hypot (GOQuad *res,
               const GOQuad *a,
               const GOQuad *b);

This function computes the square root of a ^2 plugs b ^2, storing the result in res .

go_quad_hypotl ()

void
go_quad_hypotl (GOQuadl *res,
                const GOQuadl *a,
                const GOQuadl *b);

This function computes the square root of a ^2 plugs b ^2, storing the result in res .

go_quad_log ()

void
go_quad_log (GOQuad *res,
             const GOQuad *a);

This function computes the natural logarithm at a , storing the result in res .

go_quad_logl ()

void
go_quad_logl (GOQuadl *res,
              const GOQuadl *a);

This function computes the natural logarithm at a , storing the result in res .

go_quad_pow ()

void
go_quad_pow (GOQuad *res,
             double *exp2,
             const GOQuad *x,
             const GOQuad *y);

This function computes x to the power of y , storing the result in res . If the optional exp2 is supplied, it is used to return a power of 2 by which the result should be scaled. This is useful to represent results much, much bigger than double precision can handle.

go_quad_powl ()

void
go_quad_powl (GOQuadl *res,
              long double *exp2,
              const GOQuadl *x,
              const GOQuadl *y);

This function computes x to the power of y , storing the result in res . If the optional exp2 is supplied, it is used to return a power of 2 by which the result should be scaled. This is useful to represent results much, much bigger than double precision can handle.

go_quad_sin ()

void
go_quad_sin (GOQuad *res,
             const GOQuad *a);

This function computes the sine of a , storing the result in res .

go_quad_sinl ()

void
go_quad_sinl (GOQuadl *res,
              const GOQuadl *a);

This function computes the sine of a , storing the result in res .

go_quad_sinpi ()

void
go_quad_sinpi (GOQuad *res,
               const GOQuad *a);

This function computes the sine of a times pi, storing the result in res . This is more accurate than actually doing the multiplication.

go_quad_sinpil ()

void
go_quad_sinpil (GOQuadl *res,
                const GOQuadl *a);

This function computes the sine of a times pi, storing the result in res . This is more accurate than actually doing the multiplication.

go_sinpi ()

double
go_sinpi (double x);

go_sinpil ()

long double
go_sinpil (long double x);

go_tanpi ()

double
go_tanpi (double x);

go_tanpil ()

long double
go_tanpil (long double x);