diagram.java

用java实现的神经网络bp的核心算法

/*
 * Diagram.java
 *
 * Created on 2007年11月21日, 下午1:58
 *
 * To change this template, choose Tools | Template Manager
 * and open the template in the editor.
 */

package myUtil;
import javax.swing.*;
import java.util.*;
import java.awt.*;
import java.awt.geom.*;
import java.io.*;
/**
 * This class will draw a curve by input data in a panel. Each time redaw()  invocated ,a line from last data the current
 * one will be drawn.
 * @author yuhui_bear 
 */
public class Diagram extends JPanel {
    private double[]  yc;
    private int maxSize,cnt=0 ;
    private double max =0.6 ,min =0.5 , dm=1000;
    private double exMax =0 , exMin=0;
    private final int xl,yl ;
    private Image bf;
    private String uprightLab , downrightLab;
    public Diagram(int xlin,int ylin ){
        uprightLab = ".";
        downrightLab =".";
        xl = xlin;
        yl = ylin;
        maxSize = xl;
        yc = new double[maxSize];
        Arrays.fill(yc,0);
        this.setBounds(this.getX(),this.getY(),xl+ this.getX(),yl + this.getY());
        Dimension size = new Dimension(xl,yl);
        this.setPreferredSize(size);
        this.setMaximumSize(size);
        this.setMinimumSize(size);
        this.setBackground(Color.BLACK);
        this.setOpaque(false);
        this.setVisible(true);
    }
    public void paintComponent(Graphics g){
        Graphics2D g2d = (Graphics2D) g;
        g2d.setColor(Color.BLACK);
        g2d.fillRect(0,0,xl,yl);
        g2d.setColor(Color.GREEN);
        int y1,y2;
        y2 = (int) (yl*(1-(yc[0] -min)/dm )* 0.9);
        for(int i = 0 ; i< cnt;i++){
            y1=y2;
            y2 = (int) (yl*(1-(yc[i] -min)/dm )* 0.9);
            g2d.drawLine(i ,y1,i+1 ,y2);
        }
        g2d.setColor(Color.WHITE);
        g2d.drawLine(0,(int)(yl * 0.9),xl,(int)(yl * 0.9));
        g2d.drawLine(0,(int)(yl * 0.1),xl,(int)(yl * 0.1));
        g2d.drawString(uprightLab ,(float)(xl * 0.65),(float)(yl * 0.1));
        g2d.drawString(downrightLab ,(float)(xl * 0.65),(float)(yl * 0.9));
        g2d.drawString("Max ="+exMax ,0,yl-2);
        g2d.drawString("Min ="+exMin ,xl/2,yl-2);
        g2d.setColor(Color.YELLOW);
        g2d.drawString("Min In Graph="+min ,0,(int)(yl * 0.9));        
        g2d.drawString("Max In Graph="+max ,0,(float)(yl * 0.1));
    }
    
    public int redraw(double din , String mStr ,String rStr){
        uprightLab = mStr ;
        downrightLab = rStr;
        if(cnt < 3){
            switch(cnt){
                case 0 :{
                    yc[0] = din;
                    break;
                }
                case 1 :{
                    yc[1] = din;
                    max = yc[0] > yc[1] ? yc[0]:yc[1];
                    min = yc[0] < yc[1] ? yc[0]:yc[1];            
                    break;
                }
                case 2 :{
                    max = din > max ? din : max;
                    min = din < min ? din : min;
                    exMax =max;
                    exMin = min;
                    dm = max - min;
                    yc[2] = din;
                    break;
                }
            }
        }else{
            if(exMax < din){
                    exMax = din;
            }else{
                if(exMin > din){
                    exMin = din;
                }
            }
            if(max < din){
                    max = din;
            }else{
                if(min > din){
                    min = din;
                }
            }
            //check range;
            if ( cnt + 3 >maxSize){
                int gap = maxSize/3;
                for(int i = 0 ; i< maxSize -gap;i++){
                    yc[i] = yc[i+gap];
                }
                cnt = cnt -gap;
                //rescan extremum
                max = Evaluate.mean(yc);
                for (int i =0 ;i<cnt;i++){
                    if(max < yc[i]){
                        max = yc[i];
                    }else{
                        if(min > yc[i]){
                            min = yc[i];
                        }
                    }
                }                
            }              
            dm = max - min;
        }
//            System.out.println("cnt@yc[cnt] = " + cnt);    //for testing only.
        yc[cnt] = din;
        if(yc[cnt] ==0){
            yc[cnt]=0.0001;
        }
        if(dm ==0){
            dm = 1;
        }
        this.repaint();
        return ++cnt;
        }
    
}

//class Dig implements Comparable{
//    public double data;
//    public Dig(){
//        data=0;
//    }
//    public Dig(float d){
//        data = (double)d;
//    }
//    public Dig(double d){
//        data = d;
//    }
//    public int compareTo(Object obj){
//        if(data > ((Dig)obj).data){
//            return 1;
//        }else {
//            if(data < ((Dig)obj).data){
//                return -1;
//            }else {
//                return 0;
//            }
//        }
//    }
//    public String toString(){
//        return String.valueOf(data);
//    }
//}