datapoints.java,v

包含了模式识别中常用的一些分类器设计算法

      third.addElement(new MyPoint(xval[i], yval[i]));
d414 11
a424 36
    // generate the binormal gaussian random deviates
    //
    bn.gaussian(
      maxsize,
      xmax - (xmax-xmin)/4.0,
      ymin + (ymax-ymin)/4.0,
      xval,
      yval,
      ((0.1*(xmax-xmin))/4)*(((xmax-xmin))/4),
      0.0,
      0.0,
      ((0.1*(ymax-ymin))/4)*(((ymax-ymin))/4));

    // format the point to be plotted on the screen
    //
    Vector forth = new Vector(maxsize);
    for (int i = 0; i < maxsize; i++)
    {
      forth.addElement(new MyPoint(xval[i], yval[i]));
    }

    dset1 = (Vector)first.clone();
    dset2 = (Vector)second.clone();
    dset3 = (Vector)third.clone();
    dset4 = (Vector)forth.clone();
  }

  // method: setOverGaussian
  //
  // arguments: none
  // return   : none
  //
  // create a set of point that correspond to two overlapped gaussians to
  // be displayed on the input canvas
  //
  public void setOverGaussian(DisplayScale scale)
d427 7
a433 7
    // local variables
    //
    double xmax, xmin, ymax, ymin;  
    int maxsize = 0;
    double[] xval = null;
    double[] yval = null;
    BiNormal bn = new BiNormal();
d435 9
a443 9
    // initialize variables
    //
    xmax = scale.xmax;
    xmin = scale.xmin;
    ymax = scale.ymax;
    ymin = scale.ymin;
    maxsize = 200;
    xval = new double[maxsize];
    yval = new double[maxsize];
d445 12
a456 12
    // generate the binormal gaussian random deviates
    //
    bn.gaussian(
      maxsize,
      ((xmax-xmin)/1.75 + xmin),
      ((ymax-ymin)/2 + ymin),
      xval,
      yval,
      ((0.1*(ymax-ymin))/4)*(((ymax-ymin))/4),
      0.0,
      0.0,
      ((0.1*(ymax-ymin))/4)*(((ymax-ymin))/4));
d458 7
a464 7
    // format the point to be plotted on the screen
    //
    Vector first = new Vector(maxsize);
    for (int i = 0; i < maxsize; i++)
    {
      first.addElement(new MyPoint(xval[i], yval[i]));
    }
d466 33
a498 12
    // generate the binormal gaussian random deviates
    //
    bn.gaussian(
      maxsize,
      (xmax - (xmax-xmin)/1.75),
      ((ymax-ymin)/2 + ymin),
      xval,
      yval,
      ((0.1*(ymax-ymin))/4)*(((ymax-ymin))/4),
      0.0,
      0.0,
      ((0.1*(ymax-ymin))/4)*(((ymax-ymin))/4));
d500 7
a506 7
    // format the point to be plotted on the screen
    //
    Vector second = new Vector(maxsize);
    for (int i = 0; i < maxsize; i++)
    {
      second.addElement(new MyPoint(xval[i], yval[i]));
    }
d508 12
a519 3
    dset1 = (Vector)first.clone();
    dset2 = (Vector)second.clone();
  }
d521 12
a532 73
  // method: setTwoEllipses
  //
  // arguments: none
  // return   : none
  //
  // create a set of point that correspond to two ellipses to
  // be displayed on the input canvas
  //
  public void setTwoEllipses(DisplayScale scale)
  {

    // local variables
    //
    double xmax, xmin, ymax, ymin;  
    int maxsize = 0;
    double[] xval = null;
    double[] yval = null;
    BiNormal bn = new BiNormal();

    // initialize variables
    //
    xmax = scale.xmax;
    xmin = scale.xmin;
    ymax = scale.ymax;
    ymin = scale.ymin;
    maxsize = 200;
    xval = new double[maxsize];
    yval = new double[maxsize];

    // generate the binormal gaussian random deviates
    //
    bn.gaussian(
      maxsize,
      xmin + (xmax-xmin)/4.0,
      ymax - (ymax-ymin)/4.0,
      xval,
      yval,
      ((0.133*(xmax-xmin))/4)*(((xmax-xmin))/4),
      0.0,
      0.0,
      ((0.017*(xmax-xmin))/4)*(((xmax-xmin))/4));

    // format the point to be plotted on the screen
    //
    Vector first = new Vector(maxsize);
    for (int i = 0; i < maxsize; i++)
    {
      first.addElement(new MyPoint(xval[i], yval[i]));
    }

    // generate the binormal gaussian random deviates
    //
    bn.gaussian(
      maxsize,
      xmax - (xmax-xmin)/4.0,
      ymin + (ymax-ymin)/4.0,
      xval,
      yval,
      ((0.133*(xmax-xmin))/4)*(((xmax-xmin))/4),
      0.0,
      0.0,
      ((0.017*(xmax-xmin))/4)*(((xmax-xmin))/4));

    // format the point to be plotted on the screen
    //
    Vector second = new Vector(maxsize);
    for (int i = 0; i < maxsize; i++)
    {
      second.addElement(new MyPoint(xval[i], yval[i]));
    }

    dset1 = (Vector)first.clone();
    dset2 = (Vector)second.clone();
d534 21
d556 30
a585 10
  // method: setRotatedEllipses
  //
  // arguments: none
  // return   : none
  //
  // create a set of point that correspond to two rotated ellipses to
  // be displayed on the input canvas
  //
  public void setRotatedEllipses(DisplayScale scale)  
    {
d587 23
a609 37
    // local variables
    //
    double xmax, xmin, ymax, ymin;  
    int maxsize = 0;
    double[] xval = null;
    double[] yval = null;
    BiNormal bn = new BiNormal();

    // initialize variables
    //
    xmax = scale.xmax;
    xmin = scale.xmin;
    ymax = scale.ymax;
    ymin = scale.ymin;
    maxsize = 200;
    xval = new double[maxsize];
    yval = new double[maxsize];

    // generate the binormal gaussian random deviates
    //
    bn.gaussian(
      maxsize,
      xmin + (xmax-xmin)/4.0,
      ymax - (ymax-ymin)/4.0,     
      xval,
      yval,
      ((0.133*(xmax-xmin))/4)*(((xmax-xmin))/4),
      0.0,
      0.0,
      ((0.017*(xmax-xmin))/4)*(((xmax-xmin))/4));

    // format the point to be plotted on the screen
    //
    Vector first = new Vector(maxsize);
    for (int i = 0; i < maxsize; i++)
    {
      first.addElement(new MyPoint(xval[i], yval[i]));
d611 12
a622 18

    // generate the binormal gaussian random deviates
    //
    bn.gaussian(
      maxsize,
      xmax - (xmax-xmin)/4.0,
      ymin + (ymax-ymin)/4.0,   
      xval,
      yval,
      ((0.017*(xmax-xmin))/4)*(((xmax-xmin))/4),
      0.0,
      0.0,
      ((0.133*(xmax-xmin))/4)*(((xmax-xmin))/4));

    // format the point to be plotted on the screen
    //
    Vector second = new Vector(maxsize);
    for (int i = 0; i < maxsize; i++)
d624 8
a631 2
      second.addElement(new MyPoint(xval[i], yval[i]));
    }
d633 30
a662 3
    dset1 = (Vector)first.clone();
    dset2 = (Vector)second.clone();
  }
d664 20
a683 41
  // method: setFourEllipses
  //
  // arguments: none
  // return   : none
  //
  // create a set of point that correspond to four ellipses to
  // be displayed on the input canvas
  //
  public void setFourEllipses(DisplayScale scale)
  {

    // local variables
    //
    double xmax, xmin, ymax, ymin;  
    int maxsize = 0;
    double[] xval = null;
    double[] yval = null;
    BiNormal bn = new BiNormal();

    // initialize variables
    //
    xmax = scale.xmax;
    xmin = scale.xmin;
    ymax = scale.ymax;
    ymin = scale.ymin;
    maxsize = 200;
    xval = new double[maxsize];
    yval = new double[maxsize];

    // generate the binormal gaussian random deviates
    //
    bn.gaussian(
      maxsize,
      xmax - (xmax-xmin)/4.0,
      ymax - (ymax-ymin)/4.0,   
      xval,
      yval,
      ((0.133*(xmax-xmin))/4)*(((xmax-xmin))/4),
      0.0,
      0.0,
      ((0.017*(ymax-ymin))/4)*(((ymax-ymin))/4));
d685 2
a686 6
    // format the point to be plotted on the screen
    //
    Vector first = new Vector(maxsize);
    for (int i = 0; i < maxsize; i++)
    {
      first.addElement(new MyPoint(xval[i], yval[i]));
d689 20
a708 12
    // generate the binormal gaussian random deviates
    //
    bn.gaussian(
      maxsize,
      xmin + (xmax-xmin)/4.0,
      ymax - (ymax-ymin)/4.0,
      xval,
      yval,
      ((0.133*(xmax-xmin))/4)*(((xmax-xmin))/4),
      0.0,
      0.0,
      ((0.017*(ymax-ymin))/4)*(((ymax-ymin))/4));
d710 30
a739 7
    // format the point to be plotted on the screen
    //
    Vector second = new Vector(maxsize);
    for (int i = 0; i < maxsize; i++)
    {
      second.addElement(new MyPoint(xval[i], yval[i]));
    }
d741 20
a760 12
    // generate the binormal gaussian random deviates
    //
    bn.gaussian(
      maxsize,
      xmin + (xmax-xmin)/4.0,
      ymin + (ymax-ymin)/4.0,
      xval,
      yval,
      ((0.133*(xmax-xmin))/4)*(((xmax-xmin))/4),
      0.0,
      0.0,
      ((0.017*(ymax-ymin))/4)*(((ymax-ymin))/4));
d762 2
a763 6
    // format the point to be plotted on the screen
    //
    Vector third = new Vector(maxsize);
    for (int i = 0; i < maxsize; i++)
    {
      third.addElement(new MyPoint(xval[i], yval[i]));
d766 51
a816 12
    // generate the binormal gaussian random deviates
    //
    bn.gaussian(
      maxsize,
      xmax - (xmax-xmin)/4.0,
      ymin + (ymax-ymin)/4.0,
      xval,
      yval,
      ((0.133*(xmax-xmin))/4)*(((xmax-xmin))/4),
      0.0,
      0.0,
      ((0.017*(ymax-ymin))/4)*(((ymax-ymin))/4));
d818 20
a837 7
    // format the point to be plotted on the screen
    //
    Vector forth = new Vector(maxsize);
    for (int i = 0; i < maxsize; i++)
    {
      forth.addElement(new MyPoint(xval[i], yval[i]));
    }
d839 20
a858 5
    dset1 = (Vector)first.clone();
    dset2 = (Vector)second.clone();
    dset3 = (Vector)third.clone();
    dset4 = (Vector)forth.clone();
  }
d860 20
a879 10
  // method: setToroidal
  //
  // arguments: none
  // return   : none
  //
  // create a set of point that correspond a toroidal to
  // be displayed on the input canvas
  //
  public void setToroidal(DisplayScale scale)
  {
d881 35
a915 16
    // declare variables
    //
    double xmax, xmin, ymax, ymin;  
    Vector torodial1;
    Vector torodial2;
    int maxsize = 0;
    double[] xval = null;
    double[] yval = null;
    BiNormal bn = new BiNormal();
    double angle = 0.0;
    double radius = 0.0;
    double x1 = 0.0;
    double y1 = 0.0;
    double ring_radius;
    double stddev_radius;
    int num_ring = 2000;
d917 53
a969 17
    // initialize variables
    //
    xmax = scale.xmax;
    xmin = scale.xmin;
    ymax = scale.ymax;
    ymin = scale.ymin;
    maxsize = 400;
    xval = new double[maxsize];
    yval = new double[maxsize];
    torodial1 = new Vector(50, 10);
    torodial2 = new Vector(50, 10);
    ring_radius = 1.5*((ymax-ymin))/4;
    stddev_radius = 0.1*((ymax-ymin))/4;
    // make outside ring
    //
    for (int i = 1; i <= num_ring; i++)
    {
d971 34
a1004 4
      // the angle is linearly distributed from 0 to 2 pi
      //
      angle = MathUtil.random.nextDouble() * 2 * Math.PI;
      radius = MathUtil.grand(ring_radius, stddev_radius);
d1006 11
a1016 4
      // set points
      //
      x1 = radius * Math.cos(angle);
      y1 = radius * Math.sin(angle);
d1018 79
a1096 146
      // plot the points
      //	
      torodial2.addElement(new MyPoint(x1 + xmin + (xmax-xmin)/2.0,
				       y1 + ymin + (ymax-ymin)/2.0));
    }

    // generate the binormal gaussian random deviates
    //
    bn.gaussian(
      maxsize,
      xmin + (xmax-xmin)/2.0,
      ymin + (ymax-ymin)/2.0,
      xval,
      yval,
      ((0.033*(xmax-xmin))/4)*(((xmax-xmin))/4),
      0.0,
      0.0,
      ((0.033*(xmax-xmin))/4)*((xmax-xmin)/4));

    // format the point to be plotted on the screen
    //
    for (int i = 0; i < maxsize; i++)
    {
      torodial1.addElement(new MyPoint(xval[i], yval[i]));
    }

    // initialize each torodial to each set
    //
    dset1 = (Vector)torodial1.clone();
    dset2 = (Vector)torodial2.clone();
  }

  // method: setYinYang
  //
  // arguments: none
  // return   : none
  //
  // create a set of point that correspond a yin and yang symbol to
  // be displayed on the input canvas
  //
  public void setYinYang(DisplayScale scale)
  {

    // declare variables
    //
    double xmax, xmin, ymax, ymin;  
    Vector Yin;
    Vector Yang;
    double xpt = 0.0;
    double ypt = 0.0;
    double currPoints = 0;
    double maxPoints = 1000;
    double distance1 = 0.0;
    double distance2 = 0.0;
    double distance3 = 0.0;
    double radius1 = 0.0;
    double radius2 = 0.0;
    double stddev_center;

    // initialize variables
    //
    xmax = scale.xmax;
    xmin = scale.xmin;
    ymax = scale.ymax;
    ymin = scale.ymin;
    stddev_center = 1.5*(xmax-xmin)/2;
    Yin = new Vector(50, 10);
    Yang = new Vector(50, 10);
    radius1 = 1.5*(((xmax-xmin))/4);
    radius2 = 0.75*(((xmax-xmin))/4);

    while (currPoints < maxPoints)
    {

      // generate points
      //
      xpt = MathUtil.grand(xmin + (xmax-xmin)/2.0, stddev_center);
      ypt = MathUtil.grand(ymin + (ymax-ymin)/2.0, stddev_center);

      // calculate radius for each generated point
      //
      distance1 =
        Math.sqrt(
          (xpt) * (xpt)
            + (ypt) * (ypt));

      distance2 =
        Math.sqrt(
          (xpt) * (xpt)
            + (ypt + radius2)
              * (ypt + radius2));

      distance3 =
        Math.sqrt(
          (xpt) * (xpt)
            + (ypt - radius2)
              * (ypt - radius2));

      // decide where to plot each point
      //
      if (distance1 <= radius1)
      {
        if (xpt >= (0.0 - radius1)
	    && xpt <= 0.0)
        {
          if ((distance1 <= radius1 || distance2 <= radius2)
            && distance3 > radius2)
          {
            Yin.addElement(new MyPoint(xpt, ypt));
            currPoints++;
          } else
          {
            Yang.addElement(new MyPoint(xpt, ypt));
          }
        }
        if (xpt > 0.0
          && xpt <= radius1)
        {
          if ((distance1 <= radius1 || distance3 <= radius2)
            && distance2 > radius2)
          {
            Yang.addElement(new MyPoint(xpt, ypt));
            currPoints++;
          } else
          {
            Yin.addElement(new MyPoint(xpt, ypt));
          }
        }
      }
    }

    // set yin and yang to each set
    //   
    dset1 = (Vector)Yang.clone();
    dset2 = (Vector)Yin.clone();
  }

  // method: convertPoint
  //
  // arguments: Point, panelWidth, panelHeight
  // return   : MyPoint
  //
  //
  // Converts an instance of Point to an instance of MyPoint containing the
  // cartesian x-y values
  //
d1106 6
a1111 5
	return new MyPoint(MathUtil.SetDecimal((((double)jpoint.x/panelWidth)
						* (xmax-xmin)) + xmin, 8),
			   MathUtil.SetDecimal((((panelHeight-(double)jpoint.y)/panelHeight)
						* (ymax-ymin)) + ymin, 8));
						
d1114 13
a1126 11


  // method: convertPoints
  //
  // arguments: Vector, panelWidth, panelHeight
  // return   : Vector
  //
  //
  // Converts a vector of Points to a vector of MyPoints containing the
  // cartesian x-y values
  //
d1137 1
a1137 1

d1140 13
a1152 11



  // method: convertMyPoint
  //
  // arguments: MyPoint, panelWidth, panelHeight
  // return   : Point
  //
  //
  // Converts an instance of MyPoint to an instance of Point
  //
d1159 1
a1159 1

d1164 3
a1166 3

	xpt = (panelWidth * (dpoint.x - xmin))/(xmax-xmin);
	ypt = panelHeight - (((dpoint.y-ymin) * panelHeight)/(ymax-ymin));
d1168 1
a1168 1
    
d1172 12
a1183 8
  // method: convertMyPoints
  //
  // arguments: dset, panelWidth, panelHeight
  // return   : Vector
  //
  //
  // Converts a Vector of MyPoints to a Vector of points that correspond to
  // Java coordinates.  
d1190 1
a1190 1

d1196 1
a1196 1

d1200 13
a1212 3


	    
d1214 1
a1214 1
				  double cov21, double cov22)
d1216 1
a1216 1

d1223 13
a1235 2
	

a1245 8

//
// end of file





@