## lustrec / include / mpfr_lustre.c @ 8d164031

History | View | Annotate | Download (6.23 KB)

1 | 66e25f0f | xthirioux | #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 | d948c0bd | ploc | |

98 | e5d77428 | ploc | ```
// 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 | 8d164031 | ploc | |

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 | d948c0bd | ploc | ```
// 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 | } |