## GOQuad GOQuad |

## Synopsis

    void                go_quad_add                         (GOQuad *res,
                                                             const GOQuad *a,
                                                             const GOQuad *b);
    void                go_quad_addl                        (GOQuadl *res,
                                                             const GOQuadl *a,
                                                             const GOQuadl *b);
    void                go_quad_div                         (GOQuad *res,
                                                             const GOQuad *a,
                                                             const GOQuad *b);
    void                go_quad_divl                        (GOQuadl *res,
                                                             const GOQuadl *a,
                                                             const GOQuadl *b);
    void                go_quad_dot_product                 (GOQuad *res,
                                                             const GOQuad *a,
                                                             const GOQuad *b,
                                                             int n);
    void                go_quad_dot_productl                (GOQuadl *res,
                                                             const GOQuadl *a,
                                                             const GOQuadl *b,
                                                             int n);
    void                go_quad_end                         (void *state);
    void                go_quad_endl                        (void *state);
    gboolean            go_quad_functional                  (void);
    gboolean            go_quad_functionall                 (void);
    void                go_quad_init                        (GOQuad *res,
                                                             double h);
    void                go_quad_initl                       (GOQuadl *res,
                                                             long double h);
    void                go_quad_mul                         (GOQuad *res,
                                                             const GOQuad *a,
                                                             const GOQuad *b);
    void                go_quad_mul12                       (GOQuad *res,
                                                             double x,
                                                             double y);
    void                go_quad_mul12l                      (GOQuadl *res,
                                                             long double x,
                                                             long double y);
    void                go_quad_mull                        (GOQuadl *res,
                                                             const GOQuadl *a,
                                                             const GOQuadl *b);
    void                go_quad_sqrt                        (GOQuad *res,
                                                             const GOQuad *a);
    void                go_quad_sqrtl                       (GOQuadl *res,
                                                             const GOQuadl *a);
    void *              go_quad_start                       (void);
    void *              go_quad_startl                      (void);
    void                go_quad_sub                         (GOQuad *res,
                                                             const GOQuad *a,
                                                             const GOQuad *b);
    void                go_quad_subl                        (GOQuadl *res,
                                                             const GOQuadl *a,
                                                             const GOQuadl *b);
    double              go_quad_value                       (const GOQuad *a);
    long double         go_quad_valuel                      (const GOQuadl *a);

## Description

## Details

### go_quad_add ()

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

### go_quad_addl ()

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

### go_quad_div ()

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

### go_quad_divl ()

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

### 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);

### go_quad_endl ()

    void                go_quad_endl                        (void *state);

### 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);

### go_quad_initl ()

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

### go_quad_mul ()

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

### go_quad_mul12 ()

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

### go_quad_mul12l ()

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

### go_quad_mull ()

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

### go_quad_sqrt ()

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

### go_quad_sqrtl ()

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

### go_quad_start ()

    void *              go_quad_start                       (void);

Initializes GOQuad arythmetics. 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 arythmetics. 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);

### go_quad_subl ()

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

### go_quad_value ()

    double              go_quad_value                       (const GOQuad *a);

### go_quad_valuel ()

    long double         go_quad_valuel                      (const GOQuadl *a);