## GOQuad

GOQuad

## Functions

void | go_quad_add ()
void | go_quad_addl ()
void | go_quad_div ()
void | go_quad_divl ()
void | go_quad_dot_product ()
void | go_quad_dot_productl ()
void | go_quad_end ()
void | go_quad_endl ()
gboolean | go_quad_functional ()
gboolean | go_quad_functionall ()
void | go_quad_init ()
void | go_quad_initl ()
void | go_quad_mul ()
void | go_quad_mul12 ()
void | go_quad_mul12l ()
void | go_quad_mull ()
void | go_quad_sqrt ()
void | go_quad_sqrtl ()
void * | go_quad_start ()
void * | go_quad_startl ()
void | go_quad_sub ()
void | go_quad_subl ()
double | go_quad_value ()
long double | go_quad_valuel ()
void | go_quad_acos ()
void | go_quad_acosl ()
void | go_quad_asin ()
void | go_quad_asinl ()
void | go_quad_atan2 ()
void | go_quad_atan2l ()
void | go_quad_atan2pi ()
void | go_quad_atan2pil ()
void | go_quad_constant8 ()
void | go_quad_constant8l ()
void | go_quad_cos ()
void | go_quad_cosl ()
void | go_quad_cospi ()
void | go_quad_cospil ()
void | go_quad_exp ()
void | go_quad_expl ()
void | go_quad_expm1 ()
void | go_quad_expm1l ()
void | go_quad_floor ()
void | go_quad_floorl ()
void | go_quad_hypot ()
void | go_quad_hypotl ()
void | go_quad_log ()
void | go_quad_logl ()
void | go_quad_pow ()
void | go_quad_powl ()
void | go_quad_sin ()
void | go_quad_sinl ()
void | go_quad_sinpi ()
void | go_quad_sinpil ()
double | go_sinpi ()
long double | go_sinpil ()
double | go_tanpi ()
long double | go_tanpil ()

## Description

## Functions

### 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_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_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_end ()

    void
    go_quad_end (void *state);

This ends a section of quad precision arithmetic.

#### Parameters

state | state pointer from go_quad_start. |

### go_quad_endl ()

    void
    go_quad_endl (void *state);

This ends a section of quad precision arithmetic.

#### Parameters

state | state pointer from go_quad_startl. |

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

#### 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_startl and go_quad_endl 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_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_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_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_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 GOQuadl arithmetic. Any use of GOQuadl must occur between calls to `go_quad_startl()` and `go_quad_endl()`.

#### Returns

a pointer to pass to `go_quad_endl()` 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_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_startl and go_quad_endl 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_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_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_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_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_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_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_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.

#### Parameters

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

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

#### Parameters

res | result location. | [out]
exp2 | (allow-none): power-of-2 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_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_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` .

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

#### Parameters

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

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

#### Parameters

res | result location. | [out]
exp2 | (allow-none): power-of-2 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_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_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_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.