3

I need to convert arbitary length binary into an exact ternary representation. Ideally, given an array of bits char buffer[n], the algorithm would be able to produce a array of trits(analog of bits), and vice versa. Is there such an algorithm?

I am aware of ways to convert individual int to ternary:

int nth_trit(int num, int n)
{
    for(int i = 0; i < n; i++)
        num /= 3;

    return num % 3;
}

Alas, with a bitstream even a long long long int wouldn't suffice. I think using a big integer library would suffice, although I'm not sure, and feel that there should be better way calculate the ternary representation.

A visual example:

// Conversion is simple(short stream)
Binary  - 0 1 0 0 1 0 0 1
Decimal -             7 3
Ternary -         2 2 0 1

// Conversion is hard(long stream)
Binary  - 1 0 1 0 0 0 0 1 ..........
Ternary - ? ? ?

The short stream is simple because, since it nicely fits into an int, the nth_trit function can be used, but the long stream doesn't, and so apart from using a big integer library, no easy solution occurs to me.

scientiaesthete
  • 919
  • 9
  • 20
  • 1
    One trit actually represents about 1.58496 ~ log(3) bits of information. If I understand you correctly, you are saying that I can take, i.e. every 3 bits and convert them to 2 trits, because trits approximately represent 1.5 bits. Unfortunately, 3 bits(2^3) is not exactly represented by 2 trits(3^2). I need an exact representation. – scientiaesthete Aug 18 '12 at 04:26
  • Is your array of "bits" an array of `'0'` and `'1'` char values? Or is it an array of 8-bit numbers that will be "decomposed" bit-by-bit (i.e. via your `nth_trit` function)? Likewise... what do you want your resulting "array of trits" to look like? Presumably it would either be an array of chars on the range `'0'..'2'` *or* an array of numeric values on the range `0-2`? Maybe something like: `['0', '2', '1']`? – Lee Aug 18 '12 at 04:27
  • For example, my code above takes an `int` and gives back the exact nth trit. I can replace `int` with `long long int`, but ideally I would like to convert a stream, not a fixed size number, into a ternary representation, an array of trits(ranging from `0..2`) – scientiaesthete Aug 18 '12 at 04:30

4 Answers4

2

It's possible to show that every ternary digit depend on all binary one. So you can't do better than read the whole string of bits and then do the conversion.

AProgrammer
  • 51,233
  • 8
  • 91
  • 143
1

Your algorithm is not so good if the bit buffer is long because each output trit repeats all the divisions also needed for smaller values of n. So converting this algorithm to "bignum" arithmetic will not be what you want.

Another approach: scanning the bits left to right, each new one updates the previous value:

val = val * 2 + bit

A trinary number with n trits t[i] has the value

sum(i = 0 .. n-1) t[i] * 3^i

So a trinary representation of val updated for a new scanned bit becomes,

[ 2 * sum(i = 0 .. n-1) t[i] * 3^i ] + bit
    = bit + sum(i = 0 .. n-1) 2 * t[i] * 3^i 
    = 2 * t[0] + b + sum(i = 1 .. n) 2 * t[i] * 3^i

To make the code simple let's compute the trits in an array of unsigned chars. After they're done you can repack them any way you like. 

#include <stdio.h>

// Compute the trit representation of the bits in the given
// byte buffer.  The highest order byte is bytes[0].  The
// lowest order trit in the output is trits[0].  This is 
// not a very efficient algorithm, but it doesn't use any
// division.  If the output buffer is too small, high order
// trits are lost.
void to_trits(unsigned char *bytes, int n_bytes, 
              unsigned char *trits, int n_trits)
{
  int i_trit, i_byte, mask;

  for (i_trit = 0; i_trit < n_trits; i_trit++)
    trits[i_trit] = 0;

  // Scan bits left to right.
  for (i_byte = 0; i_byte < n_bytes; i_byte++) {

    unsigned char byte = bytes[i_byte];

    for (mask = 0x80; mask; mask >>= 1) {
      // Compute the next bit.
      int bit = (byte & mask) != 0;

      // Update the trit representation
      trits[0] = trits[0] * 2 + bit;
      for (i_trit = 1; i_trit < n_trits; i_trit++) {
        trits[i_trit] *= 2;
        if (trits[i_trit - 1] > 2) {
          trits[i_trit - 1] -= 3;
          trits[i_trit]++;
        }
      }
    }
  }
}

// This test uses 64-bit quantities, but the trit 
// converter will work for buffers of any size.
int main(void)
{
  int i;

  // Make a byte buffer for an easy to recognize value.
  #define N_BYTES 7
  unsigned char bytes [N_BYTES] = 
    { 0xab, 0xcd, 0xef, 0xff, 0xfe, 0xdc, 0xba };

  // Make a trit buffer.  A 64 bit quantity may need up to 42 trits.
  #define N_TRITS 42
  unsigned char trits [N_TRITS];

  to_trits(bytes, N_BYTES, trits, N_TRITS);

  unsigned long long val = 0;
  for (i = N_TRITS - 1; i >= 0; i--) {
    printf("%d", trits[i]);
    val = val * 3 + trits[i];
  }
  // Should prinet value in original byte buffer.
  printf("\n%llx\n", val);

  return 0;
}
Gene
  • 46,253
  • 4
  • 58
  • 96
1

Multiplying/dividing by 2 is simple in any base, so the easiest way to convert any base to/from binary is to repeatedly multiply/divide by 2, keeping track of carry/parity.

#include <algorithm>
#include <cstdint>
#include <functional>
#include <iostream>
#include <iterator>
#include <vector>

// in: a vector representing a bitstring, with most-significant bit first.
// out: a vector representing a tritstring, with least-significant trit first.
static std::vector<uint8_t> b2t(const std::vector<bool>& in) {
  std::vector<uint8_t> out;
  out.reserve(in.size());  // larger than necessary; will trim later
  // for each digit (starting from the most significant bit)
  for (bool carry : in) {
    // add it to the tritstring (starting from the least significant trit)
    for (uint8_t& trit : out) {
      // double the tritstring, carrying overflow to higher places
      uint8_t new_trit = 2 * trit + carry;
      carry = new_trit / 3;
      trit = new_trit % 3;
    }
    if (carry) {
      // overflow past the end of the tritstring; add a most-significant trit
      out.push_back(1);
    }
  }
  out.reserve(out.size());
  return out;
}

// in: a vector representing a tritstring, with most-significant trit first.
// out: a vector representing a bitstring, with least-significant bit first.
static std::vector<bool> t2b(std::vector<uint8_t> in) {
  std::vector<bool> out;
  out.reserve(2 * in.size());  // larger than necessary; will trim later
  bool nonzero;
  do {
    nonzero = false;
    bool parity = false;
    for (uint8_t& trit : in) {
      // halve the tritstring, starting from the most significant trit
      uint8_t new_trit = trit + 3 * parity;
      parity = new_trit & 1;
      nonzero |= trit = new_trit / 2;
    }
    // the division ended even/odd; add a most-signiticant bit
    out.push_back(parity);
  } while (nonzero);
  out.reserve(out.size());
  return out;
}

int main() {
  bool odd = false;
  std::string s;
  while (std::cin >> s) {
    if ((odd = !odd)) {
      std::vector<bool> in(s.size());
      std::transform(s.begin(), s.end(), in.begin(),
          [](char c) {return c - '0';});
      std::vector<uint8_t> out(b2t(in));
      std::copy(out.rbegin(), out.rend(),
          std::ostream_iterator<int>(std::cout));
      std::cout << std::endl;
    } else {
      std::vector<uint8_t> in(s.size());
      std::transform(s.begin(), s.end(), in.begin(),
          [](char c) {return c - '0';});
      std::vector<bool> out(t2b(in));
      std::copy(out.rbegin(), out.rend(),
          std::ostream_iterator<int>(std::cout));
      std::cout << std::endl;
    }
  }
  return 0;
}

$ ./a.out
1011
102
102
1011
10001100001101010011010010111000011011101000111101011101000110100101101101111110110011010010111100010110100010101011010100101100001101001000000111011110101001000100011010111011000111101110111001111110110011101011101101001001110010111111100011000110011000111110110111011110110110001111011011011000100101010010111010000110101011010100011010110110000010110111000111000110101000000110000001111110101110010000011000110001010000001001100011000000100100100001100101111000101001001010101101101000011100110001111011110001
12010110110220200020211012001000211110222212120220002002120120111221021120100122221020011120010202110111112112110201211201120222000011010100122122121211112101111121002110102112000111200002121211002022100220211220220111010210200222021221020122012102101010100001122200011110210221120122022011202201002002001221211001221112001
12010110110220200020211012001000211110222212120220002002120120111221021120100122221020011120010202110111112112110201211201120222000011010100122122121211112101111121002110102112000111200002121211002022100220211220220111010210200222021221020122012102101010100001122200011110210221120122022011202201002002001221211001221112001
10001100001101010011010010111000011011101000111101011101000110100101101101111110110011010010111100010110100010101011010100101100001101001000000111011110101001000100011010111011000111101110111001111110110011101011101101001001110010111111100011000110011000111110110111011110110110001111011011011000100101010010111010000110101011010100011010110110000010110111000111000110101000000110000001111110101110010000011000110001010000001001100011000000100100100001100101111000101001001010101101101000011100110001111011110001
^D

(10112 = 8+2+1 = 11 = 9 + 2 = 1023)
(100011000011010100110100101110000110111010001111010111010001101001011011011111101100110100101111000101101000101010110101001011000011010010000001110111101010010001000110101110110001111011101110011111101100111010111011010010011100101111111000110001100110001111101101110111101101100011110110110110001001010100101110100001101010110101000110101101100000101101110001110001101010000001100000011111101011100100000110001100010100000010011000110000001001001000011001011110001010010010101011011010000111001100011110111100012 = 7343280200542654154029818354420920722408633707396360612751407162736942742985658428558632312175242897575484682660836397639769592568209070221085927986634481 = 120101101102202000202110120010002111102222121202200020021201201112210211201001222210200111200102021101111121121102012112011202220000110101001221221212111121011111210021101021120001112000021212110020221002202112202201110102102002220212210201220121021010101000011222000111102102211201220220112022010020020012212110012211120019)

ephemient
  • 198,619
  • 38
  • 280
  • 391
-1

Balanced Ternary/Trinary is better. {-1, 0, 1} Make your output in such a manner.

Batusai Jack
  • 67
  • 1
  • 2