ACCU Autumn 2019

The Secret Life of Numbers

John McFarlane

About Me

Software Engineer, Jaguar Land Rover, Shannon, Ireland

BSI, MISRA C++, WG21 (SG14 & SG6)

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!

git clone https://github.com/johnmcfarlane/cnl.git
c++ -std=c++17 -Wall -Wextra -Werror -Wpedantic slide_code.cpp

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

2. Typology

2.0. Don't Sell Yourself Short

CNL: Compositional Numeric Library

github.com/johnmcfarlane/cnl

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

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

// 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>:10:39: error: overflow in constant expression [-fpermissive]          
constexpr auto root32 = root2 * 4;
                                  ^

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

constexpr auto root32 = root2 * 4;

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

c++ -std=c++17
    -Wall -Wextra -Werror
    -fsanitize=address,undefined
    all_your_source_files.cpp

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

cnl.h:2903:51: runtime error: signed integer overflow:
1518500249 * 4 cannot be represented in type 'int'

unsigned mu = 0;
cout << (mu-1);

4294967295

int s = 1;
cout << (s << 31);

-2147483648

int ms = 100000;
cout << 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_number.h
namespace cnl {
   template<int Digits, int Exponent>
   using elastic_number =
       scaled_integer<elastic_integer<Digits>, power<Exponent>>;

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

// user code
using namespace cnl::literals;

// elastic_number<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_number.h
namespace cnl {
   template<int Digits, int Exponent>
   using elastic_number = ...;
}

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

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

// elastic_number<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_number<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