CppIndia 2022-03-12

The Secret Life of Numbers

John McFarlane

About Me

Software Engineer, Jaguar Land Rover, Shannon, Ireland

BSI, WG21 (SG6, SG14, SG21)

Background

BBC BASIC, 6502, C, 80286/7, C++, Python

Games, Fractals, AI, Simulation, APIs, Numerics, CI

Contents

1. Bit Parts
2. Typology
3. Range-Based Four
4. Round Up

1. Bit Parts

1.0. Acting Natural

1.0. Act Natural

1.1. Be Positive

1.1. Be Positive

1.2. A Slice of Π

1.2. A Slice of Π

1.3. Floatation Devices

1.3. Floatation Devices

1.4. Frame the Problem

1.4. Frame the Problem

1.9.9 Warning

Slide Code Ahead!

-std=c++20

#include <cnl/all.h>
using namespace cnl;
using namespace cnl::literals;
using namespace fmt;
using namespace std;
using namespace std::math;

2. Typology

2.0. Don't Sell Yourself Short

CNL: Compositional Numeric Library

github.com/johnmcfarlane/cnl/tree/v1.x

template<int Exponent=0, int Radix=2>
class power;

template<typename Rep=int, typename Scale=power<>>
class scaled_integer;

template<typename Rep, int Exponent, int Radix>
class scaled_integer<Rep, power<Exponent, Radix>> {
  // ...
private:
  Rep n;
};

value = n×Radix^Exponent

42... it's a byte, right?

int8_t{42}

scaled_integer<int8_t, power<1>>{42}  // 21×21

scaled_integer<int, power<1>>{42}

CNL's zero-cost abstraction

auto a(float value)
-> scaled_integer<int8_t, power<1>>
{
    return value;
}

a(float):
    mulss   xmm0, DWORD PTR .LC0[rip]
    cvttss2si       eax, xmm0
    ret

auto b(float value)
-> int8_t
{
    return value * .5f;
}

b(float):
    mulss   xmm0, DWORD PTR .LC0[rip]
    cvttss2si       eax, xmm0
    ret

int's zero-cost abstraction

auto a(float value)
-> scaled_integer<int   , power<1>>
{
    return value;
}

a(float):
    mulss   xmm0, DWORD PTR .LC0[rip]
    cvttss2si       eax, xmm0
    ret

auto b(float value)
-> int
{
    return value * .5f;
}

b(float):
    mulss   xmm0, DWORD PTR .LC0[rip]
    cvttss2si       eax, xmm0
    ret

std::int8_t costly abstraction!

auto a(float value) -> int
{
    return value * .5f;
}

to_int8(float):
    vmov.f32        s15, #5.0e-1
    vmul.f32        s0, s0, s15
    vcvt.s32.f32    s15, s0
    vmov    r0, s15 @ int
    bx      lr

auto b(float value) -> int8_t
{
    return value * .5f;
}

to_int(float):
    sub     sp, sp, #8
    vmov.f32        s15, #5.0e-1
    vmul.f32        s0, s0, s15
    vcvt.s32.f32    s15, s0
    vstr.32 s15, [sp, #4]     @ int
    ldrsb   r0, [sp, #4]
    add     sp, sp, #8
    bx      lr

42... it's a byte, right?

int8_t{42}

scaled_integer<int8_t, power<1>>{42}

scaled_integer<int, power<1>>{42}

UDL: User-Defined Literals

namespace cnl::literals {
    template<char... Chars>
    constexpr auto operator ""_c() noexcept;
}

// constant<42>
auto forty_two = 42_c;

// scaled_integer<int, power<1>>{42}
auto a = scaled_integer{forty_two};

2.0. Don't Sell Yourself Short

2.1. All Your Base

// scaled_integer<int, power<3>>{1000}
auto k = scaled_integer{1000_c};

// scaled_integer<int, power<6>>{1000000}
auto m = k*k;

2.1. All Your Base

2.1. All Your Base

Decimal Fixed-Point

// scaled_integer<int, power<3, 10>>{1000}
auto k = scaled_integer<int, power<3, 10>>{1000};

// scaled_integer<int, power<6, 10>>{1000000}
auto m = k*k;

2.1. All Your Base

2.2. Root Planning

(5.8284270763397216796875)

3. Range-Based Four

3.0. Prescriptive

          auto root2 = sqrt2_v<scaled_integer<int, power<-30>>>;

          auto root32 = root2 * 4;

<source>:7:33: error: overflow in constant expression [-fpermissive]
    7 | constexpr auto root32 = root2 * 4;
      |                                 ^

constexpr auto root2 = sqrt2_v<scaled_integer<int, power<-30>>>;

constexpr auto root32 = root2 * 4;

<source>:7:33: error: overflow in constant expression [-fpermissive]
    7 | constexpr auto root32 = root2 * 4;
      |                                 ^

If you remember one slide...

c++ -std=c++20 -fsanitize=address,undefined -fno-sanitize-recover=all
    -Wall -Wextra -Werror all_your_source_files.cpp

auto root2 = sqrt2_v<scaled_integer<int, power<-30>>>;
auto root32 = root2 * 4;

Program returned: 1
/opt/compiler-explorer/libs/cnl/v1.x/include/cnl/_impl/operators/operators.h:76:28:
runtime error: signed integer overflow:1518500249 * 4 cannot be represented in type 'int'
                

unsigned mu = 0;
fmt::print("{}\n", mu-1);

4294967295

int s = 1;
fmt::print("{}\n", s << 31);

-2147483648

int ms = 100000;
fmt::print("{}\n", short(ms));

-31072

3.0. Prescriptive

3.1. Descriptive Range

// cnl/elastic_integer.h
namespace cnl {
   template<int Digits, typename Narrowest=int>
   class elastic_integer;
}

// elastic_integer<10>{1000}
auto k = elastic_integer{1000_c};

// elastic_integer<20>{1000000}
auto m = k*k;

// elastic_integer<40>{1000000000000LL}
auto t = m*m;

// cnl/elastic_integer.h
namespace cnl {
   template<int Digits, typename Narrowest=int>
   class elastic_integer;
}

// elastic_integer<10>{1000}
auto k = elastic_integer{1000_c};

// elastic_integer<20>{1000000}
auto m = k*k;

// elastic_integer<40>{1000000000000LL}
auto t = m*m;

// cnl/elastic_scaled_integer.h
namespace cnl {
   template<int Digits, int Exponent>
   using elastic_scaled_integer =
       scaled_integer<elastic_integer<Digits>, power<Exponent>>;

   namespace literals {
      template<char ... Chars>
      constexpr auto operator ""_elastic() noexcept;
   }
}

// user code
using namespace cnl::literals;

// elastic_scaled_integer<7, 3>
constexpr auto k = 1000_elastic;

// cnl/elastic_integer.h
namespace cnl {
   template<int Digits, typename Narrowest=int>
   class elastic_integer;
}

// elastic_integer<10>{1000}
auto k = elastic_integer{1000_c};

// elastic_integer<20>{1000000}
auto m = k*k;

// elastic_integer<40>{1000000000000LL}
auto t = m*m;

// cnl/elastic_scaled_integer.h
namespace cnl {
   template<int Digits, int Exponent>
   using elastic_scaled_integer = ...;
}

// elastic_scaled_integer<7, 3>{1000}
auto k = 1000_elastic;

// elastic_scaled_integer<14, 6>{1000000}
auto m = k*k;

// elastic_scaled_integer<28, 12>{1000000000000LL}
auto t = m*m;

3.1. Descriptive Range

3.2. Adaptive Range

auto root2 = sqrt2_v<scaled_integer<int, power<-30>>>;

// scaled_integer<int, power<-28>>
auto root32 = root2 << 2_c;

// elastic_scaled_integer<31, -28>
auto root32 = root2 * 4_elastic;

3.2. Adaptive Range

4. Round Up

4.0. Conclusion

• 2∞+8
• ∞+1
• ∞+3
• 2∞+24
• 3
• scaled_integer{42_c}
• 14 1
• 5.8284270763397216796875
• don't.
• stretch!
• don't stretch.

4.1. Thank You