]>
Commit | Line | Data |
---|---|---|
f67539c2 TL |
1 | /////////////////////////////////////////////////////////////// |
2 | // Copyright 2020 John Maddock. Distributed under the Boost | |
3 | // Software License, Version 1.0. (See accompanying file | |
4 | // LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt | |
5 | ||
6 | #ifndef BOOST_MATH_SKELETON_BACKEND_HPP | |
7 | #define BOOST_MATH_SKELETON_BACKEND_HPP | |
8 | ||
9 | #include <boost/multiprecision/number.hpp> | |
10 | #include <boost/container_hash/hash.hpp> | |
11 | ||
12 | namespace boost { | |
13 | namespace multiprecision { | |
14 | namespace backends { | |
15 | ||
16 | /* | |
17 | This header defines one type - skeleton_backend - which declares the minimal | |
18 | interface to qualify as a backend for class number. In addition you'll find | |
19 | optional interfaces declared commented out - you can enable these or not as | |
20 | needed. | |
21 | ||
22 | The process of writing a new backend for class number then reduces to a search | |
23 | and replace to change the name of this class to something meaningful, followed | |
24 | by "filling in the blanks" of each of the methods. | |
25 | ||
26 | NOTE: all of the methods shown below are simple declarations, be sure to make them | |
27 | inline, constexpr and/or noexcept as appropriate - as these annotations propogate | |
28 | upwards to operations on number<>'s. | |
29 | ||
30 | If the backend is to be itself a template, thn you will have rather more editing to | |
31 | do to add all the "template<...>" prefixes to the functions. | |
32 | ||
33 | */ | |
34 | ||
35 | ||
36 | struct skeleton_backend | |
37 | { | |
38 | // | |
39 | // Each backend need to declare 3 type lists which declare the types | |
40 | // with which this can interoperate. These lists must at least contain | |
41 | // the widest type in each category - so "long long" must be the final | |
42 | // type in the signed_types list for example. Any narrower types if not | |
43 | // present in the list will get promoted to the next wider type that is | |
44 | // in the list whenever mixed arithmetic involving that type is encountered. | |
45 | // | |
1e59de90 TL |
46 | typedef std::tuple</*signed char, short, int, long,*/ long long> signed_types; |
47 | typedef std::tuple</* unsigned char, unsigned short, unsigned, unsigned long,*/ unsigned long long> unsigned_types; | |
48 | typedef std::tuple</*float, double,*/ long double> float_types; | |
f67539c2 TL |
49 | // |
50 | // This typedef is only required if this is a floating point type, it is the type | |
51 | // which holds the exponent: | |
52 | // | |
53 | typedef int exponent_type; | |
54 | ||
55 | // We must have a default constructor: | |
56 | skeleton_backend(); | |
57 | skeleton_backend(const skeleton_backend& o); | |
f67539c2 | 58 | skeleton_backend(skeleton_backend&& o); |
f67539c2 TL |
59 | |
60 | // Optional constructors, we can make this type slightly more efficient | |
61 | // by providing constructors from any type we can handle natively. | |
62 | // These will also cause number<> to be implicitly constructible | |
63 | // from these types unless we make such constructors explicit. | |
64 | // | |
65 | // skeleton_backend(int o); // If there's an efficient initialisation from int for example. | |
66 | ||
67 | // | |
68 | // In the absense of converting constructors, operator= takes the strain. | |
69 | // In addition to the usual suspects, there must be one operator= for each type | |
70 | // listed in signed_types, unsigned_types, and float_types plus a string constructor. | |
71 | // | |
72 | skeleton_backend& operator=(const skeleton_backend& o); | |
f67539c2 | 73 | skeleton_backend& operator=(skeleton_backend&& o); |
f67539c2 TL |
74 | skeleton_backend& operator=(unsigned long long i); |
75 | skeleton_backend& operator=(long long i); | |
76 | skeleton_backend& operator=(long double i); | |
77 | skeleton_backend& operator=(const char* s); | |
78 | ||
79 | void swap(skeleton_backend& o); | |
80 | std::string str(std::streamsize digits, std::ios_base::fmtflags f) const; | |
81 | void negate(); | |
82 | int compare(const skeleton_backend& o) const; | |
83 | // | |
84 | // Comparison with arithmetic types, default just constructs a temporary: | |
85 | // | |
86 | template <class A> | |
1e59de90 | 87 | typename std::enable_if<boost::multiprecision::detail::is_arithmetic<A>::value, int>::type compare(A i) const |
f67539c2 TL |
88 | { |
89 | skeleton_backend t; | |
90 | t = i; // Note: construct directly from i if supported. | |
91 | return compare(t); | |
92 | } | |
93 | }; | |
94 | ||
95 | // | |
96 | // Required non-members: | |
97 | // | |
98 | void eval_add(skeleton_backend& a, const skeleton_backend& b); | |
99 | void eval_subtract(skeleton_backend& a, const skeleton_backend& b); | |
100 | void eval_multiply(skeleton_backend& a, const skeleton_backend& b); | |
101 | void eval_divide(skeleton_backend& a, const skeleton_backend& b); | |
102 | // | |
103 | // Required only for integer types: | |
104 | // | |
105 | void eval_modulus(skeleton_backend& a, const skeleton_backend& b); | |
106 | void eval_bitwise_and(skeleton_backend& a, const skeleton_backend& b); | |
107 | void eval_bitwise_or(skeleton_backend& a, const skeleton_backend& b); | |
108 | void eval_bitwise_xor(skeleton_backend& a, const skeleton_backend& b); | |
109 | void eval_complement(skeleton_backend& a, const skeleton_backend& b); | |
110 | void eval_left_shift(skeleton_backend& a, unsigned shift); | |
111 | void eval_right_shift(skeleton_backend& a, unsigned shift); | |
112 | // | |
113 | // Conversions: must include at least unsigned long long, long long and long double. | |
114 | // Everything else is entirely optional: | |
115 | // | |
116 | void eval_convert_to(unsigned long long* result, const skeleton_backend& backend); | |
117 | void eval_convert_to(long long* result, const skeleton_backend& backend); | |
118 | void eval_convert_to(long double* result, const skeleton_backend& backend); | |
119 | ||
120 | //void eval_convert_to(unsigned long* result, const skeleton_backend& backend); | |
121 | //void eval_convert_to(unsigned* result, const skeleton_backend& backend); | |
122 | //void eval_convert_to(unsigned short* result, const skeleton_backend& backend); | |
123 | //void eval_convert_to(unsigned char* result, const skeleton_backend& backend); | |
124 | ||
125 | //void eval_convert_to(char* result, const skeleton_backend& backend); | |
126 | ||
127 | //void eval_convert_to(long* result, const skeleton_backend& backend); | |
128 | //void eval_convert_to(int* result, const skeleton_backend& backend); | |
129 | //void eval_convert_to(short* result, const skeleton_backend& backend); | |
130 | //void eval_convert_to(signed char* result, const skeleton_backend& backend); | |
131 | ||
132 | //void eval_convert_to(double* result, const skeleton_backend& backend); | |
133 | //void eval_convert_to(float* result, const skeleton_backend& backend); | |
134 | ||
135 | // | |
136 | // Operations which are required *only* if we have a floating point type: | |
137 | // | |
138 | void eval_frexp(skeleton_backend& result, const skeleton_backend& arg, skeleton_backend::exponent_type* p_exponent); | |
139 | void eval_frexp(skeleton_backend& result, const skeleton_backend& arg, int* p_exponent); // throws a runtime_error if the exponent is too large for an int | |
140 | void eval_ldexp(skeleton_backend& result, const skeleton_backend& arg, skeleton_backend::exponent_type exponent); | |
141 | void eval_ldexp(skeleton_backend& result, const skeleton_backend& arg, int exponent); | |
142 | void eval_floor(skeleton_backend& result, const skeleton_backend& arg); | |
143 | void eval_ceil(skeleton_backend& result, const skeleton_backend& arg); | |
144 | void eval_sqrt(skeleton_backend& result, const skeleton_backend& arg); | |
145 | // | |
146 | // Operations defined *only* if we have a complex number type, type | |
147 | // skeleton_real_type is assumed to be the real number type matching | |
148 | // this type. | |
149 | // | |
150 | void eval_conj(skeleton_backend& result, const skeleton_backend& arg); | |
151 | void eval_proj(skeleton_backend& result, const skeleton_backend& arg); | |
152 | //void eval_real(skeleton_real_type& result, const skeleton_backend& arg); | |
153 | //void eval_set_real(skeleton_real_type& result, const skeleton_backend& arg); | |
154 | //void eval_imag(skeleton_real_type& result, const skeleton_backend& arg); | |
155 | //void eval_set_real(skeleton_type& result, const skeleton_real_type& arg); | |
156 | //void eval_set_imag(skeleton_type& result, const skeleton_real_type& arg); | |
157 | ||
158 | // | |
159 | // Hashing support, not strictly required, but it is used in our tests: | |
160 | // | |
161 | std::size_t hash_value(const skeleton_backend& arg); | |
162 | // | |
163 | // We're now into strictly optional requirements, everything that follows is | |
164 | // nice to have, but can be synthesised from the operators above if required. | |
165 | // Typically these operations are here to improve performance and reduce the | |
166 | // number of temporaries created. | |
167 | // | |
168 | // assign_components: required number types with 2 seperate components (rationals and complex numbers). | |
169 | // Type skeleton_component_type is whatever the corresponding backend type for the components is: | |
170 | // | |
171 | //void assign_conponents(skeleton_backend& result, skeleton_component_type const& a, skeleton_component_type const& b); | |
172 | // | |
173 | // Again for arithmetic types, overload for whatever arithmetic types are directly supported: | |
174 | // | |
175 | //void assign_conponents(skeleton_backend& result, double a, double b); | |
176 | // | |
177 | // Optional comparison operators: | |
178 | // | |
179 | #if 0 | |
180 | ||
181 | bool eval_is_zero(const skeleton_backend& arg); | |
182 | int eval_get_sign(const skeleton_backend& arg); | |
183 | ||
184 | bool eval_eq(const skeleton_backend& a, const skeleton_backend& b); | |
185 | bool eval_eq(const skeleton_backend& a, unsigned long long b); | |
186 | bool eval_eq(const skeleton_backend& a, unsigned long b); | |
187 | bool eval_eq(const skeleton_backend& a, unsigned b); | |
188 | bool eval_eq(const skeleton_backend& a, unsigned short b); | |
189 | bool eval_eq(const skeleton_backend& a, unsigned char b); | |
190 | bool eval_eq(const skeleton_backend& a, long long b); | |
191 | bool eval_eq(const skeleton_backend& a, long b); | |
192 | bool eval_eq(const skeleton_backend& a, int b); | |
193 | bool eval_eq(const skeleton_backend& a, short b); | |
194 | bool eval_eq(const skeleton_backend& a, signed char b); | |
195 | bool eval_eq(const skeleton_backend& a, char b); | |
196 | bool eval_eq(const skeleton_backend& a, long double b); | |
197 | bool eval_eq(const skeleton_backend& a, double b); | |
198 | bool eval_eq(const skeleton_backend& a, float b); | |
199 | ||
200 | bool eval_eq(unsigned long long a, const skeleton_backend& b); | |
201 | bool eval_eq(unsigned long a, const skeleton_backend& b); | |
202 | bool eval_eq(unsigned a, const skeleton_backend& b); | |
203 | bool eval_eq(unsigned short a, const skeleton_backend& b); | |
204 | bool eval_eq(unsigned char a, const skeleton_backend& b); | |
205 | bool eval_eq(long long a, const skeleton_backend& b); | |
206 | bool eval_eq(long a, const skeleton_backend& b); | |
207 | bool eval_eq(int a, const skeleton_backend& b); | |
208 | bool eval_eq(short a, const skeleton_backend& b); | |
209 | bool eval_eq(signed char a, const skeleton_backend& b); | |
210 | bool eval_eq(char a, const skeleton_backend& b); | |
211 | bool eval_eq(long double a, const skeleton_backend& b); | |
212 | bool eval_eq(double a, const skeleton_backend& b); | |
213 | bool eval_eq(float a, const skeleton_backend& b); | |
214 | ||
215 | bool eval_lt(const skeleton_backend& a, const skeleton_backend& b); | |
216 | bool eval_lt(const skeleton_backend& a, unsigned long long b); | |
217 | bool eval_lt(const skeleton_backend& a, unsigned long b); | |
218 | bool eval_lt(const skeleton_backend& a, unsigned b); | |
219 | bool eval_lt(const skeleton_backend& a, unsigned short b); | |
220 | bool eval_lt(const skeleton_backend& a, unsigned char b); | |
221 | bool eval_lt(const skeleton_backend& a, long long b); | |
222 | bool eval_lt(const skeleton_backend& a, long b); | |
223 | bool eval_lt(const skeleton_backend& a, int b); | |
224 | bool eval_lt(const skeleton_backend& a, short b); | |
225 | bool eval_lt(const skeleton_backend& a, signed char b); | |
226 | bool eval_lt(const skeleton_backend& a, char b); | |
227 | bool eval_lt(const skeleton_backend& a, long double b); | |
228 | bool eval_lt(const skeleton_backend& a, double b); | |
229 | bool eval_lt(const skeleton_backend& a, float b); | |
230 | ||
231 | bool eval_lt(unsigned long long a, const skeleton_backend& b); | |
232 | bool eval_lt(unsigned long a, const skeleton_backend& b); | |
233 | bool eval_lt(unsigned a, const skeleton_backend& b); | |
234 | bool eval_lt(unsigned short a, const skeleton_backend& b); | |
235 | bool eval_lt(unsigned char a, const skeleton_backend& b); | |
236 | bool eval_lt(long long a, const skeleton_backend& b); | |
237 | bool eval_lt(long a, const skeleton_backend& b); | |
238 | bool eval_lt(int a, const skeleton_backend& b); | |
239 | bool eval_lt(short a, const skeleton_backend& b); | |
240 | bool eval_lt(signed char a, const skeleton_backend& b); | |
241 | bool eval_lt(char a, const skeleton_backend& b); | |
242 | bool eval_lt(long double a, const skeleton_backend& b); | |
243 | bool eval_lt(double a, const skeleton_backend& b); | |
244 | bool eval_lt(float a, const skeleton_backend& b); | |
245 | ||
246 | bool eval_gt(const skeleton_backend& a, const skeleton_backend& b); | |
247 | bool eval_gt(const skeleton_backend& a, unsigned long long b); | |
248 | bool eval_gt(const skeleton_backend& a, unsigned long b); | |
249 | bool eval_gt(const skeleton_backend& a, unsigned b); | |
250 | bool eval_gt(const skeleton_backend& a, unsigned short b); | |
251 | bool eval_gt(const skeleton_backend& a, unsigned char b); | |
252 | bool eval_gt(const skeleton_backend& a, long long b); | |
253 | bool eval_gt(const skeleton_backend& a, long b); | |
254 | bool eval_gt(const skeleton_backend& a, int b); | |
255 | bool eval_gt(const skeleton_backend& a, short b); | |
256 | bool eval_gt(const skeleton_backend& a, signed char b); | |
257 | bool eval_gt(const skeleton_backend& a, char b); | |
258 | bool eval_gt(const skeleton_backend& a, long double b); | |
259 | bool eval_gt(const skeleton_backend& a, double b); | |
260 | bool eval_gt(const skeleton_backend& a, float b); | |
261 | ||
262 | bool eval_gt(unsigned long long a, const skeleton_backend& b); | |
263 | bool eval_gt(unsigned long a, const skeleton_backend& b); | |
264 | bool eval_gt(unsigned a, const skeleton_backend& b); | |
265 | bool eval_gt(unsigned short a, const skeleton_backend& b); | |
266 | bool eval_gt(unsigned char a, const skeleton_backend& b); | |
267 | bool eval_gt(long long a, const skeleton_backend& b); | |
268 | bool eval_gt(long a, const skeleton_backend& b); | |
269 | bool eval_gt(int a, const skeleton_backend& b); | |
270 | bool eval_gt(short a, const skeleton_backend& b); | |
271 | bool eval_gt(signed char a, const skeleton_backend& b); | |
272 | bool eval_gt(char a, const skeleton_backend& b); | |
273 | bool eval_gt(long double a, const skeleton_backend& b); | |
274 | bool eval_gt(double a, const skeleton_backend& b); | |
275 | bool eval_gt(float a, const skeleton_backend& b); | |
276 | #endif | |
277 | ||
278 | // | |
279 | // Arithmetic operations, starting with addition: | |
280 | // | |
281 | #if 0 | |
282 | void eval_add(skeleton_backend& result, unsigned long long arg); | |
283 | void eval_add(skeleton_backend& result, unsigned long arg); | |
284 | void eval_add(skeleton_backend& result, unsigned arg); | |
285 | void eval_add(skeleton_backend& result, unsigned short arg); | |
286 | void eval_add(skeleton_backend& result, unsigned char arg); | |
287 | void eval_add(skeleton_backend& result, char arg); | |
288 | void eval_add(skeleton_backend& result, long long arg); | |
289 | void eval_add(skeleton_backend& result, long arg); | |
290 | void eval_add(skeleton_backend& result, int arg); | |
291 | void eval_add(skeleton_backend& result, short arg); | |
292 | void eval_add(skeleton_backend& result, signed char arg); | |
293 | void eval_add(skeleton_backend& result, long double arg); | |
294 | void eval_add(skeleton_backend& result, double arg); | |
295 | void eval_add(skeleton_backend& result, float arg); | |
296 | ||
297 | void eval_add(skeleton_backend& result, const skeleton_backend& a, const skeleton_backend& b); | |
298 | void eval_add(skeleton_backend& result, const skeleton_backend& a, unsigned long long b); | |
299 | void eval_add(skeleton_backend& result, const skeleton_backend& a, unsigned long b); | |
300 | void eval_add(skeleton_backend& result, const skeleton_backend& a, unsigned b); | |
301 | void eval_add(skeleton_backend& result, const skeleton_backend& a, unsigned short b); | |
302 | void eval_add(skeleton_backend& result, const skeleton_backend& a, unsigned char b); | |
303 | void eval_add(skeleton_backend& result, const skeleton_backend& a, long long b); | |
304 | void eval_add(skeleton_backend& result, const skeleton_backend& a, long b); | |
305 | void eval_add(skeleton_backend& result, const skeleton_backend& a, int b); | |
306 | void eval_add(skeleton_backend& result, const skeleton_backend& a, short b); | |
307 | void eval_add(skeleton_backend& result, const skeleton_backend& a, signed char b); | |
308 | void eval_add(skeleton_backend& result, const skeleton_backend& a, char b); | |
309 | void eval_add(skeleton_backend& result, const skeleton_backend& a, long double b); | |
310 | void eval_add(skeleton_backend& result, const skeleton_backend& a, double b); | |
311 | void eval_add(skeleton_backend& result, const skeleton_backend& a, float b); | |
312 | ||
313 | void eval_add(skeleton_backend& result, unsigned long long b, const skeleton_backend& a); | |
314 | void eval_add(skeleton_backend& result, unsigned long b, const skeleton_backend& a); | |
315 | void eval_add(skeleton_backend& result, unsigned b, const skeleton_backend& a); | |
316 | void eval_add(skeleton_backend& result, unsigned short b, const skeleton_backend& a); | |
317 | void eval_add(skeleton_backend& result, unsigned char b, const skeleton_backend& a); | |
318 | void eval_add(skeleton_backend& result, long long b, const skeleton_backend& a); | |
319 | void eval_add(skeleton_backend& result, long b, const skeleton_backend& a); | |
320 | void eval_add(skeleton_backend& result, int b, const skeleton_backend& a); | |
321 | void eval_add(skeleton_backend& result, short b, const skeleton_backend& a); | |
322 | void eval_add(skeleton_backend& result, signed char b, const skeleton_backend& a); | |
323 | void eval_add(skeleton_backend& result, char b, const skeleton_backend& a); | |
324 | void eval_add(skeleton_backend& result, long double b, const skeleton_backend& a); | |
325 | void eval_add(skeleton_backend& result, double b, const skeleton_backend& a); | |
326 | void eval_add(skeleton_backend& result, float b, const skeleton_backend& a); | |
327 | #endif | |
328 | ||
329 | // | |
330 | // Subtraction: | |
331 | // | |
332 | #if 0 | |
333 | void eval_subtract(skeleton_backend& result, unsigned long long arg); | |
334 | void eval_subtract(skeleton_backend& result, unsigned long arg); | |
335 | void eval_subtract(skeleton_backend& result, unsigned arg); | |
336 | void eval_subtract(skeleton_backend& result, unsigned short arg); | |
337 | void eval_subtract(skeleton_backend& result, unsigned char arg); | |
338 | void eval_subtract(skeleton_backend& result, char arg); | |
339 | void eval_subtract(skeleton_backend& result, long long arg); | |
340 | void eval_subtract(skeleton_backend& result, long arg); | |
341 | void eval_subtract(skeleton_backend& result, int arg); | |
342 | void eval_subtract(skeleton_backend& result, short arg); | |
343 | void eval_subtract(skeleton_backend& result, signed char arg); | |
344 | void eval_subtract(skeleton_backend& result, long double arg); | |
345 | void eval_subtract(skeleton_backend& result, double arg); | |
346 | void eval_subtract(skeleton_backend& result, float arg); | |
347 | ||
348 | void eval_subtract(skeleton_backend& result, const skeleton_backend& a, const skeleton_backend& b); | |
349 | void eval_subtract(skeleton_backend& result, const skeleton_backend& a, unsigned long long b); | |
350 | void eval_subtract(skeleton_backend& result, const skeleton_backend& a, unsigned long b); | |
351 | void eval_subtract(skeleton_backend& result, const skeleton_backend& a, unsigned b); | |
352 | void eval_subtract(skeleton_backend& result, const skeleton_backend& a, unsigned short b); | |
353 | void eval_subtract(skeleton_backend& result, const skeleton_backend& a, unsigned char b); | |
354 | void eval_subtract(skeleton_backend& result, const skeleton_backend& a, long long b); | |
355 | void eval_subtract(skeleton_backend& result, const skeleton_backend& a, long b); | |
356 | void eval_subtract(skeleton_backend& result, const skeleton_backend& a, int b); | |
357 | void eval_subtract(skeleton_backend& result, const skeleton_backend& a, short b); | |
358 | void eval_subtract(skeleton_backend& result, const skeleton_backend& a, signed char b); | |
359 | void eval_subtract(skeleton_backend& result, const skeleton_backend& a, char b); | |
360 | void eval_subtract(skeleton_backend& result, const skeleton_backend& a, long double b); | |
361 | void eval_subtract(skeleton_backend& result, const skeleton_backend& a, double b); | |
362 | void eval_subtract(skeleton_backend& result, const skeleton_backend& a, float b); | |
363 | ||
364 | void eval_subtract(skeleton_backend& result, unsigned long long b, const skeleton_backend& a); | |
365 | void eval_subtract(skeleton_backend& result, unsigned long b, const skeleton_backend& a); | |
366 | void eval_subtract(skeleton_backend& result, unsigned b, const skeleton_backend& a); | |
367 | void eval_subtract(skeleton_backend& result, unsigned short b, const skeleton_backend& a); | |
368 | void eval_subtract(skeleton_backend& result, unsigned char b, const skeleton_backend& a); | |
369 | void eval_subtract(skeleton_backend& result, long long b, const skeleton_backend& a); | |
370 | void eval_subtract(skeleton_backend& result, long b, const skeleton_backend& a); | |
371 | void eval_subtract(skeleton_backend& result, int b, const skeleton_backend& a); | |
372 | void eval_subtract(skeleton_backend& result, short b, const skeleton_backend& a); | |
373 | void eval_subtract(skeleton_backend& result, signed char b, const skeleton_backend& a); | |
374 | void eval_subtract(skeleton_backend& result, char b, const skeleton_backend& a); | |
375 | void eval_subtract(skeleton_backend& result, long double b, const skeleton_backend& a); | |
376 | void eval_subtract(skeleton_backend& result, double b, const skeleton_backend& a); | |
377 | void eval_subtract(skeleton_backend& result, float b, const skeleton_backend& a); | |
378 | #endif | |
379 | ||
380 | // | |
381 | // Multiplication: | |
382 | // | |
383 | #if 0 | |
384 | void eval_multiply(skeleton_backend& result, unsigned long long arg); | |
385 | void eval_multiply(skeleton_backend& result, unsigned long arg); | |
386 | void eval_multiply(skeleton_backend& result, unsigned arg); | |
387 | void eval_multiply(skeleton_backend& result, unsigned short arg); | |
388 | void eval_multiply(skeleton_backend& result, unsigned char arg); | |
389 | void eval_multiply(skeleton_backend& result, char arg); | |
390 | void eval_multiply(skeleton_backend& result, long long arg); | |
391 | void eval_multiply(skeleton_backend& result, long arg); | |
392 | void eval_multiply(skeleton_backend& result, int arg); | |
393 | void eval_multiply(skeleton_backend& result, short arg); | |
394 | void eval_multiply(skeleton_backend& result, signed char arg); | |
395 | void eval_multiply(skeleton_backend& result, long double arg); | |
396 | void eval_multiply(skeleton_backend& result, double arg); | |
397 | void eval_multiply(skeleton_backend& result, float arg); | |
398 | ||
399 | void eval_multiply(skeleton_backend& result, const skeleton_backend& a, const skeleton_backend& b); | |
400 | void eval_multiply(skeleton_backend& result, const skeleton_backend& a, unsigned long long b); | |
401 | void eval_multiply(skeleton_backend& result, const skeleton_backend& a, unsigned long b); | |
402 | void eval_multiply(skeleton_backend& result, const skeleton_backend& a, unsigned b); | |
403 | void eval_multiply(skeleton_backend& result, const skeleton_backend& a, unsigned short b); | |
404 | void eval_multiply(skeleton_backend& result, const skeleton_backend& a, unsigned char b); | |
405 | void eval_multiply(skeleton_backend& result, const skeleton_backend& a, long long b); | |
406 | void eval_multiply(skeleton_backend& result, const skeleton_backend& a, long b); | |
407 | void eval_multiply(skeleton_backend& result, const skeleton_backend& a, int b); | |
408 | void eval_multiply(skeleton_backend& result, const skeleton_backend& a, short b); | |
409 | void eval_multiply(skeleton_backend& result, const skeleton_backend& a, signed char b); | |
410 | void eval_multiply(skeleton_backend& result, const skeleton_backend& a, char b); | |
411 | void eval_multiply(skeleton_backend& result, const skeleton_backend& a, long double b); | |
412 | void eval_multiply(skeleton_backend& result, const skeleton_backend& a, double b); | |
413 | void eval_multiply(skeleton_backend& result, const skeleton_backend& a, float b); | |
414 | ||
415 | void eval_multiply(skeleton_backend& result, unsigned long long b, const skeleton_backend& a); | |
416 | void eval_multiply(skeleton_backend& result, unsigned long b, const skeleton_backend& a); | |
417 | void eval_multiply(skeleton_backend& result, unsigned b, const skeleton_backend& a); | |
418 | void eval_multiply(skeleton_backend& result, unsigned short b, const skeleton_backend& a); | |
419 | void eval_multiply(skeleton_backend& result, unsigned char b, const skeleton_backend& a); | |
420 | void eval_multiply(skeleton_backend& result, long long b, const skeleton_backend& a); | |
421 | void eval_multiply(skeleton_backend& result, long b, const skeleton_backend& a); | |
422 | void eval_multiply(skeleton_backend& result, int b, const skeleton_backend& a); | |
423 | void eval_multiply(skeleton_backend& result, short b, const skeleton_backend& a); | |
424 | void eval_multiply(skeleton_backend& result, signed char b, const skeleton_backend& a); | |
425 | void eval_multiply(skeleton_backend& result, char b, const skeleton_backend& a); | |
426 | void eval_multiply(skeleton_backend& result, long double b, const skeleton_backend& a); | |
427 | void eval_multiply(skeleton_backend& result, double b, const skeleton_backend& a); | |
428 | void eval_multiply(skeleton_backend& result, float b, const skeleton_backend& a); | |
429 | #endif | |
430 | ||
431 | // | |
432 | // Division: | |
433 | // | |
434 | #if 0 | |
435 | void eval_divide(skeleton_backend& result, unsigned long long arg); | |
436 | void eval_divide(skeleton_backend& result, unsigned long arg); | |
437 | void eval_divide(skeleton_backend& result, unsigned arg); | |
438 | void eval_divide(skeleton_backend& result, unsigned short arg); | |
439 | void eval_divide(skeleton_backend& result, unsigned char arg); | |
440 | void eval_divide(skeleton_backend& result, char arg); | |
441 | void eval_divide(skeleton_backend& result, long long arg); | |
442 | void eval_divide(skeleton_backend& result, long arg); | |
443 | void eval_divide(skeleton_backend& result, int arg); | |
444 | void eval_divide(skeleton_backend& result, short arg); | |
445 | void eval_divide(skeleton_backend& result, signed char arg); | |
446 | void eval_divide(skeleton_backend& result, long double arg); | |
447 | void eval_divide(skeleton_backend& result, double arg); | |
448 | void eval_divide(skeleton_backend& result, float arg); | |
449 | ||
450 | void eval_divide(skeleton_backend& result, const skeleton_backend& a, const skeleton_backend& b); | |
451 | void eval_divide(skeleton_backend& result, const skeleton_backend& a, unsigned long long b); | |
452 | void eval_divide(skeleton_backend& result, const skeleton_backend& a, unsigned long b); | |
453 | void eval_divide(skeleton_backend& result, const skeleton_backend& a, unsigned b); | |
454 | void eval_divide(skeleton_backend& result, const skeleton_backend& a, unsigned short b); | |
455 | void eval_divide(skeleton_backend& result, const skeleton_backend& a, unsigned char b); | |
456 | void eval_divide(skeleton_backend& result, const skeleton_backend& a, long long b); | |
457 | void eval_divide(skeleton_backend& result, const skeleton_backend& a, long b); | |
458 | void eval_divide(skeleton_backend& result, const skeleton_backend& a, int b); | |
459 | void eval_divide(skeleton_backend& result, const skeleton_backend& a, short b); | |
460 | void eval_divide(skeleton_backend& result, const skeleton_backend& a, signed char b); | |
461 | void eval_divide(skeleton_backend& result, const skeleton_backend& a, char b); | |
462 | void eval_divide(skeleton_backend& result, const skeleton_backend& a, long double b); | |
463 | void eval_divide(skeleton_backend& result, const skeleton_backend& a, double b); | |
464 | void eval_divide(skeleton_backend& result, const skeleton_backend& a, float b); | |
465 | ||
466 | void eval_divide(skeleton_backend& result, unsigned long long b, const skeleton_backend& a); | |
467 | void eval_divide(skeleton_backend& result, unsigned long b, const skeleton_backend& a); | |
468 | void eval_divide(skeleton_backend& result, unsigned b, const skeleton_backend& a); | |
469 | void eval_divide(skeleton_backend& result, unsigned short b, const skeleton_backend& a); | |
470 | void eval_divide(skeleton_backend& result, unsigned char b, const skeleton_backend& a); | |
471 | void eval_divide(skeleton_backend& result, long long b, const skeleton_backend& a); | |
472 | void eval_divide(skeleton_backend& result, long b, const skeleton_backend& a); | |
473 | void eval_divide(skeleton_backend& result, int b, const skeleton_backend& a); | |
474 | void eval_divide(skeleton_backend& result, short b, const skeleton_backend& a); | |
475 | void eval_divide(skeleton_backend& result, signed char b, const skeleton_backend& a); | |
476 | void eval_divide(skeleton_backend& result, char b, const skeleton_backend& a); | |
477 | void eval_divide(skeleton_backend& result, long double b, const skeleton_backend& a); | |
478 | void eval_divide(skeleton_backend& result, double b, const skeleton_backend& a); | |
479 | void eval_divide(skeleton_backend& result, float b, const skeleton_backend& a); | |
480 | #endif | |
481 | // | |
482 | // Multiply and add/subtract as one: | |
483 | // | |
484 | #if 0 | |
485 | void eval_multiply_add(skeleton_backend& result, const skeleton_backend& a, const skeleton_backend& b); | |
486 | void eval_multiply_add(skeleton_backend& result, const skeleton_backend& a, unsigned long long b); | |
487 | void eval_multiply_add(skeleton_backend& result, const skeleton_backend& a, unsigned long b); | |
488 | void eval_multiply_add(skeleton_backend& result, const skeleton_backend& a, unsigned b); | |
489 | void eval_multiply_add(skeleton_backend& result, const skeleton_backend& a, unsigned short b); | |
490 | void eval_multiply_add(skeleton_backend& result, const skeleton_backend& a, unsigned char b); | |
491 | void eval_multiply_add(skeleton_backend& result, const skeleton_backend& a, long long b); | |
492 | void eval_multiply_add(skeleton_backend& result, const skeleton_backend& a, long b); | |
493 | void eval_multiply_add(skeleton_backend& result, const skeleton_backend& a, int b); | |
494 | void eval_multiply_add(skeleton_backend& result, const skeleton_backend& a, short b); | |
495 | void eval_multiply_add(skeleton_backend& result, const skeleton_backend& a, signed char b); | |
496 | void eval_multiply_add(skeleton_backend& result, const skeleton_backend& a, char b); | |
497 | void eval_multiply_add(skeleton_backend& result, const skeleton_backend& a, long double b); | |
498 | void eval_multiply_add(skeleton_backend& result, const skeleton_backend& a, double b); | |
499 | void eval_multiply_add(skeleton_backend& result, const skeleton_backend& a, float b); | |
500 | ||
501 | void eval_multiply_add(skeleton_backend& result, unsigned long long b, const skeleton_backend& a); | |
502 | void eval_multiply_add(skeleton_backend& result, unsigned long b, const skeleton_backend& a); | |
503 | void eval_multiply_add(skeleton_backend& result, unsigned b, const skeleton_backend& a); | |
504 | void eval_multiply_add(skeleton_backend& result, unsigned short b, const skeleton_backend& a); | |
505 | void eval_multiply_add(skeleton_backend& result, unsigned char b, const skeleton_backend& a); | |
506 | void eval_multiply_add(skeleton_backend& result, long long b, const skeleton_backend& a); | |
507 | void eval_multiply_add(skeleton_backend& result, long b, const skeleton_backend& a); | |
508 | void eval_multiply_add(skeleton_backend& result, int b, const skeleton_backend& a); | |
509 | void eval_multiply_add(skeleton_backend& result, short b, const skeleton_backend& a); | |
510 | void eval_multiply_add(skeleton_backend& result, signed char b, const skeleton_backend& a); | |
511 | void eval_multiply_add(skeleton_backend& result, char b, const skeleton_backend& a); | |
512 | void eval_multiply_add(skeleton_backend& result, long double b, const skeleton_backend& a); | |
513 | void eval_multiply_add(skeleton_backend& result, double b, const skeleton_backend& a); | |
514 | void eval_multiply_add(skeleton_backend& result, float b, const skeleton_backend& a); | |
515 | ||
516 | void eval_multiply_subtract(skeleton_backend& result, const skeleton_backend& a, const skeleton_backend& b); | |
517 | void eval_multiply_subtract(skeleton_backend& result, const skeleton_backend& a, unsigned long long b); | |
518 | void eval_multiply_subtract(skeleton_backend& result, const skeleton_backend& a, unsigned long b); | |
519 | void eval_multiply_subtract(skeleton_backend& result, const skeleton_backend& a, unsigned b); | |
520 | void eval_multiply_subtract(skeleton_backend& result, const skeleton_backend& a, unsigned short b); | |
521 | void eval_multiply_subtract(skeleton_backend& result, const skeleton_backend& a, unsigned char b); | |
522 | void eval_multiply_subtract(skeleton_backend& result, const skeleton_backend& a, long long b); | |
523 | void eval_multiply_subtract(skeleton_backend& result, const skeleton_backend& a, long b); | |
524 | void eval_multiply_subtract(skeleton_backend& result, const skeleton_backend& a, int b); | |
525 | void eval_multiply_subtract(skeleton_backend& result, const skeleton_backend& a, short b); | |
526 | void eval_multiply_subtract(skeleton_backend& result, const skeleton_backend& a, signed char b); | |
527 | void eval_multiply_subtract(skeleton_backend& result, const skeleton_backend& a, char b); | |
528 | void eval_multiply_subtract(skeleton_backend& result, const skeleton_backend& a, long double b); | |
529 | void eval_multiply_subtract(skeleton_backend& result, const skeleton_backend& a, double b); | |
530 | void eval_multiply_subtract(skeleton_backend& result, const skeleton_backend& a, float b); | |
531 | ||
532 | void eval_multiply_subtract(skeleton_backend& result, unsigned long long b, const skeleton_backend& a); | |
533 | void eval_multiply_subtract(skeleton_backend& result, unsigned long b, const skeleton_backend& a); | |
534 | void eval_multiply_subtract(skeleton_backend& result, unsigned b, const skeleton_backend& a); | |
535 | void eval_multiply_subtract(skeleton_backend& result, unsigned short b, const skeleton_backend& a); | |
536 | void eval_multiply_subtract(skeleton_backend& result, unsigned char b, const skeleton_backend& a); | |
537 | void eval_multiply_subtract(skeleton_backend& result, long long b, const skeleton_backend& a); | |
538 | void eval_multiply_subtract(skeleton_backend& result, long b, const skeleton_backend& a); | |
539 | void eval_multiply_subtract(skeleton_backend& result, int b, const skeleton_backend& a); | |
540 | void eval_multiply_subtract(skeleton_backend& result, short b, const skeleton_backend& a); | |
541 | void eval_multiply_subtract(skeleton_backend& result, signed char b, const skeleton_backend& a); | |
542 | void eval_multiply_subtract(skeleton_backend& result, char b, const skeleton_backend& a); | |
543 | void eval_multiply_subtract(skeleton_backend& result, long double b, const skeleton_backend& a); | |
544 | void eval_multiply_subtract(skeleton_backend& result, double b, const skeleton_backend& a); | |
545 | void eval_multiply_subtract(skeleton_backend& result, float b, const skeleton_backend& a); | |
546 | #endif | |
547 | // | |
548 | // Increment and decrement: | |
549 | // | |
550 | //void eval_increment(skeleton_backend& arg); | |
551 | //void eval_decrement(skeleton_backend& arg); | |
552 | // | |
553 | // abs/fabs: | |
554 | // | |
555 | // void eval_abs(skeleton_backend& result, const skeleton_backend& arg); | |
556 | // void eval_fabs(skeleton_backend& result, const skeleton_backend& arg); | |
557 | // | |
558 | ||
559 | ||
560 | // | |
561 | // Now operations on Integer types, starting with modulus: | |
562 | // | |
563 | #if 0 | |
564 | void eval_modulus(skeleton_backend& result, unsigned long long arg); | |
565 | void eval_modulus(skeleton_backend& result, unsigned long arg); | |
566 | void eval_modulus(skeleton_backend& result, unsigned arg); | |
567 | void eval_modulus(skeleton_backend& result, unsigned short arg); | |
568 | void eval_modulus(skeleton_backend& result, unsigned char arg); | |
569 | void eval_modulus(skeleton_backend& result, char arg); | |
570 | void eval_modulus(skeleton_backend& result, long long arg); | |
571 | void eval_modulus(skeleton_backend& result, long arg); | |
572 | void eval_modulus(skeleton_backend& result, int arg); | |
573 | void eval_modulus(skeleton_backend& result, short arg); | |
574 | void eval_modulus(skeleton_backend& result, signed char arg); | |
575 | void eval_modulus(skeleton_backend& result, long double arg); | |
576 | void eval_modulus(skeleton_backend& result, double arg); | |
577 | void eval_modulus(skeleton_backend& result, float arg); | |
578 | ||
579 | void eval_modulus(skeleton_backend& result, const skeleton_backend& a, const skeleton_backend& b); | |
580 | void eval_modulus(skeleton_backend& result, const skeleton_backend& a, unsigned long long b); | |
581 | void eval_modulus(skeleton_backend& result, const skeleton_backend& a, unsigned long b); | |
582 | void eval_modulus(skeleton_backend& result, const skeleton_backend& a, unsigned b); | |
583 | void eval_modulus(skeleton_backend& result, const skeleton_backend& a, unsigned short b); | |
584 | void eval_modulus(skeleton_backend& result, const skeleton_backend& a, unsigned char b); | |
585 | void eval_modulus(skeleton_backend& result, const skeleton_backend& a, long long b); | |
586 | void eval_modulus(skeleton_backend& result, const skeleton_backend& a, long b); | |
587 | void eval_modulus(skeleton_backend& result, const skeleton_backend& a, int b); | |
588 | void eval_modulus(skeleton_backend& result, const skeleton_backend& a, short b); | |
589 | void eval_modulus(skeleton_backend& result, const skeleton_backend& a, signed char b); | |
590 | void eval_modulus(skeleton_backend& result, const skeleton_backend& a, char b); | |
591 | void eval_modulus(skeleton_backend& result, const skeleton_backend& a, long double b); | |
592 | void eval_modulus(skeleton_backend& result, const skeleton_backend& a, double b); | |
593 | void eval_modulus(skeleton_backend& result, const skeleton_backend& a, float b); | |
594 | ||
595 | void eval_modulus(skeleton_backend& result, unsigned long long b, const skeleton_backend& a); | |
596 | void eval_modulus(skeleton_backend& result, unsigned long b, const skeleton_backend& a); | |
597 | void eval_modulus(skeleton_backend& result, unsigned b, const skeleton_backend& a); | |
598 | void eval_modulus(skeleton_backend& result, unsigned short b, const skeleton_backend& a); | |
599 | void eval_modulus(skeleton_backend& result, unsigned char b, const skeleton_backend& a); | |
600 | void eval_modulus(skeleton_backend& result, long long b, const skeleton_backend& a); | |
601 | void eval_modulus(skeleton_backend& result, long b, const skeleton_backend& a); | |
602 | void eval_modulus(skeleton_backend& result, int b, const skeleton_backend& a); | |
603 | void eval_modulus(skeleton_backend& result, short b, const skeleton_backend& a); | |
604 | void eval_modulus(skeleton_backend& result, signed char b, const skeleton_backend& a); | |
605 | void eval_modulus(skeleton_backend& result, char b, const skeleton_backend& a); | |
606 | void eval_modulus(skeleton_backend& result, long double b, const skeleton_backend& a); | |
607 | void eval_modulus(skeleton_backend& result, double b, const skeleton_backend& a); | |
608 | void eval_modulus(skeleton_backend& result, float b, const skeleton_backend& a); | |
609 | #endif | |
610 | // | |
611 | // bitwise AND: | |
612 | // | |
613 | #if 0 | |
614 | void eval_bitwise_and(skeleton_backend& result, unsigned long long arg); | |
615 | void eval_bitwise_and(skeleton_backend& result, unsigned long arg); | |
616 | void eval_bitwise_and(skeleton_backend& result, unsigned arg); | |
617 | void eval_bitwise_and(skeleton_backend& result, unsigned short arg); | |
618 | void eval_bitwise_and(skeleton_backend& result, unsigned char arg); | |
619 | void eval_bitwise_and(skeleton_backend& result, char arg); | |
620 | void eval_bitwise_and(skeleton_backend& result, long long arg); | |
621 | void eval_bitwise_and(skeleton_backend& result, long arg); | |
622 | void eval_bitwise_and(skeleton_backend& result, int arg); | |
623 | void eval_bitwise_and(skeleton_backend& result, short arg); | |
624 | void eval_bitwise_and(skeleton_backend& result, signed char arg); | |
625 | void eval_bitwise_and(skeleton_backend& result, long double arg); | |
626 | void eval_bitwise_and(skeleton_backend& result, double arg); | |
627 | void eval_bitwise_and(skeleton_backend& result, float arg); | |
628 | ||
629 | void eval_bitwise_and(skeleton_backend& result, const skeleton_backend& a, const skeleton_backend& b); | |
630 | void eval_bitwise_and(skeleton_backend& result, const skeleton_backend& a, unsigned long long b); | |
631 | void eval_bitwise_and(skeleton_backend& result, const skeleton_backend& a, unsigned long b); | |
632 | void eval_bitwise_and(skeleton_backend& result, const skeleton_backend& a, unsigned b); | |
633 | void eval_bitwise_and(skeleton_backend& result, const skeleton_backend& a, unsigned short b); | |
634 | void eval_bitwise_and(skeleton_backend& result, const skeleton_backend& a, unsigned char b); | |
635 | void eval_bitwise_and(skeleton_backend& result, const skeleton_backend& a, long long b); | |
636 | void eval_bitwise_and(skeleton_backend& result, const skeleton_backend& a, long b); | |
637 | void eval_bitwise_and(skeleton_backend& result, const skeleton_backend& a, int b); | |
638 | void eval_bitwise_and(skeleton_backend& result, const skeleton_backend& a, short b); | |
639 | void eval_bitwise_and(skeleton_backend& result, const skeleton_backend& a, signed char b); | |
640 | void eval_bitwise_and(skeleton_backend& result, const skeleton_backend& a, char b); | |
641 | void eval_bitwise_and(skeleton_backend& result, const skeleton_backend& a, long double b); | |
642 | void eval_bitwise_and(skeleton_backend& result, const skeleton_backend& a, double b); | |
643 | void eval_bitwise_and(skeleton_backend& result, const skeleton_backend& a, float b); | |
644 | ||
645 | void eval_bitwise_and(skeleton_backend& result, unsigned long long b, const skeleton_backend& a); | |
646 | void eval_bitwise_and(skeleton_backend& result, unsigned long b, const skeleton_backend& a); | |
647 | void eval_bitwise_and(skeleton_backend& result, unsigned b, const skeleton_backend& a); | |
648 | void eval_bitwise_and(skeleton_backend& result, unsigned short b, const skeleton_backend& a); | |
649 | void eval_bitwise_and(skeleton_backend& result, unsigned char b, const skeleton_backend& a); | |
650 | void eval_bitwise_and(skeleton_backend& result, long long b, const skeleton_backend& a); | |
651 | void eval_bitwise_and(skeleton_backend& result, long b, const skeleton_backend& a); | |
652 | void eval_bitwise_and(skeleton_backend& result, int b, const skeleton_backend& a); | |
653 | void eval_bitwise_and(skeleton_backend& result, short b, const skeleton_backend& a); | |
654 | void eval_bitwise_and(skeleton_backend& result, signed char b, const skeleton_backend& a); | |
655 | void eval_bitwise_and(skeleton_backend& result, char b, const skeleton_backend& a); | |
656 | void eval_bitwise_and(skeleton_backend& result, long double b, const skeleton_backend& a); | |
657 | void eval_bitwise_and(skeleton_backend& result, double b, const skeleton_backend& a); | |
658 | void eval_bitwise_and(skeleton_backend& result, float b, const skeleton_backend& a); | |
659 | #endif | |
660 | // | |
661 | // bitwise OR: | |
662 | // | |
663 | #if 0 | |
664 | void eval_bitwise_or(skeleton_backend& result, unsigned long long arg); | |
665 | void eval_bitwise_or(skeleton_backend& result, unsigned long arg); | |
666 | void eval_bitwise_or(skeleton_backend& result, unsigned arg); | |
667 | void eval_bitwise_or(skeleton_backend& result, unsigned short arg); | |
668 | void eval_bitwise_or(skeleton_backend& result, unsigned char arg); | |
669 | void eval_bitwise_or(skeleton_backend& result, char arg); | |
670 | void eval_bitwise_or(skeleton_backend& result, long long arg); | |
671 | void eval_bitwise_or(skeleton_backend& result, long arg); | |
672 | void eval_bitwise_or(skeleton_backend& result, int arg); | |
673 | void eval_bitwise_or(skeleton_backend& result, short arg); | |
674 | void eval_bitwise_or(skeleton_backend& result, signed char arg); | |
675 | void eval_bitwise_or(skeleton_backend& result, long double arg); | |
676 | void eval_bitwise_or(skeleton_backend& result, double arg); | |
677 | void eval_bitwise_or(skeleton_backend& result, float arg); | |
678 | ||
679 | void eval_bitwise_or(skeleton_backend& result, const skeleton_backend& a, const skeleton_backend& b); | |
680 | void eval_bitwise_or(skeleton_backend& result, const skeleton_backend& a, unsigned long long b); | |
681 | void eval_bitwise_or(skeleton_backend& result, const skeleton_backend& a, unsigned long b); | |
682 | void eval_bitwise_or(skeleton_backend& result, const skeleton_backend& a, unsigned b); | |
683 | void eval_bitwise_or(skeleton_backend& result, const skeleton_backend& a, unsigned short b); | |
684 | void eval_bitwise_or(skeleton_backend& result, const skeleton_backend& a, unsigned char b); | |
685 | void eval_bitwise_or(skeleton_backend& result, const skeleton_backend& a, long long b); | |
686 | void eval_bitwise_or(skeleton_backend& result, const skeleton_backend& a, long b); | |
687 | void eval_bitwise_or(skeleton_backend& result, const skeleton_backend& a, int b); | |
688 | void eval_bitwise_or(skeleton_backend& result, const skeleton_backend& a, short b); | |
689 | void eval_bitwise_or(skeleton_backend& result, const skeleton_backend& a, signed char b); | |
690 | void eval_bitwise_or(skeleton_backend& result, const skeleton_backend& a, char b); | |
691 | void eval_bitwise_or(skeleton_backend& result, const skeleton_backend& a, long double b); | |
692 | void eval_bitwise_or(skeleton_backend& result, const skeleton_backend& a, double b); | |
693 | void eval_bitwise_or(skeleton_backend& result, const skeleton_backend& a, float b); | |
694 | ||
695 | void eval_bitwise_or(skeleton_backend& result, unsigned long long b, const skeleton_backend& a); | |
696 | void eval_bitwise_or(skeleton_backend& result, unsigned long b, const skeleton_backend& a); | |
697 | void eval_bitwise_or(skeleton_backend& result, unsigned b, const skeleton_backend& a); | |
698 | void eval_bitwise_or(skeleton_backend& result, unsigned short b, const skeleton_backend& a); | |
699 | void eval_bitwise_or(skeleton_backend& result, unsigned char b, const skeleton_backend& a); | |
700 | void eval_bitwise_or(skeleton_backend& result, long long b, const skeleton_backend& a); | |
701 | void eval_bitwise_or(skeleton_backend& result, long b, const skeleton_backend& a); | |
702 | void eval_bitwise_or(skeleton_backend& result, int b, const skeleton_backend& a); | |
703 | void eval_bitwise_or(skeleton_backend& result, short b, const skeleton_backend& a); | |
704 | void eval_bitwise_or(skeleton_backend& result, signed char b, const skeleton_backend& a); | |
705 | void eval_bitwise_or(skeleton_backend& result, char b, const skeleton_backend& a); | |
706 | void eval_bitwise_or(skeleton_backend& result, long double b, const skeleton_backend& a); | |
707 | void eval_bitwise_or(skeleton_backend& result, double b, const skeleton_backend& a); | |
708 | void eval_bitwise_or(skeleton_backend& result, float b, const skeleton_backend& a); | |
709 | #endif | |
710 | // | |
711 | // bitwise XOR: | |
712 | // | |
713 | #if 0 | |
714 | void eval_bitwise_xor(skeleton_backend& result, unsigned long long arg); | |
715 | void eval_bitwise_xor(skeleton_backend& result, unsigned long arg); | |
716 | void eval_bitwise_xor(skeleton_backend& result, unsigned arg); | |
717 | void eval_bitwise_xor(skeleton_backend& result, unsigned short arg); | |
718 | void eval_bitwise_xor(skeleton_backend& result, unsigned char arg); | |
719 | void eval_bitwise_xor(skeleton_backend& result, char arg); | |
720 | void eval_bitwise_xor(skeleton_backend& result, long long arg); | |
721 | void eval_bitwise_xor(skeleton_backend& result, long arg); | |
722 | void eval_bitwise_xor(skeleton_backend& result, int arg); | |
723 | void eval_bitwise_xor(skeleton_backend& result, short arg); | |
724 | void eval_bitwise_xor(skeleton_backend& result, signed char arg); | |
725 | void eval_bitwise_xor(skeleton_backend& result, long double arg); | |
726 | void eval_bitwise_xor(skeleton_backend& result, double arg); | |
727 | void eval_bitwise_xor(skeleton_backend& result, float arg); | |
728 | ||
729 | void eval_bitwise_xor(skeleton_backend& result, const skeleton_backend& a, const skeleton_backend& b); | |
730 | void eval_bitwise_xor(skeleton_backend& result, const skeleton_backend& a, unsigned long long b); | |
731 | void eval_bitwise_xor(skeleton_backend& result, const skeleton_backend& a, unsigned long b); | |
732 | void eval_bitwise_xor(skeleton_backend& result, const skeleton_backend& a, unsigned b); | |
733 | void eval_bitwise_xor(skeleton_backend& result, const skeleton_backend& a, unsigned short b); | |
734 | void eval_bitwise_xor(skeleton_backend& result, const skeleton_backend& a, unsigned char b); | |
735 | void eval_bitwise_xor(skeleton_backend& result, const skeleton_backend& a, long long b); | |
736 | void eval_bitwise_xor(skeleton_backend& result, const skeleton_backend& a, long b); | |
737 | void eval_bitwise_xor(skeleton_backend& result, const skeleton_backend& a, int b); | |
738 | void eval_bitwise_xor(skeleton_backend& result, const skeleton_backend& a, short b); | |
739 | void eval_bitwise_xor(skeleton_backend& result, const skeleton_backend& a, signed char b); | |
740 | void eval_bitwise_xor(skeleton_backend& result, const skeleton_backend& a, char b); | |
741 | void eval_bitwise_xor(skeleton_backend& result, const skeleton_backend& a, long double b); | |
742 | void eval_bitwise_xor(skeleton_backend& result, const skeleton_backend& a, double b); | |
743 | void eval_bitwise_xor(skeleton_backend& result, const skeleton_backend& a, float b); | |
744 | ||
745 | void eval_bitwise_xor(skeleton_backend& result, unsigned long long b, const skeleton_backend& a); | |
746 | void eval_bitwise_xor(skeleton_backend& result, unsigned long b, const skeleton_backend& a); | |
747 | void eval_bitwise_xor(skeleton_backend& result, unsigned b, const skeleton_backend& a); | |
748 | void eval_bitwise_xor(skeleton_backend& result, unsigned short b, const skeleton_backend& a); | |
749 | void eval_bitwise_xor(skeleton_backend& result, unsigned char b, const skeleton_backend& a); | |
750 | void eval_bitwise_xor(skeleton_backend& result, long long b, const skeleton_backend& a); | |
751 | void eval_bitwise_xor(skeleton_backend& result, long b, const skeleton_backend& a); | |
752 | void eval_bitwise_xor(skeleton_backend& result, int b, const skeleton_backend& a); | |
753 | void eval_bitwise_xor(skeleton_backend& result, short b, const skeleton_backend& a); | |
754 | void eval_bitwise_xor(skeleton_backend& result, signed char b, const skeleton_backend& a); | |
755 | void eval_bitwise_xor(skeleton_backend& result, char b, const skeleton_backend& a); | |
756 | void eval_bitwise_xor(skeleton_backend& result, long double b, const skeleton_backend& a); | |
757 | void eval_bitwise_xor(skeleton_backend& result, double b, const skeleton_backend& a); | |
758 | void eval_bitwise_xor(skeleton_backend& result, float b, const skeleton_backend& a); | |
759 | #endif | |
760 | // | |
761 | // left and right shift: | |
762 | // | |
763 | //void eval_left_shift(skeleton_backend& result, const skeleton_backend& arg, std::size_t shift); | |
764 | //void eval_right_shift(skeleton_backend& result, const skeleton_backend& arg, std::size_t shift); | |
765 | // | |
766 | // Quotient and remainder: | |
767 | // | |
768 | // void eval_qr(const skeleton_backend& numerator, const skeleton_backend& denominator, skeleton_backend& quotient, skeleteon_backend& remainder); | |
769 | // | |
770 | // Misc integer ops: | |
771 | // | |
772 | // unsigned long long eval_integer_modulus(const skeleton_backend& arg, unsigned long long modulus); | |
773 | // unsigned long eval_integer_modulus(const skeleton_backend& arg, unsigned long modulus); | |
774 | // unsigned eval_integer_modulus(const skeleton_backend& arg, unsigned modulus); | |
775 | // unsigned short eval_integer_modulus(const skeleton_backend& arg, unsigned short modulus); | |
776 | // unsigned char eval_integer_modulus(const skeleton_backend& arg, unsigned char modulus); | |
777 | // | |
778 | // std::size_t eval_lsb(const skeleton_backend& arg); | |
779 | // std::size_t eval_msb(const skeleton_backend& arg); | |
780 | // bool eval_bit_test(const skeleton_backend& arg, std::size_t bit); | |
781 | // void eval_bit_set(const skeleton_backend& arg, std::size_t bit); | |
782 | // void eval_bit_unset(const skeleton_backend& arg, std::size_t bit); | |
783 | // void eval_bit_flip(const skeleton_backend& arg, std::size_t bit); | |
784 | // | |
785 | // GCD/LCD: | |
786 | // | |
787 | #if 0 | |
788 | void eval_gcd(skeleton_backend& result, const skeleton_backend& a, const skeleton_backend& b); | |
789 | void eval_gcd(skeleton_backend& result, const skeleton_backend& a, unsigned long long b); | |
790 | void eval_gcd(skeleton_backend& result, const skeleton_backend& a, unsigned long b); | |
791 | void eval_gcd(skeleton_backend& result, const skeleton_backend& a, unsigned b); | |
792 | void eval_gcd(skeleton_backend& result, const skeleton_backend& a, unsigned short b); | |
793 | void eval_gcd(skeleton_backend& result, const skeleton_backend& a, unsigned char b); | |
794 | void eval_gcd(skeleton_backend& result, const skeleton_backend& a, long long b); | |
795 | void eval_gcd(skeleton_backend& result, const skeleton_backend& a, long b); | |
796 | void eval_gcd(skeleton_backend& result, const skeleton_backend& a, int b); | |
797 | void eval_gcd(skeleton_backend& result, const skeleton_backend& a, short b); | |
798 | void eval_gcd(skeleton_backend& result, const skeleton_backend& a, signed char b); | |
799 | void eval_gcd(skeleton_backend& result, const skeleton_backend& a, char b); | |
800 | void eval_gcd(skeleton_backend& result, unsigned long long a, const skeleton_backend& b); | |
801 | void eval_gcd(skeleton_backend& result, unsigned long a, const skeleton_backend& b); | |
802 | void eval_gcd(skeleton_backend& result, unsigned a, const skeleton_backend& b); | |
803 | void eval_gcd(skeleton_backend& result, unsigned short a, const skeleton_backend& b); | |
804 | void eval_gcd(skeleton_backend& result, unsigned char a, const skeleton_backend& b); | |
805 | void eval_gcd(skeleton_backend& result, long long a, const skeleton_backend& b); | |
806 | void eval_gcd(skeleton_backend& result, long a, const skeleton_backend& b); | |
807 | void eval_gcd(skeleton_backend& result, int a, const skeleton_backend& b); | |
808 | void eval_gcd(skeleton_backend& result, short a, const skeleton_backend& b); | |
809 | void eval_gcd(skeleton_backend& result, signed char a, const skeleton_backend& b); | |
810 | void eval_gcd(skeleton_backend& result, char a, const skeleton_backend& b); | |
811 | ||
812 | void eval_lcm(skeleton_backend& result, const skeleton_backend& a, const skeleton_backend& b); | |
813 | void eval_lcm(skeleton_backend& result, const skeleton_backend& a, unsigned long long b); | |
814 | void eval_lcm(skeleton_backend& result, const skeleton_backend& a, unsigned long b); | |
815 | void eval_lcm(skeleton_backend& result, const skeleton_backend& a, unsigned b); | |
816 | void eval_lcm(skeleton_backend& result, const skeleton_backend& a, unsigned short b); | |
817 | void eval_lcm(skeleton_backend& result, const skeleton_backend& a, unsigned char b); | |
818 | void eval_lcm(skeleton_backend& result, const skeleton_backend& a, long long b); | |
819 | void eval_lcm(skeleton_backend& result, const skeleton_backend& a, long b); | |
820 | void eval_lcm(skeleton_backend& result, const skeleton_backend& a, int b); | |
821 | void eval_lcm(skeleton_backend& result, const skeleton_backend& a, short b); | |
822 | void eval_lcm(skeleton_backend& result, const skeleton_backend& a, signed char b); | |
823 | void eval_lcm(skeleton_backend& result, const skeleton_backend& a, char b); | |
824 | void eval_lcm(skeleton_backend& result, unsigned long long a, const skeleton_backend& b); | |
825 | void eval_lcm(skeleton_backend& result, unsigned long a, const skeleton_backend& b); | |
826 | void eval_lcm(skeleton_backend& result, unsigned a, const skeleton_backend& b); | |
827 | void eval_lcm(skeleton_backend& result, unsigned short a, const skeleton_backend& b); | |
828 | void eval_lcm(skeleton_backend& result, unsigned char a, const skeleton_backend& b); | |
829 | void eval_lcm(skeleton_backend& result, long long a, const skeleton_backend& b); | |
830 | void eval_lcm(skeleton_backend& result, long a, const skeleton_backend& b); | |
831 | void eval_lcm(skeleton_backend& result, int a, const skeleton_backend& b); | |
832 | void eval_lcm(skeleton_backend& result, short a, const skeleton_backend& b); | |
833 | void eval_lcm(skeleton_backend& result, signed char a, const skeleton_backend& b); | |
834 | void eval_lcm(skeleton_backend& result, char a, const skeleton_backend& b); | |
835 | #endif | |
836 | // | |
837 | // Modular exponentiation: | |
838 | // | |
839 | #if 0 | |
840 | void eval_powm(skeleton_backend& result, const skeleton_backend& a, const skeleton_backend& b, const skeleton_backend& c); // a^b % c | |
841 | void eval_powm(skeleton_backend& result, const skeleton_backend& a, const skeleton_backend& b, unsigned long long c); | |
842 | void eval_powm(skeleton_backend& result, const skeleton_backend& a, const skeleton_backend& b, unsigned long c); | |
843 | void eval_powm(skeleton_backend& result, const skeleton_backend& a, const skeleton_backend& b, unsigned c); | |
844 | void eval_powm(skeleton_backend& result, const skeleton_backend& a, const skeleton_backend& b, unsigned short c); | |
845 | void eval_powm(skeleton_backend& result, const skeleton_backend& a, const skeleton_backend& b, unsigned char c); | |
846 | void eval_powm(skeleton_backend& result, const skeleton_backend& a, const skeleton_backend& b, long long c); | |
847 | void eval_powm(skeleton_backend& result, const skeleton_backend& a, const skeleton_backend& b, long c); | |
848 | void eval_powm(skeleton_backend& result, const skeleton_backend& a, const skeleton_backend& b, int c); | |
849 | void eval_powm(skeleton_backend& result, const skeleton_backend& a, const skeleton_backend& b, short c); | |
850 | void eval_powm(skeleton_backend& result, const skeleton_backend& a, const skeleton_backend& b, signed char c); | |
851 | ||
852 | void eval_powm(skeleton_backend& result, const skeleton_backend& a, unsigned long long b, const skeleton_backend& c); | |
853 | void eval_powm(skeleton_backend& result, const skeleton_backend& a, unsigned long b, const skeleton_backend& c); | |
854 | void eval_powm(skeleton_backend& result, const skeleton_backend& a, unsigned b, const skeleton_backend& c); | |
855 | void eval_powm(skeleton_backend& result, const skeleton_backend& a, unsigned short b, const skeleton_backend& c); | |
856 | void eval_powm(skeleton_backend& result, const skeleton_backend& a, unsigned char b, const skeleton_backend& c); | |
857 | void eval_powm(skeleton_backend& result, const skeleton_backend& a, long long b, const skeleton_backend& c); | |
858 | void eval_powm(skeleton_backend& result, const skeleton_backend& a, long b, const skeleton_backend& c); | |
859 | void eval_powm(skeleton_backend& result, const skeleton_backend& a, int b, const skeleton_backend& c); | |
860 | void eval_powm(skeleton_backend& result, const skeleton_backend& a, short b, const skeleton_backend& c); | |
861 | void eval_powm(skeleton_backend& result, const skeleton_backend& a, signed char b, const skeleton_backend& c); | |
862 | ||
863 | void eval_powm(skeleton_backend& result, const skeleton_backend& a, unsigned long long b, unsigned long long c); | |
864 | void eval_powm(skeleton_backend& result, const skeleton_backend& a, unsigned long b, unsigned long c); | |
865 | void eval_powm(skeleton_backend& result, const skeleton_backend& a, unsigned b, unsigned c); | |
866 | void eval_powm(skeleton_backend& result, const skeleton_backend& a, unsigned short b, unsigned short c); | |
867 | void eval_powm(skeleton_backend& result, const skeleton_backend& a, unsigned char b, unsigned char c); | |
868 | void eval_powm(skeleton_backend& result, const skeleton_backend& a, long long b, long long c); | |
869 | void eval_powm(skeleton_backend& result, const skeleton_backend& a, long b, long c); | |
870 | void eval_powm(skeleton_backend& result, const skeleton_backend& a, int b, int c); | |
871 | void eval_powm(skeleton_backend& result, const skeleton_backend& a, short b, short c); | |
872 | void eval_powm(skeleton_backend& result, const skeleton_backend& a, signed char b, signed char c); | |
873 | #endif | |
874 | // | |
875 | // Integer sqrt: | |
876 | // | |
877 | // void eval_integer_sqrt(skeleton_backend& result, const skeleton_backend& arg, skeleton_backend& remainder); | |
878 | ||
879 | /********************************************************************************************* | |
880 | ||
881 | FLOATING POINT FUNCTIONS | |
882 | ||
883 | ***********************************************************************************************/ | |
884 | ||
885 | #if 0 | |
886 | ||
887 | int eval_fpclassify(const skeleton_backend& arg); | |
888 | void eval_trunc(skeleton_backend& result, const skeleton_backend& arg); | |
889 | void eval_round(skeleton_backend& result, const skeleton_backend& arg); | |
890 | void eval_exp(skeleton_backend& result, const skeleton_backend& arg); | |
891 | void eval_exp2(skeleton_backend& result, const skeleton_backend& arg); | |
892 | void eval_log(skeleton_backend& result, const skeleton_backend& arg); | |
893 | void eval_log10(skeleton_backend& result, const skeleton_backend& arg); | |
894 | void eval_sin(skeleton_backend& result, const skeleton_backend& arg); | |
895 | void eval_cos(skeleton_backend& result, const skeleton_backend& arg); | |
896 | void eval_tan(skeleton_backend& result, const skeleton_backend& arg); | |
897 | void eval_asin(skeleton_backend& result, const skeleton_backend& arg); | |
898 | void eval_acos(skeleton_backend& result, const skeleton_backend& arg); | |
899 | void eval_atan(skeleton_backend& result, const skeleton_backend& arg); | |
900 | void eval_sinh(skeleton_backend& result, const skeleton_backend& arg); | |
901 | void eval_cosh(skeleton_backend& result, const skeleton_backend& arg); | |
902 | void eval_tanh(skeleton_backend& result, const skeleton_backend& arg); | |
903 | void eval_asinh(skeleton_backend& result, const skeleton_backend& arg); | |
904 | void eval_acosh(skeleton_backend& result, const skeleton_backend& arg); | |
905 | void eval_atanh(skeleton_backend& result, const skeleton_backend& arg); | |
906 | void eval_fmod(skeleton_backend& result, const skeleton_backend& a, const skeleton_backend& b); | |
907 | void eval_modf(skeleton_backend& result, const skeleton_backend& a, const skeleton_backend& b); | |
908 | void eval_pow(skeleton_backend& result, const skeleton_backend& a, const skeleton_backend& b); | |
909 | void eval_atan2(skeleton_backend& result, const skeleton_backend& a, const skeleton_backend& b); | |
910 | void eval_scalbn(skeleton_backend& result, const skeleton_backend& arg, skeleton_backend::exponent_type e); | |
911 | void eval_scalbln(skeleton_backend& result, const skeleton_backend& arg, skeleton_backend::exponent_type e); | |
912 | skeleton_type::exponent_type eval_ilogb(const skeleton_backend& arg); | |
913 | ||
914 | void eval_remquo(skeleton_backend& result, const skeleton_backend& a, const skeleton_backend& b, int* p_n); | |
915 | void eval_remquo(skeleton_backend& result, const skeleton_backend& a, unsigned long long b, int* p_n); | |
916 | void eval_remquo(skeleton_backend& result, const skeleton_backend& a, unsigned long b, int* p_n); | |
917 | void eval_remquo(skeleton_backend& result, const skeleton_backend& a, unsigned b, int* p_n); | |
918 | void eval_remquo(skeleton_backend& result, const skeleton_backend& a, unsigned short b, int* p_n); | |
919 | void eval_remquo(skeleton_backend& result, const skeleton_backend& a, unsigned char b, int* p_n); | |
920 | void eval_remquo(skeleton_backend& result, const skeleton_backend& a, long long b, int* p_n); | |
921 | void eval_remquo(skeleton_backend& result, const skeleton_backend& a, long b, int* p_n); | |
922 | void eval_remquo(skeleton_backend& result, const skeleton_backend& a, int b, int* p_n); | |
923 | void eval_remquo(skeleton_backend& result, const skeleton_backend& a, short b, int* p_n); | |
924 | void eval_remquo(skeleton_backend& result, const skeleton_backend& a, signed char b, int* p_n); | |
925 | void eval_remquo(skeleton_backend& result, const skeleton_backend& a, long double b, int* p_n); | |
926 | void eval_remquo(skeleton_backend& result, const skeleton_backend& a, double b, int* p_n); | |
927 | void eval_remquo(skeleton_backend& result, const skeleton_backend& a, float b, int* p_n); | |
928 | void eval_remquo(skeleton_backend& result, unsigned long long a, const skeleton_backend& b, int* p_n); | |
929 | void eval_remquo(skeleton_backend& result, unsigned long a, const skeleton_backend& b, int* p_n); | |
930 | void eval_remquo(skeleton_backend& result, unsigned a, const skeleton_backend& b, int* p_n); | |
931 | void eval_remquo(skeleton_backend& result, unsigned short a, const skeleton_backend& b, int* p_n); | |
932 | void eval_remquo(skeleton_backend& result, unsigned char a, const skeleton_backend& b, int* p_n); | |
933 | void eval_remquo(skeleton_backend& result, long long a, const skeleton_backend& b, int* p_n); | |
934 | void eval_remquo(skeleton_backend& result, long a, const skeleton_backend& b, int* p_n); | |
935 | void eval_remquo(skeleton_backend& result, int a, const skeleton_backend& b, int* p_n); | |
936 | void eval_remquo(skeleton_backend& result, short a, const skeleton_backend& b, int* p_n); | |
937 | void eval_remquo(skeleton_backend& result, signed char a, const skeleton_backend& b, int* p_n); | |
938 | ||
939 | void eval_remainder(skeleton_backend& result, const skeleton_backend& a, const skeleton_backend& b); | |
940 | void eval_remainder(skeleton_backend& result, const skeleton_backend& a, unsigned long long b); | |
941 | void eval_remainder(skeleton_backend& result, const skeleton_backend& a, unsigned long b); | |
942 | void eval_remainder(skeleton_backend& result, const skeleton_backend& a, unsigned b); | |
943 | void eval_remainder(skeleton_backend& result, const skeleton_backend& a, unsigned short b); | |
944 | void eval_remainder(skeleton_backend& result, const skeleton_backend& a, unsigned char b); | |
945 | void eval_remainder(skeleton_backend& result, const skeleton_backend& a, long long b); | |
946 | void eval_remainder(skeleton_backend& result, const skeleton_backend& a, long b); | |
947 | void eval_remainder(skeleton_backend& result, const skeleton_backend& a, int b); | |
948 | void eval_remainder(skeleton_backend& result, const skeleton_backend& a, short b); | |
949 | void eval_remainder(skeleton_backend& result, const skeleton_backend& a, signed char b); | |
950 | void eval_remainder(skeleton_backend& result, const skeleton_backend& a, long double b); | |
951 | void eval_remainder(skeleton_backend& result, const skeleton_backend& a, double b); | |
952 | void eval_remainder(skeleton_backend& result, const skeleton_backend& a, float b); | |
953 | void eval_remainder(skeleton_backend& result, unsigned long long a, const skeleton_backend& b); | |
954 | void eval_remainder(skeleton_backend& result, unsigned long a, const skeleton_backend& b); | |
955 | void eval_remainder(skeleton_backend& result, unsigned a, const skeleton_backend& b); | |
956 | void eval_remainder(skeleton_backend& result, unsigned short a, const skeleton_backend& b); | |
957 | void eval_remainder(skeleton_backend& result, unsigned char a, const skeleton_backend& b); | |
958 | void eval_remainder(skeleton_backend& result, long long a, const skeleton_backend& b); | |
959 | void eval_remainder(skeleton_backend& result, long a, const skeleton_backend& b); | |
960 | void eval_remainder(skeleton_backend& result, int a, const skeleton_backend& b); | |
961 | void eval_remainder(skeleton_backend& result, short a, const skeleton_backend& b); | |
962 | void eval_remainder(skeleton_backend& result, signed char a, const skeleton_backend& b); | |
963 | ||
964 | void eval_fdim(skeleton_backend& result, const skeleton_backend& a, const skeleton_backend& b); | |
965 | void eval_fdim(skeleton_backend& result, const skeleton_backend& a, unsigned long long b); | |
966 | void eval_fdim(skeleton_backend& result, const skeleton_backend& a, unsigned long b); | |
967 | void eval_fdim(skeleton_backend& result, const skeleton_backend& a, unsigned b); | |
968 | void eval_fdim(skeleton_backend& result, const skeleton_backend& a, unsigned short b); | |
969 | void eval_fdim(skeleton_backend& result, const skeleton_backend& a, unsigned char b); | |
970 | void eval_fdim(skeleton_backend& result, const skeleton_backend& a, long long b); | |
971 | void eval_fdim(skeleton_backend& result, const skeleton_backend& a, long b); | |
972 | void eval_fdim(skeleton_backend& result, const skeleton_backend& a, int b); | |
973 | void eval_fdim(skeleton_backend& result, const skeleton_backend& a, short b); | |
974 | void eval_fdim(skeleton_backend& result, const skeleton_backend& a, signed char b); | |
975 | void eval_fdim(skeleton_backend& result, const skeleton_backend& a, long double b); | |
976 | void eval_fdim(skeleton_backend& result, const skeleton_backend& a, double b); | |
977 | void eval_fdim(skeleton_backend& result, const skeleton_backend& a, float b); | |
978 | void eval_fdim(skeleton_backend& result, unsigned long long a, const skeleton_backend& b); | |
979 | void eval_fdim(skeleton_backend& result, unsigned long a, const skeleton_backend& b); | |
980 | void eval_fdim(skeleton_backend& result, unsigned a, const skeleton_backend& b); | |
981 | void eval_fdim(skeleton_backend& result, unsigned short a, const skeleton_backend& b); | |
982 | void eval_fdim(skeleton_backend& result, unsigned char a, const skeleton_backend& b); | |
983 | void eval_fdim(skeleton_backend& result, long long a, const skeleton_backend& b); | |
984 | void eval_fdim(skeleton_backend& result, long a, const skeleton_backend& b); | |
985 | void eval_fdim(skeleton_backend& result, int a, const skeleton_backend& b); | |
986 | void eval_fdim(skeleton_backend& result, short a, const skeleton_backend& b); | |
987 | void eval_fdim(skeleton_backend& result, signed char a, const skeleton_backend& b); | |
988 | ||
989 | void eval_fmax(skeleton_backend& result, const skeleton_backend& a, const skeleton_backend& b); | |
990 | void eval_fmax(skeleton_backend& result, const skeleton_backend& a, unsigned long long b); | |
991 | void eval_fmax(skeleton_backend& result, const skeleton_backend& a, unsigned long b); | |
992 | void eval_fmax(skeleton_backend& result, const skeleton_backend& a, unsigned b); | |
993 | void eval_fmax(skeleton_backend& result, const skeleton_backend& a, unsigned short b); | |
994 | void eval_fmax(skeleton_backend& result, const skeleton_backend& a, unsigned char b); | |
995 | void eval_fmax(skeleton_backend& result, const skeleton_backend& a, long long b); | |
996 | void eval_fmax(skeleton_backend& result, const skeleton_backend& a, long b); | |
997 | void eval_fmax(skeleton_backend& result, const skeleton_backend& a, int b); | |
998 | void eval_fmax(skeleton_backend& result, const skeleton_backend& a, short b); | |
999 | void eval_fmax(skeleton_backend& result, const skeleton_backend& a, signed char b); | |
1000 | void eval_fmax(skeleton_backend& result, const skeleton_backend& a, long double b); | |
1001 | void eval_fmax(skeleton_backend& result, const skeleton_backend& a, double b); | |
1002 | void eval_fmax(skeleton_backend& result, const skeleton_backend& a, float b); | |
1003 | void eval_fmax(skeleton_backend& result, unsigned long long a, const skeleton_backend& b); | |
1004 | void eval_fmax(skeleton_backend& result, unsigned long a, const skeleton_backend& b); | |
1005 | void eval_fmax(skeleton_backend& result, unsigned a, const skeleton_backend& b); | |
1006 | void eval_fmax(skeleton_backend& result, unsigned short a, const skeleton_backend& b); | |
1007 | void eval_fmax(skeleton_backend& result, unsigned char a, const skeleton_backend& b); | |
1008 | void eval_fmax(skeleton_backend& result, long long a, const skeleton_backend& b); | |
1009 | void eval_fmax(skeleton_backend& result, long a, const skeleton_backend& b); | |
1010 | void eval_fmax(skeleton_backend& result, int a, const skeleton_backend& b); | |
1011 | void eval_fmax(skeleton_backend& result, short a, const skeleton_backend& b); | |
1012 | void eval_fmax(skeleton_backend& result, signed char a, const skeleton_backend& b); | |
1013 | ||
1014 | void eval_fmin(skeleton_backend& result, const skeleton_backend& a, const skeleton_backend& b); | |
1015 | void eval_fmin(skeleton_backend& result, const skeleton_backend& a, unsigned long long b); | |
1016 | void eval_fmin(skeleton_backend& result, const skeleton_backend& a, unsigned long b); | |
1017 | void eval_fmin(skeleton_backend& result, const skeleton_backend& a, unsigned b); | |
1018 | void eval_fmin(skeleton_backend& result, const skeleton_backend& a, unsigned short b); | |
1019 | void eval_fmin(skeleton_backend& result, const skeleton_backend& a, unsigned char b); | |
1020 | void eval_fmin(skeleton_backend& result, const skeleton_backend& a, long long b); | |
1021 | void eval_fmin(skeleton_backend& result, const skeleton_backend& a, long b); | |
1022 | void eval_fmin(skeleton_backend& result, const skeleton_backend& a, int b); | |
1023 | void eval_fmin(skeleton_backend& result, const skeleton_backend& a, short b); | |
1024 | void eval_fmin(skeleton_backend& result, const skeleton_backend& a, signed char b); | |
1025 | void eval_fmin(skeleton_backend& result, const skeleton_backend& a, long double b); | |
1026 | void eval_fmin(skeleton_backend& result, const skeleton_backend& a, double b); | |
1027 | void eval_fmin(skeleton_backend& result, const skeleton_backend& a, float b); | |
1028 | void eval_fmin(skeleton_backend& result, unsigned long long a, const skeleton_backend& b); | |
1029 | void eval_fmin(skeleton_backend& result, unsigned long a, const skeleton_backend& b); | |
1030 | void eval_fmin(skeleton_backend& result, unsigned a, const skeleton_backend& b); | |
1031 | void eval_fmin(skeleton_backend& result, unsigned short a, const skeleton_backend& b); | |
1032 | void eval_fmin(skeleton_backend& result, unsigned char a, const skeleton_backend& b); | |
1033 | void eval_fmin(skeleton_backend& result, long long a, const skeleton_backend& b); | |
1034 | void eval_fmin(skeleton_backend& result, long a, const skeleton_backend& b); | |
1035 | void eval_fmin(skeleton_backend& result, int a, const skeleton_backend& b); | |
1036 | void eval_fmin(skeleton_backend& result, short a, const skeleton_backend& b); | |
1037 | void eval_fmin(skeleton_backend& result, signed char a, const skeleton_backend& b); | |
1038 | ||
1039 | void eval_hypot(skeleton_backend& result, const skeleton_backend& a, const skeleton_backend& b); | |
1040 | void eval_hypot(skeleton_backend& result, const skeleton_backend& a, unsigned long long b); | |
1041 | void eval_hypot(skeleton_backend& result, const skeleton_backend& a, unsigned long b); | |
1042 | void eval_hypot(skeleton_backend& result, const skeleton_backend& a, unsigned b); | |
1043 | void eval_hypot(skeleton_backend& result, const skeleton_backend& a, unsigned short b); | |
1044 | void eval_hypot(skeleton_backend& result, const skeleton_backend& a, unsigned char b); | |
1045 | void eval_hypot(skeleton_backend& result, const skeleton_backend& a, long long b); | |
1046 | void eval_hypot(skeleton_backend& result, const skeleton_backend& a, long b); | |
1047 | void eval_hypot(skeleton_backend& result, const skeleton_backend& a, int b); | |
1048 | void eval_hypot(skeleton_backend& result, const skeleton_backend& a, short b); | |
1049 | void eval_hypot(skeleton_backend& result, const skeleton_backend& a, signed char b); | |
1050 | void eval_hypot(skeleton_backend& result, const skeleton_backend& a, long double b); | |
1051 | void eval_hypot(skeleton_backend& result, const skeleton_backend& a, double b); | |
1052 | void eval_hypot(skeleton_backend& result, const skeleton_backend& a, float b); | |
1053 | void eval_hypot(skeleton_backend& result, unsigned long long a, const skeleton_backend& b); | |
1054 | void eval_hypot(skeleton_backend& result, unsigned long a, const skeleton_backend& b); | |
1055 | void eval_hypot(skeleton_backend& result, unsigned a, const skeleton_backend& b); | |
1056 | void eval_hypot(skeleton_backend& result, unsigned short a, const skeleton_backend& b); | |
1057 | void eval_hypot(skeleton_backend& result, unsigned char a, const skeleton_backend& b); | |
1058 | void eval_hypot(skeleton_backend& result, long long a, const skeleton_backend& b); | |
1059 | void eval_hypot(skeleton_backend& result, long a, const skeleton_backend& b); | |
1060 | void eval_hypot(skeleton_backend& result, int a, const skeleton_backend& b); | |
1061 | void eval_hypot(skeleton_backend& result, short a, const skeleton_backend& b); | |
1062 | void eval_hypot(skeleton_backend& result, signed char a, const skeleton_backend& b); | |
1063 | ||
1064 | void eval_logb(skeleton_backend& result, const skeleton_backend& arg); | |
1065 | void eval_nearbtint(skeleton_backend& result, const skeleton_backend& arg); | |
1066 | void eval_rint(skeleton_backend& result, const skeleton_backend& arg); | |
1067 | void eval_log2(skeleton_backend& result, const skeleton_backend& arg); | |
1068 | #endif | |
1069 | ||
1070 | ||
1071 | } // namespace backends | |
1072 | ||
1073 | // | |
1074 | // Import the backend into this namespace: | |
1075 | // | |
1076 | using boost::multiprecision::backends::skeleton_backend; | |
1077 | // | |
1078 | // Typedef whatever number's make use of this backend: | |
1079 | // | |
1080 | typedef number<skeleton_backend, et_off> skeleton_number; | |
1081 | // | |
1082 | // Define a category for this number type, one of: | |
1083 | // | |
1084 | // number_kind_integer | |
1085 | // number_kind_floating_point | |
1086 | // number_kind_rational | |
1087 | // number_kind_fixed_point | |
1088 | // number_kind_complex | |
1089 | // | |
1090 | template<> | |
1e59de90 | 1091 | struct number_category<skeleton_backend > : public std::integral_constant<int, number_kind_floating_point> |
f67539c2 TL |
1092 | {}; |
1093 | ||
1094 | // | |
1095 | // These 2 traits classes are required for complex types only: | |
1096 | // | |
1097 | /* | |
1098 | template <expression_template_option ExpressionTemplates> | |
1099 | struct component_type<number<skeleton_backend, ExpressionTemplates> > | |
1100 | { | |
1101 | typedef number<skeleton_real_type, ExpressionTemplates> type; | |
1102 | }; | |
1103 | ||
1104 | template <expression_template_option ExpressionTemplates> | |
1105 | struct complex_result_from_scalar<number<skeleton_real_type, ExpressionTemplates> > | |
1106 | { | |
1107 | typedef number<skeleton_backend, ExpressionTemplates> type; | |
1108 | }; | |
1109 | */ | |
1110 | ||
1111 | /************************************************************** | |
1112 | ||
1113 | OVERLOADABLE FUNCTIONS - FLOATING POINT TYPES ONLY | |
1114 | ||
1115 | ****************************************************************/ | |
1116 | ||
1117 | #if 0 | |
1118 | ||
1119 | template <boost::multiprecision::expression_template_option ExpressionTemplates> | |
1120 | int sign(const number<skeleton_backend, ExpressionTemplates>& arg); | |
1121 | template <boost::multiprecision::expression_template_option ExpressionTemplates> | |
1122 | int signbit(const number<skeleton_backend, ExpressionTemplates>& arg); | |
1123 | template <boost::multiprecision::expression_template_option ExpressionTemplates> | |
1124 | number<skeleton_backend, ExpressionTemplates> changesign(const number<skeleton_backend, ExpressionTemplates>& arg); | |
1125 | template <boost::multiprecision::expression_template_option ExpressionTemplates> | |
1126 | number<skeleton_backend, ExpressionTemplates> copysign(const number<skeleton_backend, ExpressionTemplates>& a, const number<skeleton_backend, ExpressionTemplates>& b); | |
1127 | ||
1128 | template <boost::multiprecision::expression_template_option ExpressionTemplates> | |
1129 | number<skeleton_backend, ExpressionTemplates> cbrt(const number<skeleton_backend, ExpressionTemplates>& arg); | |
1130 | template <boost::multiprecision::expression_template_option ExpressionTemplates> | |
1131 | number<skeleton_backend, ExpressionTemplates> erf(const number<skeleton_backend, ExpressionTemplates>& arg); | |
1132 | template <boost::multiprecision::expression_template_option ExpressionTemplates> | |
1133 | number<skeleton_backend, ExpressionTemplates> erfc(const number<skeleton_backend, ExpressionTemplates>& arg); | |
1134 | template <boost::multiprecision::expression_template_option ExpressionTemplates> | |
1135 | number<skeleton_backend, ExpressionTemplates> expm1(const number<skeleton_backend, ExpressionTemplates>& arg); | |
1136 | template <boost::multiprecision::expression_template_option ExpressionTemplates> | |
1137 | number<skeleton_backend, ExpressionTemplates> log1p(const number<skeleton_backend, ExpressionTemplates>& arg); | |
1138 | template <boost::multiprecision::expression_template_option ExpressionTemplates> | |
1139 | number<skeleton_backend, ExpressionTemplates> tgamma(const number<skeleton_backend, ExpressionTemplates>& arg); | |
1140 | template <boost::multiprecision::expression_template_option ExpressionTemplates> | |
1141 | number<skeleton_backend, ExpressionTemplates> lgamma(const number<skeleton_backend, ExpressionTemplates>& arg); | |
1142 | ||
1143 | template <boost::multiprecision::expression_template_option ExpressionTemplates> | |
1144 | long lrint(const number<skeleton_backend, ExpressionTemplates>& arg); | |
1145 | template <boost::multiprecision::expression_template_option ExpressionTemplates> | |
1146 | long long llrint(const number<skeleton_backend, ExpressionTemplates>& arg); | |
1147 | ||
1148 | template <boost::multiprecision::expression_template_option ExpressionTemplates> | |
1149 | number<skeleton_backend, ExpressionTemplates> nextafter(const number<skeleton_backend, ExpressionTemplates>& a, const number<skeleton_backend, ExpressionTemplates>& b); | |
1150 | template <boost::multiprecision::expression_template_option ExpressionTemplates> | |
1151 | number<skeleton_backend, ExpressionTemplates> nexttoward(const number<skeleton_backend, ExpressionTemplates>& a, const number<skeleton_backend, ExpressionTemplates>& b); | |
1152 | ||
1153 | #endif | |
1154 | ||
1155 | }} // namespace boost::multiprecision | |
1156 | ||
1157 | /********************************************************************************** | |
1158 | ||
1159 | FLOATING POINT ONLY | |
1160 | Nice to have stuff for better integration with Boost.Math. | |
1161 | ||
1162 | ***********************************************************************************/ | |
1163 | ||
1164 | namespace boost { | |
1165 | namespace math { | |
1166 | namespace tools { | |
1167 | ||
1168 | #if 0 | |
1169 | ||
1170 | template <> | |
1171 | int digits<boost::multiprecision::number<boost::multiprecision::skeleton_number> >(); | |
1172 | ||
1173 | template <> | |
1174 | boost::multiprecision::mpfr_float max_value<boost::multiprecision::skeleton_number>(); | |
1175 | ||
1176 | template <> | |
1177 | boost::multiprecision::mpfr_float min_value<boost::multiprecision::skeleton_number>(); | |
1178 | ||
1179 | #endif | |
1180 | ||
1181 | } // namespace tools | |
1182 | ||
1183 | namespace constants { | |
1184 | namespace detail { | |
1185 | ||
1186 | #if 0 | |
1187 | template <boost::multiprecision::expression_template_option ExpressionTemplates> | |
1188 | struct constant_pi<boost::multiprecision::number<boost::multiprecision::skeleton_backend, ExpressionTemplates> > | |
1189 | { | |
1190 | typedef boost::multiprecision::number<boost::multiprecision::skeleton_backend, ExpressionTemplates> result_type; | |
1191 | // | |
1192 | // Fixed N-digit precision, return reference to internal/cached object: | |
1193 | // | |
1194 | template <int N> | |
1e59de90 | 1195 | static inline const result_type& get(const std::integral_constant<int, N>&); |
f67539c2 TL |
1196 | // |
1197 | // Variable precision, returns fresh result each time (unless precision is unchanged from last call): | |
1198 | // | |
1e59de90 | 1199 | static inline const result_type get(const std::integral_constant<int, 0>&); |
f67539c2 TL |
1200 | }; |
1201 | // | |
1202 | // Plus any other constants supported natively by this type.... | |
1203 | // | |
1204 | #endif | |
1205 | ||
1206 | } // namespace detail | |
1207 | } // namespace constants | |
1208 | ||
1209 | }} // namespace boost::math | |
1210 | ||
1211 | ||
1212 | namespace std { | |
1213 | ||
1214 | template <boost::multiprecision::expression_template_option ExpressionTemplates> | |
1215 | class numeric_limits<boost::multiprecision::number<boost::multiprecision::skeleton_backend, ExpressionTemplates> > | |
1216 | { | |
1217 | typedef boost::multiprecision::number<boost::multiprecision::skeleton_backend, ExpressionTemplates> number_type; | |
1218 | ||
1219 | public: | |
1e59de90 | 1220 | static constexpr bool is_specialized = true; |
f67539c2 TL |
1221 | static number_type(min)(); |
1222 | static number_type(max)(); | |
1223 | static number_type lowest(); | |
1e59de90 TL |
1224 | static constexpr int digits = 0; |
1225 | static constexpr int digits10 = 0; | |
1226 | static constexpr int max_digits10 = 0; | |
1227 | static constexpr bool is_signed = false; | |
1228 | static constexpr bool is_integer = false; | |
1229 | static constexpr bool is_exact = false; | |
1230 | static constexpr int radix = 2; | |
f67539c2 TL |
1231 | static number_type epsilon(); |
1232 | static number_type round_error(); | |
1e59de90 TL |
1233 | static constexpr int min_exponent = 0; |
1234 | static constexpr int min_exponent10 = 0; | |
1235 | static constexpr int max_exponent = 0; | |
1236 | static constexpr int max_exponent10 = 0; | |
1237 | static constexpr bool has_infinity = false; | |
1238 | static constexpr bool has_quiet_NaN = false; | |
1239 | static constexpr bool has_signaling_NaN = false; | |
1240 | static constexpr float_denorm_style has_denorm = denorm_absent; | |
1241 | static constexpr bool has_denorm_loss = false; | |
f67539c2 TL |
1242 | static number_type infinity(); |
1243 | static number_type quiet_NaN(); | |
1244 | static number_type signaling_NaN(); | |
1245 | static number_type denorm_min(); | |
1e59de90 TL |
1246 | static constexpr bool is_iec559 = false; |
1247 | static constexpr bool is_bounded = false; | |
1248 | static constexpr bool is_modulo = false; | |
1249 | static constexpr bool traps = false; | |
1250 | static constexpr bool tinyness_before = false; | |
1251 | static constexpr float_round_style round_style = round_toward_zero; | |
f67539c2 TL |
1252 | }; |
1253 | ||
f67539c2 | 1254 | template <boost::multiprecision::expression_template_option ExpressionTemplates> |
1e59de90 | 1255 | constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::skeleton_backend, ExpressionTemplates> >::digits; |
f67539c2 | 1256 | template <boost::multiprecision::expression_template_option ExpressionTemplates> |
1e59de90 | 1257 | constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::skeleton_backend, ExpressionTemplates> >::digits10; |
f67539c2 | 1258 | template <boost::multiprecision::expression_template_option ExpressionTemplates> |
1e59de90 | 1259 | constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::skeleton_backend, ExpressionTemplates> >::max_digits10; |
f67539c2 | 1260 | template <boost::multiprecision::expression_template_option ExpressionTemplates> |
1e59de90 | 1261 | constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::skeleton_backend, ExpressionTemplates> >::is_signed; |
f67539c2 | 1262 | template <boost::multiprecision::expression_template_option ExpressionTemplates> |
1e59de90 | 1263 | constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::skeleton_backend, ExpressionTemplates> >::is_integer; |
f67539c2 | 1264 | template <boost::multiprecision::expression_template_option ExpressionTemplates> |
1e59de90 | 1265 | constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::skeleton_backend, ExpressionTemplates> >::is_exact; |
f67539c2 | 1266 | template <boost::multiprecision::expression_template_option ExpressionTemplates> |
1e59de90 | 1267 | constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::skeleton_backend, ExpressionTemplates> >::radix; |
f67539c2 | 1268 | template <boost::multiprecision::expression_template_option ExpressionTemplates> |
1e59de90 | 1269 | constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::skeleton_backend, ExpressionTemplates> >::min_exponent; |
f67539c2 | 1270 | template <boost::multiprecision::expression_template_option ExpressionTemplates> |
1e59de90 | 1271 | constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::skeleton_backend, ExpressionTemplates> >::min_exponent10; |
f67539c2 | 1272 | template <boost::multiprecision::expression_template_option ExpressionTemplates> |
1e59de90 | 1273 | constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::skeleton_backend, ExpressionTemplates> >::max_exponent; |
f67539c2 | 1274 | template <boost::multiprecision::expression_template_option ExpressionTemplates> |
1e59de90 | 1275 | constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::skeleton_backend, ExpressionTemplates> >::max_exponent10; |
f67539c2 | 1276 | template <boost::multiprecision::expression_template_option ExpressionTemplates> |
1e59de90 | 1277 | constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::skeleton_backend, ExpressionTemplates> >::has_infinity; |
f67539c2 | 1278 | template <boost::multiprecision::expression_template_option ExpressionTemplates> |
1e59de90 | 1279 | constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::skeleton_backend, ExpressionTemplates> >::has_quiet_NaN; |
f67539c2 | 1280 | template <boost::multiprecision::expression_template_option ExpressionTemplates> |
1e59de90 | 1281 | constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::skeleton_backend, ExpressionTemplates> >::has_signaling_NaN; |
f67539c2 | 1282 | template <boost::multiprecision::expression_template_option ExpressionTemplates> |
1e59de90 | 1283 | constexpr float_denorm_style numeric_limits<boost::multiprecision::number<boost::multiprecision::skeleton_backend, ExpressionTemplates> >::has_denorm; |
f67539c2 | 1284 | template <boost::multiprecision::expression_template_option ExpressionTemplates> |
1e59de90 | 1285 | constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::skeleton_backend, ExpressionTemplates> >::has_denorm_loss; |
f67539c2 | 1286 | template <boost::multiprecision::expression_template_option ExpressionTemplates> |
1e59de90 | 1287 | constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::skeleton_backend, ExpressionTemplates> >::is_iec559; |
f67539c2 | 1288 | template <boost::multiprecision::expression_template_option ExpressionTemplates> |
1e59de90 | 1289 | constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::skeleton_backend, ExpressionTemplates> >::is_bounded; |
f67539c2 | 1290 | template <boost::multiprecision::expression_template_option ExpressionTemplates> |
1e59de90 | 1291 | constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::skeleton_backend, ExpressionTemplates> >::is_modulo; |
f67539c2 | 1292 | template <boost::multiprecision::expression_template_option ExpressionTemplates> |
1e59de90 | 1293 | constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::skeleton_backend, ExpressionTemplates> >::traps; |
f67539c2 | 1294 | template <boost::multiprecision::expression_template_option ExpressionTemplates> |
1e59de90 | 1295 | constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::skeleton_backend, ExpressionTemplates> >::tinyness_before; |
f67539c2 | 1296 | template <boost::multiprecision::expression_template_option ExpressionTemplates> |
1e59de90 | 1297 | constexpr float_round_style numeric_limits<boost::multiprecision::number<boost::multiprecision::skeleton_backend, ExpressionTemplates> >::round_style; |
f67539c2 TL |
1298 | |
1299 | } // namespace std | |
1300 | ||
1301 | #endif |