leonetienne/GeneralUtility
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Namespacyfied

Browse Source
This commit is contained in:
Leonetienne 2022-02-27 19:59:09 +01:00
parent 425d53dc90
commit 9bece91a1d
7 changed files with 235 additions and 207 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

377
Src/BaseConversion.h
View File

@ -8,213 +8,226 @@
#include "ContainerUtility.h" #include "ContainerUtility.h"
class BaseConversion { namespace Leonetienne {
public: namespace GeneralUtility {
//! Will divide a number of arbitrary base in `dividend` by an integer divisor.
//! This is a specific helper function for the base conversion functions.
//! \tparam T_Container The type of container used for the digitstring
//! \param dividend The number to be divided in listlike container-form (such as a string)
//! \param divisor The integer divisor
//! \param set The set/base of `dividend`
//! \return A pair of the result. (result, rest)
template <class T_Container>
static std::pair<T_Container, int> DigitstringDivision(const T_Container& dividend, const unsigned int divisor, const T_Container& set);
//! Will convert a number of arbitrary base to base 10 class BaseConversion {
//! \tparam T_Container The type of container used for the digitstring public:
//! \param num A listlike container representing the number (such as a string) //! Will divide a number of arbitrary base in `dividend` by an integer divisor.
//! \param set The set/base of the number //! This is a specific helper function for the base conversion functions.
//! \return A 64-bit integer representing the number //! \tparam T_Container The type of container used for the digitstring
template <class T_Container> //! \param dividend The number to be divided in listlike container-form (such as a string)
static std::uint64_t BaseX_2_10(const T_Container& num, const T_Container& set); //! \param divisor The integer divisor
//! \param set The set/base of `dividend`
//! \return A pair of the result. (result, rest)
template<class T_Container>
static std::pair<T_Container, int>
DigitstringDivision(const T_Container &dividend, const unsigned int divisor, const T_Container &set);
//! Will convert a number to an arbitrary base. //! Will convert a number of arbitrary base to base 10
//! This just a wrapper for BaseX_2_Y. //! \tparam T_Container The type of container used for the digitstring
//! \tparam T_Container The type of container used for the digitstring //! \param num A listlike container representing the number (such as a string)
//! \param num The number to be converted //! \param set The set/base of the number
//! \param set The desired set/base for the output to be in. Should be a listlike container (such as a string) //! \return A 64-bit integer representing the number
//! \return `num` in base `set` template<class T_Container>
template <class T_Container> static std::uint64_t BaseX_2_10(const T_Container &num, const T_Container &set);
static T_Container Base10_2_X(const std::uint64_t& num, const T_Container& set, const std::uint32_t minOutLen = 1);
//! Will convert a number from an arbitrary base to another arbitrary base. //! Will convert a number to an arbitrary base.
//! \tparam T_ContainerIn The type of container used for the incoming digitstring //! This just a wrapper for BaseX_2_Y.
//! \tparam T_ContainerOut The type of container used for the outgoing digitstring //! \tparam T_Container The type of container used for the digitstring
//! \param num A representation of a number in a listlike container (such as a string) //! \param num The number to be converted
//! \param set_in The set/base of the input //! \param set The desired set/base for the output to be in. Should be a listlike container (such as a string)
//! \param set_out The desired set/base to output //! \return `num` in base `set`
//! \param minLen The minimum output length. Setting this will result in zero-padded output (Like, 00000001 instead of 1) template<class T_Container>
//! \return `num` in base `set_out` static T_Container
template <class T_ContainerIn, class T_ContainerOut> Base10_2_X(const std::uint64_t &num, const T_Container &set, const std::uint32_t minOutLen = 1);
static T_ContainerOut BaseX_2_Y(const T_ContainerIn& num, const T_ContainerIn& set_in, const T_ContainerOut& set_out, const std::uint32_t minOutLen = 1);
private: //! Will convert a number from an arbitrary base to another arbitrary base.
// No instantiation! >:( //! \tparam T_ContainerIn The type of container used for the incoming digitstring
BaseConversion(); //! \tparam T_ContainerOut The type of container used for the outgoing digitstring
}; //! \param num A representation of a number in a listlike container (such as a string)
//! \param set_in The set/base of the input
//! \param set_out The desired set/base to output
//! \param minLen The minimum output length. Setting this will result in zero-padded output (Like, 00000001 instead of 1)
//! \return `num` in base `set_out`
template<class T_ContainerIn, class T_ContainerOut>
static T_ContainerOut
BaseX_2_Y(const T_ContainerIn &num, const T_ContainerIn &set_in, const T_ContainerOut &set_out,
const std::uint32_t minOutLen = 1);
namespace { private:
// Fast 64-bit int power function // No instantiation! >:(
inline std::uint64_t Powuli(const std::uint64_t &b, const std::uint64_t &e) { BaseConversion();
std::uint64_t buf = 1; };
for (std::uint64_t i = 0; i < e; i++) namespace {
buf *= b; // Fast 64-bit int power function
inline std::uint64_t Powuli(const std::uint64_t &b, const std::uint64_t &e) {
std::uint64_t buf = 1;
return buf; for (std::uint64_t i = 0; i < e; i++)
} buf *= b;
}
template <class T_Container> return buf;
std::uint64_t BaseConversion::BaseX_2_10(const T_Container& num, const T_Container& set) {
// If base is 0, throw logic error
if (set.size() == 0)
throw std::logic_error("Can't convert from base0! Please supply a nonempty set!");
unsigned long long int buf = 0;
for (std::size_t i = 0; i < num.size(); i++) {
for (std::size_t j = 0; j < set.size(); j++) {
if (num[i] == set[j]) {
buf += Powuli((std::uint64_t)set.size(), (uint64_t)(num.size() - (i + 1))) * j;
break;
} }
} }
}
return buf; template<class T_Container>
} std::uint64_t BaseConversion::BaseX_2_10(const T_Container &num, const T_Container &set) {
// If base is 0, throw logic error
if (set.size() == 0)
throw std::logic_error("Can't convert from base0! Please supply a nonempty set!");
unsigned long long int buf = 0;
for (std::size_t i = 0; i < num.size(); i++) {
for (std::size_t j = 0; j < set.size(); j++) {
if (num[i] == set[j]) {
buf += Powuli((std::uint64_t) set.size(), (uint64_t) (num.size() - (i + 1))) * j;
break;
}
}
}
return buf;
}
// Based on: https://www.geeksforgeeks.org/divide-large-number-represented-string/ // Based on: https://www.geeksforgeeks.org/divide-large-number-represented-string/
template <class T_Container> template<class T_Container>
std::pair<T_Container, int> std::pair<T_Container, int>
BaseConversion::DigitstringDivision(const T_Container& dividend, const unsigned int divisor, const T_Container& set) { BaseConversion::DigitstringDivision(const T_Container &dividend, const unsigned int divisor,
// Quick rejects: const T_Container &set) {
// Quick rejects:
// No set? Throw logic error // No set? Throw logic error
if (set.size() == 0) if (set.size() == 0)
throw std::logic_error("Can't divide a number of base0! Please supply a nonempty set!"); throw std::logic_error("Can't divide a number of base0! Please supply a nonempty set!");
// No division by 0 // No division by 0
if (divisor == 0) if (divisor == 0)
throw std::overflow_error("Division by zero!"); throw std::overflow_error("Division by zero!");
// Dividend size 0? Return 0. // Dividend size 0? Return 0.
if (dividend.size() == 0) if (dividend.size() == 0)
return std::make_pair(T_Container({set[0]}), 0); return std::make_pair(T_Container({set[0]}), 0);
// Verify that all digits are represented in the set/base // Verify that all digits are represented in the set/base
for (const auto& c : dividend) for (const auto &c: dividend)
if (ContainerUtility::Ord(c, set) == -1) if (ContainerUtility::Ord(c, set) == -1)
throw std::logic_error("The supplied dividend contains a digit that is not represented in the set/base!"); throw std::logic_error(
"The supplied dividend contains a digit that is not represented in the set/base!");
// Now for the actual algorithm: // Now for the actual algorithm:
T_Container result; T_Container result;
// Find prefix of number that is larger than divisor. // Find prefix of number that is larger than divisor.
int idx = 0; int idx = 0;
int temp = ContainerUtility::Ord(dividend[idx], set); int temp = ContainerUtility::Ord(dividend[idx], set);
while (temp < divisor) { while (temp < divisor) {
idx++; idx++;
if (idx < dividend.size()) if (idx < dividend.size())
temp = temp * set.size() + ContainerUtility::Ord(dividend[idx], set); temp = temp * set.size() + ContainerUtility::Ord(dividend[idx], set);
else else
break; break;
}
// Repeatedly divide divisor with temp. After
// every division, update temp to include one
// more digit.
int curRest = temp % divisor;
while (dividend.size() > idx) {
// Store result in answer i.e. temp / divisor
result.insert(result.cend(), set[temp / divisor]);
curRest = temp % divisor;
// Take next digit of number
idx++;
if (idx < dividend.size())
temp = (temp % divisor) * set.size() + ContainerUtility::Ord(dividend[idx], set);
}
// If divisor is greater than number
if (result.size() == 0) {
// Generate 0-value digitstring
result.clear();
result.insert(result.cend(), set[0]);
return std::make_pair(result, BaseX_2_10(dividend, set));
}
// else return the answer
return std::make_pair(result, curRest);
}
template <class T_ContainerIn, class T_ContainerOut>
T_ContainerOut BaseConversion::BaseX_2_Y(const T_ContainerIn& num, const T_ContainerIn& set_in, const T_ContainerOut& set_out, const std::uint32_t minOutLen) {
if ((set_in.size() == 0) || (set_out.size() == 0))
throw std::logic_error("Can't convert from or to base0! Please supply a nonempty set!");
T_ContainerOut result;
// Generate a 0-value string for inbase
const T_ContainerIn zeroInbase({set_in[0]});
if (num != zeroInbase) {
// Populate result object
{
T_ContainerIn buf = num;
while (buf != zeroInbase) {
const auto divRes = DigitstringDivision(buf, set_out.size(), set_in);
const std::uint64_t mod = divRes.second;
buf = divRes.first;
result.insert(result.cend(), set_out[mod]);
} }
// Repeatedly divide divisor with temp. After
// every division, update temp to include one
// more digit.
int curRest = temp % divisor;
while (dividend.size() > idx) {
// Store result in answer i.e. temp / divisor
result.insert(result.cend(), set[temp / divisor]);
curRest = temp % divisor;
// Take next digit of number
idx++;
if (idx < dividend.size())
temp = (temp % divisor) * set.size() + ContainerUtility::Ord(dividend[idx], set);
}
// If divisor is greater than number
if (result.size() == 0) {
// Generate 0-value digitstring
result.clear();
result.insert(result.cend(), set[0]);
return std::make_pair(result, BaseX_2_10(dividend, set));
}
// else return the answer
return std::make_pair(result, curRest);
} }
// Reverse result object item order template<class T_ContainerIn, class T_ContainerOut>
{ T_ContainerOut
// Now reverse result BaseConversion::BaseX_2_Y(const T_ContainerIn &num, const T_ContainerIn &set_in, const T_ContainerOut &set_out,
T_ContainerOut buf = result; const std::uint32_t minOutLen) {
result.clear(); if ((set_in.size() == 0) || (set_out.size() == 0))
for (std::size_t i = 0; i < buf.size(); i++) throw std::logic_error("Can't convert from or to base0! Please supply a nonempty set!");
result.insert(result.cend(), buf[buf.size() - i - 1]);
T_ContainerOut result;
// Generate a 0-value string for inbase
const T_ContainerIn zeroInbase({set_in[0]});
if (num != zeroInbase) {
// Populate result object
{
T_ContainerIn buf = num;
while (buf != zeroInbase) {
const auto divRes = DigitstringDivision(buf, set_out.size(), set_in);
const std::uint64_t mod = divRes.second;
buf = divRes.first;
result.insert(result.cend(), set_out[mod]);
}
}
// Reverse result object item order
{
// Now reverse result
T_ContainerOut buf = result;
result.clear();
for (std::size_t i = 0; i < buf.size(); i++)
result.insert(result.cend(), buf[buf.size() - i - 1]);
}
} else {
// If num is 0, just pass a null-value. The algorithm would hang otherwise.
result.insert(result.cend(), set_out[0]);
}
// Add as much null-values to the left as requested.
if (result.size() < minOutLen) {
const std::size_t cachedLen = result.size();
const T_ContainerOut cachedStr = result;
result.clear();
for (std::size_t i = 0; i < minOutLen - cachedLen; i++)
result.insert(result.cend(), set_out[0]);
for (const auto &it: cachedStr)
result.insert(result.cend(), it);
}
return result;
} }
template<class T_Container>
T_Container
BaseConversion::Base10_2_X(const std::uint64_t &num, const T_Container &set, const std::uint32_t minOutLen) {
// Convert num to a string
std::stringstream ss;
ss << num;
const std::string numStr = ss.str();
// Use BaseX_2_Y to convert to outbase
const T_Container convertedNum = BaseX_2_Y<std::string, T_Container>(numStr, "0123456789", set, minOutLen);
// return it
return convertedNum;
}
} }
else
{
// If num is 0, just pass a null-value. The algorithm would hang otherwise.
result.insert(result.cend(), set_out[0]);
}
// Add as much null-values to the left as requested.
if (result.size() < minOutLen)
{
const std::size_t cachedLen = result.size();
const T_ContainerOut cachedStr = result;
result.clear();
for (std::size_t i = 0; i < minOutLen - cachedLen; i++)
result.insert(result.cend(), set_out[0]);
for (const auto& it : cachedStr)
result.insert(result.cend(), it);
}
return result;
}
template <class T_Container>
T_Container BaseConversion::Base10_2_X(const std::uint64_t &num, const T_Container& set, const std::uint32_t minOutLen) {
// Convert num to a string
std::stringstream ss;
ss << num;
const std::string numStr = ss.str();
// Use BaseX_2_Y to convert to outbase
const T_Container convertedNum = BaseX_2_Y<std::string, T_Container>(numStr, "0123456789", set, minOutLen);
// return it
return convertedNum;
} }
#endif //GENERALUTILITY_BASECONVERSION_H #endif //GENERALUTILITY_BASECONVERSION_H

55
Src/ContainerUtility.h
View File

@ -3,34 +3,39 @@
#include <algorithm> #include <algorithm>
class ContainerUtility { namespace Leonetienne {
public: namespace GeneralUtility {
//! Will return the index of `item` in `set`.
//! \tparam T_Type The type of `item`
//! \tparam T_Container The type of container
//! \param item The item to find the index for
//! \param set The container to be looking in
//! \return The index of `item` in `set`. -1 if not found.
template <typename T_Type, class T_Container>
static int Ord(const T_Type& item, const T_Container& set);
private: class ContainerUtility {
// No instantiation! >:( public:
ContainerUtility(); //! Will return the index of `item` in `set`.
}; //! \tparam T_Type The type of `item`
//! \tparam T_Container The type of container
//! \param item The item to find the index for
//! \param set The container to be looking in
//! \return The index of `item` in `set`. -1 if not found.
template<typename T_Type, class T_Container>
static int Ord(const T_Type &item, const T_Container &set);
template<typename T_Type, class T_Container> private:
int ContainerUtility::Ord(const T_Type& item, const T_Container& set) { // No instantiation! >:(
const auto result = ContainerUtility();
std::find_if(set.begin(), set.end(), [item](const T_Type& c) -> bool { };
return c == item;
});
// No item found template<typename T_Type, class T_Container>
if (result == set.end()) int ContainerUtility::Ord(const T_Type &item, const T_Container &set) {
return -1; const auto result =
else std::find_if(set.begin(), set.end(), [item](const T_Type &c) -> bool {
return result - set.begin(); return c == item;
});
// No item found
if (result == set.end())
return -1;
else
return result - set.begin();
}
}
} }
#endif //GENERALUTILITY_CONTAINERUTILITY_H #endif //GENERALUTILITY_CONTAINERUTILITY_H

2
Test/Base10_2_X.cpp
View File

@ -1,6 +1,8 @@
#include <BaseConversion.h> #include <BaseConversion.h>
#include "Catch2.h" #include "Catch2.h"
using namespace Leonetienne::GeneralUtility;
// Tests base 10 to 10 // Tests base 10 to 10
TEST_CASE(__FILE__"/Base10_to_10", "[BaseConversion][Base10_2_X]") TEST_CASE(__FILE__"/Base10_to_10", "[BaseConversion][Base10_2_X]")
{ {

2
Test/BaseX_2_10.cpp
View File

@ -1,6 +1,8 @@
#include <BaseConversion.h> #include <BaseConversion.h>
#include "Catch2.h" #include "Catch2.h"
using namespace Leonetienne::GeneralUtility;
// Tests base 10 to 10 // Tests base 10 to 10
TEST_CASE(__FILE__"/Base10_to_10", "[BaseConversion][BaseX_2_10]") TEST_CASE(__FILE__"/Base10_to_10", "[BaseConversion][BaseX_2_10]")
{ {

2
Test/BaseX_2_Y.cpp
View File

@ -1,6 +1,8 @@
#include <BaseConversion.h> #include <BaseConversion.h>
#include "Catch2.h" #include "Catch2.h"
using namespace Leonetienne::GeneralUtility;
// Tests base 10 to 10 // Tests base 10 to 10
TEST_CASE(__FILE__"/Base10_to_10", "[BaseConversion][BaseX_2_Y]") TEST_CASE(__FILE__"/Base10_to_10", "[BaseConversion][BaseX_2_Y]")
{ {

2
Test/DigitstringDivision.cpp
View File

@ -5,6 +5,8 @@
#include <time.h> #include <time.h>
#include <stdexcept> #include <stdexcept>
using namespace Leonetienne::GeneralUtility;
// Tests that basic division (base10) is working, with oracle values // Tests that basic division (base10) is working, with oracle values
TEST_CASE(__FILE__"/Base10", "[BaseConversion][DigitstringDivision]") TEST_CASE(__FILE__"/Base10", "[BaseConversion][DigitstringDivision]")
{ {

2
Test/Ord.cpp
View File

@ -3,6 +3,8 @@
#include <string> #include <string>
#include <vector> #include <vector>
using namespace Leonetienne::GeneralUtility;
// Tests that the Ord method works with characters in a string // Tests that the Ord method works with characters in a string
TEST_CASE(__FILE__"/WorksWithCharsInString", "[ContainerUtility][Ord]") TEST_CASE(__FILE__"/WorksWithCharsInString", "[ContainerUtility][Ord]")
{ {