1 /* glpgmp.h (bignum arithmetic) */
2 
3 /***********************************************************************
4 *  This code is part of GLPK (GNU Linear Programming Kit).
5 *
6 *  Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
7 *  2009, 2010 Andrew Makhorin, Department for Applied Informatics,
8 *  Moscow Aviation Institute, Moscow, Russia. All rights reserved.
9 *  E-mail: <mao@gnu.org>.
10 *
11 *  GLPK is free software: you can redistribute it and/or modify it
12 *  under the terms of the GNU General Public License as published by
13 *  the Free Software Foundation, either version 3 of the License, or
14 *  (at your option) any later version.
15 *
16 *  GLPK is distributed in the hope that it will be useful, but WITHOUT
17 *  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
18 *  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
19 *  License for more details.
20 *
21 *  You should have received a copy of the GNU General Public License
22 *  along with GLPK. If not, see <http://www.gnu.org/licenses/>.
23 ***********************************************************************/
24 
25 #ifndef GLPGMP_H
26 #define GLPGMP_H
27 
28 #ifdef HAVE_CONFIG_H
29 #include <config.h>
30 #endif
31 
32 #ifdef HAVE_GMP               /* use GNU MP bignum library */
33 
34 #include <gmp.h>
35 
36 #define gmp_pool_count        _glp_gmp_pool_count
37 #define gmp_free_mem          _glp_gmp_free_mem
38 
39 int gmp_pool_count(void);
40 void gmp_free_mem(void);
41 
42 #else                         /* use GLPK bignum module */
43 
44 /*----------------------------------------------------------------------
45 // INTEGER NUMBERS
46 //
47 // Depending on its magnitude an integer number of arbitrary precision
48 // is represented either in short format or in long format.
49 //
50 // Short format corresponds to the int type and allows representing
51 // integer numbers in the range [-(2^31-1), +(2^31-1)]. Note that for
52 // the most negative number of int type the short format is not used.
53 //
54 // In long format integer numbers are represented using the positional
55 // system with the base (radix) 2^16 = 65536:
56 //
57 //    x = (-1)^s sum{j in 0..n-1} d[j] * 65536^j,
58 //
59 // where x is the integer to be represented, s is its sign (+1 or -1),
60 // d[j] are its digits (0 <= d[j] <= 65535).
61 //
62 // RATIONAL NUMBERS
63 //
64 // A rational number is represented as an irreducible fraction:
65 //
66 //    p / q,
67 //
68 // where p (numerator) and q (denominator) are integer numbers (q > 0)
69 // having no common divisors. */
70 
71 struct mpz
72 {     /* integer number */
73       int val;
74       /* if ptr is a null pointer, the number is in short format, and
75          val is its value; otherwise, the number is in long format, and
76          val is its sign (+1 or -1) */
77       struct mpz_seg *ptr;
78       /* pointer to the linked list of the number segments ordered in
79          ascending of powers of the base */
80 };
81 
82 struct mpz_seg
83 {     /* integer number segment */
84       unsigned short d[6];
85       /* six digits of the number ordered in ascending of powers of the
86          base */
87       struct mpz_seg *next;
88       /* pointer to the next number segment */
89 };
90 
91 struct mpq
92 {     /* rational number (p / q) */
93       struct mpz p;
94       /* numerator */
95       struct mpz q;
96       /* denominator */
97 };
98 
99 typedef struct mpz *mpz_t;
100 typedef struct mpq *mpq_t;
101 
102 #define gmp_get_atom          _glp_gmp_get_atom
103 #define gmp_free_atom         _glp_gmp_free_atom
104 #define gmp_pool_count        _glp_gmp_pool_count
105 #define gmp_get_work          _glp_gmp_get_work
106 #define gmp_free_mem          _glp_gmp_free_mem
107 
108 #define _mpz_init             _glp_mpz_init
109 #define mpz_clear             _glp_mpz_clear
110 #define mpz_set               _glp_mpz_set
111 #define mpz_set_si            _glp_mpz_set_si
112 #define mpz_get_d             _glp_mpz_get_d
113 #define mpz_get_d_2exp        _glp_mpz_get_d_2exp
114 #define mpz_swap              _glp_mpz_swap
115 #define mpz_add               _glp_mpz_add
116 #define mpz_sub               _glp_mpz_sub
117 #define mpz_mul               _glp_mpz_mul
118 #define mpz_neg               _glp_mpz_neg
119 #define mpz_abs               _glp_mpz_abs
120 #define mpz_div               _glp_mpz_div
121 #define mpz_gcd               _glp_mpz_gcd
122 #define mpz_cmp               _glp_mpz_cmp
123 #define mpz_sgn               _glp_mpz_sgn
124 #define mpz_out_str           _glp_mpz_out_str
125 
126 #define _mpq_init             _glp_mpq_init
127 #define mpq_clear             _glp_mpq_clear
128 #define mpq_canonicalize      _glp_mpq_canonicalize
129 #define mpq_set               _glp_mpq_set
130 #define mpq_set_si            _glp_mpq_set_si
131 #define mpq_get_d             _glp_mpq_get_d
132 #define mpq_set_d             _glp_mpq_set_d
133 #define mpq_add               _glp_mpq_add
134 #define mpq_sub               _glp_mpq_sub
135 #define mpq_mul               _glp_mpq_mul
136 #define mpq_div               _glp_mpq_div
137 #define mpq_neg               _glp_mpq_neg
138 #define mpq_abs               _glp_mpq_abs
139 #define mpq_cmp               _glp_mpq_cmp
140 #define mpq_sgn               _glp_mpq_sgn
141 #define mpq_out_str           _glp_mpq_out_str
142 
143 void *gmp_get_atom(int size);
144 void gmp_free_atom(void *ptr, int size);
145 int gmp_pool_count(void);
146 unsigned short *gmp_get_work(int size);
147 void gmp_free_mem(void);
148 
149 mpz_t _mpz_init(void);
150 #define mpz_init(x) (void)((x) = _mpz_init())
151 void mpz_clear(mpz_t x);
152 void mpz_set(mpz_t z, mpz_t x);
153 void mpz_set_si(mpz_t x, int val);
154 double mpz_get_d(mpz_t x);
155 double mpz_get_d_2exp(int *exp, mpz_t x);
156 void mpz_swap(mpz_t x, mpz_t y);
157 void mpz_add(mpz_t, mpz_t, mpz_t);
158 void mpz_sub(mpz_t, mpz_t, mpz_t);
159 void mpz_mul(mpz_t, mpz_t, mpz_t);
160 void mpz_neg(mpz_t z, mpz_t x);
161 void mpz_abs(mpz_t z, mpz_t x);
162 void mpz_div(mpz_t q, mpz_t r, mpz_t x, mpz_t y);
163 void mpz_gcd(mpz_t z, mpz_t x, mpz_t y);
164 int mpz_cmp(mpz_t x, mpz_t y);
165 int mpz_sgn(mpz_t x);
166 int mpz_out_str(void *fp, int base, mpz_t x);
167 
168 mpq_t _mpq_init(void);
169 #define mpq_init(x) (void)((x) = _mpq_init())
170 void mpq_clear(mpq_t x);
171 void mpq_canonicalize(mpq_t x);
172 void mpq_set(mpq_t z, mpq_t x);
173 void mpq_set_si(mpq_t x, int p, unsigned int q);
174 double mpq_get_d(mpq_t x);
175 void mpq_set_d(mpq_t x, double val);
176 void mpq_add(mpq_t z, mpq_t x, mpq_t y);
177 void mpq_sub(mpq_t z, mpq_t x, mpq_t y);
178 void mpq_mul(mpq_t z, mpq_t x, mpq_t y);
179 void mpq_div(mpq_t z, mpq_t x, mpq_t y);
180 void mpq_neg(mpq_t z, mpq_t x);
181 void mpq_abs(mpq_t z, mpq_t x);
182 int mpq_cmp(mpq_t x, mpq_t y);
183 int mpq_sgn(mpq_t x);
184 int mpq_out_str(void *fp, int base, mpq_t x);
185 
186 #endif
187 
188 #endif
189 
190 /* eof */
191