Implementing the Trinary routines.

• Remember last time we built Trinary.h
• We now need to implement the routines.
• We will do this in Trinary.cpp
  • I make the names of my header and implementation files the same.
• Start by including
  • Any libraries you will need.
    • I always include iostream, I will need to debug.
  • The header file you just built.
    • Note, this is in the local directory, so the include is different.

• // Trinary.cpp 
  #include <iostream>
  #include "Trinary.h"
      

• This file will be compiled as a unit, so we cannot pollute other code's name space.
  • Thus include a using statement if you wish.

• // Trinary.cpp 
  #include <iostream>
  #include "Trinary.h"
  
  using namespace std;
      

• Next copy the headers from the header file and turn them into functions.

• // Trinary.cpp 
  #include <iostream>
  #include "Trinary.h"
  
  using namespace std;
  
  std::string IntToTrinary(int number){
  }
  
  int TrinaryToInt(std::string number){
  }
  
  char IntDigitToTrinary(int d){
  }
  
  int TrinaryDigitToInt(char d){
  } 

• Finally implement each.
• IntDigitToTrinary
  • This is easy, just return TRINARY_DIGITS[d]
  • I am going to put in a check to make sure the digit is in the right range.
  • I bet the compiler will complain about the comparison, so do a static_cast

  • char IntDigitToTrinary(int d){
        int value{' '};
        if(d >= 0 and d < static_cast<int>(TRINARY_DIGITS.size())) {
           value = TRINARY_DIGITS[d];
        }
    
        return value;
    } 

• TrinaryDigitToInt
  • This is also a trick based on the TRINARY_DIGITS string.
  • Note, each digit is stored at it's value
    • 0 at 0
    • 1 at 1
    • 2 at 2.
  • So just find it and return it.
  • But again, I am going to be careful.

  • int TrinaryDigitToInt(char d){
        int value{-1};
        size_t pos;
        pos = TRINARY_DIGITS.find(d);
        if (pos != string::npos) {
            value = static_cast<int>(pos);
        }
        return value;
    } 

  • TrinaryToInt is just a series of multiplications.
    • I am going to use an algorithm known as Horner's Method
    • It allows quick evaluation of a polynomial
      • $120_3 = 1x3^2 + 2x3^1 + 0x3^0$
      • The trick is to slowly build up this value

        Start with the most significant digit 1
        Set value to be 0
        While there are digits
            Multiply value by 3
            Add the digit to value
            
          digit    value   new value  Think
                     0        0       
            1       0x3+1     1       $1x3^0$
            2       1x3+1     5       $1x3^1 + 2x3^0$
            0       5x3+0    15       $1x3^2 + 2x3^1 + 0x3^0$
        
        Let's try 122010
          digit   value  newvalue    Think
                     0         0
            1       0x3+1      1      $1x3^0$
            2       1x3+2      5      $1x3^1 + 2x3^0$
            2       5x3+2     17      $1x3^2 + 2x3^1 + 2x3^0$ 
            0      17x3+0     51      $1x3^3 + 2x3^2 + 2x3^1 + 0x3^0$ 
            1      51x3+1    154      $1x3^4 + 2x3^3 + 2x3^2 + 0x3^1 + 1x3^0$ 
            0     154x3+0    462      $1x3^5 + 2x3^4 + 2x3^3 + 0x3^2 + 2x3^1 + 0x3^0$
                        

    • There are a few things to handle first.
      • If the number is negative, remove the negative sign.
      • If the number starts with a + sign, remove this.
      • Deal with 0 as a special case.
    • Look at the code in Trinary.cpp
  • IntToTrinary is the series of divs and mods we discussed in earlier notes.