src/N.Conversion.cpp

#include <symbolism/N.h>
#include <string>
#include <sstream>

using namespace std;

namespace symbolism {
namespace ring {


const char* english_zero = "zero ";

const char* english_digits[20] =
{
    "", "one ", "two ", "three ", "four ", "five ", "six ", "seven ", "eight ", "nine ",
    "ten ", "eleven ", "twelve ", "thirteen ", "fourteen ", "fifteen ", "sixteen ", "seventeen ", "eighteen ", "nineteen "
};

const char* english_tens[10] =
{
    "", "ten ", "twenty ", "thirty ", "forty ", "fifty ", "sixty ", "seventy ", "eighty ", "ninety "
};

const char* english_hundreds[10] =
{
    "", "hundred ", "two hundred ", "three hundred ", "four hundred ", "five hundred ", "six hundred ", "seven hundred ", "eight hundred ", "nine hundred "
};

const char* english_thousand = "thousand";

const char* latin_digits_single[11] =
{
    "", "million", "billion", "trillion", "quadrillion", "quintillion", "sextillion", "septillion", "octillion", "nonillion", "decillion"
};

const char* latin_digits[10] =
{
    "", "un-", "do-", "tre-", "quattuor-", "quin-", "sex-", "septen-", "octo-", "novem-"
};

const char* latin_tens[10] =
{
    "", "dec-", "vigin-", "trigin-", "quadragin-", "quinquagin-", "sexagin-", "septuagin-", "octogin-", "nonagin-"
};

const char* latin_hundreds[10] =
{
    "", "cen-", "ducen-", "trecen-", "quadringen-", "quingen-", "sescen-", "septingen-", "octingen-", "nongen-"
};

const char* latin_thousand = "millia-";


string N::to_binary() const
{
    char* bytes = new char[(size + 1) * 64 + 1] ();
    unsigned char* ubytes = reinterpret_cast<unsigned char*>(bytes);
    int s = mpn_get_str(ubytes, 2, const_cast<limb_t*>(limbs()), size + 1);
    //bytes = reinterpret_cast<char*>(realloc(bytes, s + 1));

    for(int i=0; i < s; i++)
    {
        bytes[i] += '0';
    }
    bytes[s] = 0x00;

    string str(bytes);
    delete[] bytes;
    return str;
}

string N::to_hexadecimal() const
{
    char* bytes = new char[(size + 1) * 16 + 2] ();
    unsigned char* ubytes = reinterpret_cast<unsigned char*>(bytes);
    int s = mpn_get_str(ubytes, 16, const_cast<limb_t*>(limbs()), size + 1);
    //bytes = reinterpret_cast<char*>(realloc(bytes, s + 1));

    for(int i=0; i < s; i++)
    {
        if(bytes[i] < 10)
        {
            bytes[i] += '0';
        }
        else
        {
            bytes[i] += 'A' - 10;
        }
    }
    bytes[s] = 0x00;

    string str(bytes);
    delete[] bytes;
    return str;
}

string N::to_decimal() const
{
    if(this_small)
    {
        stringstream strstream;
        strstream << limb;
        return strstream.str();
    }
    else
    {
        limb_t* cpy = new limb_t[size + 1] ();
        memcpy(cpy, data, (size + 1) * sizeof(limb_t));

        char* bytes = new char[(size + 1) * 20 + 1] ();
        unsigned char* ubytes = reinterpret_cast<unsigned char*>(bytes);

        int s = mpn_get_str(ubytes, 10, cpy, size + 1);

        // And give some back
        delete[] cpy;
        //bytes = reinterpret_cast<char*>(realloc(bytes, s + 1));

        for(int i=0; i < s; i++)
        {
            bytes[i] += '0';
        }
        bytes[s] = 0x00;

        string str(bytes);
        delete[] bytes;
        return str;
    }
}

string N::to_english() const
{
    stringstream strstream;
    write_english(strstream);
    return strstream.str();
}

void write_sub_thousand(ostream& out, unsigned int n)
{
    unsigned int ones = n % 10;
    unsigned int tens = (n / 10) % 10;
    unsigned int hundreds = (n / 100) % 10;
    if(tens >= 2)
    {
        out << english_hundreds[hundreds] << english_tens[tens] << english_digits[ones];
    }
    else
    {
        out << english_hundreds[hundreds] << english_digits[ones + 10 * tens];
    }
}

void write_latin_exp(ostream& out, unsigned long int n)
{
    if(n == 0)
    {
        out << english_thousand;
        return;
    }
    if(n <= 10)
    {
        out << latin_digits_single[n];
        return;
    }
    unsigned int groups[7]; // ln(2^64) / ln(10^3) =
    unsigned int ngroups = 0;
    while(n)
    {
        groups[ngroups] = n % 1000;
        n /= 1000;
        ngroups++;
    }
    unsigned int g = ngroups;
    unsigned char ones, tens, hundreds;
    while(--g)
    {
        if(groups[g] == 0)
        {
            continue;
        }
        if(!(g == ngroups - 1 && groups[g] == 1))
        {
            ones = groups[g] % 10;
            tens = (groups[g] / 10) % 10;
            hundreds = (groups[g] / 100) % 10;
            out << latin_hundreds[hundreds] << latin_digits[ones] << latin_tens[tens];
        }
        for(unsigned int i=0; i < g; i++)
        {
            out << latin_thousand;
        }
    }
    if(groups[0] == 0)
    {
        out << "tillion";
    }
    else if(groups[0] <= 10)
    {
        out << latin_digits_single[groups[0]];
    }
    else
    {
        ones = groups[0] % 10;
        tens = (groups[0] / 10) % 10;
        hundreds = (groups[0] / 100) % 10;
        out << latin_hundreds[hundreds] << latin_digits[ones] << latin_tens[tens];

        if(tens == 1)
        {
            out << "illion";
        }
        else
        {
            out << "tillion";
        }
    }
}

void N::write_english(ostream& out) const
{
    // Writes the integer out in english
    // based on: http://www.isthe.com/chongo/tech/math/number/howhigh.html

    // Convert to base 10
    unsigned char* digits = new unsigned char[(size + 1) * 20 + 1] ();
    limb_t* cpy = new limb_t[size + 1] ();
    memcpy(cpy, limbs(), (size + 1) * sizeof(limb_t));
    int ndigits = mpn_get_str(digits, 10, cpy, size + 1);
    delete[] cpy;

    // Convert to base thousand
    unsigned int ngroups = (ndigits - 1) / 3 + 1;
    unsigned int* groups = new unsigned int[ngroups] ();
    for(int i=0; i < ndigits; i++)
    {
        int tenexp = ndigits - i - 1;
        if(tenexp % 3 == 0)
        {
            groups[tenexp / 3] += digits[i];
        }
        else if(tenexp % 3 == 1)
        {
            groups[tenexp / 3] += digits[i] * 10;
        }
        else
        {
            groups[tenexp / 3] += digits[i] * 100;
        }
    }
    delete[] digits;

    // Write the groups
    bool started = false;
    for(int i=ngroups - 1; i >= 0; i--)
    {
        if(groups[i] == 0)
        {
            continue;
        }
        if(started)
        {
            out << "," << endl;
        }
        write_sub_thousand(out, groups[i]);
        if(i)
        {
            write_latin_exp(out, i - 1);
        }
        started = true;
    }
    out << endl;

    delete[] groups;
}

}}

---

Copyright © 2007-2008 Remco Bloemen.

Generated on Tue Jan 22 17:35:31 2008 for symbolism by doxygen 1.5.4

Hosted by