#include <limits>
#include <iostream> // needed for demonstration purpose only
#include <stdexcept> // needed for demonstration purpose only
#include <array> // needed for demonstration purpose only
#include <utility> // needed for demonstration purpose only
namespace safe
{
constexpr static auto max = std::numeric_limits<int>::max();
constexpr static auto min = std::numeric_limits<int>::min();
int negation(int a);
int multiplication(int a, int b);
int division(int a, int b);
int addition(int a, int b);
int subtraction(int a, int b);
}
namespace test
{
template <typename Function>
void unary(Function function, const char* function_name, int a);
template <typename Function>
void binary(Function function, const char* function_name, int a, int b);
}
int main()
{
using namespace safe;
using UnaryFunction = int (*)(int);
using BinaryFunction = int (*)(int, int);
using FunctionName = const char*;
using TestsUnary = std::array<std::pair<UnaryFunction, FunctionName>, 1>;
using TestsBinary = std::array<std::pair<BinaryFunction, FunctionName>, 4>;
TestsUnary unary_functions = {std::make_pair(negation, "negation")};
TestsBinary binary_functions = {std::make_pair(multiplication, "multiplication"),
std::make_pair(division, "division"),
std::make_pair(addition, "addition"),
std::make_pair(subtraction, "subtraction")};
std::array<int, 19> values = { min,
(min / 2) - 1,
min / 2,
(min / 2) + 1,
min / 3,
-4,
-3,
-2,
-1,
0,
1,
2,
3,
4,
max / 3,
(max / 2) - 1,
max / 2,
(max / 2) + 1,
max};
using namespace test;
for ( auto& testable : unary_functions )
{
auto& function = std::get<0>(testable);
auto& name = std::get<1>(testable);
std::cout << name << ":\n";
for ( auto value : values )
{
test::unary(function, name, value);
}
std::cout << '\n';
}
for ( auto& testable : binary_functions )
{
auto& function = std::get<0>(testable);
auto& name = std::get<1>(testable);
std::cout << name << ":\n";
for ( auto value1 : values )
{
for ( auto value2 : values )
{
test::binary(function, name, value1, value2);
}
std::cout << '\n';
}
std::cout << '\n';
}
return 0;
}
namespace safe
{
/**
* Integer multiplication.
*
* Detailed logic:
* if ( a == 0 || b == 0 )
* {
* return 0;
* }
* else if ( a == -1 )
* {
* return negation(b);
* }
* else if ( b == -1 )
* {
* return negation(a);
* }
* else if ( a > 0 && b > 0 )
* {
* const auto limit_result = max; // result will be positive
* const auto limit_a = limit_result / b; // (limit_a + 1) * b > max, which is invalid.
* if ( a > limit_a )
* {
* // error
* }
* }
* else if ( a < 0 && b < 0 )
* {
* const auto limit_result = max; // result will be positive
* const auto limit_a = limit_result / b; // (limit_a - 1) * b > max, which is invalid.
* if ( a < limit_a )
* {
* // error
* }
* }
* else if ( a > 0 && b < 0 )
* {
* const auto limit_result = min; // result will be negative
* const auto limit_a = limit_result / b; // (limit_a + 1) * b < min, which is invalid
* if ( a > limit_a )
* {
* // error
* }
* }
* else if ( a < 0 && b > 0 )
* {
* const auto limit_result = min; // result will be negative
* const auto limit_a = limit_result / b; // (limit_a - 1) * b < min, which is invalid
* if ( a < limit_a )
* {
* // error
* }
* }
* return a * b;
*
*/
int multiplication(int a, int b)
{
if ( (a == 0) || (b == 0) )
{
return 0;
}
if ( a == -1 )
{
return negation(b);
}
if ( b == -1 )
{
return negation(a);
}
const auto limit_result = ((a > 0) == (b > 0)) ? max : min;
const auto limit_a = limit_result / b; // well defined, since b != 0, b != -1.
if ( (0 < a && limit_a < a) || (0 > a && limit_a > a) )
{
throw std::invalid_argument("Multiplication overflow.");
}
return a * b;
}
/**
*
* Integer division can only fail if the divisor is zero.
* It can also fail, it the divisor is -1 (because then only the sign changes and the magnitude isn't guaranteed to fit.)
*/
int division(int a, int b)
{
if ( b == 0 )
{
throw std::invalid_argument("Division by zero.");
}
if ( b == -1 )
{
return negation(a);
}
return a / b; // division is safe, if divisor is not equal to zero.
}
/**
If the operands have different sign, the result cannot be invalid:
w.l.o.g. a < 0 && b > 0
min <= a < 0 < b <= max
Hence,
a >= min && b > 0, therefore a + b >= min + b >= min
b <= max && a < 0, therefore b - (-a) <= max - (-a) <= max
If the operands have the same sign, the result may be invalid.
If a > 0 and b > 0:
If a + b > max, then conversely a > max - b. max - b is valid.
If a < 0 and b < 0:
If a + b < min, then conversely a < min - b, min - b is valid.
*/
int addition(int a, int b)
{
if ( (a > 0 && b > 0 && max - b < a) ||
(a < 0 && b < 0 && a < min - b) )
{
throw std::invalid_argument("Addition overflow.");
}
return a + b;
}
/**
* Technically, this can be done by inverting b and calculating a + (-b).
* This however can fail, if -b cannot be represented.
*
* Hence, the same logic as in addition is applied:
* If a and b have the same sign, the result is valid.
* If a > 0 and b < 0, the result may be too large, however, max + b is a valid number
* If a < 0 and b > 0, the result may be too small, however, min + b is a valid number.
*/
int subtraction(int a, int b)
{
if ( (a > 0 && b < 0 && max + b < a) ||
(a < 0 && b > 0 && a < min + b) )
{
throw std::invalid_argument("Subtraction overflow.");
}
return a - b;
}
/**
-a is invalid, if it cannot be represented in that range.
The integer type either has the range [-2^n, 2^n) or
(-2^n, 2^n)
That is, either the smallest number is -2^n or -2^n + 1,
while the largest number is always 2^n - 1.
Hence, the only value that may not be valid input is the smallest number.
If the range is symmetric, every value can be inverted,
otherwise, the negation fails for the smallest number.
*/
int negation(int a)
{
constexpr static bool symmetric_range = (min + max == 0);
if ( !symmetric_range && a == min )
{
throw std::invalid_argument("The integer representation doesn't allow negation of the smallest integer.");
}
return -a;
}
}
namespace test
{
template <typename Function>
void unary(Function function, const char* function_name, int a)
try
{
function(a);
std::cout << '1';
}
catch ( ... )
{
std::cout << '0';
}
template <typename Function>
void binary(Function function, const char* function_name, int a, int b)
try
{
function(a, b);
std::cout << '1';
}
catch ( ... )
{
std::cout << '0';
}
}

#include <limits>

#include <iostream>  // needed for demonstration purpose only
#include <stdexcept> // needed for demonstration purpose only
#include <array>     // needed for demonstration purpose only
#include <utility>   // needed for demonstration purpose only

namespace safe
{
	constexpr static auto max = std::numeric_limits<int>::max();
	constexpr static auto min = std::numeric_limits<int>::min();

	int negation(int a);
	
	int multiplication(int a, int b);
	int division(int a, int b);
	int addition(int a, int b);
	int subtraction(int a, int b);
}

namespace test
{
	template <typename Function>
	void unary(Function function, const char* function_name, int a);
	
	template <typename Function>
	void binary(Function function, const char* function_name, int a, int b);
}

int main()
{
	using namespace safe;
	using UnaryFunction = int (*)(int);
	using BinaryFunction = int (*)(int, int);
	using FunctionName = const char*;
	using TestsUnary = std::array<std::pair<UnaryFunction, FunctionName>, 1>;
	using TestsBinary = std::array<std::pair<BinaryFunction, FunctionName>, 4>;
	TestsUnary unary_functions = {std::make_pair(negation, "negation")};
	TestsBinary binary_functions = {std::make_pair(multiplication, "multiplication"),
	                                std::make_pair(division, "division"),
	                                std::make_pair(addition, "addition"),
	                                std::make_pair(subtraction, "subtraction")};
	
	std::array<int, 19> values = { min,
	                              (min / 2) - 1,
	                               min / 2,
	                              (min / 2) + 1,
	                               min / 3,
	                              -4,
	                              -3,
	                              -2,
	                              -1,
	                               0,
	                               1,
	                               2,
	                               3,
	                               4,
	                               max / 3,
	                              (max / 2) - 1,
	                               max / 2,
	                              (max / 2) + 1,
	                               max};

	using namespace test;
	for ( auto& testable : unary_functions )
	{
		auto& function = std::get<0>(testable);
		auto& name = std::get<1>(testable);
		std::cout << name << ":\n";
		for ( auto value : values )
		{
			test::unary(function, name, value);
		}
		std::cout << '\n';
	}

	for ( auto& testable : binary_functions )
	{
		auto& function = std::get<0>(testable);
		auto& name = std::get<1>(testable);
		std::cout << name << ":\n";
		for ( auto value1 : values )
		{
			for ( auto value2 : values )
			{
				test::binary(function, name, value1, value2);
			}
			std::cout << '\n';
		}
		std::cout << '\n';
	}
	return 0;
}

namespace safe
{


		/**
		 * 	Integer multiplication.
		 * 	
		 * 	Detailed logic:
		 * 	if ( a == 0 || b == 0 )
		 * 	{
 		*		return 0;
		 * 	}
		 *  else if ( a == -1 )
		 *  {
		 *      return negation(b);
		 *  }
		 *  else if ( b == -1 )
		 *  {
		 *      return negation(a);
		 *  }
		 * 	else if ( a > 0 && b > 0 )
		 * 	{
 		 *	 	const auto limit_result = max; // result will be positive
		 * 		const auto limit_a = limit_result / b; // (limit_a + 1) * b > max, which is invalid.
		 * 		if ( a > limit_a )
		 * 		{
 		 *			// error
		 * 		}
		 * 	}
		 * 	else if ( a < 0 && b < 0 )
		 * 	{
 		 * 		const auto limit_result = max; // result will be positive
	     *	 	const auto limit_a = limit_result / b; // (limit_a - 1) * b > max, which is invalid.
		 * 		if ( a < limit_a )
		 * 		{
		 *			// error
		 * 		}
		 * 	}
		 * 	else if ( a > 0 && b < 0 )
		 * 	{
 		 * 		const auto limit_result = min; // result will be negative
		 * 		const auto limit_a = limit_result / b; // (limit_a + 1) * b < min, which is invalid
		 * 		if ( a > limit_a )
		 * 		{
  		 * 			// error
		 * 		}
		 * 	}
		 * 	else if ( a < 0 && b > 0 )
		 *	{
		 *		const auto limit_result = min; // result will be negative
		 *		const auto limit_a = limit_result / b; // (limit_a - 1) * b < min, which is invalid
		 *		if ( a < limit_a )
		 *		{
		 *			// error
		 *		}
		 * 	}
		 *	return a * b;
		 * 
		 */
	int multiplication(int a, int b)
	{
		if ( (a == 0) || (b == 0) )
		{
			return 0;
		}
		if ( a == -1 )
		{
			return negation(b);
		}
		if ( b == -1 )
		{
			return negation(a);
		}
		const auto limit_result = ((a > 0) == (b > 0)) ? max : min;
		const auto limit_a = limit_result / b; // well defined, since b != 0, b != -1.
		if ( (0 < a && limit_a < a) || (0 > a && limit_a > a) )
		{
			throw std::invalid_argument("Multiplication overflow.");
		}
		return a * b;
	}

	/**
	 * 
	 * 	Integer division can only fail if the divisor is zero.
	 *  It can also fail, it the divisor is -1 (because then only the sign changes and the magnitude isn't guaranteed to fit.)
	 */
	int division(int a, int b)
	{
		if ( b == 0 )
		{
			throw std::invalid_argument("Division by zero.");
		}
		if ( b == -1 )
		{
			return negation(a);
		}
		return a / b; // division is safe, if divisor is not equal to zero.
	}

	/**
		If the operands have different sign, the result cannot be invalid:
		   w.l.o.g. a < 0 && b > 0
			min <= a < 0 < b <= max
			Hence, 
			a >= min && b > 0, therefore a + b    >= min + b    >= min
			b <= max && a < 0, therefore b - (-a) <= max - (-a) <= max
		If the operands have the same sign, the result may be invalid.
		  If a > 0 and b > 0:
		    If a + b > max, then conversely a > max - b. max - b is valid.
		  If a < 0 and b < 0:
		  	If a + b < min, then conversely a < min - b, min - b is valid.
	 */
	int addition(int a, int b)
	{
		if ( (a > 0 && b > 0 && max - b < a) ||
		     (a < 0 && b < 0 && a < min - b) )
		{
			throw std::invalid_argument("Addition overflow.");
		}
		return a + b;
	}

	/**
	 * Technically, this can be done by inverting b and calculating a + (-b).
	 * This however can fail, if -b cannot be represented.
	 * 
	 * Hence, the same logic as in addition is applied:
	 * If a and b have the same sign, the result is valid.
	 * If a > 0 and b < 0, the result may be too large, however, max + b is a valid number
	 * If a < 0 and b > 0, the result may be too small, however, min + b is a valid number.
	 */
	int subtraction(int a, int b)
	{
		if ( (a > 0 && b < 0 && max + b < a) ||
		     (a < 0 && b > 0 && a < min + b) )
		{
			throw std::invalid_argument("Subtraction overflow.");
		}
		return a - b;
	}

	/**
		-a is invalid, if it cannot be represented in that range.
		The integer type either has the range [-2^n, 2^n) or
		                                      (-2^n, 2^n)
		That is, either the smallest number is -2^n or -2^n + 1,
		 while the largest number is always 2^n - 1.
		
		Hence, the only value that may not be valid input is the smallest number.
		
		If the range is symmetric, every value can be inverted,
		otherwise, the negation fails for the smallest number.
	*/
	int negation(int a)
	{
		constexpr static bool symmetric_range = (min + max == 0);
		if ( !symmetric_range && a == min )
		{
			throw std::invalid_argument("The integer representation doesn't allow negation of the smallest integer.");
		}
		return -a;
	}
}

namespace test
{
	template <typename Function>
	void unary(Function function, const char* function_name, int a)
	try
	{
		function(a);
		std::cout << '1';
	}
	catch ( ... )
	{
		std::cout << '0';
	}
	
	template <typename Function>
	void binary(Function function, const char* function_name, int a, int b)
	try
	{
		function(a, b);
		std::cout << '1';
	}
	catch ( ... )
	{
		std::cout << '0';
	}
}
