## GOQuad GOQuad |

## Functions

void | go_quad_abs ()
void | go_quad_absl ()
void | go_quad_absD ()
void | go_quad_add ()
void | go_quad_addl ()
void | go_quad_addD ()
void | go_quad_div ()
void | go_quad_divl ()
void | go_quad_divD ()
void | go_quad_dot_product ()
void | go_quad_dot_productl ()
void | go_quad_dot_productD ()
void | go_quad_end ()
void | go_quad_endl ()
void | go_quad_endD ()
gboolean | go_quad_functional ()
gboolean | go_quad_functionall ()
gboolean | go_quad_functionalD ()
void | go_quad_init ()
void | go_quad_initl ()
void | go_quad_initD ()
void | go_quad_mul ()
void | go_quad_mull ()
void | go_quad_mulD ()
void | go_quad_mul12 ()
void | go_quad_mul12l ()
void | go_quad_mul12D ()
void | go_quad_negate ()
void | go_quad_negatel ()
void | go_quad_negateD ()
void | go_quad_scalbn ()
void | go_quad_scalbnl ()
void | go_quad_scalbnD ()
void | go_quad_sqrt ()
void | go_quad_sqrtl ()
void | go_quad_sqrtD ()
void * | go_quad_start ()
void * | go_quad_startl ()
void * | go_quad_startD ()
void | go_quad_sub ()
void | go_quad_subl ()
void | go_quad_subD ()
double | go_quad_value ()
long double | go_quad_valuel ()
_Decimal64 | go_quad_valueD ()
void | go_quad_acos ()
void | go_quad_acosl ()
void | go_quad_acosD ()
void | go_quad_asin ()
void | go_quad_asinl ()
void | go_quad_asinD ()
void | go_quad_atan2 ()
void | go_quad_atan2l ()
void | go_quad_atan2D ()
void | go_quad_atan2pi ()
void | go_quad_atan2pil ()
void | go_quad_atan2piD ()
void | go_quad_constant8 ()
void | go_quad_constant8l ()
void | go_quad_constant8D ()
void | go_quad_cos ()
void | go_quad_cosl ()
void | go_quad_cosD ()
void | go_quad_cospi ()
void | go_quad_cospil ()
void | go_quad_cospiD ()
void | go_quad_exp ()
void | go_quad_expl ()
void | go_quad_expD ()
void | go_quad_expm1 ()
void | go_quad_expm1l ()
void | go_quad_expm1D ()
void | go_quad_floor ()
void | go_quad_floorl ()
void | go_quad_floorD ()
void | go_quad_hypot ()
void | go_quad_hypotl ()
void | go_quad_hypotD ()
void | go_quad_log ()
void | go_quad_logl ()
void | go_quad_logD ()
void | go_quad_pow ()
void | go_quad_powl ()
void | go_quad_powD ()
void | go_quad_sin ()
void | go_quad_sinl ()
void | go_quad_sinD ()
void | go_quad_sinpi ()
void | go_quad_sinpil ()
void | go_quad_sinpiD ()
double | go_sinpi ()
long double | go_sinpil ()
_Decimal64 | go_sinpiD ()
double | go_tanpi ()
long double | go_tanpil ()
_Decimal64 | go_tanpiD ()

## Description

## Functions

### go_quad_abs ()

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

This function computes the absolute value of `a` , storing the result in `res` .

#### Parameters

res | result location. | [out]
a | quad-precision value |

### go_quad_absl ()

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

This function computes the absolute value of `a` , storing the result in `res` .

#### Parameters

res | result location. | [out]
a | quad-precision value |

### go_quad_absD ()

    void
    go_quad_absD (GOQuadD *res,
                  const GOQuadD *a);

This function computes the absolute value of `a` , storing the result in `res` .

#### Parameters

res | result location. | [out]
a | quad-precision value |

### 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` .

#### Parameters

res | result location. | [out]
a | quad-precision value |
b | quad-precision value |

### 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` .

#### Parameters

res | result location. | [out]
a | quad-precision value |
b | quad-precision value |

### go_quad_addD ()

    void
    go_quad_addD (GOQuadD *res,
                  const GOQuadD *a,
                  const GOQuadD *b);

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

#### Parameters

res | result location. | [out]
a | quad-precision value |
b | quad-precision value |

### 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` .

#### Parameters

res | result location. | [out]
a | quad-precision value |
b | quad-precision value |

### 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` .

#### Parameters

res | result location. | [out]
a | quad-precision value |
b | quad-precision value |

### go_quad_divD ()

    void
    go_quad_divD (GOQuadD *res,
                  const GOQuadD *a,
                  const GOQuadD *b);

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

#### Parameters

res | result location. | [out]
a | quad-precision value |
b | quad-precision value |

### go_quad_dot_product ()

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

#### Parameters

res | result location. | [out]
a | vector of quad-precision values. | [array length=n]
b | vector of quad-precision values. | [array length=n]
n | length of vectors. |

### go_quad_dot_productl ()

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

#### Parameters

res | result location. | [out]
a | vector of quad-precision values. | [array length=n]
b | vector of quad-precision values. | [array length=n]
n | length of vectors. |

### go_quad_dot_productD ()

    void
    go_quad_dot_productD (GOQuadD *res,
                          const GOQuadD *a,
                          const GOQuadD *b,
                          int n);

#### Parameters

res | result location. | [out]
a | vector of quad-precision values. | [array length=n]
b | vector of quad-precision values. | [array length=n]
n | length of vectors. |

### go_quad_end ()

    void
    go_quad_end (void *state);

This ends a section of quad precision arithmetic.

#### Parameters

state | state pointer from go_quad_start. | [transfer full]

### go_quad_endl ()

    void
    go_quad_endl (void *state);

This ends a section of quad precision arithmetic.

#### Parameters

state | state pointer from go_quad_start. | [transfer full]

### go_quad_endD ()

    void
    go_quad_endD (void *state);

This ends a section of quad precision arithmetic.

#### Parameters

state | state pointer from go_quad_start. | [transfer full]

### go_quad_functional ()

    gboolean
    go_quad_functional (void);

#### Returns

`TRUE` if GOQuad arithmetic is supported and functional.

### go_quad_functionall ()

    gboolean
    go_quad_functionall (void);

#### Returns

`TRUE` if GOQuad arithmetic is supported and functional.

### go_quad_functionalD ()

    gboolean
    go_quad_functionalD (void);

#### Returns

`TRUE` if GOQuad arithmetic is supported and functional.

### 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.

#### Parameters

res | result location. | [out]
h | a double precision value |

### 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_start and go_quad_end sections.

#### Parameters

res | result location. | [out]
h | a double precision value |

### go_quad_initD ()

    void
    go_quad_initD (GOQuadD *res,
                   _Decimal64 h);

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

#### Parameters

res | result location. | [out]
h | a double precision value |

### 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` .

#### Parameters

res | result location. | [out]
a | quad-precision value |
b | quad-precision value |

### 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` .

#### Parameters

res | result location. | [out]
a | quad-precision value |
b | quad-precision value |

### go_quad_mulD ()

    void
    go_quad_mulD (GOQuadD *res,
                  const GOQuadD *a,
                  const GOQuadD *b);

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

#### Parameters

res | result location. | [out]
a | quad-precision value |
b | quad-precision value |

### 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.

#### Parameters

res | result location. | [out]
x | double precision value |
y | double precision value |

### 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.

#### Parameters

res | result location. | [out]
x | double precision value |
y | double precision value |

### go_quad_mul12D ()

    void
    go_quad_mul12D (GOQuadD *res,
                    _Decimal64 x,
                    _Decimal64 y);

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

#### Parameters

res | result location. | [out]
x | double precision value |
y | double precision value |

### go_quad_negate ()

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

This function negates `a` and stores the result in `res` .

#### Parameters

res | result location. | [out]
a | quad-precision value |

### go_quad_negatel ()

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

This function negates `a` and stores the result in `res` .

#### Parameters

res | result location. | [out]
a | quad-precision value |

### go_quad_negateD ()

    void
    go_quad_negateD (GOQuadD *res,
                     const GOQuadD *a);

This function negates `a` and stores the result in `res` .

#### Parameters

res | result location. | [out]
a | quad-precision value |

### go_quad_scalbn ()

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

This function scales `a` by radix to the power of `n` , storing the result in `res` .

#### Parameters

res | result location. | [out]
a | quad-precision value |
n | exponent |

### go_quad_scalbnl ()

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

This function scales `a` by radix to the power of `n` , storing the result in `res` .

#### Parameters

res | result location. | [out]
a | quad-precision value |
n | exponent |

### go_quad_scalbnD ()

    void
    go_quad_scalbnD (GOQuadD *res,
                     const GOQuadD *a,
                     int n);

This function scales `a` by radix to the power of `n` , storing the result in `res` .

#### Parameters

res | result location. | [out]
a | quad-precision value |
n | exponent |

### 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` .

#### Parameters

res | result location. | [out]
a | quad-precision value |

### 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` .

#### Parameters

res | result location. | [out]
a | quad-precision value |

### go_quad_sqrtD ()

    void
    go_quad_sqrtD (GOQuadD *res,
                   const GOQuadD *a);

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

#### Parameters

res | result location. | [out]
a | quad-precision value |

### 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()`.

#### Returns

a pointer to pass to `go_quad_end()` when done.

[transfer full]

### go_quad_startl ()

    void *
    go_quad_startl (void);

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

#### Returns

a pointer to pass to `go_quad_end()` when done.

[transfer full]

### go_quad_startD ()

    void *
    go_quad_startD (void);

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

#### Returns

a pointer to pass to `go_quad_end()` when done.

[transfer full]

### 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` .

#### Parameters

res | result location. | [out]
a | quad-precision value |
b | quad-precision value |

### 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` .

#### Parameters

res | result location. | [out]
a | quad-precision value |
b | quad-precision value |

### go_quad_subD ()

    void
    go_quad_subD (GOQuadD *res,
                  const GOQuadD *a,
                  const GOQuadD *b);

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

#### Parameters

res | result location. | [out]
a | quad-precision value |
b | quad-precision value |

### go_quad_value ()

    double
    go_quad_value (const GOQuad *a);

#### Parameters

a | quad-precision value |

#### Returns

closest double precision value to `a` . As an exception, this may be called outside go_quad_start and go_quad_end sections.

### go_quad_valuel ()

    long double
    go_quad_valuel (const GOQuadl *a);

#### Parameters

a | quad-precision value |

#### Returns

closest double precision value to `a` . As an exception, this may be called outside go_quad_start and go_quad_end sections.

### go_quad_valueD ()

    _Decimal64
    go_quad_valueD (const GOQuadD *a);

#### Parameters

a | quad-precision value |

#### Returns

closest double precision value to `a` . As an exception, this may be called outside go_quad_start and go_quad_end sections.

### 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` .

#### Parameters

res | result location. | [out]
a | quad-precision value |

### 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` .

#### Parameters

res | result location. | [out]
a | quad-precision value |

### go_quad_acosD ()

    void
    go_quad_acosD (GOQuadD *res,
                   const GOQuadD *a);

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

#### Parameters

res | result location. | [out]
a | quad-precision value |

### 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` .

#### Parameters

res | result location. | [out]
a | quad-precision value |

### 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` .

#### Parameters

res | result location. | [out]
a | quad-precision value |

### go_quad_asinD ()

    void
    go_quad_asinD (GOQuadD *res,
                   const GOQuadD *a);

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

#### Parameters

res | result location. | [out]
a | quad-precision value |

### 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` .

#### Parameters

res | result location. | [out]
y | quad-precision value |
x | quad-precision value |

### 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` .

#### Parameters

res | result location. | [out]
y | quad-precision value |
x | quad-precision value |

### go_quad_atan2D ()

    void
    go_quad_atan2D (GOQuadD *res,
                    const GOQuadD *y,
                    const GOQuadD *x);

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

#### Parameters

res | result location. | [out]
y | quad-precision value |
x | quad-precision value |

### 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` .

#### Parameters

res | result location. | [out]
y | quad-precision value |
x | quad-precision value |

### 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` .

#### Parameters

res | result location. | [out]
y | quad-precision value |
x | quad-precision value |

### go_quad_atan2piD ()

    void
    go_quad_atan2piD (GOQuadD *res,
                      const GOQuadD *y,
                      const GOQuadD *x);

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

#### Parameters

res | result location. | [out]
y | quad-precision value |
x | quad-precision value |

### 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.

#### Parameters

res | result location. | [out]
data | vector of digits. | [array length=n]
base | base of vector's elements |
n | length of digit vector. |
scale | scaling value after interpreting digits |

### 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.

#### Parameters

res | result location. | [out]
data | vector of digits. | [array length=n]
base | base of vector's elements |
n | length of digit vector. |
scale | scaling value after interpreting digits |

### go_quad_constant8D ()

    void
    go_quad_constant8D (GOQuadD *res,
                        const guint8 *data,
                        gsize n,
                        _Decimal64 base,
                        _Decimal64 scale);

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

#### Parameters

res | result location. | [out]
data | vector of digits. | [array length=n]
base | base of vector's elements |
n | length of digit vector. |
scale | scaling value after interpreting digits |

### go_quad_cos ()

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

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

#### Parameters

res | result location. | [out]
a | quad-precision value |

### go_quad_cosl ()

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

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

#### Parameters

res | result location. | [out]
a | quad-precision value |

### go_quad_cosD ()

    void
    go_quad_cosD (GOQuadD *res,
                  const GOQuadD *a);

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

#### Parameters

res | result location. | [out]
a | quad-precision value |

### 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.

#### Parameters

res | result location. | [out]
a | quad-precision value |

### 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.

#### Parameters

res | result location. | [out]
a | quad-precision value |

### go_quad_cospiD ()

    void
    go_quad_cospiD (GOQuadD *res,
                    const GOQuadD *a);

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

#### Parameters

res | result location. | [out]
a | quad-precision value |

### go_quad_exp ()

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

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

#### Parameters

res | result location. | [out]
expb | (allow-none): power-of-base result scaling location. | [out]
a | quad-precision value |

### go_quad_expl ()

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

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

#### Parameters

res | result location. | [out]
expb | (allow-none): power-of-base result scaling location. | [out]
a | quad-precision value |

### go_quad_expD ()

    void
    go_quad_expD (GOQuadD *res,
                  _Decimal64 *expb,
                  const GOQuadD *a);

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

#### Parameters

res | result location. | [out]
expb | (allow-none): power-of-base result scaling location. | [out]
a | quad-precision value |

### 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` .

#### Parameters

res | result location. | [out]
a | quad-precision value |

### 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` .

#### Parameters

res | result location. | [out]
a | quad-precision value |

### go_quad_expm1D ()

    void
    go_quad_expm1D (GOQuadD *res,
                    const GOQuadD *a);

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

#### Parameters

res | result location. | [out]
a | quad-precision value |

### go_quad_floor ()

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

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

#### Parameters

res | result location. | [out]
a | quad-precision value |

### go_quad_floorl ()

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

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

#### Parameters

res | result location. | [out]
a | quad-precision value |

### go_quad_floorD ()

    void
    go_quad_floorD (GOQuadD *res,
                    const GOQuadD *a);

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

#### Parameters

res | result location. | [out]
a | quad-precision value |

### go_quad_hypot ()

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

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

#### Parameters

res | result location. | [out]
a | quad-precision value |
b | quad-precision value |

### go_quad_hypotl ()

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

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

#### Parameters

res | result location. | [out]
a | quad-precision value |
b | quad-precision value |

### go_quad_hypotD ()

    void
    go_quad_hypotD (GOQuadD *res,
                    const GOQuadD *a,
                    const GOQuadD *b);

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

#### Parameters

res | result location. | [out]
a | quad-precision value |
b | quad-precision value |

### 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` .

#### Parameters

res | result location. | [out]
a | quad-precision value |

### 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` .

#### Parameters

res | result location. | [out]
a | quad-precision value |

### go_quad_logD ()

    void
    go_quad_logD (GOQuadD *res,
                  const GOQuadD *a);

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

#### Parameters

res | result location. | [out]
a | quad-precision value |

### go_quad_pow ()

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

This function computes `x` to the power of `y` , storing the result in `res` . If the optional `expb` is supplied, it is used to return a power of radix by which the result should be scaled. Such scaling can be done with the scalbn function, typically after combining multiple such terms. This is useful to represent results much, much bigger than double precision can handle.

#### Parameters

res | result location. | [out]
expb | (allow-none): power-of-base result scaling location. | [out]
x | quad-precision value |
y | quad-precision value |

### go_quad_powl ()

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

This function computes `x` to the power of `y` , storing the result in `res` . If the optional `expb` is supplied, it is used to return a power of radix by which the result should be scaled. Such scaling can be done with the scalbn function, typically after combining multiple such terms. This is useful to represent results much, much bigger than double precision can handle.

#### Parameters

res | result location. | [out]
expb | (allow-none): power-of-base result scaling location. | [out]
x | quad-precision value |
y | quad-precision value |

### go_quad_powD ()

    void
    go_quad_powD (GOQuadD *res,
                  _Decimal64 *expb,
                  const GOQuadD *x,
                  const GOQuadD *y);

This function computes `x` to the power of `y` , storing the result in `res` . If the optional `expb` is supplied, it is used to return a power of radix by which the result should be scaled. Such scaling can be done with the scalbn function, typically after combining multiple such terms. This is useful to represent results much, much bigger than double precision can handle.

#### Parameters

res | result location. | [out]
expb | (allow-none): power-of-base result scaling location. | [out]
x | quad-precision value |
y | quad-precision value |

### go_quad_sin ()

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

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

#### Parameters

res | result location. | [out]
a | quad-precision value |

### go_quad_sinl ()

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

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

#### Parameters

res | result location. | [out]
a | quad-precision value |

### go_quad_sinD ()

    void
    go_quad_sinD (GOQuadD *res,
                  const GOQuadD *a);

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

#### Parameters

res | result location. | [out]
a | quad-precision value |

### 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.

#### Parameters

res | result location. | [out]
a | quad-precision value |

### 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.

#### Parameters

res | result location. | [out]
a | quad-precision value |

### go_quad_sinpiD ()

    void
    go_quad_sinpiD (GOQuadD *res,
                    const GOQuadD *a);

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

#### Parameters

res | result location. | [out]
a | quad-precision value |

### go_sinpi ()

    double
    go_sinpi (double x);

#### Parameters

x | a number |

#### Returns

the sine of Pi times `x` , but with less error than doing the multiplication outright.

### go_sinpil ()

    long double
    go_sinpil (long double x);

#### Parameters

x | a number |

#### Returns

the sine of Pi times `x` , but with less error than doing the multiplication outright.

### go_sinpiD ()

    _Decimal64
    go_sinpiD (_Decimal64 x);

#### Parameters

x | a number |

#### Returns

the sine of Pi times `x` , but with less error than doing the multiplication outright.

### go_tanpi ()

    double
    go_tanpi (double x);

#### Parameters

x | a number |

#### Returns

the tangent of Pi times `x` , but with less error than doing the multiplication outright.

### go_tanpil ()

    long double
    go_tanpil (long double x);

#### Parameters

x | a number |

#### Returns

the tangent of Pi times `x` , but with less error than doing the multiplication outright.

### go_tanpiD ()

    _Decimal64
    go_tanpiD (_Decimal64 x);

#### Parameters

x | a number |

#### Returns

the tangent of Pi times `x` , but with less error than doing the multiplication outright.