/*
 * Started May 17, 1996
 */

import java.applet.*;
import java.net.*;
import java.io.*;
import java.awt.*;
import java.util.*;
import java.lang.*;

class Matrix
{
  int m,n;	// rows and columns
  double[][] A;

  public Matrix()
  {
    this.m = 0;
    this.n = 0;
  }

  public Matrix(int row, int col)
  {
    int i,j;

    this.m = row;
    this.n = col;
    this.A = new double[m][n];
    for (i=0; i<this.m; i++) for (j=0; j<this.n; j++)
    {
      this.A[i][j] = 0;
    }
  }

  public Matrix(Matrix M)
  {
    int i,j;

    this.m = M.m();
    this.n = M.n();
    for (i=0; i<this.m; i++) for (j=0; j<this.n; j++)
    {
      this.A[i][j] = M.A(i,j);
    }
  }

  public Matrix(Matrix M, int i, int j)
  {
    if (i >= M.m() || j >= M.n())
    {
      System.err.println("minor out of range");
      System.exit(1);
    }
    else
    {
      int k,l;

      this.m = M.m() - 1;
      this.n = M.n() - 1;
      this.A = new double[this.m][this.n];
      for (k=0; k<this.m; k++) for (l=0; l<this.n; l++)
      {
	if ((k<i) && (l<j)) {
	  this.A[k][l] = M.A(k,l);
        } else if((k<i) && (l>=j)) {
	  this.A[k][l] = M.A(k,l+1);
        } else if((k>=i) && (l<j)) {
	  this.A[k][l] = M.A(k+1,l);
        } else if((k>=i) && (l>=j)) {
	  this.A[k][l] = M.A(k+1,l+1);
        }
      }
    }
  }

  public int m() {return this.m;}
  public int n() {return this.n;}
  public double A(int i,int j)
  {
    return this.A[i][j];
  }
  public void setA(int i,int j,double val) {this.A[i][j] = val;}

  public Matrix transpose()
  {
    int i,j;
    Matrix res = new Matrix(this.n,this.m);

    for (i=0; i<this.n; i++) for (j=0; j<this.m; j++){
      res.setA(i,j,this.A[j][i]);
    }

    return res;
  }

  public Matrix plus(Matrix M)
  {
    if ((this.m != M.m()) || (this.n != M.n())){
      System.err.println("matrix dim mismatch");
      System.exit(1);
    }

    int i,j;
    Matrix res = new Matrix(this.m,this.n);

    for (i=0; i<this.m; i++) for (j=0; j<this.n; j++){
      res.setA(i,j,this.A[i][j]+M.A(i,j));
    }

    return res;
  }

  public Matrix times(Matrix M)
  {
    if (this.n != M.m())
    {
      System.err.println("matrix dim mismatch");
      System.exit(1);
    }

    int i,j,k;
    Matrix res = new Matrix(this.m, M.n());

    for (i=0; i<this.m; i++) for (j=0; j< M.n(); j++)
    {
      double a = 0;
      for (k=0; k<this.n; k++)
      {
	a += this.A[i][k] * M.A(k,j);
      }
      res.setA(i,j,a);
    }

    return res;
  }

  public Matrix times(double a)
  {
    int i,j;
    Matrix res = new Matrix(this.m,this.n);

    for (i=0; i<this.m; i++) for (j=0; j<this.n; j++){
      res.setA(i,j,a*this.A[i][j]);
    }

    return res;
  }

  
  public double det()
  {
    if (this.m != this.n)
    {
      System.err.println("determinant of nonsquared matrix");
      System.exit(1);
    }

    int i;

    if (this.m > 1)
    {
      double tmp = 0;

      for (i=0; i<this.m; i++)
      {
	tmp += Math.pow((double)(-1),(double)i)*this.A[0][i]*(new Matrix(this,0,i)).det();
      }
      return tmp;
    }
    else if (this.m == 1)
    {
      return this.A[0][0];
    }
    else
    {
      return 0;
    }
  }

  public Matrix inv()
  {
    if (this.m != this.n)
    {
      System.err.println("inverse of nonsquared matrix");
      System.exit(1);
    }

    int i,j;
    Matrix res = new Matrix(this.m, this.n);
    double det = this.det();

    if (Math.abs(det) < 1.e-300)
    {
      System.err.println("inverse of singular matrix");
      System.exit(1);
    }

    for (i=0; i<this.n; i++) for (j=0; j<this.m; j++)
    {
      res.setA(j,i,Math.pow((double)(-1),(double)(i+j))*(new Matrix(this,i,j)).det()/det);
    }
    return res;
  }
}

/* 
 * "Main Class"
 */
public class EfficientFrontier extends Applet
{
  int numberAssets = 0;
  List assetList;
  Button go_button, clear_button;
  Canvas graphics_canvas;
  // canvas properties
  int applet_width;
  int applet_height;
  int canvas_width; 
  int canvas_height;
  int left_margin;
  int right_margin;
  int bottom_margin;
  int top_margin;
  int left;
  int right;
  int bottom;
  int top;


  // statixtics
  Matrix mu;
  Matrix V;

  double ReMin = 0;
  double ReMax = 0;
  double SigmaMin = 0;
  double SigmaMax = 0;

  /* some useful ASCII codes */
  int EOF = 4;
  int CARRIAGE_RETURN = 10;
  int SPACE = 32;
  int COMMA = 44;
  int NEGATIVE_SIGN = 45;
  int DECIMAL_POINT = 46;
  int ZERO = 48;

  // colors
  int maxColors = 8;
  Color[] frontierColors = {
    Color.blue,
    Color.cyan,
    Color.gray,
    Color.green,
    Color.orange,
    Color.pink,
    Color.red,
    Color.yellow
  };
  int colorIndex = 0;



  public void init() {
    int i = 0;
    int j = 0;
    int k = 0;
    int l = 0;

    // reading parameters
    applet_width = Integer.parseInt(this.getParameter("appletWidth"),10);
    applet_height = Integer.parseInt(this.getParameter("appletHeight"),10);
    canvas_width = Integer.parseInt(this.getParameter("canvasWidth"),10);
    canvas_height = Integer.parseInt(this.getParameter("canvasHeight"),10);
    left_margin = Integer.parseInt(this.getParameter("leftMargin"),10);
    right_margin = Integer.parseInt(this.getParameter("rightMargin"),10);
    bottom_margin = Integer.parseInt(this.getParameter("bottomMargin"),10);
    top_margin = Integer.parseInt(this.getParameter("topMargin"),10);
    left = left_margin; 
    right = canvas_width-right_margin;
    bottom = canvas_height-bottom_margin; 
    top = top_margin;

    // reading the CSV file and initialize data
    String dataFileName = this.getParameter("assetDataFileName");
    String URLPrefix = new String("http://www.duke.edu/~charvey/frontier/");
    String dataURLName = new String(URLPrefix+dataFileName);
    // System.out.println(dataURLName);

    int assetIndex;
    int samplePointIndex;

    String[] assetNames = new String[0];
    int numberSamplePoints = 0;
    double[][] data = new double[0][0];

    int[] months = new int[0];
    int[] years = new int[0];

    int startingMonth;
    int startingYear;
    int endingMonth;
    int endingYear;

    try{
      URL url = new URL(dataURLName);
      try{
	// open the asset URL connection and reads data
	URLConnection connection = url.openConnection();
	DataInputStream in = new DataInputStream(connection.getInputStream());
	int size = connection.getContentLength();
	System.out.println(size);
	byte[] bStream = new byte[size];
	int bytes_read = 0;
	while (bytes_read < size){
	  bytes_read += in.read(bStream,bytes_read,size-bytes_read);
	}

	int position = 0;
	int tmp_position = 0;

	// count the number of assetes 
	tmp_position = position;
	numberAssets = 0;
	while (bStream[tmp_position] != CARRIAGE_RETURN){
	  if (bStream[tmp_position] == COMMA){
	    numberAssets ++;
	  }
	  tmp_position ++;
	}
	System.out.println(numberAssets);

	// read asset names
	assetNames = new String[numberAssets];
	for(assetIndex = 0; assetIndex < numberAssets; assetIndex ++){
	  assetNames[assetIndex] = "";
	}

	tmp_position = position;
	boolean NullEntry = true;
	while (bStream[tmp_position] != COMMA){
	  NullEntry = (NullEntry && (bStream[tmp_position] == SPACE));
	  tmp_position ++;
	}

	while (NullEntry){
	  position = tmp_position + 1; // skip the comma
	  for(assetIndex = 0; assetIndex < numberAssets; assetIndex ++){
	    while ((bStream[position] != COMMA) && (bStream[position] != CARRIAGE_RETURN)){
	      assetNames[assetIndex] += (char)bStream[position];
	      position ++;
	    }
	    position ++; // skip the comma or return
	  }

	  tmp_position = position;
	  NullEntry = true;
	  while (bStream[tmp_position] != COMMA){
	    NullEntry = (NullEntry && (bStream[tmp_position] == SPACE));
	    tmp_position ++;
	  }
	}

	// clean asset names
	for (i=0; i < numberAssets; i++){
	  assetNames[i] = formatString(assetNames[i]);
	}

	// count the number of sample points
	tmp_position = position;
	numberSamplePoints = 0;
	while (tmp_position < size){
	  if (bStream[tmp_position] == CARRIAGE_RETURN){
	    numberSamplePoints ++;
	    // System.out.println(numberSamplePoints);
	  }
	  // System.out.print(bStream[tmp_position]+"/");
	  tmp_position ++;
	}

	System.out.println(numberSamplePoints);

	// read the sample data
	data = new double[numberAssets][numberSamplePoints];
	months = new int[numberSamplePoints];
	years = new int[numberSamplePoints];

	for (samplePointIndex = 0; samplePointIndex < numberSamplePoints; samplePointIndex ++){
	  while (bStream[position] == SPACE) position ++; // skip spaces 
	  String month = new String(bStream,0,position,3);
	  position += 3;
	  months[samplePointIndex] = getMonth(month);
	  // System.out.println(month+" "+months[samplePointIndex]);
	  while (bStream[position] == SPACE) position ++; // skip spaces 
	  String year = new String(bStream,0,position,4);
	  position += 4;
	  years[samplePointIndex] = getInt(year);
	  // System.out.println(year+" "+years[samplePointIndex]);
	  while (bStream[position] == SPACE) position ++; // skip spaces 
	  position ++; // skip comma
	  for (assetIndex = 0; assetIndex < numberAssets; assetIndex ++){
	    String number = new String("");
	    while ((bStream[position] != COMMA) && (bStream[position] != CARRIAGE_RETURN)){
	      number += new String(bStream,0,position,1);
	      position ++;
	    }
	    data[assetIndex][samplePointIndex] = getDouble(number);
	    position ++; // skip comma or return
	  }
	}
      } catch (IOException e) System.err.println(e);
    } catch (MalformedURLException e) System.err.println(e);

    /*
    for (assetIndex = 0; assetIndex < numberAssets; assetIndex ++){
      System.out.print(assetNames[assetIndex]+",");
    }
    System.out.println();
    for (samplePointIndex = 0; samplePointIndex < numberSamplePoints; samplePointIndex ++){
      System.out.print(months[samplePointIndex]+" "+years[samplePointIndex]+",");
      for (assetIndex = 0; assetIndex < numberAssets; assetIndex ++){
	System.out.print(data[assetIndex][samplePointIndex]+",");
      }
      System.out.println();
    }
    */

    // rescaling -- divide by 100 to convert the percentage
    for (i=0; i<numberAssets; i++) for (j=0; j<numberSamplePoints; j++){
      data[i][j] /= 100;
    }

    // compute statistics
    mu = new Matrix(numberAssets,1);  // mean vector
    V = new Matrix(numberAssets,numberAssets);  // covariant matrix

    for (i=0; i<numberAssets; i++){
      for (k=0; k<numberSamplePoints; k++){
	mu.setA(i,0,(mu.A(i,0)+data[i][k]));
      }
      mu.setA(i,0,(mu.A(i,0)/numberSamplePoints));
      // System.out.println(mu.A(i,0));
    }
    // System.out.println();
 
    for (i=0; i<numberAssets; i++){
      for (j=0; j<numberAssets; j++){
	for (k=0; k<numberSamplePoints; k++){
	  V.setA(i,j,(V.A(i,j)+(data[i][k]-mu.A(i,0))*(data[j][k]-mu.A(j,0))));
	}
	V.setA(i,j,(V.A(i,j)/numberSamplePoints));
	// System.out.print("\t"+V.A(i,j));
      }
      // System.out.println();
    }

    // find ReMax, and SigmaMax
    for (i=0; i<numberAssets; i++){
      if (ReMin > mu.A(i,0)) ReMin = mu.A(i,0);
      if (ReMax < mu.A(i,0)) ReMax = mu.A(i,0);
      for (j=0; j<numberAssets; j++){
	if (SigmaMax < V.A(i,j)) SigmaMax = V.A(i,j);
      }
    }
    // rescaling
    ReMin = ReMin * 1200;
    ReMax = ReMax * 1200;
    SigmaMin = 0;
    SigmaMax = Math.sqrt(SigmaMax*12)*100;


    // initialize background
    this.setBackground(new Color(Integer.parseInt(getParameter("bgColor"),16)));
    resize(applet_width,applet_height);
    
    // create the "Go" button
    go_button = new Button("Go");
    go_button.setForeground(Color.black);
    go_button.setBackground(new Color(Integer.parseInt(getParameter("dkColor"),16)));
    // this.add(go_button);

    // asset list menu
    assetList = new List(6, true);
    // assetList.resize(Integer.parseInt(getParameter("listWidth")),Integer.parseInt(getParameter("listHight")));
    for (i=0; i<numberAssets; i++){
      assetList.addItem(assetNames[i]);
    }
    // this.add(assetList);

    // create the "Clear" button
    clear_button = new Button("Clear");
    clear_button.setForeground(Color.black);
    clear_button.setBackground(new Color(Integer.parseInt(getParameter("dkColor"),16)));
    // this.add(clear_button);

    // creat panel
    GridBagLayout gridbag = new GridBagLayout();
    this.setLayout(gridbag);

    Panel button_panel = new Panel();
    button_panel.setLayout(gridbag);
    constrain(button_panel,go_button,0,0,1,1,GridBagConstraints.NONE,
	      GridBagConstraints.CENTER,0.3,0.0,0,0,0,0);
    constrain(button_panel,clear_button,1,0,1,1,GridBagConstraints.NONE,
	      GridBagConstraints.CENTER,0.3,0.0,0,0,0,0);
    
    Panel panel = new Panel();
    panel.setLayout(gridbag);
    constrain(panel,new Label("Asset List"),0,0,1,1);
    constrain(panel,new Label(months[0]+","+years[0]+"  --  "+months[numberSamplePoints-1]+","+years[numberSamplePoints-1]),0,1,1,1);
    constrain(panel,assetList,0,2,1,1,GridBagConstraints.VERTICAL,GridBagConstraints.NORTHWEST,
	      0.0,1.0,0,0,0,0);
    constrain(panel,button_panel,0,3,1,1,GridBagConstraints.HORIZONTAL,GridBagConstraints.CENTER,
	      0.0,1.0,0,0,0,0);

    // create graphics canvas
    graphics_canvas = new Canvas();
    graphics_canvas.resize(canvas_width, canvas_height);
    Panel graphics_panel = new Panel();
    graphics_panel.setLayout(new BorderLayout(0,0));
    graphics_panel.add("Center",graphics_canvas);

    constrain(this,graphics_panel,0,0,3,1,GridBagConstraints.HORIZONTAL,GridBagConstraints.CENTER,
	      1.0,0.0,10,10,5,5);
    constrain(this,panel,3,0,1,1,GridBagConstraints.VERTICAL,GridBagConstraints.NORTHWEST,
	      0.0,1.0,20,10,5,5);
  }

  // convert months into integers
  int getMonth(String month)
  {
    if (month.equalsIgnoreCase("Jan")) return 1;
    if (month.equalsIgnoreCase("Feb")) return 2;
    if (month.equalsIgnoreCase("Mar")) return 3;
    if (month.equalsIgnoreCase("Apr")) return 4;
    if (month.equalsIgnoreCase("May")) return 5;
    if (month.equalsIgnoreCase("Jun")) return 6;
    if (month.equalsIgnoreCase("Jul")) return 7;
    if (month.equalsIgnoreCase("Aug")) return 8;
    if (month.equalsIgnoreCase("Sep")) return 9;
    if (month.equalsIgnoreCase("Oct")) return 10;
    if (month.equalsIgnoreCase("Nov")) return 11;
    if (month.equalsIgnoreCase("Dec")) return 12;
    return 0;
  }

  // convert a string into an integer
  int getInt(String number)
  {
    int result = 0;
    int length = number.length();
    int digit = 0;
    boolean negative = false;

    if (number.charAt(digit) == NEGATIVE_SIGN){
      negative = true;
      digit ++;
    }

    while (digit < length){
      if (((int)number.charAt(digit)-ZERO) > 9 || ((int)number.charAt(digit)-ZERO) < 0){
	System.err.println("integer number reading error: "+number);
	System.exit(1);
      } else{
	result = result*10 + (int)number.charAt(digit) - ZERO;
      }
      digit ++;
    }

    if (negative) result *= -1;

    return result;
  }

  // convert a string into a double
  double getDouble(String number)
  {
    double result = 0;
    int length = number.length();
    int digit = 0;
    int decimalDigit = 0;
    boolean before = true;
    boolean negative = false;

    if (number.charAt(digit) == NEGATIVE_SIGN){
      negative = true;
      digit ++;
    }

    while (digit < length){
      if (number.charAt(digit) == DECIMAL_POINT){
	decimalDigit = 0;
	before = false;
      } else  if (((int)number.charAt(digit)-ZERO) > 9 || ((int)number.charAt(digit)-ZERO) < 0){
	System.err.println("real number reading error "+number+" "+number.charAt(digit));
	System.exit(1);
      } else  if (before){
	result = result*10 + (double)number.charAt(digit) - (double)ZERO;
      } else{
	decimalDigit ++;
	int ddIndex = 0;
	double dd = (double)number.charAt(digit)-(double)ZERO;
	for (ddIndex=0; ddIndex<decimalDigit; ddIndex++){
	  dd = dd/((double)10);
	}
	result = result + dd;
      }
      digit ++;
    }

    if (negative) result *= -1;

    return result;
  }

  // format sting : get rid of additional spaces
  String formatString(String s)
  {
    String res = s;
    int i = 1;

    while (i<res.length()){
      if (res.charAt(i-1) == SPACE && res.charAt(i) == SPACE){
	res = res.substring(0,i) + res.substring(i+1);
      } else{
	i ++;
      }
    }

    if (res.charAt(0) == SPACE) res = res.substring(1);
    if (res.charAt(res.length()-1) == SPACE) res = res.substring(0,res.length()-1);

    return res;
  }

  public void constrain(Container container, Component component, 
			int grid_x, int grid_y, int grid_width, int grid_height,
			int fill, int anchor, double weight_x, double weight_y,
			int top, int left, int bottom, int right)
  {
    GridBagConstraints c = new GridBagConstraints();
    c.gridx = grid_x; c.gridy = grid_y;
    c.gridwidth = grid_width; c.gridheight = grid_height;
    c.fill = fill; c.anchor = anchor;
    c.weightx = weight_x; c.weighty = weight_y;
    if (top+bottom+left+right > 0)
      c.insets = new Insets(top, left, bottom, right);
    
    ((GridBagLayout)container.getLayout()).setConstraints(component, c);
    container.add(component);
  }

  public void constrain(Container container, Component component, 
			int grid_x, int grid_y, int grid_width, int grid_height)
  {
    constrain(container, component, grid_x, grid_y, 
              grid_width, grid_height, GridBagConstraints.NONE, 
              GridBagConstraints.NORTHWEST, 0.0, 0.0, 0, 0, 0, 0);
  }

  public void constrain(Container container, Component component, 
			int grid_x, int grid_y, int grid_width, int grid_height,
			int top, int left, int bottom, int right)
  {
    constrain(container, component, grid_x, grid_y, 
              grid_width, grid_height, GridBagConstraints.NONE, 
              GridBagConstraints.NORTHWEST, 
              0.0, 0.0, top, left, bottom, right);
  }

  public void paintCoord(Graphics g)
  {
    String xLable = "sigma";
    String yLable = "E[r_e]";
    int xTicks = 5;
    int yTicks = 5;
    if (xTicks<2 || yTicks<2){
      System.err.println("xTicks or yTicks has to be at least 2");
      System.exit(1);
    }
    double xMin = 0;
    double xMax = (int)(SigmaMax/(xTicks-1)+1)*(xTicks-1);
    double yMin = (int)(ReMin/(yTicks-1)-1)*(yTicks-1);
    double yMax = (int)(ReMax/(yTicks-1)+1)*(yTicks-1);

    int i = 0;

    // draw coordinate axes
    g.drawLine(left,bottom,right,bottom);  // x axis
    g.drawLine(left,bottom,left,top);      // y axis

    // dra2w coordinate lables
    g.drawString(xLable,(int)(right+right_margin*0.5),bottom);
    g.drawString(yLable,left,(int)(top-top_margin*0.5));

    // draw coordinate ticks
    for (i=0; i<xTicks; i++){
      double x = xMin+(xMax-xMin)*(double)i/(double)(xTicks-1);
      g.drawString(Double.toString(x),
		   (int)(left+(double)(right-left)*(double)i/(double)(xTicks-1)),
		   (int)(bottom+bottom_margin*0.5));
    }
    for (i=0; i<yTicks; i++){
      double y = yMin+(yMax-yMin)*(double)i/(double)(xTicks-1);
      g.drawString(Double.toString(y), (int)(left-left_margin*0.5),
		   (int)(bottom-(double)(bottom-top)*
			 (double)i/(double)(yTicks-1)));
    }
  }

  public boolean action(Event event, Object arg)
  {
    Graphics g = graphics_canvas.getGraphics();

    int numPoints = 20;

    if (event.target == go_button){
      int i,j ,ip, jp;

      int numChosen = 0;
      for (i=0; i<numberAssets; i++){
	if (assetList.isSelected(i)) numChosen ++;
      }

      if (numChosen < 2){
	System.out.println("You have to choose at least two asset.");
	return true;
      }

      // construct the submatrices mu_p and V_p
      Matrix mu_p = new Matrix(numChosen,1);
      Matrix V_p = new Matrix(numChosen,numChosen);
      ip = 0;
      for (i=0; i<numberAssets; i++){
	if (assetList.isSelected(i)){
	  mu_p.setA(ip,0,mu.A(i,0));
	  jp = 0;
	  for (j=0; j<numberAssets; j++){
	    if (assetList.isSelected(j)){
	      V_p.setA(ip,jp,V.A(i,j));
	      jp ++;
	    }
	  }
	  ip ++;
	}
      }

      /* compute the efficient frontier */
      Matrix V_p_inv = new Matrix(numChosen,numChosen);
      V_p_inv = V_p.inv();

      Matrix one = new Matrix(numChosen,1);
      for (i=0; i<numChosen; i++){
	one.setA(i,0,1.0);
      }

      double a = (mu_p.transpose()).times(V_p_inv.times(mu_p)).A(0,0);
      double b = (mu_p.transpose()).times(V_p_inv.times(one)).A(0,0);
      double c = (one.transpose()).times(V_p_inv.times(mu_p)).A(0,0);
      double d = (one.transpose()).times(V_p_inv.times(one)).A(0,0);

      double[] r_e = new double[numPoints+1];
      double[] sigma = new double[numPoints+1];
      double r_e_min = mu_p.A(0,0);
      double r_e_max = mu_p.A(0,0);
      for (i=1; i<mu_p.m(); i++){
	if (r_e_min > mu_p.A(i,0)) r_e_min = mu_p.A(i,0);
	if (r_e_max < mu_p.A(i,0)) r_e_max = mu_p.A(i,0);
      }
      // System.out.println("re_min: "+r_e_min+" re_max: "+r_e_max);
      for (i=0; i<=numPoints; i++){
	r_e[i] = r_e_min + (r_e_max-r_e_min)*i/((double)numPoints);

	double lambda_1 = (r_e[i]*d-b)/(a*d-b*c);
	double lambda_2 = (a-r_e[i]*c)/(a*d-b*c);

	Matrix w_p = V_p_inv.times(mu_p).times(lambda_1).plus
	  (V_p_inv.times(one).times(lambda_2));
	sigma[i] = w_p.transpose().times(V_p.times(w_p)).A(0,0);
	sigma[i] = Math.sqrt(sigma[i]);
	/* rescaling, convert to annually percent */
	r_e[i] *= 1200;
	sigma[i] *= (Math.sqrt(12)*100);
	// System.out.println(r_e[i]+"\t"+sigma[i]+"\t");
      }
      double sigma_min = sigma[0];
      double sigma_max = sigma[0];
      for (i=1; i<=numPoints; i++){
	if (sigma_min > sigma[i]) sigma_min = sigma[i];
	if (sigma_max < sigma[i]) sigma_max = sigma[i];
      }

      /* scailing and flipping up-side-down */
      int[] x = new int[numPoints+1];
      int[] y = new int[numPoints+1];
      for (i=0; i<=numPoints; i++){
	x[i] = (int)(left+(right-left)*(sigma[i]-SigmaMin)/(SigmaMax-SigmaMin));
	y[i] = (int)(bottom-(bottom-top)*(r_e[i]-ReMin)/(ReMax-ReMin));
      }

      this.paintCoord(g);
      for (i=0; i<numPoints; i++){
	g.setColor(frontierColors[colorIndex]);
	g.drawLine(x[i],y[i],x[i+1],y[i+1]);
      }
      colorIndex = (colorIndex+1)%maxColors;
      return true;
    } else if (event.target == clear_button){
      g.clearRect(0,0,canvas_width,canvas_height);
      this.paintCoord(g);
      return true;
    } else return super.action(event, arg);
  }
}