2. Numbers

//----------------------------------------------------------------------------------
String s;
NumberFormat nf = NumberFormat.getInstance(locale);
Number nb;
try {
    nb = nf.parse(s);
} catch (ParseException ex) {
    // not a number
}
//----------------------------------------------------------------------------------
String s1;
try {
    int i = Integer.parseInt(s1);
} catch (NumberFormatException ex) {
    System.out.println(s1 + " is not an integer");
}

String s2;
try {
    float f = Float.parseFloat(s);
} catch (NumberFormatException ex) {
    System.out.println(s2 + " is not a float");
}
//----------------------------------------------------------------------------------
NumberFormat nf = NumberFormat.getInstance(locale);

boolean isNumeric(String string) {
    try {
       nf.parse(string);
       return true;
   } catch (ParseException ex) {
       return false;
   }
}
//----------------------------------------------------------------------------------

//----------------------------------------------------------------------------------
/**
 * Returns true if given values are equal to accuracy number of decimal places
 */
boolean equal(double num1, double num2, int accuracy) {
    BigDecimal bigNum1 = new BigDecimal(num1).setScale(accuracy, BigDecimal.ROUND_DOWN);
    BigDecimal bigNum2 = new BigDecimal(num2).setScale(accuracy, BigDecimal.ROUND_DOWN);
    return (bigNum1.compareTo(bigNum2) == 0);
  }
//----------------------------------------------------------------------------------
// with a scaling factor
int wage = 536;       // $5.36/hour
int week = 40 * wage; // $214.40
System.out.println("One week's wage is: $" + (double) week/100);
//=> One week's wage is: $214.40
//----------------------------------------------------------------------------------
// with BigDecimal
BigDecimal wage = new BigDecimal("5.36"); // $5.36/hour
BigDecimal hours = new BigDecimal("40");  // 40 hours/week
BigDecimal week = wage.multiply(hours);   // $214.40
System.out.println("One week's wage is: $" + week);
//=> One week's wage is: $214.40
//----------------------------------------------------------------------------------

//----------------------------------------------------------------------------------
BigDecimal rounded = unrounded.setScale(scale, roundingMode);
//----------------------------------------------------------------------------------
BigDecimal a = new BigDecimal("0.255");
BigDecimal b = a.setScale(2, BigDecimal.ROUND_HALF_UP);
System.out.println("Unrounded: " + a);
System.out.println("Rounded: " + b);
//=> Unrounded: 0.255
//=> Rounded: 0.26
//----------------------------------------------------------------------------------
// caution, Math.rint() rounds to the nearest integer !
double[] a = new double[] {3.3 , 3.5 , 3.7, -3.3};
System.out.println("number\tint\tfloor\tceil");
for (int i=0; i<a.length; i++)
    System.out.println(Math.rint(a[i]) + "\t" + Math.floor(a[i]) + "\t" + Math.ceil(a[i]));

//=> number  int     floor   ceil
//=> 
//=>  3.3     3.0     3.0     4.0
//=> 
//=>  3.5     3.0     3.0     4.0
//=> 
//=>  3.7     3.0     3.0     4.0
//=> 
//=> -3.3    -3.0    -4.0    -3.0
//----------------------------------------------------------------------------------

//----------------------------------------------------------------------------------
int i = Integer.parseInt(s, 2);
//----------------------------------------------------------------------------------
string s = Integer.toString(i, 2);
//----------------------------------------------------------------------------------
int i = Integer.parseInt("0110110", 2); // i = 54
String s = Integer.toString(54, 2);     // s = 110110
//----------------------------------------------------------------------------------

//----------------------------------------------------------------------------------
for (int i=X, i<=Y, i++) {
    i is set to every integer from X to Y, inclusive
}

for (int i=X, i<=Y, i+=7) {
    i is set to every integer from X to Y, stepsize = 7
}
//----------------------------------------------------------------------------------
System.out.print("Childhood is: ");
for (int i=5; i<=12; i++) {
    System.out.print(i + " ");
}
System.out.println();

//=> Childhood is: 5 6 7 8 9 10 11 12 
//----------------------------------------------------------------------------------

//----------------------------------------------------------------------------------
// no roman module available
//----------------------------------------------------------------------------------

//----------------------------------------------------------------------------------
Random random = new Random();
int i = random.nextInt(Y-X+1) + X;
//----------------------------------------------------------------------------------
int i = random.nextInt(51) + 25;
System.out.println(i);
//----------------------------------------------------------------------------------
String elt = array[random.nextInt(array.length)];
//----------------------------------------------------------------------------------
StringBuffer buffer = new StringBuffer();
for (int i=0; i<8; i++)
    buffer.append((char) (random.nextInt(43) + 48));
String password = buffer.toString();
//----------------------------------------------------------------------------------

//----------------------------------------------------------------------------------
long seed;
Random random = new Random(seed);
//----------------------------------------------------------------------------------
try {
    DataInputStream input = new DataInputStream(System.in);
    Random random = new Random(input.readLong());
} catch (IOException ex) {
    System.err.println("Exception occured while initialising random seed");
}
//----------------------------------------------------------------------------------

//----------------------------------------------------------------------------------
// java.util.Random class already uses a 48-bit seed
//----------------------------------------------------------------------------------

//----------------------------------------------------------------------------------
// use Random.nextGaussian() method
//----------------------------------------------------------------------------------
/*
 * WeightedDistribution.java
 */
package pleac.ch02.part10;

import java.util.Random;
/**
 * A weighted distribution of values
 */
public class WeightedDistribution {

    private Random random;
    private Object[] values;
    private int[] limits;
    private int total;

    /**
     * Creates a new weighted distribution with given values and given weights
     */
    public WeightedDistribution(Object[] values, int[] weights) {
        if (values.length != weights.length)
            throw new IllegalArgumentException(
                    "values and weights array size don't match");

        this.random = new Random();
        this.values = new Object[values.length];
        this.limits = new int[weights.length];
        for (int i=0; i<values.length; i++) {
            this.values[i] = values[i];
            total += weights[i];
            this.limits[i] = total;
        }
    }

    /**
     * Draws a random value
     */
    public Object draw() {
        int token = random.nextInt(total + 1);
        for (int i=0; i<limits.length; i++)
            if (token <= limits[i])
                return values[i];
        return null;
    }

}

Object values[];
int weights[];

// creates distribution
WeightedDistribution distribution = new WeightedDistribution(values, weights);
// draws a value from it
Object value = distribution.draw();
//----------------------------------------------------------------------------------
Random random = new Random();
int mean = 25;
int sdev = 2;
double salary = random.nextGaussian() * sdev + mean;
System.out.println("You have been hired at " + salary);
//----------------------------------------------------------------------------------

//----------------------------------------------------------------------------------
// use Math.toDegrees() and Math.toRadians() methods
//----------------------------------------------------------------------------------
double radians = Math.toRadians(degrees);
double degrees = Math.toDegrees(radians);
//----------------------------------------------------------------------------------
/**
 * Returns sine of an angle expressed in degrees
 */
double degreeSine(double a) {
    return Math.sin(Math.toRadians(a));
}
//----------------------------------------------------------------------------------

//----------------------------------------------------------------------------------
// use Math.tan() method
//----------------------------------------------------------------------------------
double y = Math.acos(3.7);
//----------------------------------------------------------------------------------

//----------------------------------------------------------------------------------
double log = Math.log(10000.00);
//----------------------------------------------------------------------------------
/**
 * Returns log in given base of given value
 */
double logBase(int base, double value) {
    return Math.log(value)/Math.log(base);
}
//----------------------------------------------------------------------------------
double answer = logBase(10, 10000.00);
System.out.println("log10(10000) = " + answer);
log10(10,000) = 4
//----------------------------------------------------------------------------------

//----------------------------------------------------------------------------------
/**
 * Compute multiplication of two given matrices
 */
int[][] multiplyMatrix(int[][] matrix1, int[][] matrix2) {

    if (matrix1 == null)
        throw new IllegalArgumentException("Null height matrix1");
    int rows1 = matrix1.length;

    if (matrix1[0] == null)
        throw new IllegalArgumentException("Null width matrix1");
    int cols1 = matrix1[0].length;

    if (matrix2 == null)
        throw new IllegalArgumentException("Null height matrix2");
    int rows2 = matrix2.length;

    if (matrix2[0] == null)
        throw new IllegalArgumentException("Null width matrix2");
    int cols2 = matrix2[0].length;

    if (cols1 != rows2) 
        throw new IllegalArgumentException("Matrices don't match: " + cols1 + " != " + rows2);

    int[][] result = new int[rows1][cols2];

    for (int i=0; i<rows1; i++) 
        for (int j=0; j<cols2; j++)
            for (int k=0; k<cols1; k++)
                result[i][j] += matrix1[i][k] * matrix2[k][j];

    return result;
}
//----------------------------------------------------------------------------------
int[][] matrix1 = new int[][] {
   {3, 2, 3},
   {5, 9, 8}
};

int[][] matrix2 = new int[][] {
   {4, 7},
   {9, 3},
   {8, 1}
};

int[][] product = multiplyMatrix(matrix1, matrix2);
//----------------------------------------------------------------------------------

//----------------------------------------------------------------------------------
/**
 * A basic complex number implementation
 */
public class Complex {
    
    private int real;
    private int imaginary;

    public Complex(int real, int imaginary) {
        this.real = real;
        this.imaginary = imaginary;
    }

    public int getReal() {
        return real;
    }

    public int getImaginary() {
        return imaginary;
    }

    public Complex multiply(Complex other) {
        return new Complex(
           (this.real * other.getReal()) - (this.imaginary * other.getImaginary()),
           (this.real * other.getImaginary()) + (this.imaginary * other.getReal())
       );
    }

    public String toString() {
        if (imaginary > 0)
            return real + "+" + Math.abs(imaginary) + "i";
        if (imaginary < 0)
            return real + "-" + Math.abs(imaginary) + "i";
        return real;
    }

}
//----------------------------------------------------------------------------------
Complex a = new Complex(3, 5);  // 3 + 5i
Complex b = new Complex(2, -2); // 2 - 2i
Complex c = a.multiply(b);

System.out.println("c = " + c);
//=> c = 16+4i
//----------------------------------------------------------------------------------

//----------------------------------------------------------------------------------
int number = Integer.parseInt(hexadecimal, 16); // hexadecimal
int number = Integer.parseInt(octal, 8);        // octal
//----------------------------------------------------------------------------------
System.out.println("Gimme a number in decimal, octal, or hex: ");
try {
    BufferedReader input = new BufferedReader(new InputStreamReader(System.in));
    String num = input.readLine().trim();
    int number;
    if (num.startsWith("0x"))
        number = Integer.parseInt(num.substring(2), 16);
        else if (num.startsWith("0"))
            number = Integer.parseInt(num.substring(1), 8);
            else
                number = Integer.parseInt(num);

    System.out.println("Decimal value: " + number);
} catch (IOException ex) {
    System.err.println("Exception occured while getting input");
} catch (NumberFormatException ex) {
    System.err.println("Exception occured while parsing input");
}
//----------------------------------------------------------------------------------
System.out.println("Enter file permission in octal: ");
try {
    BufferedReader input = new BufferedReader(new InputStreamReader(System.in));
    String num = input.readLine().trim();
    int permission = Integer.parseInt(num, 8);

    System.out.println("Decimal value: " + permission);
} catch (IOException ex) {
    System.err.println("Exception occured while getting input");
} catch (NumberFormatException ex) {
    System.err.println("Exception occured while parsing input");
}
//----------------------------------------------------------------------------------

//----------------------------------------------------------------------------------
// using a localized number format
NumberFormat format = NumberFormat.getInstance(locale);

format.format(value);
//----------------------------------------------------------------------------------
// using a customized number format
DecimalFormatSymbols symbols = new DecimalFormatSymbols();
symbols.setGroupingSeparator(',');
DecimalFormat format = new DecimalFormat();
format.setDecimalFormatSymbols(symbols);

format.format(value);
//----------------------------------------------------------------------------------
int hits = truly_random_value(); // negative hits!
System.out.println("Your web page received " + format.format(hits) + " accesses last month.");
//=> Your web page received -1,740,525,205 accesses last month.
//----------------------------------------------------------------------------------

//----------------------------------------------------------------------------------
System.out.println("It took " + time + " hour" + ((time == 1) ? "" : "s"));
System.out.println(time + " hour" + ((time == 1) ? " is" : "s are") + " enough");  
//----------------------------------------------------------------------------------
double[] limits = new double[] {1, ChoiceFormat.nextDouble(1)};
String[] names = new String[] {"century", "centuries"};
ChoiceFormat format = new ChoiceFormat(limits, names);
System.out.println("It took " + time + " " + format.format(time));
//----------------------------------------------------------------------------------
Perl5Util util = new Perl5Util();
/**
 * Compute plural of given noun
 */
String nounPlural(String noun) {
    // order really matters here!
    if (util.match("/ss$/", noun))
        return util.substitute("s/ss$/sses", noun);
    if (util.match("/([psc]h)$/", noun))
        return util.substitute("s/([psc]h)$/${1}es/", noun);
    if (util.match("/z$/", noun))
        return util.substitute("s/z$/zes/", noun);
    if (util.match("/ff$/", noun))
        return util.substitute("s/ff$/ffs/", noun);
    if (util.match("/f$/", noun))
        return util.substitute("s/f$/ves/", noun);
    if (util.match("/ey$/", noun))
        return util.substitute("s/ey$/eys/", noun);
    if (util.match("/y$/", noun))
        return util.substitute("s/y$/ies/", noun);
    if (util.match("/ix$/", noun))
        return util.substitute("s/ix$/ices/", noun);
    if (util.match("/([sx])$/", noun))
        return util.substitute("s/([sx])$/$1es/", noun);
    return util.substitute("s/$/s/", noun);
}
//----------------------------------------------------------------------------------

//----------------------------------------------------------------------------------
//=> # java pleac.ch02.part19.BigFact 8 9 96 2178
//=> 8: 2^3
//=> 9: 3^2
//=> 96: 2^5 3
//=> 2178: 2 3^2 11^2
//----------------------------------------------------------------------------------
//=> # java pleac.ch02.part19.BigFact 25000000000000000000000000
//=> 25000000000000000000000000: 2^24 5^26
//=> # java pleac.ch02.part19.BigFact 239322000000000000000000
//=> 239322000000000000000000: 2^19 3 5^18 39887
//----------------------------------------------------------------------------------
/*
 * BigFact.java
 */
package pleac.ch02.part19;

import java.math.BigInteger;
import java.util.*;
/**
 * Calculate prime factors
 * Usage: java pleac.ch02.part19.BigFact [-b] <number>
 */
public class BigFact {

    private static final Integer ONE = new Integer(1);

    private static TreeMap getFactors(int n) {
        int orig = n;
        TreeMap factors = new TreeMap();
        int i, sqi;
        for (i = 2, sqi = 4; sqi <= n; sqi += 2 * i++ + 1) {
            while (n % i == 0) {
                n /= i;
                Integer factor = new Integer(i);
                if (! factors.containsKey(factor))
                    factors.put(factor, ONE);
                else
                    factors.put(factor, new Integer(((Integer) factors.get(factor)).intValue() + 1));
            }
        }
        if ((n != 1) && (n != orig))
            factors.put(new Integer(n), ONE);
        return factors;
    }

    private static TreeMap getFactors(BigInteger n) {
        BigInteger orig = n;
        TreeMap factors = new TreeMap();
        BigInteger i = new BigInteger("2");
        BigInteger sqi = new BigInteger("4");
        BigInteger step = new BigInteger("2");
        while (sqi.compareTo(n) <= 0) {
            while (n.mod(i).equals(BigInteger.ZERO)) {
                n = n.divide(i);
                if (! factors.containsKey(i))
                    factors.put(i, BigInteger.ONE);
                else
                    factors.put(i, ((BigInteger) factors.get(i)).add(BigInteger.ONE));
            }
            sqi = sqi.add((i.multiply(step)).add(BigInteger.ONE));
            i = i.add(BigInteger.ONE);
        }
        if ((! n.equals(BigInteger.ONE)) && (! n.equals(orig)))
            factors.put(n, BigInteger.ONE);
        return factors;
    }

    private static void displayFactors(int n, TreeMap factors) {
        System.out.print(n + ": ");
        if (factors.isEmpty())
            System.out.println("PRIME");
        else {
            Iterator it = factors.keySet().iterator();
            while (it.hasNext()) {
                Object factor = it.next();
                Object power = factors.get(factor);
                System.out.print(factor + ((power.equals(ONE))? "": "^" + power) + " ");
            }
            System.out.println();
        }
    }

    private static void displayFactors(BigInteger n, TreeMap factors) {
        System.out.print(n + ": ");
        if (factors.isEmpty())
            System.out.println("PRIME");
        else {
            Iterator it = factors.keySet().iterator();
            while (it.hasNext()) {
                Object factor = it.next();
                Object power = factors.get(factor);
                System.out.print(factor + ((power.equals(BigInteger.ONE))? "": "^" + power) + " ");
            }
            System.out.println();
        }
    }

    public static void main(String args[]) {
        if (args.length < 1) {
            System.err.println("Usage: java pleac.ch02.part19.BigFact [-b] <number>...");
            System.exit(1);
        }

        boolean useBigInteger = false;
        int index = 0;

        if (args[0].equals("-b")) {
            useBigInteger = true;
            index = 1;
        }

        for (int i=index; i<args.length;i++) {
            if (useBigInteger) {
                BigInteger n = new BigInteger(args[i]);
                displayFactors(n, getFactors(n));
            } else {
            try {
                int n = Integer.parseInt(args[i]);
                displayFactors(n, getFactors(n));
                } catch (NumberFormatException ex) {
                    BigInteger n = new BigInteger(args[i]);
                    displayFactors(n, getFactors(n));
                }
            }
        }

    }
    
}
//----------------------------------------------------------------------------------