lustrec/include/mpfr_lustre.c @ 589ccf9f
1 
#include <mpfr.h>


2 
#include "mpfr_lustre.h"

3  
4 
void MPFR_LUSTRE_INIT () { 
5 
return; 
6 
}

7  
8 
void MPFR_LUSTRE_CLEAR () { 
9 
return; 
10 
}

11  
12 
void MPFRNeq_step (mpfr_t i1, mpfr_t i2, 
13 
_Bool (*out) 
14 
)

15 
{

16 
*out = mpfr_lessgreater_p(i1, i2); 
17 
}

18  
19 
void MPFREq_step (mpfr_t i1, mpfr_t i2, 
20 
_Bool (*out) 
21 
)

22 
{

23 
*out = mpfr_equal_p(i1, i2); 
24 
}

25  
26 
void MPFRGt_step (mpfr_t i1, mpfr_t i2, 
27 
_Bool (*out) 
28 
)

29 
{

30 
*out = mpfr_greater_p(i1, i2); 
31 
}

32  
33 
void MPFRGe_step (mpfr_t i1, mpfr_t i2, 
34 
_Bool (*out) 
35 
)

36 
{

37 
*out = mpfr_greaterequal_p(i1, i2); 
38 
}

39  
40 
extern void MPFRLt_step (mpfr_t i1, mpfr_t i2, 
41 
_Bool (*out) 
42 
)

43 
{

44 
*out = mpfr_less_p(i1, i2); 
45 
}

46 
void MPFRLe_step (mpfr_t i1, mpfr_t i2, 
47 
_Bool (*out) 
48 
)

49 
{

50 
*out = mpfr_lessequal_p(i1, i2); 
51 
}

52  
53 
void MPFRDiv_step (mpfr_t i1, mpfr_t i2, 
54 
mpfr_t out 
55 
)

56 
{

57 
mpfr_div(out, i1, i2, MPFR_RNDN); 
58 
}

59  
60 
void MPFRTimes_step (mpfr_t i1, mpfr_t i2, 
61 
mpfr_t out 
62 
)

63 
{

64 
mpfr_mul(out, i1, i2, MPFR_RNDN); 
65 
}

66  
67 
void MPFRMinus_step (mpfr_t i1, mpfr_t i2, 
68 
mpfr_t out 
69 
)

70 
{

71 
mpfr_sub(out, i1, i2, MPFR_RNDN); 
72 
}

73  
74 
void MPFRPlus_step (mpfr_t i1, mpfr_t i2, 
75 
mpfr_t out 
76 
)

77 
{

78 
mpfr_add(out, i1, i2, MPFR_RNDN); 
79 
}

80  
81 
void MPFRUminus_step (mpfr_t i, 
82 
mpfr_t out 
83 
)

84 
{

85 
mpfr_neg(out, i, MPFR_RNDN); 
86 
}

87  
88 
void MPFRInit(mpfr_t i, mpfr_prec_t prec) 
89 
{

90 
mpfr_init2(i, prec); 
91 
}

92  
93 
void MPFRClear(mpfr_t i) 
94 
{

95 
mpfr_clear(i); 
96 
}

97  
98 
// functions of conv

99  
100 
void MPFRint_to_real_step (int i, mpfr_t out) 
101 
{

102 
mpfr_set_si(out, i, MPFR_RNDN); 
103 
}

104  
105 
void MPFRreal_to_int_step (mpfr_t in1, int *out) 
106 
{

107 
*out = mpfr_get_sj (in1, MPFR_RNDN); 
108 
}

109  
110 
void MPFRFloor (mpfr_t in1, int *out) 
111 
{

112 
mpfr_t tmp; 
113 
int prec; 
114 
mpfr_init (tmp); // would be better to avoid local init 
115 
prec = mpfr_get_prec (in1); 
116 
mpfr_set_prec(tmp, prec); 
117  
118 
mpfr_floor(tmp, in1); 
119 
*out = mpfr_get_sj (tmp, MPFR_RNDN); 
120  
121 
mpfr_clear(tmp); 
122 
}

123  
124 
void MPFRCeiling (mpfr_t in1, int *out) 
125 
{

126 
mpfr_t tmp; 
127 
int prec; 
128 
mpfr_init (tmp); // would be better to avoid local init 
129 
prec = mpfr_get_prec (in1); 
130 
mpfr_set_prec(tmp, prec); 
131 

132 
mpfr_ceil(tmp, in1); 
133 
*out = mpfr_get_sj (tmp, MPFR_RNDN); 
134  
135 
mpfr_clear(tmp); 
136 
}

137  
138 
void MPFRRound (mpfr_t in1, int *out) 
139 
{

140 
mpfr_t tmp; 
141 
int prec; 
142 
mpfr_init (tmp); // would be better to avoid local init 
143 
prec = mpfr_get_prec (in1); 
144 
mpfr_set_prec(tmp, prec); 
145 

146 
mpfr_round(tmp, in1); 
147 
*out = mpfr_get_sj (tmp, MPFR_RNDN); 
148  
149 
mpfr_clear(tmp); 
150 
}

151  
152 
// functions of lustrec_math

153 
void MPFRacos_step (mpfr_t i, 
154 
mpfr_t out 
155 
)

156 
{

157 
mpfr_acos(out, i, MPFR_RNDN); 
158 
}

159  
160 
void MPFRacosh_step (mpfr_t i, 
161 
mpfr_t out 
162 
)

163 
{

164 
mpfr_acosh(out, i, MPFR_RNDN); 
165 
}

166 
void MPFRasin_step (mpfr_t i, 
167 
mpfr_t out 
168 
)

169 
{

170 
mpfr_asin(out, i, MPFR_RNDN); 
171 
}

172 
void MPFRasinh_step (mpfr_t i, 
173 
mpfr_t out 
174 
)

175 
{

176 
mpfr_asinh(out, i, MPFR_RNDN); 
177 
}

178 
void MPFRatan_step (mpfr_t i, 
179 
mpfr_t out 
180 
)

181 
{

182 
mpfr_atan(out, i, MPFR_RNDN); 
183 
}

184  
185 
void MPFRatan2_step (mpfr_t y, mpfr_t x, 
186 
mpfr_t out 
187 
)

188 
{

189 
mpfr_atan2(out, y, x, MPFR_RNDN); 
190 
}

191  
192 
void MPFRatanh_step (mpfr_t i, 
193 
mpfr_t out 
194 
)

195 
{

196 
mpfr_atanh(out, i, MPFR_RNDN); 
197 
}

198 
void MPFRcbrt_step (mpfr_t i, 
199 
mpfr_t out 
200 
)

201 
{

202 
mpfr_cbrt(out, i, MPFR_RNDN); 
203 
}

204  
205 
void MPFRcos_step (mpfr_t i, 
206 
mpfr_t out 
207 
)

208 
{

209 
mpfr_cos(out, i, MPFR_RNDN); 
210 
}

211  
212 
void MPFRcosh_step (mpfr_t i, 
213 
mpfr_t out 
214 
)

215 
{

216 
mpfr_cosh(out, i, MPFR_RNDN); 
217 
}

218  
219 
void MPFRceil_step (mpfr_t i, 
220 
mpfr_t out 
221 
)

222 
{

223 
mpfr_ceil(out, i); 
224 
}

225  
226 
void MPFRerf_step (mpfr_t i, 
227 
mpfr_t out 
228 
)

229 
{

230 
mpfr_erf(out, i, MPFR_RNDN); 
231 
}

232  
233 
void MPFRexp_step (mpfr_t i, 
234 
mpfr_t out 
235 
)

236 
{

237 
mpfr_exp(out, i, MPFR_RNDN); 
238 
}

239  
240 
void MPFRfabs_step (mpfr_t i, 
241 
mpfr_t out 
242 
)

243 
{

244 
mpfr_abs(out, i, MPFR_RNDN); 
245 
}

246  
247 
void MPFRfloor_step (mpfr_t i, 
248 
mpfr_t out 
249 
)

250 
{

251 
mpfr_floor(out, i); 
252 
}

253  
254 
void MPFRfmod_step (mpfr_t i1, mpfr_t i2, 
255 
mpfr_t out 
256 
)

257 
{

258 
mpfr_fmod(out, i1, i2, MPFR_RNDN); 
259 
}

260  
261 
void MPFRlog_step (mpfr_t i, 
262 
mpfr_t out 
263 
)

264 
{

265 
mpfr_log(out, i, MPFR_RNDN); 
266 
}

267  
268 
void MPFRlog10_step (mpfr_t i, 
269 
mpfr_t out 
270 
)

271 
{

272 
mpfr_log10(out, i, MPFR_RNDN); 
273 
}

274  
275 
void MPFRpow_step (mpfr_t i1, mpfr_t i2, 
276 
mpfr_t out 
277 
)

278 
{

279 
mpfr_pow(out, i1, i2, MPFR_RNDN); 
280 
}

281  
282 
void MPFRround_step (mpfr_t i, 
283 
mpfr_t out 
284 
)

285 
{

286 
mpfr_round(out, i); 
287 
}

288  
289 
void MPFRsin_step (mpfr_t i, 
290 
mpfr_t out 
291 
)

292 
{

293 
mpfr_sin(out, i, MPFR_RNDN); 
294 
}

295  
296 
void MPFRsinh_step (mpfr_t i, 
297 
mpfr_t out 
298 
)

299 
{

300 
mpfr_sinh(out, i, MPFR_RNDN); 
301 
}

302  
303 
void MPFRsqrt_step (mpfr_t i, 
304 
mpfr_t out 
305 
)

306 
{

307 
mpfr_sqrt(out, i, MPFR_RNDN); 
308 
}

309  
310 
void MPFRtrunc_step (mpfr_t i, 
311 
mpfr_t out 
312 
)

313 
{

314 
mpfr_trunc(out, i); 
315 
}

316  
317 
void MPFRtan_step (mpfr_t i, 
318 
mpfr_t out 
319 
)

320 
{

321 
mpfr_tan(out, i, MPFR_RNDN); 
322 
}
