datareadermultialpha.java

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

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

class DataReaderMultiAlpha
{
    

    BufferedReader reader;
    ModelMaker modelmaker;
    
    public DataReaderMultiAlpha()
    {
	reader = new BufferedReader(new InputStreamReader(System.in));
	modelmaker = new ModelMaker();
	
	println("Welcome to modhmmc!");
	createHMM();
	int nrAlpha = specifyNrOfAlphabets();
	for(int i = 0; i < nrAlpha; i++) {
	    specifyAlphabet(i+1);
	}
	specifyModules();
	specifyInterConnectivity();
	specifyDistributionGroups();
	specifyTransitionTies();
	for(int i = 0; i < nrAlpha; i++) {
	    specifyInitvalues(i+1);
	}
	specifyTransitionInitvalues();
	cleanUp();
	println("Creating untrained HMM...");
	saveHMM("");
	println("HMM '"+ modelmaker.getName() + "' saved to '" +
		modelmaker.getFileName() + "'.");
    }


    /****************input/output handling**********************************/
    private void println(String s)
    {
	System.out.println(s);
    }

    private void newln(){
	System.out.println("");
    }
    private void printerr(String s)
    {
	System.out.println("Error: " + s);
    }
    private void print(String s)
    {
	System.out.print(s);
	System.out.flush();
    }

    private String readln()
    {
	try {
	String s = reader.readLine();
	s = s.trim();
	return s;
	}
	catch(IOException e) {
	    P.INTERNAL_ERROR("DataReader.readLine: IOException");
	    return null;
	}
    }


    /*******************************HMM methods****************************/
    private void createHMM()
    {
	print("Name of HMM? ");
	String name = readln();
	name = name.trim();
	modelmaker.createHMM(name);
	newln();
    }

    /********************************************************************************************
     ********************** methods for getting alphabet specification ****************************
     ********************************************************************************************/
    private int specifyNrOfAlphabets()
    {
	print("Nr of alphabets (1-4)? ");
	String s = readln();
	s = s.trim();
	try {
	    int nr = Integer.parseInt(s);
	    if(nr > 0 && nr <= 4) {
		modelmaker.setNrOfAlphabets(nr);
		return nr;
	    }
	    else {
		printerr("Unallowed nr of alphabets");
		return specifyNrOfAlphabets();
	    }
	}
	catch (NumberFormatException e) {
	    printerr("Not an integer");
	    return specifyNrOfAlphabets();
	}
    }
    
    private void specifyAlphabet(int nr)
    {

	print("Alphabet " + nr + " (A:N:G:S)? ");
	String s = readln();
	if(s.equals("A")){
	    modelmaker.setAlphabet(nr,HMM.AMINO);
	    println("Alphabet set to amino");
	    newln();
	}
	else if(s.equals("N")){
	    modelmaker.setAlphabet(nr,HMM.DNA);
	    println("Alphabet set to nucleotides");
	    newln();
	}
	else if(s.equals("G")){
	    modelmaker.setAlphabet(nr,HMM.AMINO_GAP);
	    println("Alphabet set to amino + gap");
	    newln();
	}
	else if(s.equals("S")){
	    modelmaker.setAlphabet(nr,getSpecAlphabet());
	    println("Alphabet set to custom");
	    newln();
	}
	
	else {
	    printerr("Invalid option");
	    specifyAlphabet(nr);
	}	
    }

    private String[] getSpecAlphabet()
    {
	print("Specify alphabet (separate with ';'): ");
	String s = readln();
	StringTokenizer st = new StringTokenizer(s,";");
	String[] alphabet = new String[st.countTokens()];
	int i=0; /* counter for the alphabet array */
	while (st.hasMoreTokens()){
	    String l = st.nextToken();
	    l = l.trim();
	    if(l.length() <= 4) /* letter OK*/ {
		alphabet[i] = l;
		i++;
	    }
	    else /* letter not OK */ {
		printerr("Only symbols of 4 characters or less are allowed in alphabet");
		return getSpecAlphabet();
		
	    }
	}
	
	/* Check for doubles */
	for(int k = 0 ; k < alphabet.length - 1; k++) {
	    for (int j = k+1; j < alphabet.length; j++) {
		if(alphabet[k].equals( alphabet[j])) {
		    printerr("Alphabet contains doubles");
		    return getSpecAlphabet();
		}
	    }
	}
	return alphabet;
    }

    /********************************************************************************************
     ********************** methods for getting module specification ****************************
     ********************************************************************************************/
    private void specifyModules()
    {
	println("Specify modules");

	/* start node */
	print("Start node: ");
	String str = readln();
	if(str.length() == 0) {
	    int res = modelmaker.createModule("s", HMM.STARTNODE, HMM.ZERO, 1, "0");
	}
	else {
	    int res = modelmaker.createModule(str, HMM.STARTNODE, HMM.ZERO, 1, "0");
	}
	
	/* intermediate nodes */
	int i = 1;
	while(true) /* loop until user is done */ {
	    print("Module " + i + " (type,name,label): ");
	    String s = readln();
	    if(s.length() == 0) {
		break;
	    }
	    else if(s.equals("d")){
		break;
	    }
	    else if(s.equals("done")){
		break;
	    }
	    StringTokenizer st = new StringTokenizer(s,",");
	    if(st.countTokens() != 2 && st.countTokens() != 3) {
		printerr("illegal choice");
		continue;
	    }
	    
	    String t = st.nextToken();
	    t = t.trim();
	    String name = st.nextToken();
	    name = name.trim();
	    String label = "1";
	    if(st.hasMoreTokens()) {
		label = st.nextToken();
		label = label.substring(0,1);
	    }
	    int type = parseType(t);
	    int size = 0;
	    int intervalStart = 0; /* only for forward and forward_std modules */
	    int intervalEnd = 0; /*   ------------------ " -------------------------*/
	    InternalInitDistrib  internalInitDistrib = new InternalInitDistrib(); /* different meaning for different */
	    switch(type) {
	    case HMM.SINGLENODE: size = 1; break;
	    case HMM.CLUSTER:
	    case HMM.U_TURN:
	    case HMM.PROFILE7:
	    case HMM.PROFILE9: size = getSize(); break;
	    case HMM.SINGLELOOP: size = getLength(); break;
	    case HMM.FORWARD_STD:
	    case HMM.FORWARD_ALT:
		while(true) {
		    String intervals = getIntervals();
		    intervalStart = getIntervalStart(intervals);
		    intervalEnd = getIntervalEnd(intervals);
		    if(intervalStart >= 0 && intervalEnd >= 0) {
			break;
		    }
		    else {
			printerr("illegal choice");
		    }
		}
		getInternalInitDistrib(HMM.FORWARD_STD, internalInitDistrib);
		break;
	    }
	    if(type != HMM.NOTYPE && type != HMM.FORWARD_STD && type != HMM.FORWARD_ALT) {
		/* create most module types */
		int res = modelmaker.createModule(name, type, HMM.EVEN, size, label);
		if(res == 1) /* name exists already */{
		    printerr("module names may not be identical");
		    continue;
		}
		else if(res == 1) {
		    printerr("impossible module size");
		    continue;
		}
		else if(res == 2) {
		    printerr("Unallowed module size");
		    continue;
		}
		/* more errors may be added */
		else /* Everything OK*/{
		    i++;
		}
	    }
	    else if(type != HMM.NOTYPE) {
		/* create forward_std and forward_alt modules */
		int res = modelmaker.createModule(name, type, HMM.EVEN, intervalStart, intervalEnd, label);
		if(res == 1) /* name exists already */{
		    printerr("module names may not be identical");
		    continue;
		}
		else if(res == 2) {
		    printerr("Unallowed module size");
		    continue;
		}
		/* more errors may be added */
		else /* Everything OK*/{
		    i++;
		}
		modelmaker.setInternalInitDistrib(name, internalInitDistrib);
	    }
	    else /* notype module */ {
		printerr("Nonexisting module- or distribution type");
		continue;
	    }
	}
				
	/* end node */
	print("End node: ");
	String e = readln();
	if(e.length() == 0) {
	    int res = modelmaker.createModule("e", HMM.ENDNODE, HMM.ZERO, 1, "0");
	}
	else {
	    int res = modelmaker.createModule(e, HMM.ENDNODE, HMM.ZERO, 1, "0");
	}
	newln();
 
    }

    private int parseType(String t) 
    {
	t = t.toLowerCase();
	if(t.equals("s")){
	    return HMM.SINGLENODE;
	}
	else if(t.equals("singlenode")) {
	    return HMM.SINGLENODE;
	}
	else if(t.equals("c")) {
	    return HMM.CLUSTER;
	}
	else if(t.equals("cluster")) {
	    return HMM.CLUSTER;
	}
	else if(t.equals("u")) {
	    return HMM.U_TURN;
	}
	else if(t.equals("uturn")) {
	    return HMM.U_TURN;
	}
	else if(t.equals("l")) {
	    return HMM.SINGLELOOP;
	}
	else if(t.equals("loop")) {
	    return HMM.SINGLELOOP;
	}
	else if(t.equals("forward")) {
	    return HMM.FORWARD_STD;
	}
	else if(t.equals("f")) {
	    return HMM.FORWARD_STD;
	}
	else if(t.equals("fa")) {
	    return HMM.FORWARD_ALT;
	}
	else if(t.equals("forward_alternative")) {
	    return HMM.FORWARD_ALT;
	}
	else if(t.equals("p9")) {
	    return HMM.PROFILE9;
	}
	else if(t.equals("profile9")) {
	    return HMM.PROFILE9;
	}
		else if(t.equals("p7")) {
	    return HMM.PROFILE7;
	}
	else if(t.equals("profile7")) {
	    return HMM.PROFILE7;
	}
	/* Free to define more valid types here */

	else {
	    /* type not defined */
	    return HMM.NOTYPE;
	}
    }

    private int getSize() {
	print("Specify module size: ");
	String s = readln();
	try {
	    int size = Integer.parseInt(s);
	    if(size > 0) {
		return size;
	    }
	    else {
		printerr("Unallowed module size");
		return getSize();
	    }
	}
	catch (NumberFormatException e) {
	    printerr("Not an integer");
	    return getSize();
	}
    }
    
    private int getLength()
    {
	print("Specify expected loop length: ");
	String s = readln();
	try {
	    int size = Integer.parseInt(s);
	    if(size > 0) {
		return size;
	    }
	    else {
		printerr("Negative loop length");
		return getLength();
	    }
	}
	catch (NumberFormatException e) {
	    printerr("Not an integer");
	    return getLength();
	}
    }

    private String getIntervals()
    {
	print("Specify min and max length (min,max): ");
	String s = readln();
	return s;
    }
    
    private int getIntervalStart(String s)
    {
	StringTokenizer st = new StringTokenizer(s, ",");
	String start = "";
	if(st.hasMoreTokens()) {
	    start = st.nextToken();
	}
	else {
	    return -1;
	}
	try {
	    int i = Integer.parseInt(start);
	    if(i > 0) {
		return i;
	    }
	    else {
		printerr("Negative min value");
		return -1;
	    }
	}
	catch (NumberFormatException e) {
	    printerr("Not an integer");
	    return -1;
	}
    }
    
    private int getIntervalEnd(String s)
    {
	StringTokenizer st = new StringTokenizer(s, ",");
	String end = "";
	if(st.countTokens() == 2) {
	    st.nextToken();
	    end = st.nextToken();
	}
	else {
	    return -1;
	}
	try {
	    int i = Integer.parseInt(end);
	    if(i > 0) {
		return i;
	    }
	    else {
		printerr("Negative min value");
		return -1;
	    }
	}
	catch (NumberFormatException e) {
	    printerr("Not an integer");
	    return -1;
	}
    }

    private void getInternalInitDistrib(int moduleType, InternalInitDistrib iid)
    {
	if(moduleType == HMM.FORWARD_STD || moduleType == HMM.FORWARD_ALT) {
	    while(true) {
		print("Specify initial distribution (U,B,P): ");
		String s = readln();
		if(s.equals("U") || s.equals("Uniform")) {
		    iid.setDistrib("U");
		    break;
		}
		else if(s.equals("B") || s.equals("Binomial")) {
		    iid.setDistrib("B");
		    while(true) {
			print("Specify value of parameter p (n depends on the module length): ");
			s = readln();
			try {
			    double p = Double.parseDouble(s);
			    if(p < 0.0) {
				continue;
			    }
			    else {
				iid.setPar1(p);
				break;
			    }
			}
			catch(NumberFormatException e) {
			    continue;
			}
		    }
		    break;
		}
		else if(s.equals("P") || s.equals("Poisson")) {
		    iid.setDistrib("P");
		    while(true) {
			print("Specify value of parameter lambda and possible reversing (separate by ','): ");
			s = readln();
			StringTokenizer st = new StringTokenizer(s, ",");
			if(st.countTokens() == 0) {
			    continue;
			}
			else {
			    try {
				double p = Double.parseDouble(st.nextToken());
				if(p < 0.0) {
				    continue;
				}
				else {
				    iid.setPar1(p);
				}
			    }
			    catch(NumberFormatException e) {
				continue;
			    }