Subversion Repositories HelenOS-historic

Rev

Rev 875 | Rev 1031 | Go to most recent revision | Only display areas with differences | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 875 Rev 876
1
/*
1
/*
2
 * Copyright (C) 2005 Josef Cejka
2
 * Copyright (C) 2005 Josef Cejka
3
 * All rights reserved.
3
 * All rights reserved.
4
 *
4
 *
5
 * Redistribution and use in source and binary forms, with or without
5
 * Redistribution and use in source and binary forms, with or without
6
 * modification, are permitted provided that the following conditions
6
 * modification, are permitted provided that the following conditions
7
 * are met:
7
 * are met:
8
 *
8
 *
9
 * - Redistributions of source code must retain the above copyright
9
 * - Redistributions of source code must retain the above copyright
10
 *   notice, this list of conditions and the following disclaimer.
10
 *   notice, this list of conditions and the following disclaimer.
11
 * - Redistributions in binary form must reproduce the above copyright
11
 * - Redistributions in binary form must reproduce the above copyright
12
 *   notice, this list of conditions and the following disclaimer in the
12
 *   notice, this list of conditions and the following disclaimer in the
13
 *   documentation and/or other materials provided with the distribution.
13
 *   documentation and/or other materials provided with the distribution.
14
 * - The name of the author may not be used to endorse or promote products
14
 * - The name of the author may not be used to endorse or promote products
15
 *   derived from this software without specific prior written permission.
15
 *   derived from this software without specific prior written permission.
16
 *
16
 *
17
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
17
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
18
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
19
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
20
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
21
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
22
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
23
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
25
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27
 */
27
 */
28
 
28
 
29
#include "sftypes.h"
29
#include "sftypes.h"
30
#include "conversion.h"
30
#include "conversion.h"
31
#include "comparison.h"
31
#include "comparison.h"
32
#include "common.h"
32
#include "common.h"
33
 
33
 
34
float64 convertFloat32ToFloat64(float32 a)
34
float64 convertFloat32ToFloat64(float32 a)
35
{
35
{
36
    float64 result;
36
    float64 result;
37
    __u64 frac;
37
    __u64 frac;
38
   
38
   
39
    result.parts.sign = a.parts.sign;
39
    result.parts.sign = a.parts.sign;
40
    result.parts.fraction = a.parts.fraction;
40
    result.parts.fraction = a.parts.fraction;
41
    result.parts.fraction <<= (FLOAT64_FRACTION_SIZE - FLOAT32_FRACTION_SIZE );
41
    result.parts.fraction <<= (FLOAT64_FRACTION_SIZE - FLOAT32_FRACTION_SIZE );
42
   
42
   
43
    if ((isFloat32Infinity(a))||(isFloat32NaN(a))) {
43
    if ((isFloat32Infinity(a))||(isFloat32NaN(a))) {
44
        result.parts.exp = 0x7FF;
44
        result.parts.exp = 0x7FF;
45
        /* TODO; check if its correct for SigNaNs*/
45
        /* TODO; check if its correct for SigNaNs*/
46
        return result;
46
        return result;
47
    };
47
    };
48
   
48
   
49
    result.parts.exp = a.parts.exp + ( (int)FLOAT64_BIAS - FLOAT32_BIAS );
49
    result.parts.exp = a.parts.exp + ( (int)FLOAT64_BIAS - FLOAT32_BIAS );
50
    if (a.parts.exp == 0) {
50
    if (a.parts.exp == 0) {
51
        /* normalize denormalized numbers */
51
        /* normalize denormalized numbers */
52
 
52
 
53
        if (result.parts.fraction == 0ll) { /* fix zero */
53
        if (result.parts.fraction == 0ll) { /* fix zero */
54
            result.parts.exp = 0ll;
54
            result.parts.exp = 0ll;
55
            return result;
55
            return result;
56
        }
56
        }
57
           
57
           
58
        frac = result.parts.fraction;
58
        frac = result.parts.fraction;
59
       
59
       
60
        while (!(frac & (0x10000000000000ll))) {
60
        while (!(frac & (0x10000000000000ll))) {
61
            frac <<= 1;
61
            frac <<= 1;
62
            --result.parts.exp;
62
            --result.parts.exp;
63
        };
63
        };
64
       
64
       
65
        ++result.parts.exp;
65
        ++result.parts.exp;
66
        result.parts.fraction = frac;
66
        result.parts.fraction = frac;
67
    };
67
    };
68
   
68
   
69
    return result;
69
    return result;
70
   
70
   
71
}
71
}
72
 
72
 
73
float32 convertFloat64ToFloat32(float64 a)
73
float32 convertFloat64ToFloat32(float64 a)
74
{
74
{
75
    float32 result;
75
    float32 result;
76
    __s32 exp;
76
    __s32 exp;
77
    __u64 frac;
77
    __u64 frac;
78
   
78
   
79
    result.parts.sign = a.parts.sign;
79
    result.parts.sign = a.parts.sign;
80
   
80
   
81
    if (isFloat64NaN(a)) {
81
    if (isFloat64NaN(a)) {
82
       
82
       
83
        result.parts.exp = 0xFF;
83
        result.parts.exp = 0xFF;
84
       
84
       
85
        if (isFloat64SigNaN(a)) {
85
        if (isFloat64SigNaN(a)) {
86
            result.parts.fraction = 0x800000; /* set first bit of fraction nonzero */
86
            result.parts.fraction = 0x800000; /* set first bit of fraction nonzero */
87
            return result;
87
            return result;
88
        }
88
        }
89
   
89
   
90
        result.parts.fraction = 0x1; /* fraction nonzero but its first bit is zero */
90
        result.parts.fraction = 0x1; /* fraction nonzero but its first bit is zero */
91
        return result;
91
        return result;
92
    };
92
    };
93
 
93
 
94
    if (isFloat64Infinity(a)) {
94
    if (isFloat64Infinity(a)) {
95
        result.parts.fraction = 0;
95
        result.parts.fraction = 0;
96
        result.parts.exp = 0xFF;
96
        result.parts.exp = 0xFF;
97
        return result;
97
        return result;
98
    };
98
    };
99
 
99
 
100
    exp = (int)a.parts.exp - FLOAT64_BIAS + FLOAT32_BIAS;
100
    exp = (int)a.parts.exp - FLOAT64_BIAS + FLOAT32_BIAS;
101
   
101
   
102
    if (exp >= 0xFF) {
102
    if (exp >= 0xFF) {
103
        /*FIXME: overflow*/
103
        /*FIXME: overflow*/
104
        result.parts.fraction = 0;
104
        result.parts.fraction = 0;
105
        result.parts.exp = 0xFF;
105
        result.parts.exp = 0xFF;
106
        return result;
106
        return result;
107
       
107
       
108
    } else if (exp <= 0 ) {
108
    } else if (exp <= 0 ) {
109
       
109
       
110
        /* underflow or denormalized */
110
        /* underflow or denormalized */
111
       
111
       
112
        result.parts.exp = 0;
112
        result.parts.exp = 0;
113
       
113
       
114
        exp *= -1; 
114
        exp *= -1; 
115
        if (exp > FLOAT32_FRACTION_SIZE ) {
115
        if (exp > FLOAT32_FRACTION_SIZE ) {
116
            /* FIXME: underflow */
116
            /* FIXME: underflow */
117
            result.parts.fraction = 0;
117
            result.parts.fraction = 0;
118
            return result;
118
            return result;
119
        };
119
        };
120
       
120
       
121
        /* denormalized */
121
        /* denormalized */
122
       
122
       
123
        frac = a.parts.fraction;
123
        frac = a.parts.fraction;
124
        frac |= 0x10000000000000ll; /* denormalize and set hidden bit */
124
        frac |= 0x10000000000000ll; /* denormalize and set hidden bit */
125
       
125
       
126
        frac >>= (FLOAT64_FRACTION_SIZE - FLOAT32_FRACTION_SIZE + 1);
126
        frac >>= (FLOAT64_FRACTION_SIZE - FLOAT32_FRACTION_SIZE + 1);
127
       
127
       
128
        while (exp > 0) {
128
        while (exp > 0) {
129
            --exp;
129
            --exp;
130
            frac >>= 1;
130
            frac >>= 1;
131
        };
131
        };
132
        result.parts.fraction = frac;
132
        result.parts.fraction = frac;
133
       
133
       
134
        return result;
134
        return result;
135
    };
135
    };
136
 
136
 
137
    result.parts.exp = exp;
137
    result.parts.exp = exp;
138
    result.parts.fraction = a.parts.fraction >> (FLOAT64_FRACTION_SIZE - FLOAT32_FRACTION_SIZE);
138
    result.parts.fraction = a.parts.fraction >> (FLOAT64_FRACTION_SIZE - FLOAT32_FRACTION_SIZE);
139
    return result;
139
    return result;
140
}
140
}
141
 
141
 
142
 
142
 
143
/** Helping procedure for converting float32 to uint32
143
/** Helping procedure for converting float32 to uint32
144
 * @param a floating point number in normalized form (no NaNs or Inf are checked )
144
 * @param a floating point number in normalized form (no NaNs or Inf are checked )
145
 * @return unsigned integer
145
 * @return unsigned integer
146
 */
146
 */
147
static __u32 _float32_to_uint32_helper(float32 a)
147
static __u32 _float32_to_uint32_helper(float32 a)
148
{
148
{
149
    __u32 frac;
149
    __u32 frac;
150
   
150
   
151
    if (a.parts.exp < FLOAT32_BIAS) {
151
    if (a.parts.exp < FLOAT32_BIAS) {
152
        /*TODO: rounding*/
152
        /*TODO: rounding*/
153
        return 0;
153
        return 0;
154
    }
154
    }
155
   
155
   
156
    frac = a.parts.fraction;
156
    frac = a.parts.fraction;
157
   
157
   
158
    frac |= FLOAT32_HIDDEN_BIT_MASK;
158
    frac |= FLOAT32_HIDDEN_BIT_MASK;
159
    /* shift fraction to left so hidden bit will be the most significant bit */
159
    /* shift fraction to left so hidden bit will be the most significant bit */
160
    frac <<= 32 - FLOAT32_FRACTION_SIZE - 1;
160
    frac <<= 32 - FLOAT32_FRACTION_SIZE - 1;
161
 
161
 
162
    frac >>= 32 - (a.parts.exp - FLOAT32_BIAS) - 1;
162
    frac >>= 32 - (a.parts.exp - FLOAT32_BIAS) - 1;
163
    if ((a.parts.sign == 1) && (frac != 0)) {
163
    if ((a.parts.sign == 1) && (frac != 0)) {
164
        frac = ~frac;
164
        frac = ~frac;
165
        ++frac;
165
        ++frac;
166
    }
166
    }
167
   
167
   
168
    return frac;
168
    return frac;
169
}
169
}
170
 
170
 
171
/* Convert float to unsigned int32
171
/* Convert float to unsigned int32
172
 * FIXME: Im not sure what to return if overflow/underflow happens
172
 * FIXME: Im not sure what to return if overflow/underflow happens
173
 *  - now its the biggest or the smallest int
173
 *  - now its the biggest or the smallest int
174
 */
174
 */
175
__u32 float32_to_uint32(float32 a)
175
__u32 float32_to_uint32(float32 a)
176
{
176
{
177
    if (isFloat32NaN(a)) {
177
    if (isFloat32NaN(a)) {
178
        return MAX_UINT32;
178
        return MAX_UINT32;
179
    }
179
    }
180
   
180
   
181
    if (isFloat32Infinity(a) || (a.parts.exp >= (32 + FLOAT32_BIAS)))  {
181
    if (isFloat32Infinity(a) || (a.parts.exp >= (32 + FLOAT32_BIAS)))  {
182
        if (a.parts.sign) {
182
        if (a.parts.sign) {
183
            return MIN_UINT32;
183
            return MIN_UINT32;
184
        }
184
        }
185
        return MAX_UINT32;
185
        return MAX_UINT32;
186
    }
186
    }
187
   
187
   
188
    return _float32_to_uint32_helper(a);   
188
    return _float32_to_uint32_helper(a);   
189
}
189
}
190
 
190
 
191
/* Convert float to signed int32
191
/* Convert float to signed int32
192
 * FIXME: Im not sure what to return if overflow/underflow happens
192
 * FIXME: Im not sure what to return if overflow/underflow happens
193
 *  - now its the biggest or the smallest int
193
 *  - now its the biggest or the smallest int
194
 */
194
 */
195
__s32 float32_to_int32(float32 a)
195
__s32 float32_to_int32(float32 a)
196
{
196
{
197
    if (isFloat32NaN(a)) {
197
    if (isFloat32NaN(a)) {
198
        return MAX_INT32;
198
        return MAX_INT32;
199
    }
199
    }
200
   
200
   
201
    if (isFloat32Infinity(a) || (a.parts.exp >= (32 + FLOAT32_BIAS)))  {
201
    if (isFloat32Infinity(a) || (a.parts.exp >= (32 + FLOAT32_BIAS)))  {
202
        if (a.parts.sign) {
202
        if (a.parts.sign) {
203
            return MIN_INT32;
203
            return MIN_INT32;
204
        }
204
        }
205
        return MAX_INT32;
205
        return MAX_INT32;
206
    }
206
    }
207
    return _float32_to_uint32_helper(a);
207
    return _float32_to_uint32_helper(a);
208
}  
208
}  
209
 
209
 
210
 
210
 
211
/** Helping procedure for converting float64 to uint64
211
/** Helping procedure for converting float64 to uint64
212
 * @param a floating point number in normalized form (no NaNs or Inf are checked )
212
 * @param a floating point number in normalized form (no NaNs or Inf are checked )
213
 * @return unsigned integer
213
 * @return unsigned integer
214
 */
214
 */
215
static __u64 _float64_to_uint64_helper(float64 a)
215
static __u64 _float64_to_uint64_helper(float64 a)
216
{
216
{
217
    __u64 frac;
217
    __u64 frac;
218
   
218
   
219
    if (a.parts.exp < FLOAT64_BIAS) {
219
    if (a.parts.exp < FLOAT64_BIAS) {
220
        /*TODO: rounding*/
220
        /*TODO: rounding*/
221
        return 0;
221
        return 0;
222
    }
222
    }
223
   
223
   
224
    frac = a.parts.fraction;
224
    frac = a.parts.fraction;
225
   
225
   
226
    frac |= FLOAT64_HIDDEN_BIT_MASK;
226
    frac |= FLOAT64_HIDDEN_BIT_MASK;
227
    /* shift fraction to left so hidden bit will be the most significant bit */
227
    /* shift fraction to left so hidden bit will be the most significant bit */
228
    frac <<= 64 - FLOAT64_FRACTION_SIZE - 1;
228
    frac <<= 64 - FLOAT64_FRACTION_SIZE - 1;
229
 
229
 
230
    frac >>= 64 - (a.parts.exp - FLOAT64_BIAS) - 1;
230
    frac >>= 64 - (a.parts.exp - FLOAT64_BIAS) - 1;
231
    if ((a.parts.sign == 1) && (frac != 0)) {
231
    if ((a.parts.sign == 1) && (frac != 0)) {
232
        frac = ~frac;
232
        frac = ~frac;
233
        ++frac;
233
        ++frac;
234
    }
234
    }
235
   
235
   
236
    return frac;
236
    return frac;
237
}
237
}
238
 
238
 
239
/* Convert float to unsigned int64
239
/* Convert float to unsigned int64
240
 * FIXME: Im not sure what to return if overflow/underflow happens
240
 * FIXME: Im not sure what to return if overflow/underflow happens
241
 *  - now its the biggest or the smallest int
241
 *  - now its the biggest or the smallest int
242
 */
242
 */
243
__u64 float64_to_uint64(float64 a)
243
__u64 float64_to_uint64(float64 a)
244
{
244
{
245
    if (isFloat64NaN(a)) {
245
    if (isFloat64NaN(a)) {
246
        return MAX_UINT64;
246
        return MAX_UINT64;
247
    }
247
    }
248
   
248
   
249
    if (isFloat64Infinity(a) || (a.parts.exp >= (64 + FLOAT64_BIAS)))  {
249
    if (isFloat64Infinity(a) || (a.parts.exp >= (64 + FLOAT64_BIAS)))  {
250
        if (a.parts.sign) {
250
        if (a.parts.sign) {
251
            return MIN_UINT64;
251
            return MIN_UINT64;
252
        }
252
        }
253
        return MAX_UINT64;
253
        return MAX_UINT64;
254
    }
254
    }
255
   
255
   
256
    return _float64_to_uint64_helper(a);   
256
    return _float64_to_uint64_helper(a);   
257
}
257
}
258
 
258
 
259
/* Convert float to signed int64
259
/* Convert float to signed int64
260
 * FIXME: Im not sure what to return if overflow/underflow happens
260
 * FIXME: Im not sure what to return if overflow/underflow happens
261
 *  - now its the biggest or the smallest int
261
 *  - now its the biggest or the smallest int
262
 */
262
 */
263
__s64 float64_to_int64(float64 a)
263
__s64 float64_to_int64(float64 a)
264
{
264
{
265
    if (isFloat64NaN(a)) {
265
    if (isFloat64NaN(a)) {
266
        return MAX_INT64;
266
        return MAX_INT64;
267
    }
267
    }
268
   
268
   
269
    if (isFloat64Infinity(a) || (a.parts.exp >= (64 + FLOAT64_BIAS)))  {
269
    if (isFloat64Infinity(a) || (a.parts.exp >= (64 + FLOAT64_BIAS)))  {
270
        if (a.parts.sign) {
270
        if (a.parts.sign) {
271
            return MIN_INT64;
271
            return MIN_INT64;
272
        }
272
        }
273
        return MAX_INT64;
273
        return MAX_INT64;
274
    }
274
    }
275
    return _float64_to_uint64_helper(a);
275
    return _float64_to_uint64_helper(a);
276
}  
276
}  
277
 
277
 
278
 
278
 
279
 
279
 
280
 
280
 
281
 
281
 
282
/** Helping procedure for converting float32 to uint64
282
/** Helping procedure for converting float32 to uint64
283
 * @param a floating point number in normalized form (no NaNs or Inf are checked )
283
 * @param a floating point number in normalized form (no NaNs or Inf are checked )
284
 * @return unsigned integer
284
 * @return unsigned integer
285
 */
285
 */
286
static __u64 _float32_to_uint64_helper(float32 a)
286
static __u64 _float32_to_uint64_helper(float32 a)
287
{
287
{
288
    __u64 frac;
288
    __u64 frac;
289
   
289
   
290
    if (a.parts.exp < FLOAT32_BIAS) {
290
    if (a.parts.exp < FLOAT32_BIAS) {
291
        /*TODO: rounding*/
291
        /*TODO: rounding*/
292
        return 0;
292
        return 0;
293
    }
293
    }
294
   
294
   
295
    frac = a.parts.fraction;
295
    frac = a.parts.fraction;
296
   
296
   
297
    frac |= FLOAT32_HIDDEN_BIT_MASK;
297
    frac |= FLOAT32_HIDDEN_BIT_MASK;
298
    /* shift fraction to left so hidden bit will be the most significant bit */
298
    /* shift fraction to left so hidden bit will be the most significant bit */
299
    frac <<= 64 - FLOAT32_FRACTION_SIZE - 1;
299
    frac <<= 64 - FLOAT32_FRACTION_SIZE - 1;
300
 
300
 
301
    frac >>= 64 - (a.parts.exp - FLOAT32_BIAS) - 1;
301
    frac >>= 64 - (a.parts.exp - FLOAT32_BIAS) - 1;
302
    if ((a.parts.sign == 1) && (frac != 0)) {
302
    if ((a.parts.sign == 1) && (frac != 0)) {
303
        frac = ~frac;
303
        frac = ~frac;
304
        ++frac;
304
        ++frac;
305
    }
305
    }
306
   
306
   
307
    return frac;
307
    return frac;
308
}
308
}
309
 
309
 
310
/* Convert float to unsigned int64
310
/* Convert float to unsigned int64
311
 * FIXME: Im not sure what to return if overflow/underflow happens
311
 * FIXME: Im not sure what to return if overflow/underflow happens
312
 *  - now its the biggest or the smallest int
312
 *  - now its the biggest or the smallest int
313
 */
313
 */
314
__u64 float32_to_uint64(float32 a)
314
__u64 float32_to_uint64(float32 a)
315
{
315
{
316
    if (isFloat32NaN(a)) {
316
    if (isFloat32NaN(a)) {
317
        return MAX_UINT64;
317
        return MAX_UINT64;
318
    }
318
    }
319
   
319
   
320
    if (isFloat32Infinity(a) || (a.parts.exp >= (64 + FLOAT32_BIAS)))  {
320
    if (isFloat32Infinity(a) || (a.parts.exp >= (64 + FLOAT32_BIAS)))  {
321
        if (a.parts.sign) {
321
        if (a.parts.sign) {
322
            return MIN_UINT64;
322
            return MIN_UINT64;
323
        }
323
        }
324
        return MAX_UINT64;
324
        return MAX_UINT64;
325
    }
325
    }
326
   
326
   
327
    return _float32_to_uint64_helper(a);   
327
    return _float32_to_uint64_helper(a);   
328
}
328
}
329
 
329
 
330
/* Convert float to signed int64
330
/* Convert float to signed int64
331
 * FIXME: Im not sure what to return if overflow/underflow happens
331
 * FIXME: Im not sure what to return if overflow/underflow happens
332
 *  - now its the biggest or the smallest int
332
 *  - now its the biggest or the smallest int
333
 */
333
 */
334
__s64 float32_to_int64(float32 a)
334
__s64 float32_to_int64(float32 a)
335
{
335
{
336
    if (isFloat32NaN(a)) {
336
    if (isFloat32NaN(a)) {
337
        return MAX_INT64;
337
        return MAX_INT64;
338
    }
338
    }
339
   
339
   
340
    if (isFloat32Infinity(a) || (a.parts.exp >= (64 + FLOAT32_BIAS)))  {
340
    if (isFloat32Infinity(a) || (a.parts.exp >= (64 + FLOAT32_BIAS)))  {
341
        if (a.parts.sign) {
341
        if (a.parts.sign) {
342
            return (MIN_INT64);
342
            return (MIN_INT64);
343
        }
343
        }
344
        return MAX_INT64;
344
        return MAX_INT64;
345
    }
345
    }
346
    return _float32_to_uint64_helper(a);
346
    return _float32_to_uint64_helper(a);
347
}  
347
}  
348
 
348
 
349
 
349
 
350
/* Convert float64 to unsigned int32
350
/* Convert float64 to unsigned int32
351
 * FIXME: Im not sure what to return if overflow/underflow happens
351
 * FIXME: Im not sure what to return if overflow/underflow happens
352
 *  - now its the biggest or the smallest int
352
 *  - now its the biggest or the smallest int
353
 */
353
 */
354
__u32 float64_to_uint32(float64 a)
354
__u32 float64_to_uint32(float64 a)
355
{
355
{
356
    if (isFloat64NaN(a)) {
356
    if (isFloat64NaN(a)) {
357
        return MAX_UINT32;
357
        return MAX_UINT32;
358
    }
358
    }
359
   
359
   
360
    if (isFloat64Infinity(a) || (a.parts.exp >= (32 + FLOAT64_BIAS)))  {
360
    if (isFloat64Infinity(a) || (a.parts.exp >= (32 + FLOAT64_BIAS)))  {
361
        if (a.parts.sign) {
361
        if (a.parts.sign) {
362
            return MIN_UINT32;
362
            return MIN_UINT32;
363
        }
363
        }
364
        return MAX_UINT32;
364
        return MAX_UINT32;
365
    }
365
    }
366
   
366
   
367
    return (__u32)_float64_to_uint64_helper(a);
367
    return (__u32)_float64_to_uint64_helper(a);
368
}
368
}
369
 
369
 
370
/* Convert float64 to signed int32
370
/* Convert float64 to signed int32
371
 * FIXME: Im not sure what to return if overflow/underflow happens
371
 * FIXME: Im not sure what to return if overflow/underflow happens
372
 *  - now its the biggest or the smallest int
372
 *  - now its the biggest or the smallest int
373
 */
373
 */
374
__s32 float64_to_int32(float64 a)
374
__s32 float64_to_int32(float64 a)
375
{
375
{
376
    if (isFloat64NaN(a)) {
376
    if (isFloat64NaN(a)) {
377
        return MAX_INT32;
377
        return MAX_INT32;
378
    }
378
    }
379
   
379
   
380
    if (isFloat64Infinity(a) || (a.parts.exp >= (32 + FLOAT64_BIAS)))  {
380
    if (isFloat64Infinity(a) || (a.parts.exp >= (32 + FLOAT64_BIAS)))  {
381
        if (a.parts.sign) {
381
        if (a.parts.sign) {
382
            return MIN_INT32;
382
            return MIN_INT32;
383
        }
383
        }
384
        return MAX_INT32;
384
        return MAX_INT32;
385
    }
385
    }
386
    return (__s32)_float64_to_uint64_helper(a);
386
    return (__s32)_float64_to_uint64_helper(a);
387
}  
387
}  
388
 
388
 
389
   
-
 
390
/** Convert unsigned integer to float32
389
/** Convert unsigned integer to float32
391
 *
390
 *
392
 *
391
 *
393
 */
392
 */
394
float32 uint32_to_float32(__u32 i)
393
float32 uint32_to_float32(__u32 i)
395
{
394
{
396
    int counter;
395
    int counter;
397
    __s32 exp;
396
    __s32 exp;
398
    float32 result;
397
    float32 result;
399
   
398
   
400
    result.parts.sign = 0;
399
    result.parts.sign = 0;
401
    result.parts.fraction = 0;
400
    result.parts.fraction = 0;
402
 
401
 
403
    counter = countZeroes32(i);
402
    counter = countZeroes32(i);
404
 
403
 
405
    exp = FLOAT32_BIAS + 32 - counter - 1;
404
    exp = FLOAT32_BIAS + 32 - counter - 1;
406
   
405
   
407
    if (counter == 32) {
406
    if (counter == 32) {
408
        result.binary = 0;
407
        result.binary = 0;
409
        return result;
408
        return result;
410
    }
409
    }
411
   
410
   
412
    if (counter > 0) {
411
    if (counter > 0) {
413
        i <<= counter - 1;
412
        i <<= counter - 1;
414
    } else {
413
    } else {
415
        i >>= 1;
414
        i >>= 1;
416
    }
415
    }
417
 
416
 
418
    roundFloat32(&exp, &i);
417
    roundFloat32(&exp, &i);
419
 
418
 
420
    result.parts.fraction = i >> 7;
419
    result.parts.fraction = i >> 7;
421
    result.parts.exp = exp;
420
    result.parts.exp = exp;
422
 
421
 
423
    return result;
422
    return result;
424
}
423
}
425
 
424
 
426
float32 int32_to_float32(__s32 i)
425
float32 int32_to_float32(__s32 i)
427
{
426
{
428
    float32 result;
427
    float32 result;
429
 
428
 
430
    if (i < 0) {
429
    if (i < 0) {
431
        result = uint32_to_float32((__u32)(-i));
430
        result = uint32_to_float32((__u32)(-i));
432
    } else {
431
    } else {
433
        result = uint32_to_float32((__u32)i);
432
        result = uint32_to_float32((__u32)i);
434
    }
433
    }
435
   
434
   
436
    result.parts.sign = i < 0;
435
    result.parts.sign = i < 0;
437
 
436
 
438
    return result;
437
    return result;
439
}
438
}
440
 
439
 
441
 
440
 
442
float32 uint64_to_float32(__u64 i)
441
float32 uint64_to_float32(__u64 i)
443
{
442
{
444
    int counter;
443
    int counter;
445
    __s32 exp;
444
    __s32 exp;
446
    float32 result;
445
    float32 result;
447
   
446
   
448
    result.parts.sign = 0;
447
    result.parts.sign = 0;
449
    result.parts.fraction = 0;
448
    result.parts.fraction = 0;
450
 
449
 
451
    counter = countZeroes64(i);
450
    counter = countZeroes64(i);
452
 
451
 
453
    exp = FLOAT32_BIAS + 64 - counter - 1;
452
    exp = FLOAT32_BIAS + 64 - counter - 1;
454
   
453
   
455
    if (counter == 64) {
454
    if (counter == 64) {
456
        result.binary = 0;
455
        result.binary = 0;
457
        return result;
456
        return result;
458
    }
457
    }
459
   
458
   
460
    /* Shift all to the first 31 bits (31. will be hidden 1)*/
459
    /* Shift all to the first 31 bits (31. will be hidden 1)*/
461
    if (counter > 33) {
460
    if (counter > 33) {
462
        i <<= counter - 1 - 32;
461
        i <<= counter - 1 - 32;
463
    } else {
462
    } else {
464
        i >>= 1 + 32 - counter;
463
        i >>= 1 + 32 - counter;
465
    }
464
    }
466
 
465
 
467
    roundFloat32(&exp, &i);
466
    roundFloat32(&exp, &i);
468
 
467
 
469
    result.parts.fraction = i >> 7;
468
    result.parts.fraction = i >> 7;
470
    result.parts.exp = exp;
469
    result.parts.exp = exp;
471
    return result;
470
    return result;
472
}
471
}
473
 
472
 
474
float32 int64_to_float32(__s64 i)
473
float32 int64_to_float32(__s64 i)
475
{
474
{
476
    float32 result;
475
    float32 result;
477
 
476
 
478
    if (i < 0) {
477
    if (i < 0) {
479
        result = uint64_to_float32((__u64)(-i));
478
        result = uint64_to_float32((__u64)(-i));
480
    } else {
479
    } else {
481
        result = uint64_to_float32((__u64)i);
480
        result = uint64_to_float32((__u64)i);
482
    }
481
    }
483
   
482
   
484
    result.parts.sign = i < 0;
483
    result.parts.sign = i < 0;
485
 
484
 
486
    return result;
485
    return result;
487
}
486
}
-
 
487
 
-
 
488
/** Convert unsigned integer to float64
-
 
489
 *
-
 
490
 *
-
 
491
 */
-
 
492
float64 uint32_to_float64(__u32 i)
-
 
493
{
-
 
494
    int counter;
-
 
495
    __s32 exp;
-
 
496
    float64 result;
-
 
497
    __u64 frac;
-
 
498
   
-
 
499
    result.parts.sign = 0;
-
 
500
    result.parts.fraction = 0;
-
 
501
 
-
 
502
    counter = countZeroes32(i);
-
 
503
 
-
 
504
    exp = FLOAT64_BIAS + 32 - counter - 1;
-
 
505
   
-
 
506
    if (counter == 32) {
-
 
507
        result.binary = 0;
-
 
508
        return result;
-
 
509
    }
-
 
510
   
-
 
511
    frac = i;
-
 
512
    frac <<= counter + 32 - 1;
-
 
513
 
-
 
514
    roundFloat64(&exp, &frac);
-
 
515
 
-
 
516
    result.parts.fraction = frac >> 10;
-
 
517
    result.parts.exp = exp;
-
 
518
 
-
 
519
    return result;
-
 
520
}
-
 
521
 
-
 
522
float64 int32_to_float64(__s32 i)
-
 
523
{
-
 
524
    float64 result;
-
 
525
 
-
 
526
    if (i < 0) {
-
 
527
        result = uint32_to_float64((__u32)(-i));
-
 
528
    } else {
-
 
529
        result = uint32_to_float64((__u32)i);
-
 
530
    }
-
 
531
   
-
 
532
    result.parts.sign = i < 0;
-
 
533
 
-
 
534
    return result;
-
 
535
}
-
 
536
 
-
 
537
 
-
 
538
float64 uint64_to_float64(__u64 i)
-
 
539
{
-
 
540
    int counter;
-
 
541
    __s32 exp;
-
 
542
    float64 result;
-
 
543
   
-
 
544
    result.parts.sign = 0;
-
 
545
    result.parts.fraction = 0;
-
 
546
 
-
 
547
    counter = countZeroes64(i);
-
 
548
 
-
 
549
    exp = FLOAT64_BIAS + 64 - counter - 1;
-
 
550
   
-
 
551
    if (counter == 64) {
-
 
552
        result.binary = 0;
-
 
553
        return result;
-
 
554
    }
-
 
555
   
-
 
556
    if (counter > 0) {
-
 
557
        i <<= counter - 1;
-
 
558
    } else {
-
 
559
        i >>= 1;
-
 
560
    }
-
 
561
 
-
 
562
    roundFloat64(&exp, &i);
-
 
563
 
-
 
564
    result.parts.fraction = i >> 10;
-
 
565
    result.parts.exp = exp;
-
 
566
    return result;
-
 
567
}
-
 
568
 
-
 
569
float64 int64_to_float64(__s64 i)
-
 
570
{
-
 
571
    float64 result;
-
 
572
 
-
 
573
    if (i < 0) {
-
 
574
        result = uint64_to_float64((__u64)(-i));
-
 
575
    } else {
-
 
576
        result = uint64_to_float64((__u64)i);
-
 
577
    }
-
 
578
   
-
 
579
    result.parts.sign = i < 0;
-
 
580
 
-
 
581
    return result;
-
 
582
}
-
 
583
 
-
 
584
 
488
 
585