bistlib.java

Java遗传算法库

/*i
 * BISTLib.java
 *
 * Created on 13 June 2003, 11:23
 */

package jaga.pj.circuits.control;

import jaga.SampleData;
import jaga.BitSet;
import jaga.pj.circuits.SimulatorCircuit;
import jaga.pj.circuits.SimulatorSimpleCircuit;
import jaga.pj.circuits.CircuitsLib;
import jaga.pj.circuits.fpgaft.FTLib;
import jaga.pj.circuits.fpgaft.FPGALUTAbsoluteMapping;
import jaga.pj.circuits.ConstantDelayModel;

import java.util.Collection;
import java.util.Vector;
import java.util.ArrayList;

import java.awt.Point;
/**
 *
 * @author  mmg20
 */
public abstract class BISTLib implements java.io.Serializable {

    public final static int E_MODE_HIGH = 0;
    public final static int E_MODE_OSCILLATING = 1;
    public final static int E_MODE_DUAL = 2;
    
    public static final int E_BEHAVIOUR_HIGH = 1;
    public static final int E_BEHAVIOUR_LOW_OK = 0;
    public static final int E_BEHAVIOUR_LOW_ERROR = -1;    
    
    public final static String[] getEModeStrings = { "Error signal is Line High", "Error signal is non-Oscillating", "Error signal is Dual Rail" };
        
    protected static int getEMode = E_MODE_HIGH;
    
    public static void setGetEMode( int mode )
    {
        getEMode = mode;
    }
    
    /** Asume current circuit programmed already.  Returns collection with SSA0 and SSA1 at
     * faults at all elements which are connected to outputs.
     */
    public static Collection buildAllFaultsColl( SimulatorCircuit circuit )
    {
        Vector rv = new Vector();
        boolean[] used = jaga.pj.circuits.CircuitsLib.getUsed( circuit ); // even to E lines
        for( int ul = 0; ul < used.length; ul++ )
        {
            if( used[ ul ] )
            {
                rv.add( new Point( ul, FTLib.SSAV0 ) );
                rv.add( new Point( ul, FTLib.SSAV1 ) );
            }
        }
        return  rv;
    }
    
    public static boolean faultPosE( Point currF, Collection faultCol )
    {
        Point currFC = ( Point ) currF.clone();
        currFC.y = FTLib.SSAV0;
        boolean rv = faultCol.contains( currFC );
        currFC.y = FTLib.SSAV1;
        rv = rv || faultCol.contains( currFC );
        return rv;
    }    
    
    public static Collection removeFaultAtPos( Point f, Collection col )
    {
        Point fr = new Point( f.x, FTLib.SSAV0 );
        col.remove( fr );
        fr.y = FTLib.SSAV1;
        col.remove( fr );
        return col;
    }
    

    public static boolean getE( BitSet[] output, int ix, int eSize, int nrEs, int iss, int startAt )
    {
        BitSet[] Es = new BitSet[ nrEs ];
        for( int el = 0; el < nrEs; el++ )
        {
            Es[ el ] = output[ output.length - 1 - el ];
        }
        int start = ix * iss;
        switch( getEMode )
        {
            case E_MODE_HIGH:
            {               
                int conc = 0;
                for( int bl = start + startAt; bl < start + iss; bl++ )
                {
                    boolean someE = false;
                    for( int el = 0; el < nrEs; el++ )
                    {
                        someE = someE || Es[ el ].get( bl );
                    }
                    if( someE )
                    {
                        conc++;
                        if( conc >= eSize )
                        {
                            return true;
                        }
                    }else
                    {
                        conc = 0;
                    }
                }
                return false;
            }
            case E_MODE_OSCILLATING:
            {
                int risingEdges = 0;
                for( int bl = start + startAt + 1; bl < start + iss; bl++ )
                {
                    boolean someRisingEdge = false;
                    for( int el = 0; el < nrEs; el++ )
                    {
                        someRisingEdge = someRisingEdge || ( Es[ el ].get( bl ) && !Es[ el ].get( bl - 1 ) );
                    }
                    if( someRisingEdge )
                    {
                        risingEdges++;
                        //System.out.println("some rising edge at " + bl + " counting " + risingEdges ); //D
                        if( risingEdges >= eSize )
                        {
                            return false;
                        }
                    }
                }
                return true;
            }
            case E_MODE_DUAL:
            {               
                int conc = 0;
                for( int bl = start + startAt; bl < start + iss; bl++ )
                {
                    boolean someE = Es[ 0 ].get( bl ) == Es[ 1 ].get( bl );
                    if( someE )
                    {
                        conc++;
                        if( conc >= eSize )
                        {
                            return true;
                        }
                    }else
                    {
                        conc = 0;
                    }
                }
                return false;
            }
        }
        return false;
    }

    public static boolean getE( BitSet[] output, int eSize, int nrEs, int iss, int startAt )
    {
        return getE( 0, output, eSize, nrEs, iss, startAt );
    }
    
    /** Returns the value of E for this segment */
    public static boolean getE( int ignoredSets, BitSet[] output, int eSize, int nrEs, int iss, int startAt )
    {
        BitSet[] Es = new BitSet[ nrEs ];
        for( int el = 0; el < nrEs; el++ )
        {
            Es[ el ] = output[ output.length - 1 - el ];
        }
        int outLen = output[ 0 ].length();
        switch( getEMode )
        {
            case E_MODE_HIGH:
            {
                //System.out.println("Checking if E High"); //D
                int conc = 0;
                for( int bl = ignoredSets * iss + startAt; bl < outLen; bl++ )
                {
                    boolean someE = false;
                    for( int el = 0; el < nrEs; el++ )
                    {
                        someE = someE || Es[ el ].get( bl );
                    }
                    if( someE )
                    {
                        conc++;
                        if( conc == eSize )
                        {
                            return true;
                        }
                    }else
                    {
                        conc = 0;
                    }
                }
                return false;
            }
            case E_MODE_OSCILLATING:
            case E_MODE_DUAL:
            {
                int nrInputSamples = outLen / iss;
                for( int dl = ignoredSets; dl < nrInputSamples; dl++ )
                {
                    if( getE( output, dl, eSize, nrEs, iss, startAt ) )
                    {
                        return true;
                    }
                }
                return false;
            }
            /*
            case E_MODE_DUAL:
            {               
                int conc = 0;
                for( int bl = ignoredSets * iss + startAt; bl < outLen; bl++ )
                {
                    boolean someE = Es[ 0 ].get( bl ) == Es[ 1 ].get( bl );
                    if( someE )
                    {
                        conc++;
                        if( conc >= eSize )
                        {
                            return true;
                        }
                    }else
                    {
                        conc = 0;
                    }
                }
                return false;
            }*/
            
        }
        return false;
    }
    
    
    public static int getSingleOutAt( BitSet[] outs, int index, int nrEs, int iss )
    {
        int rv = jaga.ESLib.getLine( outs, iss * ( index + 1 ) - 1, 0, outs.length - 1 - nrEs );
        return rv;
    }
    
    /** Returns the value as an integer of this sampeldata array at in this range
     * checking that is stable
    */
    public static int getOutAt( BitSet[] outs, int index, int nrEs, int iss, double validChunkProp )
    {
        int end = ( index + 1 ) * iss;
        int lastChunkLen = ( int )( iss * validChunkProp );
        int lastOut = outs.length - 1 - nrEs;
        int val0 = jaga.ESLib.getLine( outs, end - lastChunkLen, 0, lastOut );
        int val1 = jaga.ESLib.getLine( outs, end - lastChunkLen / 2, 0, lastOut );
        if( val0 == val1 )
        {