baseConverter.java

Go to the documentation of this file.

import java.util.Arrays; 
import java.text.DecimalFormat;
import java.text.DecimalFormatSymbols;
 
public class baseConverter {
  static private final char decimalPoint = DecimalFormatSymbols.getInstance().getDecimalSeparator();
 
  static private final int WORD_LEN = Integer.SIZE;
 
  static private final int EXPO_LEN = 8;
 
  static private final int FRAC_LEN = 23;
 
  static private final int EXPO_MAG = 127;
/*
  static private final int WORD_LEN = Long.SIZE;
 
  static private final int EXPO_LEN = 11;
 
  static private final int FRAC_LEN = 52;
 
  static private final int EXPO_MAG = 1023;
*/
 
  public static void main(String[] args) {
    int n = 0, base = 2;
    double f = 0;
    if (args.length > 2) {
        try {
           n = Integer.parseInt(args[0]);
           f = Double.parseDouble(args[1]);
           base = Integer.parseInt(args[2]);
        } catch (NumberFormatException e) {
           System.err.println("Arguments: decimal integer, decimal float and base");
           System.exit(1);
        }
    }
    baseConverter bc = new baseConverter();
 
    System.out.println ( String.format ("Size of long = %d ", bc.getLongSize()) );
    System.out.println ( String.format ("%d * %d = %d ", n, base, bc.Product(n,base)) );
    String ns = bc.itoa ( n, base );
    System.out.println ( String.format ("%d in base 10 = %s in base %d", n, ns, base) ); 
    System.out.println ( String.format ("%s in base %d = %s in base 10", ns, base, bc.atoi ( ns, base )) ); 
    String nsf = bc.ftoa ( f, base );
    System.out.println ( String.format ("%e in base 10 = %s in base %d", f, nsf, base) ); 
    System.out.println ( String.format ("%s in base %d = %s in base 10", nsf, base, bc.atof ( nsf, base )) ); 
    String nsIEEE754 = bc.ftoIEEE754 ( f );
    System.out.println ( String.format ("%s in base %d = %s in IEEE754", nsf, base, nsIEEE754) ); 
    System.out.println ( String.format ("%s in IEEE754 = %s in base 10", nsIEEE754, bc.IEEE754tof ( nsIEEE754 )) ); 
    System.out.print ( String.format ("%d   = ", n) ); bc.printBits ( n ); 
    if ( n < 0 ) {
         System.out.print ( String.format ("(Negative numbers are represented in two's complement)\n") );
         System.out.print ( String.format ( "~%d+1 = ", -n ) );
         bc.printBits ( ~-n+1 );
    }
    System.out.println ();
    System.out.print ( String.format ( "Magnitude (%d) = %d\n", n, bc.getMagnitude(n) ) );
    System.out.println ( String.format ("Number of bits of (%d) = ", n) + bc.getNumberOfBits ( n ) ); 
    long k;
    System.out.print ( String.format ("%d reversed = ", n) ); bc.printBits ( k=bc.reverseBits(n) ); 
    System.out.print ( String.format  ( " = %d\n", k ) );
    System.out.print  ( String.format ( "Magnitude (%d reversed) = %d\n", n, bc.getMagnitude(k) ) );
    System.out.println ( String.format ("Number of bits of (%d reversed) = ", n) + bc.getNumberOfBits ( k ) ); 
    System.out.println ( String.format ("Power: 2**-4 = %f", bc.pow ( 2,-4 ) ) );
    System.out.println ( String.format ("Power: 2**3 = %f", bc.pow ( 2,3 ) ) );
    bc.printAsciiTable();
    System.out.println ( String.format ("modf: (%e,%e)", modf(f)[0], modf(f)[1]) );
    System.out.println ( String.format ("frac: (%e,%e)", inte(f), frac(f)) );
  }
 
  public static int Product (int a, int b) {
    int p = 0;
    while (b != 0) {
       if ((b & 1) == 1)
           p += a;
       a <<= 1;
       b >>>= 1;
    }
    return p;
}
 
  public static void printAsciiTable ( ) {
    for ( int x = 32; x < 127; ++x ) {
          System.out.print ( String.format ( "%03d = %c ", x, (char) x ) );
          if ( (x-31)%10 == 0 ) System.out.println ( );
    }
    System.out.println ( );
  }
 
  public static long reverseBits(long x) {
    long h = 0;
 
    while (x!=0) {
        h = (h << 1) | (x & 1); 
        x >>>= 1; 
    }
 
    return h;
  }
 
  public static double pow(long x, long p) {
    long pw = ipow(x, Math.abs(p));
    return p >= 0 ? pw : 1.0/pw;
  }
 
  public static long ipow(long x, long p) {
    if ( p <= 0 ) 
       return 1;
    else if ( p%2 == 0 ) { 
       long pw = ipow (x, p/2);
       return pw*pw;
    }
    else { 
       long pw = ipow (x,(p-1)/2);
       return x*pw*pw;
    }
  }
 
  public static void printBits (long n) {
    // do not print zeros on the left
    if (n == 0 || n == 1) {
        System.out.print ( n );
    }
    else {
        // >>> is the logical right shift, necessary because of the lack of an 
        // unsigned type in Java.
        printBits (n >>> 1);
        System.out.print ( n & 1 );
    }
  }
 
  public static int getMagnitude ( long n ) {
    int d = 0;
    while (n!=0) {
        n /= 10;
        ++d;
    }
    return d;
  }
 
  public static int getNumberOfBits ( long n ) {
    int c = 0;
    while (n!=0) {
       n >>>= 1;  // logical shift
       ++c;
    }
    return c;
  }
 
  public static int getLongSize ( ) {
    long a = 1;
    int c = 0;
    while (a!=0) {
        a <<= 1;
        ++c;
    }
    return c;
  }
 
  public static String itoa ( int num, int base ) {
    String str = "";
    if ( num == 0 ) return "0";
    if ( base < 2 || base > 36 ) return str; // starting at 10 and using 26 letters equals 36
 
    int n = Math.abs(num);
    int nb;
 
    while ( n != 0 ) {
      nb = n%base; 
      if ( base > 10 && nb > 9 )
           str = (char)(nb-10 + 'a') + str;
      else
           str = nb + str;
      n /= base; 
    }
 
    if ( num < 0 ) str = '-' + str;
    return str;
  }
 
  public static String fftoa ( double num, int base ) {
    String str = "";
    if ( num == 0 ) return "0";
    if ( base < 2 || base > 36 ) return str; // starting at 10 and using 26 letters equals 36
 
    double n = Math.abs(num);
 
    while ( n != 0 ) {
      int nb = (int)modf(n%base)[0]; 
      if ( base > 10 && nb > 9 )
           str = (char)(nb-10 + 'a') + str;
      else
           str = (char)(nb+'0') + str;
      n = modf(n/base)[0]; 
    }
 
    if ( num < 0 ) str = '-' + str;
    return str;
  }
 
  public static String trimTrailingZeros ( String str ) {
    int i;
    for ( i = str.length()-1; i >= 0; i-- ) {
        if (str.charAt(i) != '0' || str.charAt(i) == decimalPoint)
           break;
    }
    if (str.charAt(i) == decimalPoint) i += 1;
    return str.substring(0,i+1);
  }
 
  public static String normalize ( String str ) {
    int point = str.indexOf(decimalPoint);
    StringBuilder str2 = new StringBuilder();
    if ( point >= 2 ) {  // more than two digits before the decimal point (a positive expoent)
        str2.append (str.charAt(0)+decimalPoint);
        str2.append (str,1,point);
        str2.append (str,point+1,str.length());
        str2.replace(0,str2.length(),trimTrailingZeros(str2.toString()));
        str2.append ("E");
        str2.append (itoa(point-1,10));
        str = str2.toString();
    } else {
        int i; 
        for ( i = 0; i < str.length(); ++i ) {
              if ( str.charAt(i) != '0' && str.charAt(i) != decimalPoint )
                   break;
        }
        if ( i >= 2 && i < str.length() ) {  // a number of the form 0. (a negative expoent)
                i = Math.min (i,EXPO_MAG);   // expo should be in the range [-126..127]
                str2.append (str.charAt(i)+decimalPoint);
                str2.append (str,i+1,str.length());
                if ( str2.charAt(str2.length()-1) == decimalPoint )
                     str2.append ('0');      // for not having a number ending just with a point
                str2.replace(0,str2.length(),trimTrailingZeros(str2.toString()));
                str2.append ("E");
                str2.append (itoa(-i+1,10));
                str = str2.toString();
        }
    }
    return str;
}
 
  public static String ftoa ( double num, int base ) {
    String str = "";
    if ( num == 0 ) return "0";
    if ( base < 2 || base > 36 ) return str; // starting at 10 and using 26 letters equals 36
 
    double n = Math.abs(num);
    double nf = modf(n)[1];   // fractional part
 
    str = fftoa ( modf(n)[0], base ) + decimalPoint;
 
    int cnt = 0;  // to avoid an infinite loop in case of a repeating (recurring) decimal 
    while ( nf > 0.0 && cnt++ < EXPO_MAG+FRAC_LEN ) {
       nf *= base;
       int ni = (int)nf;
       if ( ni > 9 )
          str += (char)((ni-10)+'a');
       else
          str += (char)(ni+'0');
       nf = modf(nf)[1];
    }
 
    str = normalize(str);
 
    if ( num < 0 ) 
         str = '-' + str;
    return str;
  }
 
  public static String zero (int len) {
    char[] repeat = new char[len];
    Arrays.fill(repeat, '0');
    return new String(repeat);
 }
 
  public static String ftoIEEE754 ( double num ) {
    int base = 2;
 
    if (num == 0)
        return zero(FRAC_LEN+EXPO_LEN+1);
 
    String str = ftoa ( num, base );
 
    String[] parts = str.split("E");
    int expo = 0;
    if ( parts.length > 1 ) {
        expo = atoi(parts[1],10); // the expoent is in base 10
        expo = Math.min(Math.max(expo,-EXPO_MAG),EXPO_MAG);
    }
 
    String expoent = itoa(expo+EXPO_MAG,base);
    if ( str.charAt(0) == '0' || (str.charAt(0) == '-' && str.charAt(1) == '0') )  // a denormalized number
         expoent = "0";
    if ( expoent.length() < EXPO_LEN ) {
        expoent = zero(EXPO_LEN).substring(expoent.length()) + expoent;
    }
    else
        expoent = expoent.substring(0,EXPO_LEN);
 
    String mantissa = parts[0].substring(parts[0].indexOf(decimalPoint)+1,parts[0].length());
    String signal = (num < 0) ? "1" : "0";
    if ( mantissa.length() < FRAC_LEN ) {
        mantissa += zero(FRAC_LEN).substring(mantissa.length());
    }
    else
        mantissa = mantissa.substring(0,FRAC_LEN);
 
    return signal+expoent+mantissa;
  }
 
  public static double IEEE754tof ( String num ) {
    if (num.equals(zero(FRAC_LEN+EXPO_LEN+1)))
        return 0;
    int signal = num.charAt(0) == '1' ? -1 : 1;
    int expoent = atoi(num.substring(1,EXPO_LEN+1),2)-EXPO_MAG;
    double mantissa;
    if (expoent == -EXPO_MAG) {  // denormalize the number
        mantissa = atof("0"+decimalPoint+num.substring(EXPO_LEN+1,EXPO_LEN+1+FRAC_LEN),2);
        expoent += 1;
    } else
        mantissa = atof("1"+decimalPoint+num.substring(EXPO_LEN+1,EXPO_LEN+1+FRAC_LEN),2);
    return signal * mantissa * Math.pow(2,expoent);
  }
 
  public static int atoi ( String num, int base ) {
    int n = 0;
    int len = num.length();
    if ( base < 2 || base > 36 || len < 1 ) return n; // starting at 10 and using 26 letters equals 36
 
    int p = 1;
    char c;
    int j;
    for (int i = len-1; i>=0; i--){
        c = num.charAt(i);
        if ( base > 10 && c >= 'a' && c <= 'a'+base-11 ) {
             c -= 'a';
             j = (int)c + 10; 
        }
        else if ( c >= '0' && c <= '0'+Math.min(base,10)-1 ) {
             c -= '0';
             j = (int)c;
        } else j = 0;
 
        n += p*j;
        p *= base;
    }
    return num.charAt(0)=='-'?-n:n;
  }
 
  public static double atof ( String num, int base ) {
    double n = 0;
    int len = num.length();
 
    if ( base < 2 || base > 36 || len < 1 ) return n; // starting at 10 and using 26 letters equals 36
 
    String[] parts = num.split("E");
    num = parts[0];
    len = num.length();
    int pt = num.indexOf(decimalPoint);
    int point = len - Math.max(pt,0) - 1;  // number of digits after the point
    if ( parts.length > 1 ) {
         point -= atoi(parts[1],10);      // add the expoent
    }
 
    if ( pt == -1 ) { // no point found
         num += decimalPoint+"0";
         point = 1;                       // number of digits after the point
         len+=2;
    }
 
    double p = Math.pow(base,-point);
    char c;
    int j;
    for (int i = len-1; i>=0; i--){
        c = num.charAt(i);
        if ( base > 10 && c >= 'a' && c <= 'a'+base-11 ) {
             c -= 'a';
             j = (int)c + 10; 
        }
        else if ( c >= '0' && c <= '0'+Math.min(base,10)-1 ) {
             c -= '0';
             j = (int)c;
        } else continue;
 
        n += p*j;
        p *= base;
    }
    return num.charAt(0)=='-'?-n:n;
  }
 
  private static double frac(double d) {
    return d-inte(d);
  }
 
  private static double inte(double d) {
    return d > 0 ? Math.floor(d) : Math.ceil(d);
  }
 
  private static double[] modf(double d) {
    String num = Double.toString(d);
    double[] arr = new double[2];
    String[] parts = num.split("E");
    if ( parts.length > 1 ) {
        int expo = Integer.valueOf ( parts[1] );
        if ( expo > 0 ) {
            int pt = parts[0].indexOf(decimalPoint);
            int len = parts[0].length();
            int nc = pt+1+expo;
            String number = parts[0].substring(0,pt);
            number += parts[0].substring(pt+1,Math.min(nc,len));
            String frac="0"+decimalPoint;
            if ( nc < len ) {
                 frac += parts[0].substring( nc, len );
                 if ( d < 0 ) frac = '-'+frac; 
            }
            else
                 number += zero(nc-len);
            arr[0] = Double.parseDouble(number);
            arr[1] = Double.parseDouble(frac);
        } else {
            arr[0] = 0;
            arr[1] = Double.parseDouble(num); 
        }
    } else {
        parts = num.split("\\"+decimalPoint);
        if ( parts.length > 1 ) {
             parts[1] = "0"+decimalPoint+parts[1];
             if ( d < 0 ) parts[1] = '-'+parts[1];
        }
        for ( int i = 0; i < parts.length; ++i )
              arr[i] = Double.parseDouble(parts[i]);
    }
    return arr;
  }
}