librvg/bits.c at master · probsys/librvg · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
/*
  Name:     bits.c
  Purpose:  Operations on binary representations.
  Author:   F. Saad
  Copyright (C) 2025 CMU Probabilistic Computing Systems Lab
*/

#include <assert.h>
#include <math.h>

#include "bits.h"

const int FLT_SIZE = CHAR_BIT * sizeof(float);
const int DBL_SIZE = CHAR_BIT * sizeof(double);

uint32_t float2int(float f) {
    return ((union float_bits){.f = f}).i;
}

float int2float(uint32_t i) {
    return ((union float_bits){.i = i}).f;
}

uint64_t double2int(double f) {
    return ((union double_bits){.f = f}).i;
}

double int2double(uint64_t i) {
    return ((union double_bits){.i = i}).f;
}

uint32_t bij32_sm2lex(uint32_t b) {
    // size_t width = CHAR_BIT * sizeof(b);
    // assert(width == 32);
    unsigned char c = (b >> (FLT_SIZE - 1)) & 1;
    if (c == 0) {
        // Flip MSB: 0x80000000 = 2^31
        return b ^ 0x80000000;
    } else {
        return ~b;
    }
}

uint32_t bij32_lex2sm(uint32_t b) {
    // size_t width = CHAR_BIT * sizeof(b);
    // assert(width == 32);
    unsigned char c = (b >> (FLT_SIZE - 1)) & 1;
    if (c == 0) {
        return ~b;
    } else {
        // Flip MSB: 0x80000000 = 2^31
        return b ^ 0x80000000;
    }
}

uint32_t bij32_lex2float(uint32_t b) {
    // 0xFF800000 = 1 1^E 0^m
    if (b <= 0xFF800000) {
        // 0x007FFFFF = 2^m - 1
        return bij32_lex2sm(b + 0x007FFFFF);
    } else {
        assert(isnan(int2float(b)));
        return b;
    }
}

uint32_t bij32_float2lex(uint32_t b) {
    // 0xFF800000 = 1 1^E 0^m
    if (b <= 0xFF800000) {
        // 0x007FFFFF = 2^m - 1
        return bij32_sm2lex(b) - 0x007FFFFF;
    } else {
        assert(isnan(int2float(b)));
        return b;
    }
}

uint64_t bij64_sm2lex(uint64_t b) {
    // size_t width = CHAR_BIT * sizeof(b);
    // assert(width == 64);
    unsigned char c = (b >> (DBL_SIZE - 1)) & 1;
    if (c == 0) {
        // Flip MSB: 0x8000000000000000 = 2^63
        return b ^ 0x8000000000000000;
    } else {
        return ~b;
    }
}

uint64_t bij64_lex2sm(uint64_t b) {
    // size_t width = CHAR_BIT * sizeof(b);
    // assert(width == 64);
    unsigned char c = (b >> (DBL_SIZE - 1)) & 1;
    if (c == 0) {
        return ~b;
    } else {
        // Flip MSB: 0x8000000000000000 = 2^63
        return b ^ 0x8000000000000000;
    }
}

uint64_t bij64_lex2float(uint64_t b) {
    // 0xFFF0000000000000 = 1 1^E 0^m
    if (b <= 0xFFF0000000000000) {
        // 0x000FFFFFFFFFFFFF = 2^m - 1
        return bij64_lex2sm(b + 0x000FFFFFFFFFFFFF);
    } else {
        assert(isnan(int2double(b)));
        return b;
    }
}

uint64_t bij64_float2lex(uint64_t b) {
    // 0xFFF0000000000000 = 1 1^E 0^m
    if (b <= 0xFFF0000000000000) {
        // 0x000FFFFFFFFFFFFF = 2^m - 1, where m = 52 mantissa bits.
        return bij64_sm2lex(b) - 0x000FFFFFFFFFFFFF;
    } else {
        assert(isnan(int2double(b)));
        return b;
    }
}