Home > Articles

  • Print
  • + Share This
This chapter is from the book

Exercises

  • 2.2.1 Add to Gaussian (PROGRAM 2.1.2) an implementation of the three-argument static method pdf(x, mu, sigma) specified in the API that computes the Gaussian probability density function with a given mean μ and standard deviation σ, based on the formula ϕ(x, μ, σ) = ϕ(( x– μ) / σ)/σ. Also add an implementation of the associated cumulative distribution function cdf(z, mu, sigma), based on the formula Φ(z, μ, σ) = Φ((z – μ) / σ).

  • 2.2.2 Write a library of static methods that implements the hyperbolic functions based on the definitions sinh(x) = (exex) / 2 and cosh(x) = (ex + ex) / 2, with tanh(x), coth(x), sech(x), and csch(x) defined in a manner analogous to standard trigonometric functions.

  • 2.2.3 Write a test client for both StdStats and StdRandom that checks that the methods in both libraries operate as expected. Take a command-line argument n, generate n random numbers using each of the methods in StdRandom, and print their statistics. Extra credit: Defend the results that you get by comparing them to those that are to be expected from analysis.

  • 2.2.4 Add to StdRandom a method shuffle() that takes an array of double values as argument and rearranges them in random order. Implement a test client that checks that each permutation of the array is produced about the same number of times. Add overloaded methods that take arrays of integers and strings.

  • 2.2.5 Develop a client that does stress testing for StdRandom. Pay particular attention to discrete(). For example, do the probabilities sum to 1?

  • 2.2.6 Write a static method that takes double values ymin and ymax (with ymin strictly less than ymax), and a double array a[] as arguments and uses the StdStats library to linearly scale the values in a[] so that they are all between ymin and ymax.

  • 2.2.7 Write a Gaussian and StdStats client that explores the effects of changing the mean and standard deviation for the Gaussian probability density function. Create one plot with the Gaussian distributions having a fixed mean and various standard deviations and another with Gaussian distributions having a fixed standard deviation and various means.

  • 2.2.8 Add a method exp() to StdRandom that takes an argument λ and returns a random number drawn from the exponential distribution with rate λ. Hint: If x is a random number uniformly distributed between 0 and 1, then –ln x / λ is a random number from the exponential distribution with rate λ.

  • 2.2.9 Add to StdRandom a static method maxwellBoltzmann() that returns a random value drawn from a Maxwell–Boltzmann distribution with parameter σ. To produce such a value, return the square root of the sum of the squares of three random numbers drawn from the Gaussian distribution with mean 0 and standard deviation σ. The speeds of molecules in an ideal gas obey a Maxwell–Boltzmann distribution.

  • 2.2.10 Modify Bernoulli (PROGRAM 2.2.6) to animate the bar graph, replotting it after each experiment, so that you can watch it converge to the Gaussian distribution. Then add a command-line argument and an overloaded binomial() implementation to allow you to specify the probability p that a biased coin comes up heads, and run experiments to get a feeling for the distribution corresponding to a biased coin. Be sure to try values of p that are close to 0 and close to 1.

  • 2.2.11 Develop a full implementation of StdArrayIO (implement all 12 methods indicated in the API).

  • 2.2.12 Write a library Matrix that implements the following API:

    public class Matrix
    double dot(double[] a, double[] b)

    vector dot product

    double[][] multiply(double[][] a, double[][] b)

    matrix-matrix product

    double[][] transpose(double[][] a)

    transpose

    double[] multiply(double[][] a, double[] x)

    matrix-vector product

    double[] multiply(double[] x, double[][] a)

    vector-matrix product

    (See SECTION 1.4.) As a test client, use the following code, which performs the same calculation as Markov (PROGRAM 1.6.3):

    public static void main(String[] args)
    {
       int trials = Integer.parseInt(args[0]);
       double[][] p = StdArrayIO.readDouble2D();
       double[] ranks = new double[p.length];
       rank[0] = 1.0;
       for (int t = 0; t < trials; t++)
           ranks = Matrix.multiply(ranks, p);
       StdArrayIO.print(ranks);
    }

    Mathematicians and scientists use mature libraries or special-purpose matrix-processing languages for such tasks. See the booksite for details on using such libraries.

  • 2.2.13 Write a Matrix client that implements the version of Markov described in SECTION 1.6 but is based on squaring the matrix, instead of iterating the vector–matrix multiplication.

  • 2.2.14 Rewrite RandomSurfer (PROGRAM 1.6.2) using the StdArrayIO and StdRandom libraries.

    Partial solution.

    ...
    double[][] p = StdArrayIO.readDouble2D();
    int page = 0; // Start at page 0.
    int[] freq = new int[n];
    for (int t = 0; t < trials; t++)
    {
       page = StdRandom.discrete(p[page]);
       freq[page]++;
    }
    ...
  • + Share This
  • 🔖 Save To Your Account