//
// This applet is based on code which was kindly provided by Matt Roughan 
// It uses Matt's PlotCanvas class which extends Canvas
//    Last updated 07/08/98
//

import java.util.*;
import java.applet.*;
import java.awt.*;
import MyUtil.*;

public class PlotProbability extends Applet {

  Panel cardStack = null;
  CardLayout c1 = null;

  DistributionCard currentCard;
  int N = 5;
  DistributionCard[] theCards = new DistributionCard[N];
  Button[] SelectionButtons = new Button[N];
  String[] DistributionNames = {"Binomial",
                                "Poisson",
                                "Geometric",
                                "Negative Binomial",
                                "Hypergeometric"
                               };

  String startCard;

  MyDialog helpDialog;

  static Frame theFrame;

  //this array of strings is what is displayed by the help button
  String[] helpText = {
    "This applet graphs the probability function p(n) for several of",
    "the standard discrete distributions.",
    "",
    "The various parameters are controlled using the scrollbars.",
    "Pressing h brings up this message.",
    ""
  };
  
  public void init(){

    BorderLayout new_BorderLayout = new BorderLayout(0,0);
    setLayout(new_BorderLayout);

    cardStack = new Panel();
    c1 = new CardLayout();
    cardStack.setBackground(Color.white);
    cardStack.setLayout(c1);
    add("Center", cardStack);

    //create the cards for plotting each distribution
    theCards[0] = new BinomialCard();
    cardStack.add(DistributionNames[0], theCards[0]);

    theCards[1] = new PoissonCard();
    cardStack.add(DistributionNames[1], theCards[1]);

    theCards[2] = new GeometricCard();
    cardStack.add(DistributionNames[2], theCards[2]);

    theCards[3] = new NegBinomialCard();
    cardStack.add(DistributionNames[3], theCards[3]);

    theCards[4] = new HypergeometricCard();
    cardStack.add(DistributionNames[4], theCards[4]);

    //put selection buttons on the bottom of the page
    Panel SelectionBar = new Panel();
    SelectionBar.setBackground(Color.white);
    
    GridLayout new_GridLayout = new GridLayout(3,2,3,3);
    SelectionBar.setLayout(new_GridLayout);

    SelectionBar.add(new Label());
    SelectionBar.add(new Label());
    SelectionBar.add(new Label());

    for (int i=0; i<SelectionButtons.length; i++) {
      SelectionButtons[i] = new Button(DistributionNames[i]);
      SelectionButtons[i].setForeground(Color.black);
      SelectionButtons[i].setBackground(Color.lightGray);
      SelectionBar.add(SelectionButtons[i]);
    }

    //add help button

    Button help_button = new Button("Help");
    help_button.setForeground(Color.black);
    help_button.setBackground(Color.cyan);
    SelectionBar.add(help_button);

    add("South", SelectionBar);

    //if running as an Applet then get the parameter
    try {
      startCard = getParameter("startCard");
    } catch (Exception e) {
    }
  }

  //things to do when the application starts up
  public void start() {
    //the default startup distribution is distribution 0
    currentCard = theCards[0];
    c1.show(cardStack, DistributionNames[0]);
    theCards[0].init();
    theCards[0].plot();      

    //if the parameter was set, then use this to select the startup
    //distribution
    if (startCard != null) {
      for (int i=0; i<DistributionNames.length; i++) {
	if (startCard.equals(DistributionNames[i])) {
	  currentCard = theCards[i];
	  c1.show(cardStack, DistributionNames[i]);	  
	  theCards[i].init();
	  theCards[i].plot();
	}
      }
    }
  }

  //what to do when a button is pushed
  public boolean action(Event evt, Object arg) {
    for (int i=0; i<SelectionButtons.length; i++) {
      //if a selection button is pushed, change the current 
      //displayed distribution
      if (evt.target == SelectionButtons[i]) {
	currentCard = theCards[i];
	c1.show(cardStack, DistributionNames[i]);
	currentCard.init();
	currentCard.plot();
	return true;
      }
    }
    if ("Help".equals(arg)) {
      helpDialog = new MyDialog("About Plot Probability", helpText);
    } 
    return false;
  }

  //check to see whether a scroll bar has been used
  public boolean handleEvent(Event evt) {
    for (int i=0; i<currentCard.NumberOfParameters; i++) {
      if (evt.target == currentCard.ParameterScrollbars[i]) {
	currentCard.setParameter(i, 
            currentCard.ParameterScrollbars[i].getValue());
	currentCard.plot();
	return true;
      }
    }
    return super.handleEvent(evt);
  }

  //react to keystrokes
  public boolean keyDown(Event e, int key) {
    if (key == 'h') {
      helpDialog = new MyDialog("About Plot Distribution", helpText);
      return true;
    }
    return false;
  }
} //end PlotDistribution

//
// This abstract class is intended to provide the graphics object
// which plots a probability distribution. To extend it to a real class
// it must have defined functions: prob_function.
//

abstract class DistributionCard extends Panel {

  //the name of the distribution to be plotted
  String DistributionName;

  //description of the distribution to be plotted
  String DistributionDesc;

  //a window upon which to plot the distribution
  PlotCanvas1 PlotWindow;

  //variables to do with the parameters of the distribution
  int NumberOfParameters;
  String[] ParameterStrings;
  double[] ParameterDefaults;
  double[] ParameterValues;
  double[][] ParameterRanges;
  Label[] ParameterLabels;
  Scrollbar[] ParameterScrollbars;

  //the range and domain that will be displayed, along with the number
  //of points to be plotted, and the distance between these points.
  int[] range = new int[2];
  double[] domain = new double[2];
  double BinWidth;
  int NumberOfBins;

  int[] x;      //the range of x-values over which to plot the distribution
  double[] p;   //the probability function over the range of x-values
  double low,high,step,default_par;
  int nn,default_par_index;

  //define a constructor
  DistributionCard(String DistributionName, 
                   String DistributionDesc, 
		   String[] ParameterStrings,
		   double[] ParameterDefaults,
		   double[][] ParameterRanges,
		   int[] range,
		   double[] domain,
		   double BinWidth) {
    
    this.DistributionName = DistributionName;
    this.DistributionDesc = DistributionDesc;
    
    this.NumberOfParameters = ParameterStrings.length;
    this.ParameterStrings = ParameterStrings;
    this.ParameterDefaults = ParameterDefaults;
    this.ParameterValues = ParameterDefaults;
    this.ParameterRanges = ParameterRanges;

    //set the values of x and p
    this.domain = domain;
    this.range = range;
    this.BinWidth = BinWidth;
    NumberOfBins = range[1] - range[0] + 1;
    x = new int[NumberOfBins];
    p = new double[NumberOfBins];

    recalculate();

    //Layout the panels subcomponents
    setLayout(new BorderLayout(0, 0));

    //create the plot window
    PlotWindow =  new PlotCanvas1(this.range[0], this.domain[0], 
				 this.range[1], this.domain[1], 
				 "n", " p(n)", " ",
				 Color.black, Color.blue, Color.red, 
				 this.DistributionName+" Distribution",
				 this.DistributionDesc);

    add("Center", PlotWindow); 

    //create the scroll bars, with labels
    Panel scrollbars = new Panel();
    ParameterLabels = new Label[NumberOfParameters];
    ParameterScrollbars = new Scrollbar[NumberOfParameters];

    scrollbars.setLayout(new GridLayout(NumberOfParameters, 3, 5, 5)); 
    scrollbars.setForeground(Color.black);
    scrollbars.setBackground(Color.white);
    for (int i=0; i<NumberOfParameters; i++) {
      ParameterLabels[i] = new Label(ParameterStrings[i]+" = "+ParameterDefaults[i]);
      low = ParameterRanges[i][0];
      high = ParameterRanges[i][1];
      step = ParameterRanges[i][2];
      nn = 1 + Math.round( Math.round( (high - low)/step) );
      default_par = ParameterDefaults[i];
      default_par_index = 1 + Math.round(Math.round((default_par - low)/step));

      ParameterScrollbars[i] = new Scrollbar(Scrollbar.HORIZONTAL, 
                                             default_par_index, 1, 1, nn);
      ParameterLabels[i].setBackground(Color.white);
      ParameterScrollbars[i].setBackground(Color.lightGray);
      scrollbars.add(new Label());
      scrollbars.add(ParameterScrollbars[i]);
      scrollbars.add(ParameterLabels[i]);
    }
    add("South", scrollbars);
  }
  
  public void init() {
    PlotWindow.init();
  }

  //define a method for changing parameter values
  public void setParameter(int i, double value) {
    double low,high,step,par_value;

    low = ParameterRanges[i][0];
    high = ParameterRanges[i][1];
    step = ParameterRanges[i][2];
    par_value = low + step* (value - 1);
    par_value = (Math.round(Math.round(100.0*par_value)))/100.0;

    if ((par_value >= low) & (par_value <= high)) {
     ParameterValues[i] = par_value;
     ParameterLabels[i].setText(ParameterStrings[i]+" = "+ParameterDefaults[i]);
      recalculate();
    } else {
      System.out.println("Error: Parameter outside acceptible range!");
    }
  }

  //define a method for plotting the graph
  public void plot() {
    PlotWindow.plot(x,BinWidth,p, Color.blue); //plot the probability function
    PlotWindow.repaint();
  }

  int Factorial(int n) {
    if (n>1) {
       return n*Factorial(n-1);
    } else if ( (n==1) | (n==0) ) {
       return 1;
    } else {
    return 0;
    }
  }

  double P1(double lambda, int n) {

    double fac=Math.exp(-lambda);
    for (int i=1; i<=n; i++) {
        fac=fac*lambda/( (double) i);
      }
    return fac;
  }

  int Binom1(int n, int r) {
    // Adapted from my matlab code
    // Binom1(n,r) returns the binomial coefficient n choose r
    // This function is used by binom.m
    //
    //        P.K. Pollett, May 1992.

    double fac=1.0;
    if ((n>0) & (r>0)) {
      fac=( (double) n)/( (double) r);
      for (int i=1; i<=(r-1); i++) {
        fac=fac*( (double) n-i)/( (double) r-i);
      }
    } 
    else {
      fac=1.0;
    }
    return Math.round(Math.round(fac));
  }

  int Binom(int n, int r) {
    // Adapted from my matlab code
    // Binom(n,r) returns the binomial coefficient n choose r
    //
    //        P.K. Pollett, May 1992.

    double fac=1.0;
    if ((n>0) & (r>0)) {
      double m = Math.round(Math.round( n/2 ));
      if (r>m) {
        fac=( (double) Binom1(n,n-r) );
      }
      else {
        fac=( (double) n)/( (double) r);
        for (int i=1; i<=(r-1); i++) {
          fac=fac*( (double) n-i)/( (double) r-i);
        }
      }
    }
    else {
      fac=1.0;
    }
    return Math.round(Math.round(fac));
  }

  double Bin1(double p, int n, int r) {
    // Adapted from my matlab code
    // Bin1(p,n,r) returns the binomial probability binom(n,r)*p^r*(1-p)^{n-r}
    //   P.K. Pollett, April 1992.
    if (r>n) {
       return 0.0;
    } else {
       double fac=1.0;
       double q=1-p;
       double s=p*q;
       if ((n>0) & (r>0)) {
         double m = Math.round(Math.round( n/2 ));
         int mm=n-2*r;
         fac=s*( (double) n)/( (double) r);
         for (int i=1; i<=(r-1); i++) {
           fac=fac*s*( (double) n-i)/( (double) r-i);
         }
         for (int i=1; i<=mm; i++) {
           fac=fac*q;
         }
       }
       else {
         for (int i=1; i<=n; i++) {
           fac=fac*q;
           }
       }
       return fac;
    }
  }

  double Bin(double p, int n, int r) {
    // Adapted from my matlab code
    // Bin(p,n,r) returns the binomial probability binom(n,r)*p^r*(1-p)^{n-r}
    // P.K. Pollett, April 1992.

    if (r>n) {
       return 0.0;
    } else {
       double fac=1.0;
       double q=1-p;
       double s=p*q;
       if ((n>0) & (r>0)) {
          double m = Math.round(Math.round( n/2 ));
          if (r>m) {
             fac=Bin1(q,n,n-r);
          } else {
             int mm=n-2*r;
             fac=s*( (double) n)/( (double) r);
             for (int i=1; i<=(r-1); i++) {
               fac=fac*s*( (double) n-i)/( (double) r-i);
             }
             for (int i=1; i<=mm; i++) {
               fac=fac*q;
             }
          }
       } else {
          for (int i=1; i<=n; i++) {
            fac=fac*q;
          }
       }
       return fac;
    }
  }

  double NegBin(int r, double p, int n) {
  // p(n) = ((n+r-1) choose (r-1)) p^r (1-p)^n
     double q=1-p;
     if (r==1) {
        return p*Math.pow(q,n);
     } else {
        return p*(( (double) n+r-1.0)/( (double) r-1.0))*NegBin(r-1,p,n);
     }
  }
       

  //define the function which recalculates the values of the 
  //distribution - it calls the three abstract functions
  void recalculate() {
    for (int i=0; i<x.length; i++) {
      x[i] = range[0] + i;
      p[i] = prob_function(x[i]);
    }
  }

  // define an abstract method for calculating the probability prob_function.

  abstract double prob_function(int n);

}//end DistributionCard

//
// define some real instances of the abstract class above
//

// define a Binomial distribution card
class BinomialCard extends  DistributionCard {

  static String[] parameterNames = {"m","p"};
  static double[] parameterDefaults = {16.0, 0.5};
  static double[][] parameterRanges = {{3.0, 30.0, 1.0}, {0.1, 0.9, 0.1}};
  static int[] r = {0, 22};
  static double[] d = {0.0, 0.4};

  BinomialCard() {
    super("Binomial", 
          "p(n) = (m choose n) p^n ( 1 - p )^( m - n ) ",
	  parameterNames, 
	  parameterDefaults, 
	  parameterRanges, 
	  r, d,
	  0.4);
  }

  double prob_function(int n) {
    double mm = ParameterValues[0];
    int m = Math.round(Math.round(mm));
    double pp = ParameterValues[1];
    return Bin(pp,m,n);
  }
}


// define a Poisson distribution card
class PoissonCard extends  DistributionCard {

  static String[] parameterNames = {"lambda"};
  static double[] parameterDefaults = {3.5};
  static double[][] parameterRanges = {{0.5, 20.0, 0.5}};
  static int[] r = {0, 22};
  static double[] d = {0.0, 0.3};

  PoissonCard() {
    super("Poisson", 
          "p(n) = exp( - lambda ) lambda^n / n ! ",
	  parameterNames, 
	  parameterDefaults, 
	  parameterRanges, 
	  r, d,
	  0.4);
  }

  double prob_function(int n) {
    double lambda = ParameterValues[0];
    return P1(lambda,n);
  }
}


// define a Geometric distribution card
class GeometricCard extends  DistributionCard {

  static String[] parameterNames = {"p"};
  static double[] parameterDefaults = {0.3};
  static double[][] parameterRanges = {{0.05, 0.4, 0.01}};
  static int[] r = {0, 22};
  static double[] d = {0.0, 0.4};

  GeometricCard() {
    super("Geometric", 
          "p(n) =  p ( 1 - p )^n ",
	  parameterNames, 
	  parameterDefaults, 
	  parameterRanges, 
	  r, d,
	  0.4);
  }

  double prob_function(int n) {
    double pp = ParameterValues[0];
    return pp*Math.pow(1-pp,n);
  }
}

// define a Negative Binomial distribution card
class NegBinomialCard extends  DistributionCard {

  static String[] parameterNames = {"r","p"};
  static double[] parameterDefaults = {3, 0.5};
  static double[][] parameterRanges = {{1.0, 10.0, 1.0}, {0.05, 0.95, 0.05}};
  static int[] r = {0, 22};
  static double[] d = {0.0, 0.4};

  NegBinomialCard() {
    super("Negative Binomial", 
          "p(n) =  ( ( n + r - 1 ) choose ( r - 1 ) ) p^r ( 1 - p )^n ",
	  parameterNames, 
	  parameterDefaults, 
	  parameterRanges, 
	  r, d,
	  0.4);
  }

  double prob_function(int n) {
    double rr = ParameterValues[0];
    int r = Math.round(Math.round(rr));
    double pp = ParameterValues[1];
    return NegBin(r,pp,n);
  }
}

// define a Hypergeometric distribution card
class HypergeometricCard extends DistributionCard {

  static String[] parameterNames = {"N","a","m"};
  static double[] parameterDefaults = {26, 13, 12};
  static double[][] parameterRanges = 
      {{1.0,34.0,1.0},{0.0,30.0,1.0},{1.0,30.0,1.0}};
  static int[] r = {0, 22};
  static double[] d = {0.0, 0.4};

  HypergeometricCard() {
    super("Hypergeometric", 
    "p(n) = ( a choose n ) ( ( N - a ) choose ( m - n ) ) / ( N choose m )",
	  parameterNames, 
	  parameterDefaults, 
	  parameterRanges, 
	  r, d,
	  0.4);
  }

  double prob_function(int n) {
    int low,high;

    double NN = ParameterValues[0];
    int N = Math.round(Math.round(NN));
    double aa = ParameterValues[1];
    int a = Math.round(Math.round(aa));
    double mm = ParameterValues[2];
    int m = Math.round(Math.round(mm));

    low=m+a-N;
    if (low<0) low=0;
    high=m;
    if (a<m) high=a;
    
    if ( (n<low) | (n>high) ) {
       return 0.0;
    } else {
return ( (double) Binom(a,n))*( (double) Binom(N-a,m-n))/( (double) Binom(N,m));
    }
  }

}