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

 

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_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_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 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_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_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_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 *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_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 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_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 *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_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.