BaseConvert ( string ; baseFrom ; baseTo )

Convert a number (up to 10 billion) from one base to another.

Average rating: 4.4 (41 votes) Log in to vote

Debi Fuchs - Show more from this author
Aptworks Consulting
http://www.aptworks.com

Sample input:

BaseConvert ( "F1"; 16; 2 )

Sample output:

"11110001"

Function definition: (Copy & paste into FileMaker's Edit Custom Function window)

/*
CUSTOM FUNCTION: BaseConvert ( string ; baseFrom ; baseTo )
//written by Debi Fuchs of Aptworks Consulting, debi@aptworks.com
//bug fix by Rico Meier, MeiSol AG

Convert a number (up to 10 billion) from one base to another.

EXAMPLES:

   BaseConvert( "F1"; 16; 2 ) // --> "11110001"
   BaseConvert( -5; 10; 2 ) // --> "-101"
   BaseConvert( 255; 10; 16 ) // --> "FF"
   BaseConvert( "-101" ; 2; 10 ) // --> "-5"
   BaseConvert( -101 ; 2; 10 ) // --> -5
   BaseConvert( "FF"; 16; 10 ) // --> "255"
   BaseConvert( "-101" ; 16; 2 ) // --> "-100000001"
   BaseConvert( "-101" ; 2; 16 ) // --> "-5"
   BaseConvert( "FF"; 16; 2 ) // --> "11111111"

IMPLEMENTATION: See comments. No helper functions are required. Limit is set at 10^10 so that the math does not break down, as log calculations on large numbers can be incorrect.

LAST MODIFIED: 14-AUG-2008 by Debi Fuchs of Aptworks Consulting
*/


Case(

  // Simulate an "out of range" error if either base is out of range

  baseFrom < 2 or baseFrom > 36 or baseTo < 2 or baseTo > 36;
  Evaluate("Factorial(-1)");

  // Return a null value if the string is null;
  string = "";
  "";

  // Return a 0 value if  the string represents 0;
  string = 0 or string = "0" or IsEmpty(Substitute(string; "0"; ""));
  Case( baseTo=10; 0; "0" );

  // If the string represents a negative number, subtract from
  // 0 the result of calling the function again on the positive version.

  GetAsNumber(string) = string and string + 0 < 0;
  0 - BaseConvert( Abs( GetAsNumber( string ) ); baseFrom; baseTo );

  // If the string otherwise begins with a "minus" symbol,
  // return the result of appending a negative sign with the result of
  // calling the function again on the postive version of the string.
  
  Left( string; 1 ) = "-";
  0-BaseConvert( 
    Right( string; Length( string ) - 1 ); 
    baseFrom; 
    baseTo 
  );

  // Simulate an "out of range" error if string is a number but is either
  // a base10 number greater than 10 billion, or a non-integer, or
  //  contains characters other than the digits for BaseFrom
    
  GetAsNumber(string) = string and
  ( (baseFrom=10 and GetAsNumber(string)> 10^10) or
    GetAsNumber(string)<>Int(string) or
    Let(
      [
        sci_not_pos = Position(string; "e+"; 0; 1);
        partial_string = Case( sci_not_pos; Left( string; sci_not_pos - 1 ); string )
      ];
      Filter( 
        partial_string;
        Left(".0123456789"; baseFrom+1) 
      ) <> partial_string
    )
  );
  Evaluate("Factorial(-1)");
  
  // Simulate an "out of range" error if string is a non-number and contains
  // characters outside of the digits for BaseFrom  
  
  GetAsNumber(string) <> string and
  ( Filter( 
       string; 
       Left("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"; baseFrom) 
     ) <> string
  );
  Evaluate("Factorial(-1)");


  // Calculate the integer that the string represents. This is either the
  // original string as a number (if we're converting from base 10), or
  // the the sum of 1) the product of the first "digit" times a power
  // the target base and 2) the result of recursing on the remaining
  // "digits" in the string.
  
  Let(

    base10Int =
      Case(

      // If the baseFrom is 10, then the base10 version is (clearly) the
      // numeric version of our original string.
      
      baseFrom = 10;
      GetAsNumber( string );
      
      // If the string is a number then calculate the first digit,
      // multiply it by a power of baseFrom, and add the result of
      // recursing on the remainder. (The number might contain scientific
      // notation, so we can't use each character of digit as a number).
      
      GetAsNumber(string) = string;
      Let(
        [
          new_string_length = Int( Log( string ) ) + 1;
          
          power_of_10 = 10 ^ ( new_string_length - 1 );
          power_of_x = baseFrom ^ ( new_string_length - 1 );
         
          first_digit = Int( string / power_of_10 );

          first_digit_char =
             Middle( 
               "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"; 
               first_digit + 1; 
               1
             );

          remaining = string - first_digit * power_of_10
        ];
        
        first_digit_char*power_of_x + BaseConvert (remaining; baseFrom; 10)
      );      
                  
      // If the string is not a number then calculate the number representing
      // the first character, multiply it by a power of baseFrom, and add the result
      // of recursing on the remainder. 
      
      ( ( Position(
          "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
          Left( string; 1 );
          0;
          1 
        ) - 1 ) * baseFrom ^ ( Length( string ) - 1)
      ) +
      BaseConvert( Right( string; Length( string ) - 1 ); baseFrom; 10 )
        
    );
    
    // Return either the base10Int from above (if base10), use it to calculate
    // its representation in the new base, throwing an error on integers that
    // are too large to deal with reliably.
    
    Case(
      
      // Simulate an "out of range" error if the base10Int is too large for the math
      //   to work out
      base10Int > 10^10;
      Evaluate("Factorial(-1)");
      
      // Return the base10Int from above if the target base is 10.
      baseTo = 10;
      base10Int;

      // Otherwise, calculate the new string as follows:  Determine
      // the first digit of the new string; Then append it together
      // with 1) any subequent zeros, and 2) the result of recursing
      // on the remainder using a "fromBase" of 10.
  
      Let(
        [
          new_string_length = Int( Log( base10Int ) / Log( baseTo ) ) + 1;
          
          power_of_y = baseTo ^ ( new_string_length - 1 );
          
          first_digit = Int( base10Int / power_of_y );
          
          first_digit_char =
             Middle( 
               "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"; 
               first_digit + 1; 
               1
             );
             
          remaining = base10Int - first_digit * power_of_y;

          zero_digits_following =
            Case(
              remaining = 0;
              new_string_length - 1;
              new_string_length - Int( Log( remaining ) / Log( baseTo ) ) - 2
            );
            
          zero_chars =
            Left(
              "000000000000000000000000000000000000000000000000000" &
              "000000000000000000000000000000000000000000000000000" &
              "000000000000000000000000000000000000000000000000000";
             zero_digits_following
            )
            
        ];
        
        first_digit_char & zero_chars &
          Case( remaining > 0; BaseConvert( remaining; 10; baseTo ) )
          
      )
    )
  )
)

CUSTOM FUNCTION: BaseConvert ( string ; baseFrom ; baseTo )
//written by Debi Fuchs of Aptworks Consulting, debi@aptworks.com
//bug fix by Rico Meier, MeiSol AG

Convert a number (up to 10 billion) from one base to another.

EXAMPLES:

BaseConvert( "F1"; 16; 2 ) // --> "11110001"
BaseConvert( -5; 10; 2 ) // --> "-101"
BaseConvert( 255; 10; 16 ) // --> "FF"
BaseConvert( "-101" ; 2; 10 ) // --> "-5"
BaseConvert( -101 ; 2; 10 ) // --> -5
BaseConvert( "FF"; 16; 10 ) // --> "255"
BaseConvert( "-101" ; 16; 2 ) // --> "-100000001"
BaseConvert( "-101" ; 2; 16 ) // --> "-5"
BaseConvert( "FF"; 16; 2 ) // --> "11111111"

IMPLEMENTATION: See comments. No helper functions are required. Limit is set at 10^10 so that the math does not break down, as log calculations on large numbers can be incorrect.

LAST MODIFIED: 22-JUL-2019 by Debi Fuchs of Aptworks Consulting

Comments

		Rico Meier, MeiSol AG Jul 1, 2019
To avoid an error by submit BaseConvert( "00"; 16; 2 ) -> 0? change this: // Return a 0 value if the string represents 0; string = 0 or string = "0"; Case( baseTo=10; 0; "0" ); to // Return a 0 value if the string represents 0; getasnumber (string) = 0 or string = "0"; Case( baseTo=10; 0; "0" ); thanks

		Rico Meier, MeiSol AG Jul 2, 2019
Sorry, this will not working because "AB"; 16; 2 will get -> 0. change to: // Return a 0 value if the string represents 0; ( length (string) = patternCount ( string; "0") and GetAsNumber (string) = 0 ) or string = "0"; Case( baseTo=10; 0; "0" );

		Debi Fuchs, Aptworks Consulting Jul 22, 2019
Thanks, Rico, for finding that bug. I've edited the function and given you credit within it.

		BT Jul 8, 2020
Is there a way to increase this 10bilion limit?

		Debi Fuchs, Aptworks Consulting Jul 8, 2020
>>Is there a way to increase this 10bilion limit? Possibly...using the SetPrecision function in the right places.

Note: these functions are not guaranteed or supported by BrianDunning.com. Please contact the individual developer with any questions or problems.

BaseConvert ( string ; baseFrom ; baseTo )

Comments

Support this website.

Support this website.