Numbers and Math

#include <inttypes.h>
#include <stdio.h>
#include <stdlib.h>

int main(void)
{
    printf("%d %ld %lld\n", abs(-5), labs(-5L), llabs(-5LL));
    printf("%" PRIdMAX "\n", imaxabs((intmax_t)-5));

    // Quotient and remainder in one operation, with a defined sign convention.
    div_t d = div(-7, 2);
    ldiv_t ld = ldiv(-7L, 2L);

    printf("%d %d | %ld %ld\n", d.quot, d.rem, ld.quot, ld.rem);   // -3 -1 | -3 -1
    return 0;
}

#include <inttypes.h>
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>

int main(void)
{
    int64_t big = 9007199254740993;
    uint32_t small = 4000000000u;
    uintptr_t address;
    int32_t parsed = 0;

    address = (uintptr_t)&big;

    printf("%" PRId64 " %" PRIu32 " %" PRIxPTR "\n", big, small, address);

    // The SCN* macros do the same for scanf.
    if (sscanf("-12345", "%" SCNd32, &parsed) == 1) {
        printf("parsed %" PRId32 "\n", parsed);
    }

    // size_t and ptrdiff_t have their own built-in specifiers -- no macro needed.
    size_t count = 3;
    ptrdiff_t delta = -2;
    printf("%zu %td\n", count, delta);
    return 0;
}

#include <limits.h>
#include <stdckdint.h>
#include <stdio.h>

int main(void)
{
    int result = 0;

    // Each returns true if the mathematical result does NOT fit the destination.
    if (ckd_add(&result, INT_MAX, 1)) {
        printf("addition overflowed; wrapped value is %d\n", result);
    }

    if (!ckd_mul(&result, 1000, 1000)) {
        printf("1000 * 1000 = %d\n", result);
    }

    if (ckd_sub(&result, INT_MIN, 1)) {
        puts("subtraction overflowed");
    }

    // The destination type is what matters -- narrowing is checked too:
    signed char small = 0;
    if (ckd_add(&small, (signed char)100, (signed char)100)) {
        printf("does not fit a signed char: %d\n", small);
    }
    return 0;
}

#include <stdckdint.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>

static void *allocate_array(size_t count, size_t element_size)
{
    size_t total = 0;

    if (ckd_mul(&total, count, element_size)) {
        return nullptr;                     // the multiplication would have wrapped
    }
    return malloc(total);
}

int main(void)
{
    void *ok = allocate_array(100, sizeof(double));
    void *nope = allocate_array(SIZE_MAX, 2);

    printf("%s %s\n", ok != nullptr ? "allocated" : "failed",
                      nope == nullptr ? "rejected" : "allocated");
    free(ok);
    return 0;
}

#include <stdbit.h>
#include <stdio.h>

int main(void)
{
    unsigned int value = 0b0010'1100u;      // 44

    printf("count_ones      = %u\n", stdc_count_ones(value));           // 3
    printf("count_zeros     = %u\n", stdc_count_zeros(value));
    printf("leading_zeros   = %u\n", stdc_leading_zeros(value));
    printf("trailing_zeros  = %u\n", stdc_trailing_zeros(value));       // 2
    printf("first_leading_one  = %u\n", stdc_first_leading_one(value));
    printf("first_trailing_one = %u\n", stdc_first_trailing_one(value));
    printf("bit_width       = %u\n", stdc_bit_width(value));            // 6
    printf("has_single_bit  = %d\n", (int)stdc_has_single_bit(value));  // 0
    printf("bit_floor       = %u\n", stdc_bit_floor(value));            // 32
    printf("bit_ceil        = %u\n", stdc_bit_ceil(value));             // 64

    // Endianness, finally testable at compile time:
#if __STDC_ENDIAN_NATIVE__ == __STDC_ENDIAN_LITTLE__
    puts("little-endian");
#elif __STDC_ENDIAN_NATIVE__ == __STDC_ENDIAN_BIG__
    puts("big-endian");
#else
    puts("mixed-endian");
#endif
    return 0;
}

#include <fenv.h>
#include <math.h>
#include <stdio.h>

// Required whenever a program inspects or changes the FP environment:
#pragma STDC FENV_ACCESS ON

int main(void)
{
    feclearexcept(FE_ALL_EXCEPT);

    volatile double tiny = 1.0 / 3.0;       // inexact
    volatile double overflowed = 1e308 * 10.0;
    (void)tiny;
    (void)overflowed;

    if (fetestexcept(FE_INEXACT)) {
        puts("FE_INEXACT raised");
    }
    if (fetestexcept(FE_OVERFLOW)) {
        puts("FE_OVERFLOW raised");
    }

    // Change the rounding mode, then restore it.
    int previous = fegetround();
    if (fesetround(FE_TOWARDZERO) == 0) {
        printf("toward zero: nearbyint(2.7) = %g\n", nearbyint(2.7));
        fesetround(previous);
    }
    printf("restored:    nearbyint(2.7) = %g\n", nearbyint(2.7));
    return 0;
}

#include <complex.h>
#include <stdio.h>

int main(void)
{
    double complex z = 3.0 + 4.0 * I;
    double complex w = 1.0 - 2.0 * I;

    double complex sum = z + w;
    double complex product = z * w;

    printf("z = %g%+gi, |z| = %g, arg = %g\n", creal(z), cimag(z), cabs(z), carg(z));
    printf("sum = %g%+gi, product = %g%+gi\n",
           creal(sum), cimag(sum), creal(product), cimag(product));
    printf("conj = %g%+gi, sqrt = %g%+gi\n",
           creal(conj(z)), cimag(conj(z)), creal(csqrt(z)), cimag(csqrt(z)));
    return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

// Unbiased range: rejection sampling, NOT rand() % n (which favours low values
// whenever n does not divide RAND_MAX + 1).
// A single rand() call spans 0..RAND_MAX, so a larger bound cannot be served:
// reject it up front instead of looping forever on an empty acceptance range.
static bool random_below(int bound, int *out)
{
    if (bound <= 0 || bound > RAND_MAX) {
        return false;
    }

    int buckets = RAND_MAX / bound;
    int limit = buckets * bound;

    int value;
    do {
        value = rand();
    } while (value >= limit);

    *out = value / buckets;
    return true;
}

int main(void)
{
    srand((unsigned)time(nullptr));         // seed ONCE, at start-up

    printf("RAND_MAX = %d\n", RAND_MAX);
    for (int i = 0; i < 5; ++i) {
        int roll = 0;
        if (random_below(6, &roll)) {
            printf("%d ", roll + 1);        // a fair die
        }
    }
    putchar('\n');
    return 0;
}