u_turn.java

马尔科夫模型的c语言实现

import java.util.*;
import java.io.*;

class U_Turn extends Module
{

    /* initial transition distributions (uniform is default) */
    String name;
    LinkedList theVertices;
    int nrVertices;
    int vertexType;
    int distribType;
    int distribType_2;
    int distribType_3;
    int distribType_4;
    int size;
    int pathSize;
    String label;
    String priorfile;
    String priorfile_2;
    String priorfile_3;
    String priorfile_4;
    String transPriorfile;
    Vertex inVertex;
    Vertex outVertex_start;
    Vertex outVertex_end;

    /*  */
    public U_Turn(String name, int distribType, int vertexType, int pathSize, String label)
    {
	this.name = name;
	this.vertexType = vertexType;
	this.distribType = distribType;
	this.distribType_2 = distribType;
	this.distribType_3 = distribType;
	this.distribType_4 = distribType;
	this.size = pathSize * 2 + 1;
	this.pathSize = pathSize;
	this.label = label;
	theVertices = new LinkedList();
	nrVertices = size;
	inVertices = new int[1];
	outVertices = new int[2];
	priorfile = null;
	priorfile_2 = null;
	priorfile_3 = null;
	priorfile_4 = null;
	transPriorfile = null;
	
	/* create the vertices */
	Vertex v = new Vertex(name, vertexType, distribType, label);
	theVertices.add(v);
	inVertex = v;
	outVertex_start = v;
	inVertices[0] = v.getNumber();
	outVertices[0] = v.getNumber();
	for(int i = 1; i < nrVertices; i++) {
	    Vertex w = new Vertex(name, vertexType, v.getEmissionProbs(), label);
	    theVertices.add(w);
	    if(i == nrVertices - 1) {
		outVertices[1] = w.getNumber();
		outVertex_end = w;
	    }
	}
	
	/* add transitions between the vertices */
	Vertex cur = null;
	Vertex to = null;
	Vertex first = null;
	boolean firstV = true;
	ListIterator i = theVertices.listIterator();
	while(i.hasNext()) {
	    cur = (Vertex)i.next();
	    if(firstV) {
		first = cur;
		firstV = false;
	    }
	    ListIterator j = theVertices.listIterator();
	    while(j.hasNext()) {
		to = (Vertex)j.next();
		if(shouldHaveTransition(pathSize, cur.getNumber(), to.getNumber(), first.getNumber())) {
		/* add transition to vertex */
		    if(!cur.addTransition(to.getNumber())) {
			P.INTERNAL_ERROR("U_Turn.construct: Could not add intraconnections");
		    }	
		}
	    }
	    
	}
    }


    public U_Turn(String name, double[ ] initDistrib, int vertexType, int pathSize, String label)
    {
	this.name = name;
	this.vertexType = vertexType;
	this.distribType = HMM.MANUAL;
	this.distribType_2 = HMM.MANUAL;
	this.distribType_3 = HMM.MANUAL;
	this.distribType_4 = HMM.MANUAL;
	this.size = size;
	this.label = label;
	theVertices = new LinkedList();
	nrVertices = pathSize * 2 + 1;
	inVertices = new int[1];
	outVertices = new int[2];
	priorfile = null;
	priorfile_2 = null;
	priorfile_3 = null;
	priorfile_4 = null;
	transPriorfile = null;
	
	/* create the vertices */

	
	Vertex v = new Vertex(name, vertexType, initDistrib, label);
	theVertices.add(v);
	inVertices[0] = v.getNumber();
	outVertices[0] = v.getNumber();
	Vertex last = null;
	for(int i = 1; i < nrVertices; i++) {
	    Vertex w = new Vertex(name, vertexType, v.getEmissionProbs(), label);
	    theVertices.add(w);
	    if(i == nrVertices - 1) {
		outVertices[1] = w.getNumber();
		last = w;
	    }
	}
	
	/* add transitions between the vertices */
	Vertex cur = null;
	Vertex to = null;
	Vertex first = null;
	boolean firstV = true;
	ListIterator i = theVertices.listIterator();
	while(i.hasNext()) {
	    cur = (Vertex)i.next();
	    if(firstV) {
		first = cur;
		firstV = false;
	    }
	    ListIterator j = theVertices.listIterator();
	    while(j.hasNext()) {
		to = (Vertex)j.next();
	    }
	    if(shouldHaveTransition(pathSize, cur.getNumber(), to.getNumber(), first.getNumber())) {
		/* add transition to vertex */
		if(!cur.addTransition(to.getNumber())) {
		    P.INTERNAL_ERROR("U_Turn.construct: Could not add intraconnections");
		}	
	    }
	}
    }

    private boolean shouldHaveTransition(int pathSize, int curNumber, int toNumber, int firstNumber) {
	boolean result = false;
	int to = toNumber - firstNumber;
	int cur = curNumber - firstNumber;
	if(cur == pathSize && to == pathSize) {
	    result = true;
	}
	else if(to == cur + 1) {
	    result = true;
	}
	else if(to > cur && to + cur == pathSize * 2) {
	    result = true;
	}
	else if(to > cur && to + cur == pathSize * 2 + 1 && cur != pathSize) {
	    result = true;
	}


	return result;
    }


    public int getSize()
    {
	return size;
    }
    
    public String getName()
    {
	return name;
    }
    
    public String getLabel()
    {
	return label;
    }

    public int getVertexType()
    {
	return vertexType;
    }
    
    public int getDistribType()
    {
	return distribType;
    }

    public String getPriorfile()
    {
	return priorfile;
    }

    public Vertex getVertex(int nr)
    {
	for(int i = 0; i < theVertices.size(); i++) {
	    Vertex v = ((Vertex)theVertices.get(i));
	    if(v.getNumber() == nr) {
		return v;
	    }
	}

	return null;
    }

    public double[] getEmissionProbs()
    {
	Vertex v = (Vertex)theVertices.get(0);
	return v.getEmissionProbs();
    }
    public int[] getInVertices()
    {
	return inVertices;
    }

    public LinkedList getVertices()
    {
	return theVertices;
    }

    public int getNrOfTransitions()
    {
	int nrTransitions = 0;
	for(ListIterator i = (ListIterator)theVertices.iterator(); i.hasNext();) {
	    Vertex v = (Vertex)i.next();
	    nrTransitions = nrTransitions + v.getNrOfTransitions();
	    nrTransitions = nrTransitions + v.getNrOfEndTransitions();
	}
	return nrTransitions;
    }

    public int getNrOfRegularTransitions()
    {
	int nrTransitions = 0;
	for(ListIterator i = (ListIterator)theVertices.iterator(); i.hasNext();) {
	    Vertex v = (Vertex)i.next();
	    nrTransitions = nrTransitions + v.getNrOfTransitions();
	}
	return nrTransitions;
    }
    
    public int getNrOfEndTransitions()
    {
	int nrTransitions = 0;
	for(ListIterator i = (ListIterator)theVertices.iterator(); i.hasNext();) {
	    Vertex v = (Vertex)i.next();
	    nrTransitions = nrTransitions + v.getNrOfEndTransitions();
	}
	return nrTransitions;
    }


    public int[] getOutVertices()
    {
	return outVertices;
    }
    
    public void addVerticesToVertexHash(Hashtable theVerticesHash)
    {
	for(int i = 0; i < nrVertices; i++) {
	    Vertex v = ((Vertex)theVertices.get(i));
	    theVerticesHash.put(new Integer(v.getNumber()), v);
	}
    }

    /* adds transition from specified vertex to specified vertex */
    public boolean addTransition(int fromVertex, int toVertex)
    {
	for(ListIterator i = (ListIterator)theVertices.iterator(); i.hasNext();) {
	    Vertex v = (Vertex)i.next();
	    if(v.getNumber() == fromVertex) {
		return v.addTransition(toVertex);
	    }
	}
	
	/* could not find the vertex */
	P.INTERNAL_ERROR("U_Turn.addTransition: vertex not in module");
	return false;
    }
    
    public void setTransPriorScaler(double d)
    {
	for(ListIterator i = (ListIterator)theVertices.iterator(); i.hasNext();) {
	    Vertex v = (Vertex)i.next();
	    v.setTransPriorScaler(d);
	}
    }

    public void setEmissPriorScaler(double d)
    {
	for(ListIterator i = (ListIterator)theVertices.iterator(); i.hasNext();) {
	    Vertex v = (Vertex)i.next();
	    v.setEmissPriorScaler(d);
	}
    }

    public void setEmissPriorScaler(int nr, double d)
    {
	for(ListIterator i = (ListIterator)theVertices.iterator(); i.hasNext();) {
	    Vertex v = (Vertex)i.next();
	    v.setEmissPriorScaler(nr, d);
	}
    }

    public void lockVertexEmissions()
    {
	for(ListIterator i = (ListIterator)theVertices.iterator(); i.hasNext();) {
	    Vertex v = (Vertex)i.next();
	    v.lock();
	}
    }

    public boolean addTransition(int toVertex)
    {
	boolean res = true;
	if(!outVertex_start.addTransition(toVertex)) {
	    res = false;
	}
	if(!outVertex_end.addTransition(toVertex)) {