Data Lab

1
2
3
4

int bitXor(int x, int y)
{
    return ~(~(~x & y) & ~(x & ~y));
}

1
2
3
4

int tmin(void)
{
    return 1 << 31;
}

1
2
3
4
5
6
7
8

int isTmax(int x)
{
    int nx = ~x;
    int neg = ~nx + 1;
    int tmin_or_zero = !(nx ^ neg);
    int is_tmin = !!(nx ^ 0);
    return tmin_or_zero & is_tmin;
}

1
2
3
4
5
6
7

int allOddBits(int x)
{
    int oddbits = 0xAA;
    oddbits = (oddbits << 8) | 0xAA;
    oddbits = (oddbits << 16) | oddbits;
    return !((x & oddbits) ^ oddbits);
}

1
2
3
4

int negate(int x)
{
    return ~x + 1;
}

1
2
3
4
5
6
7
8
9

int isAsciiDigit(int x)
{
    int in_range_flag = !(0x03 ^ (x >> 4));
    int low4 = x & 0x0F;
    int lt_8 = !(low4 >> 3);
    int le_9 = !((low4 >> 1) ^ 0x04);
    int isdigit = lt_8 | le_9;
    return in_range_flag & isdigit;
}

1
2
3
4
5

int conditional(int x, int y, int z)
{
    int true_flag = ~(((!x) << 31) >> 31); // 0xFFFFFFFF if x == 1 else 0
    return (y & true_flag) | (z & ~true_flag);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

int isLessOrEqual(int x, int y)
{
    int tmin = 1 << 31;
    int x_is_pos = !(x & tmin);
    int y_is_pos = !(y & tmin);
    int sign_eq = !(x_is_pos ^ y_is_pos);
    int y_sub_x = y + ~x + 1;
    int y_ge_x = !(y_sub_x >> 31);
    return (sign_eq & y_ge_x) | (!x_is_pos & y_is_pos);
}

1
2
3
4
5

int logicalNeg(int x)
{
    int neg_x = ~x + 1;
    return ((~(x | neg_x)) >> 31) & 1;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

int howManyBits(int x)
{
    int neg_flag = x >> 31; // 0xFFFFFFFF if x < 0 else 0
    int xp = x ^ neg_flag;  // (x & ~neg_flag) | (~x & neg_flag)
    int i = 0;
    i = i + ((!!(xp >> (i + 16))) << 4);
    i = i + ((!!(xp >> (i + 8))) << 3);
    i = i + ((!!(xp >> (i + 4))) << 2);
    i = i + ((!!(xp >> (i + 2))) << 1);
    i = i + ((!!(xp >> (i + 1))) << 0);
    i = i + (xp >> i);
    return i + 1;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

unsigned floatScale2(unsigned uf)
{
    int exp_mask = 0x7F800000;
    int nexp_mask = 0x807FFFFF;
    int frac_mask = 0x7FFFFF;
    int nfrac_mask = 0xFF800000;
    int e = (uf & exp_mask) >> 23;
    int f = (uf & frac_mask);

    if (e == 0xFF) // if uf == NaN or Inf then return uf
        return uf;

    if (e != 0) // Normalized
        return (uf & nexp_mask) | ((e + 1) << 23);
    else        // Denormalized
        return (uf & nfrac_mask) | (f << 1);
}

 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

int floatFloat2Int(unsigned uf)
{
    int tmin = 0x80000000;
    int bias = 127;
    int exp_mask = 0x7F800000;
    int frac_mask = 0x7FFFFF;

    int sign = uf >> 31; // 0xFFFFFFFF if uf < 0 else 0
    int e = (uf & exp_mask) >> 23;
    int f = (uf & frac_mask);
    int minus_E = bias + ~e + 1;
    int shift = minus_E + 23;
    int f2i = 0x800000 | f;

    if (e == 0xFF) // if uf == NaN or Inf then return 0x80000000u
        return 0x80000000u;
    if ((uf & 0x7FFFFFFF) == 0) // if uf == +0 or -0 then return 0
        return 0;
    if (e < bias) // if uf < 1 then return 0
        return 0;

    if (shift > 0)
        f2i = f2i >> shift;
    else
        while ((f2i != tmin) && (shift < 0))
        {
            f2i = f2i << 1;
            ++shift;
        }

    if (sign)
        return ~f2i + 1;
    else
        return f2i;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

unsigned floatPower2(int x)
{
    int inf = 0x7F800000;
    int float_0 = 0x3F800000;
    int bias = 127;
    int denorm_bias = 0xFFFFFF82; // -126
    int minus_23 = 0xFFFFFFE9;
    int length_frac = 23;
    int minus_x = ~x + 1;

    if (x > bias) // too large to represent as a norm, return +INF
        return inf;
    if (x == 0)
        return float_0;

    if (x < (denorm_bias + minus_23)) // too small to represent as a denorm
        return 0;

    if (x >= denorm_bias) // normalized
        return (x + bias) << length_frac;
    else // denormalized
        return 1 << (denorm_bias + minus_x);
}