kissfsmexperiment.java

Java遗传算法库

/*
 * KISSFSMExperiment.java
 *
 * Created on May 30, 2003, 3:11 PM
 */

package jaga.pj.circuits.experiment;

import jaga.BitSet;
import jaga.SampleData;
import jaga.experiment.*;

import java.util.Hashtable;
import java.util.StringTokenizer;
import java.util.Random;
import java.util.Enumeration;
import java.util.HashSet;

import java.io.IOException;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.File;

/**
 *
 * @author  Michael Garvie
 * @version 
 */
public class KISSFSMExperiment implements ConfigurableSequentialCircuitExperiment {

    // Config
    protected Random rnd = new Random( ); // = new Random( .currentTimeMillis() );
    protected boolean refreshTestV = true;
    protected SampleData[] lastInput;
    protected int lastInputSampleSeparation = -1;
    protected FitnessFunction fitnessFunction = new CorrelationFitnessFunction();
    
    protected int nrInputs, nrOutputs, nrEdges;
    protected MealyFSMNode resetState;
    protected MealyFSMNode[] allStates;
    protected String[][] resetInputs;
    protected String kissFileName;
    
    protected int[] stateEnterPos;
    protected int rndStatePos;
    protected MealyFSMNode[] stateEnterOrder;
    protected int lastResetStatePreparationPatternLength = -1;
    
    protected boolean generateClock = true;

    public KISSFSMExperiment(File kissFile, String resetStateName, String[][] resetInputs, int[] permEdgeLines, boolean generateClock ) throws IOException
    {
        this(  kissFile, resetStateName, resetInputs, permEdgeLines );
        this.generateClock = generateClock;
    }
    
    public KISSFSMExperiment( File kissFile, String resetStateName, String[][] resetInputs, int[] permEdgeLines, boolean generateClock, FitnessFunction fitnessFunction ) throws IOException
    {
        this(  kissFile, resetStateName, resetInputs, permEdgeLines, generateClock );
        this.fitnessFunction = fitnessFunction;
    }
        
        
    /** Creates new KISSFSMExperiment */
    public KISSFSMExperiment( File kissFile, String resetStateName, String[][] resetInputs, int[] permEdgeLines) throws IOException
    {
        kissFileName = kissFile.toString();
        nrEdges = 0;
        BufferedReader bur = new BufferedReader( new FileReader( kissFile ) );
        Hashtable states = null;
        int lineCount = 0;
        String line;
        
        while( ( line = bur.readLine() ) != null )
        {
            lineCount++;
            StringTokenizer stk = new StringTokenizer( line );
            String t0;
            if( stk.hasMoreTokens() )
            {
                t0 = stk.nextToken();
            }else
            {
                t0 = "";
            }
            
            if( t0.equals( ".i" ) )
            {
                nrInputs = Integer.parseInt( stk.nextToken() );
                //System.out.println("Inputs:" + nrInputs ); // debug
                states = buildStateTable( kissFile );
            }else if( t0.equals( ".o" ) )
            {
                nrOutputs = Integer.parseInt( stk.nextToken() );
                //System.out.println("Outputs:" + nrOutputs );
            }else if( t0.startsWith( "." ) )
            {
                // ignore
            }else if( t0.equals("") )
            {
                //ignore empty line
            }
            else
            {
                String srcStateName = stk.nextToken();
                String destStateName = stk.nextToken();
                MealyFSMNode srcState = ( MealyFSMNode ) states.get( srcStateName );
                MealyFSMNode destState = ( MealyFSMNode ) states.get( destStateName );
                boolean permanentEdge = ( jaga.ESLib.indexOf( lineCount, permEdgeLines ) >= 0 );
                nrEdges += srcState.addEdge( destState, t0, stk.nextToken(), permanentEdge );
            }
        }
        resetState = ( MealyFSMNode ) states.get( resetStateName );
        
        int nrStates = states.size();
        allStates = new MealyFSMNode[ nrStates ];
        Enumeration statesEnum = states.elements();
        for( int sl = 0; sl < nrStates; sl++ )
        {
            allStates[ sl ] = ( MealyFSMNode ) statesEnum.nextElement();
        }
        
        stateEnterPos = new int[ nrStates ];
        stateEnterOrder = new MealyFSMNode[ nrStates ];
        System.arraycopy( allStates, 0, stateEnterOrder, 0, nrStates );
        // set up reset dummy edges
        /*resetDummyEdges = new MealyFSMEdge[ resetInputs.length ];
        for( int rl=0; rl < resetInputs.length; rl++ )
        {
            resetDummyEdges[ rl ] = new MealyFSMEdge( null, resetInputs[ rl ], "" );
        }*/
        this.resetInputs = resetInputs;
        //System.out.println("" + states);
        //printNodes();//debug
    }
    
    protected void printNodes(  )//debug
    {
        for( int sl = 0; sl < allStates.length; sl++ )
        {
            MealyFSMNode node = allStates[ sl ];
            node.resetWalk();
            System.out.println( "node " + sl + ": " );
            for( int el = 0; el < node.vNextStates.size(); el++ )
            {
                MealyFSMEdge edge = ( MealyFSMEdge ) node.vNextStates.get( el );
                System.out.println("\tedge " + el + " with ins " + jaga.ESLib.boolArr2String( edge.inputs ) + " and outs " + jaga.ESLib.boolArr2String( edge.outputs ) );
                System.out.println("\t\t going to " + jaga.ESLib.indexOf( edge.dest, allStates ) );
                if( edge.permanent ) System.out.println("\t\t\t is permanent");
            }
        }
    }
    
    public Hashtable buildStateTable( File kissFile ) throws IOException //pub for testing
    {
        BufferedReader bur = new BufferedReader( new FileReader( kissFile ) );
        String line;
        Hashtable rv = new Hashtable();
        while( ( line = bur.readLine() ) != null )
        {
            if( !line.startsWith( "." ) && !line.equals( "" ) )
            {
                StringTokenizer stk = new StringTokenizer( line );
                stk.nextToken();
                String stateName = stk.nextToken();
                if( !rv.containsKey( stateName ) )
                {
                    rv.put( stateName, new MealyFSMNode( nrInputs, rnd, stateName ) );
                    //System.out.println( stateName ); //debug
                }
            }
        }
        return rv;
    }
    
    
    public void set( Object rndSeed )
    {
        seed = rndSeed;
        long longSeed = ( ( Long ) rndSeed ).longValue(); 
        rnd.setSeed( longSeed );
        if( fitnessFunction instanceof jaga.NoisyComponent )
        {
            ( ( jaga.NoisyComponent ) fitnessFunction ).setSeed( longSeed );
        }        
        refreshTestV = true;
    }
    
    protected Object seed;
    
    public Object get( Object p )
    {
        return seed;
    }
        
    
    
    /** returns a fitness associated to a given input/output pair for
     * this experiment.  The fitness is a double and is in adjusted
     * fitness format.  From 0 to 1, 1 being perfectly fit.
     * @param in array of inputs
     * @param out array of outputs
     */
    public double getFitness(SampleData[] in,SampleData[] out) {
        //System.out.println("Get Fitness called");//debug
        int iss = in[ 0 ].getSampleSeparation();
        int nrSamples = in[ 0 ].length();
        int Cix = nrInputs;
        SampleData[] desQ = new SampleData[ nrOutputs ];
        for( int ol = 0; ol < nrOutputs; ol++ )
        {
            desQ[ ol ] = new SampleData( 1, out[ 0 ].length() );
        }
        
        // Take first input sample block as OK
        for( int ql = 0; ql < nrOutputs; ql++ )
        {
            for( int odl = 0; odl < iss; odl++ )
            {
                desQ[ ql ].setTo( odl, out[ ql ].get( odl ) );
            }
        }
        
        MealyFSMNode currNode = resetState; // assume we started reset
        boolean[] currDesQ = new boolean[ nrOutputs ];
        for( int idl = 1; idl < nrSamples; idl++ )
        {
            boolean risingEdge;
            if( generateClock )
            {
                risingEdge = in[ Cix ].get( idl ) && !in[ Cix ].get( idl - 1 );
            }else
            {
                risingEdge = true;
            }
            int baseOdl = idl * iss;
            if( risingEdge )
            {
                MealyFSMEdge trans = currNode.nextStates[ jaga.ESLib.getLine( in, idl - 1, 0, nrInputs - 1 ) ]; // idl - 1 because latches take value before rising edge
                currNode = trans.dest;
                currDesQ = trans.outputs; // doesn't last long
            }
            MealyFSMEdge nextTrans = currNode.nextStates[ jaga.ESLib.getLine( in, idl, 0, nrInputs - 1 ) ];
            currDesQ = nextTrans.outputs;
            for( int ql = 0; ql < nrOutputs; ql++ )