MPSolve 3.2.1
Loading...
Searching...
No Matches
mt.h File Reference

Library with extended types in C. More...

#include <stdio.h>

Go to the source code of this file.

Classes

struct  __cplx_struct
 
struct  __rdpe_struct
 
struct  __gdpe_struct
 
struct  __cdpe_struct
 

Macros

#define MPS_USE_BUILTIN_COMPLEX
 
#define cplx_Val(X)
 
#define cplx_Re(X)
 
#define cplx_Im(X)
 
#define cplx_Addr(X)
 
#define cplx_Move(X1, X2)
 
#define cplx_init(X)
 
#define cplx_outln_str_u(F, C)
 
#define cplx_outln_str(F, C)
 
#define cplx_out_u(C)
 
#define cplx_out(C)
 
#define cplx_outln_u(C)
 
#define cplx_outln(C)
 
#define cplx_inp_u(C)
 
#define cplx_inp(C)
 
#define cplx_valloc(N)
 
#define cplx_vfree(V)
 
#define rdpe_Val(E)
 
#define rdpe_Mnt(E)
 
#define rdpe_Esp(E)
 
#define rdpe_Addr(E)
 
#define rdpe_Move(E1, E2)
 
#define rdpe_init(E)
 
#define rdpe_outln_str_u(F, E)
 
#define rdpe_outln_str(F, E)
 
#define rdpe_out_u(E)
 
#define rdpe_out(E)
 
#define rdpe_outln_u(E)
 
#define rdpe_outln(E)
 
#define rdpe_inp_u(E)
 
#define rdpe_inp(E)
 
#define rdpe_valloc(N)
 
#define rdpe_vfree(V)
 
#define gdpe_Eps(g)
 
#define gdpe_Rel(g)
 
#define gdpe_Val(g)
 
#define gdpe_update_rel_from_abs(g)
 
#define gdpe_update_abs_from_rel(g)
 
#define gdpe_eq_zero(g)
 
#define gdpe_add_eq   (g, g2) (gdpe_add ((g), (g), (g2)))
 
#define gdpe_sub_eq   (g, g2) (gdpe_sub ((g), (g), (g2)))
 
#define gdpe_mul_eq   (g, g2) (gdpe_mul ((g), (g), (g2)))
 
#define gdpe_div_eq   (g, g2) (gdpe_div ((g), (g), (g2)))
 
#define cdpe_Val(C)
 
#define cdpe_Re(C)
 
#define cdpe_Im(C)
 
#define cdpe_Addr(C)
 
#define cdpe_Move(C1, C2)
 
#define cdpe_init(C)
 
#define cdpe_outln_str_u(F, C)
 
#define cdpe_outln_str(F, C)
 
#define cdpe_out_u(C)
 
#define cdpe_out(C)
 
#define cdpe_outln_u(C)
 
#define cdpe_outln(C)
 
#define cdpe_inp_u(C)
 
#define cdpe_inp(C)
 
#define cdpe_valloc(N)
 
#define cdpe_vfree(V)
 

Typedefs

typedef __cplx_struct cplx_t[1]
 
typedef const __cplx_structcplx_cp
 
typedef __rdpe_struct rdpe_t[1]
 
typedef const __rdpe_structrdpe_cp
 
typedef __gdpe_struct gdpe_t[1]
 
typedef __cdpe_struct cdpe_t[1]
 
typedef const __cdpe_structcdpe_cp
 

Functions

void cplx_d (cplx_t temp_cplx, double r, double i)
 
void cplx_clear (cplx_t x)
 
void cplx_set (cplx_t rx, const cplx_t x)
 
void cplx_set_d (cplx_t x, double dr, double di)
 
int cplx_set_str (cplx_t x, const char *s)
 
int cplx_check_fpe (cplx_t x)
 
void cplx_get_d (double *dr, double *di, const cplx_t x)
 
char * cplx_get_str (char *s, const cplx_t x)
 
void cplx_neg (cplx_t rx, const cplx_t x)
 
void cplx_con (cplx_t rx, const cplx_t x)
 
double cplx_smod (const cplx_t x)
 
double cplx_mod (const cplx_t x)
 
void cplx_inv (cplx_t rx, const cplx_t x)
 
void cplx_sqr (cplx_t rx, const cplx_t x)
 
void cplx_rot (cplx_t rx, const cplx_t x)
 
void cplx_flip (cplx_t rx, const cplx_t x)
 
void cplx_add (cplx_t rx, const cplx_t x1, const cplx_t x2)
 
void cplx_sub (cplx_t rx, const cplx_t x1, const cplx_t x2)
 
void cplx_mul (cplx_t rx, const cplx_t x1, const cplx_t x2)
 
void cplx_div (cplx_t rx, const cplx_t x1, const cplx_t x2)
 
void cplx_mul_d (cplx_t rx, const cplx_t x, double d)
 
void cplx_div_d (cplx_t rx, const cplx_t x, double d)
 
void cplx_pow_si (cplx_t rx, const cplx_t x, signed long int i)
 
void cplx_swap (cplx_t x1, cplx_t x2)
 
void cplx_neg_eq (cplx_t x)
 
void cplx_con_eq (cplx_t x)
 
void cplx_inv_eq (cplx_t x)
 
void cplx_sqr_eq (cplx_t x)
 
void cplx_rot_eq (cplx_t x)
 
void cplx_flip_eq (cplx_t x)
 
void cplx_add_eq (cplx_t rx, const cplx_t x)
 
void cplx_sub_eq (cplx_t rx, const cplx_t x)
 
void cplx_mul_eq (cplx_t rx, const cplx_t x)
 
void cplx_div_eq (cplx_t rx, const cplx_t x)
 
void cplx_mul_eq_d (cplx_t x, double d)
 
void cplx_div_eq_d (cplx_t x, double d)
 
void cplx_pow_eq_si (cplx_t x, signed long int i)
 
int cplx_eq_zero (const cplx_t x)
 
int cplx_eq (const cplx_t x1, const cplx_t x2)
 
int cplx_ne (const cplx_t x1, const cplx_t x2)
 
int cplx_out_str_u (FILE *f, const cplx_t x)
 
int cplx_out_str (FILE *f, const cplx_t x)
 
int cplx_inp_str_u (cplx_t x, FILE *f)
 
int cplx_inp_str (cplx_t x, FILE *f)
 
void cplx_vinit (cplx_t v[], long size)
 
void rdpe_d (rdpe_t temp_rdpe, double d)
 
void rdpe_2dl (rdpe_t temp_rdpe, double d, long l)
 
void rdpe_clear (rdpe_t e)
 
void rdpe_set (rdpe_t re, const rdpe_t e)
 
void rdpe_set_d (rdpe_t e, double d)
 
void rdpe_set_dl (rdpe_t e, double d, long int l)
 
void rdpe_set_2dl (rdpe_t e, double d, long int l)
 
int rdpe_set_str (rdpe_t e, const char *s)
 
double rdpe_get_d (const rdpe_t e)
 
void rdpe_get_dl (double *d, long int *l, const rdpe_t e)
 
void rdpe_get_2dl (double *d, long int *l, const rdpe_t e)
 
char * rdpe_get_str (char *s, const rdpe_t e)
 
void rdpe_neg (rdpe_t re, const rdpe_t e)
 
void rdpe_abs (rdpe_t re, const rdpe_t e)
 
void rdpe_inv (rdpe_t re, const rdpe_t e)
 
void rdpe_sqr (rdpe_t re, const rdpe_t e)
 
void rdpe_sqrt (rdpe_t re, const rdpe_t e)
 
double rdpe_log (const rdpe_t e)
 
double rdpe_log10 (const rdpe_t e)
 
void rdpe_exp (rdpe_t re, const rdpe_t e)
 
void rdpe_add (rdpe_t re, const rdpe_t e1, const rdpe_t e2)
 
void rdpe_sub (rdpe_t re, const rdpe_t e1, const rdpe_t e2)
 
void rdpe_mul (rdpe_t re, const rdpe_t e1, const rdpe_t e2)
 
void rdpe_div (rdpe_t re, const rdpe_t e1, const rdpe_t e2)
 
void rdpe_add_d (rdpe_t re, const rdpe_t e, double d)
 
void rdpe_sub_d (rdpe_t re, const rdpe_t e, double d)
 
void rdpe_mul_d (rdpe_t re, const rdpe_t e, double d)
 
void rdpe_mul_2exp (rdpe_t re, const rdpe_t e, unsigned long int i)
 
void rdpe_div_d (rdpe_t re, const rdpe_t e, double d)
 
void rdpe_div_2exp (rdpe_t re, const rdpe_t e, unsigned long int i)
 
void rdpe_pow_d (rdpe_t re, const rdpe_t e, double d)
 
void rdpe_pow_si (rdpe_t re, const rdpe_t e, signed long int i)
 
void rdpe_fac_ui (rdpe_t e, unsigned long int n)
 
void rdpe_swap (rdpe_t e1, rdpe_t e2)
 
void rdpe_neg_eq (rdpe_t e)
 
void rdpe_abs_eq (rdpe_t e)
 
void rdpe_inv_eq (rdpe_t e)
 
void rdpe_sqr_eq (rdpe_t e)
 
void rdpe_sqrt_eq (rdpe_t e)
 
void rdpe_exp_eq (rdpe_t e)
 
void rdpe_add_eq (rdpe_t re, const rdpe_t e)
 
void rdpe_sub_eq (rdpe_t re, const rdpe_t e)
 
void rdpe_mul_eq (rdpe_t re, const rdpe_t e)
 
void rdpe_div_eq (rdpe_t re, const rdpe_t e)
 
void rdpe_add_eq_d (rdpe_t e, double d)
 
void rdpe_sub_eq_d (rdpe_t e, double d)
 
void rdpe_mul_eq_d (rdpe_t e, double d)
 
void rdpe_mul_eq_2exp (rdpe_t e, unsigned long int i)
 
void rdpe_div_eq_d (rdpe_t e, double d)
 
void rdpe_div_eq_2exp (rdpe_t e, unsigned long int i)
 
void rdpe_pow_eq_d (rdpe_t e, double d)
 
void rdpe_pow_eq_si (rdpe_t e, signed long int i)
 
int rdpe_cmp (const rdpe_t e1, const rdpe_t e2)
 
int rdpe_sgn (const rdpe_t e)
 
int rdpe_eq_zero (const rdpe_t e)
 
int rdpe_eq (const rdpe_t e1, const rdpe_t e2)
 
int rdpe_ne (const rdpe_t e1, const rdpe_t e2)
 
int rdpe_lt (const rdpe_t e1, const rdpe_t e2)
 
int rdpe_le (const rdpe_t e1, const rdpe_t e2)
 
int rdpe_gt (const rdpe_t e1, const rdpe_t e2)
 
int rdpe_ge (const rdpe_t e1, const rdpe_t e2)
 
int rdpe_out_str_u (FILE *f, const rdpe_t e)
 
int rdpe_out_str (FILE *f, const rdpe_t e)
 
int rdpe_inp_str_u (rdpe_t e, FILE *f)
 
int rdpe_inp_str (rdpe_t e, FILE *f)
 
int rdpe_inp_str_flex (rdpe_t e, FILE *f)
 
void rdpe_vinit (rdpe_t v[], long size)
 
void gdpe_add (gdpe_t res, gdpe_t g1, gdpe_t g2)
 
void gdpe_sub (gdpe_t res, gdpe_t g1, gdpe_t g2)
 
void gdpe_mul (gdpe_t res, gdpe_t g1, gdpe_t g2)
 
void gdpe_div (gdpe_t res, gdpe_t g1, gdpe_t g2)
 
void cdpe_d (cdpe_t temp_cdpe, double r, double i)
 
void cdpe_x (cdpe_t temp_cdpe, const cplx_t x)
 
void cdpe_e (cdpe_t temp_cdpe, const rdpe_t er, const rdpe_t ei)
 
void cdpe_2dl (cdpe_t temp_cdpe, double dr, long lr, double di, long li)
 
void cdpe_clear (cdpe_t c)
 
void cdpe_set (cdpe_t rc, const cdpe_t c)
 
void cdpe_set_e (cdpe_t c, const rdpe_t er, const rdpe_t ei)
 
void cdpe_set_x (cdpe_t c, const cplx_t x)
 
void cdpe_set_d (cdpe_t c, double dr, double di)
 
void cdpe_set_dl (cdpe_t c, double dr, long int lr, double di, long int li)
 
void cdpe_set_2dl (cdpe_t c, double dr, long int lr, double di, long int li)
 
int cdpe_set_str (cdpe_t c, const char *s)
 
void cdpe_get_e (rdpe_t er, rdpe_t ei, const cdpe_t c)
 
void cdpe_get_x (cplx_t x, const cdpe_t c)
 
void cdpe_get_d (double *dr, double *di, const cdpe_t c)
 
char * cdpe_get_str (char *s, const cdpe_t c)
 
void cdpe_neg (cdpe_t rc, const cdpe_t c)
 
void cdpe_con (cdpe_t rc, const cdpe_t c)
 
void cdpe_smod (rdpe_t e, const cdpe_t c)
 
void cdpe_mod (rdpe_t e, const cdpe_t c)
 
void cdpe_inv (cdpe_t rc, const cdpe_t c)
 
void cdpe_sqr (cdpe_t rc, const cdpe_t c)
 
void cdpe_rot (cdpe_t rc, const cdpe_t c)
 
void cdpe_flip (cdpe_t rc, const cdpe_t c)
 
void cdpe_add (cdpe_t rc, const cdpe_t c1, const cdpe_t c2)
 
void cdpe_sub (cdpe_t rc, const cdpe_t c1, const cdpe_t c2)
 
void cdpe_mul (cdpe_t rc, const cdpe_t c1, const cdpe_t c2)
 
void cdpe_div (cdpe_t rc, const cdpe_t c1, const cdpe_t c2)
 
void cdpe_mul_e (cdpe_t rc, const cdpe_t c, const rdpe_t e)
 
void cdpe_mul_x (cdpe_t rc, const cdpe_t c, const cplx_t x)
 
void cdpe_mul_d (cdpe_t rc, const cdpe_t c, double d)
 
void cdpe_mul_2exp (cdpe_t rc, const cdpe_t c, unsigned long int i)
 
void cdpe_div_e (cdpe_t rc, const cdpe_t c, const rdpe_t e)
 
void cdpe_div_d (cdpe_t rc, const cdpe_t c, double d)
 
void cdpe_div_2exp (cdpe_t rc, const cdpe_t c, unsigned long int i)
 
void cdpe_pow_si (cdpe_t rc, const cdpe_t c, signed long int i)
 
void cdpe_neg_eq (cdpe_t c)
 
void cdpe_con_eq (cdpe_t c)
 
void cdpe_inv_eq (cdpe_t c)
 
void cdpe_sqr_eq (cdpe_t c)
 
void cdpe_rot_eq (cdpe_t c)
 
void cdpe_flip_eq (cdpe_t c)
 
void cdpe_add_eq (cdpe_t rc, const cdpe_t c)
 
void cdpe_sub_eq (cdpe_t rc, const cdpe_t c)
 
void cdpe_mul_eq (cdpe_t rc, const cdpe_t c)
 
void cdpe_div_eq (cdpe_t rc, const cdpe_t c)
 
void cdpe_mul_eq_e (cdpe_t c, const rdpe_t e)
 
void cdpe_mul_eq_x (cdpe_t c, const cplx_t x)
 
void cdpe_mul_eq_d (cdpe_t c, double d)
 
void cdpe_mul_eq_2exp (cdpe_t c, unsigned long int i)
 
void cdpe_div_eq_e (cdpe_t c, const rdpe_t e)
 
void cdpe_div_eq_d (cdpe_t c, double d)
 
void cdpe_div_eq_2exp (cdpe_t c, unsigned long int i)
 
void cdpe_pow_eq_si (cdpe_t c, signed long int i)
 
void cdpe_swap (cdpe_t c1, cdpe_t c2)
 
int cdpe_eq_zero (const cdpe_t c)
 
int cdpe_eq (const cdpe_t c1, const cdpe_t c2)
 
int cdpe_ne (const cdpe_t c1, const cdpe_t c2)
 
int cdpe_out_str_u (FILE *f, const cdpe_t c)
 
int cdpe_out_str (FILE *f, const cdpe_t c)
 
int cdpe_inp_str_u (cdpe_t c, FILE *f)
 
int cdpe_inp_str (cdpe_t c, FILE *f)
 
void cdpe_vinit (cdpe_t v[], long size)
 

Variables

const cplx_t cplx_zero
 
const cplx_t cplx_one
 
const cplx_t cplx_i
 
const rdpe_t rdpe_zero
 
const rdpe_t rdpe_one
 
const rdpe_t rdpe_maxd
 
const rdpe_t rdpe_mind
 
const rdpe_t RDPE_MAX
 
const rdpe_t RDPE_MIN
 
const rdpe_t RDPE_BIG
 
const cdpe_t cdpe_zero
 
const cdpe_t cdpe_one
 
const cdpe_t cdpe_i
 

Detailed Description

Library with extended types in C.

It contains complex types based on double and DPE types (Double Plus Exponent) in real and complex versions.

Macro Definition Documentation

◆ cdpe_Addr

#define cdpe_Addr ( C)
Value:
Definition mt.h:390

◆ cdpe_Im

#define cdpe_Im ( C)
Value:
(C -> i)

◆ cdpe_init

#define cdpe_init ( C)
Value:
cdpe_clear(C)

◆ cdpe_inp

#define cdpe_inp ( C)
Value:
cdpe_inp_str(C, stdin)

◆ cdpe_inp_u

#define cdpe_inp_u ( C)
Value:
cdpe_inp_str_u(C, stdin)

◆ cdpe_Move

#define cdpe_Move ( C1,
C2 )
Value:
(*C1 = *C2)

◆ cdpe_out

#define cdpe_out ( C)
Value:
cdpe_out_str(stdout, C)

◆ cdpe_out_u

#define cdpe_out_u ( C)
Value:
cdpe_out_str_u(stdout, C)

◆ cdpe_outln

#define cdpe_outln ( C)
Value:
cdpe_out_str(stdout, C); putchar('\n')

◆ cdpe_outln_str

#define cdpe_outln_str ( F,
C )
Value:
cdpe_out_str(F, C); fputc('\n', F)

◆ cdpe_outln_str_u

#define cdpe_outln_str_u ( F,
C )
Value:
cdpe_out_str_u(F, C); fputc('\n', F)

◆ cdpe_outln_u

#define cdpe_outln_u ( C)
Value:
cdpe_out_str_u(stdout, C); putchar('\n')

◆ cdpe_Re

#define cdpe_Re ( C)
Value:
(C -> r)

◆ cdpe_Val

#define cdpe_Val ( C)
Value:
(*C)

◆ cdpe_valloc

#define cdpe_valloc ( N)
Value:
(cdpe_t *) malloc((N) * sizeof(cdpe_t))

◆ cdpe_vfree

#define cdpe_vfree ( V)
Value:
free(V)

◆ cplx_Addr

#define cplx_Addr ( X)
Value:
((__cplx_struct *) (X))
Definition mt.h:48

◆ cplx_Im

#define cplx_Im ( X)
Value:
((X)->i)

◆ cplx_init

#define cplx_init ( X)
Value:
cplx_clear(X)

◆ cplx_inp

#define cplx_inp ( C)
Value:
cplx_inp_str(C, stdin)

◆ cplx_inp_u

#define cplx_inp_u ( C)
Value:
cplx_inp_str_u(C, stdin)

◆ cplx_Move

#define cplx_Move ( X1,
X2 )
Value:
(*(X1) = *(X2))

◆ cplx_out

#define cplx_out ( C)
Value:
cplx_out_str(stdout, C)

◆ cplx_out_u

#define cplx_out_u ( C)
Value:
cplx_out_str_u(stdout, C)

◆ cplx_outln

#define cplx_outln ( C)
Value:
cplx_out_str(stdout, C), putchar('\n')

◆ cplx_outln_str

#define cplx_outln_str ( F,
C )
Value:
cplx_out_str(F, C), fputc('\n', F)

◆ cplx_outln_str_u

#define cplx_outln_str_u ( F,
C )
Value:
cplx_out_str_u(F, C), fputc('\n', F)

◆ cplx_outln_u

#define cplx_outln_u ( C)
Value:
cplx_out_str_u(stdout, C), putchar('\n')

◆ cplx_Re

#define cplx_Re ( X)
Value:
((X)->r)

◆ cplx_Val

#define cplx_Val ( X)
Value:
(*(X))

◆ cplx_valloc

#define cplx_valloc ( N)
Value:
(cplx_t *) malloc((N) * sizeof(cplx_t))

◆ cplx_vfree

#define cplx_vfree ( V)
Value:
free(V)

◆ gdpe_Eps

#define gdpe_Eps ( g)
Value:
((g)->eps)

◆ gdpe_eq_zero

#define gdpe_eq_zero ( g)
Value:
(rdpe_eq_zero (gdpe_Val (g)))

◆ gdpe_Rel

#define gdpe_Rel ( g)
Value:
((g)->rel_eps)

◆ gdpe_update_abs_from_rel

#define gdpe_update_abs_from_rel ( g)
Value:
(rdpe_mul (gdpe_Eps (g), gdpe_Rel (g), gdpe_Val (g)))

◆ gdpe_update_rel_from_abs

#define gdpe_update_rel_from_abs ( g)
Value:
(rdpe_div (gdpe_Rel (g), gdpe_Eps (g), gdpe_Val (g)))

◆ gdpe_Val

#define gdpe_Val ( g)
Value:
((g)->r)

◆ rdpe_Addr

#define rdpe_Addr ( E)
Value:
Definition mt.h:226

◆ rdpe_Esp

#define rdpe_Esp ( E)
Value:
(E -> e)

◆ rdpe_init

#define rdpe_init ( E)
Value:
rdpe_clear(E)

◆ rdpe_inp

#define rdpe_inp ( E)
Value:
rdpe_inp_str(e, stdin)

◆ rdpe_inp_u

#define rdpe_inp_u ( E)
Value:
rdpe_inp_str_u(e, stdin)

◆ rdpe_Mnt

#define rdpe_Mnt ( E)
Value:
(E -> m)

◆ rdpe_Move

#define rdpe_Move ( E1,
E2 )
Value:
(*E1 = *E2)

◆ rdpe_out

#define rdpe_out ( E)
Value:
rdpe_out_str(stdout, E)

◆ rdpe_out_u

#define rdpe_out_u ( E)
Value:
rdpe_out_str_u(stdout, E)

◆ rdpe_outln

#define rdpe_outln ( E)
Value:
rdpe_out_str(stdout, E); putchar('\n')

◆ rdpe_outln_str

#define rdpe_outln_str ( F,
E )
Value:
rdpe_out_str(F, E); fputc('\n', F)

◆ rdpe_outln_str_u

#define rdpe_outln_str_u ( F,
E )
Value:
rdpe_out_str_u(F, E); fputc('\n', F)

◆ rdpe_outln_u

#define rdpe_outln_u ( E)
Value:
rdpe_out_str_u(stdout, E); putchar('\n')

◆ rdpe_Val

#define rdpe_Val ( E)
Value:
(*E)

◆ rdpe_valloc

#define rdpe_valloc ( N)
Value:
(rdpe_t *) malloc((N) * sizeof(rdpe_t))

◆ rdpe_vfree

#define rdpe_vfree ( V)
Value:
free(V)