datareadermultialpha.java

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

			    if(st.hasMoreTokens()) {
				String rev = st.nextToken();
				rev = rev.trim();
				if(rev.equals("Y") || rev.equals("r")) {
				    iid.setPar2(-1);
				    
				}
				else {
				    iid.setPar2(1);
				}
			    }
			    else {
				iid.setPar2(1);
			    }
			    
			    break;
			}
		    }
		    break;
		}
		else {
		    
		}
	    }
	}
	else {
	    /* not implemented yet */
	}
    }

    /********************************************************************************************
     ********************** methods for getting module interconnectivity ****************************
     ********************************************************************************************/
    private void specifyInterConnectivity()
    {
	int nrModules = modelmaker.getNrModules();
	String[] theNames = new String[nrModules];
	println("Specify interconnectivity");
	print("(Possible modules are:");
	int j = 0;
	for(ListIterator i = modelmaker.getModules();i.hasNext();) {
	    String name = ((Module)i.next()).getName();
	    print(" " + name);
	    theNames[j] = name;
	    j++;
	}
	print(")");
	newln();

	int i = 0;
	boolean nextModule;
	while(i < nrModules) {
	    nextModule = true;
	    print("Connection from " + theNames[i] +
		  " to (separate by ';'): ");
	
	    String s = readln();
	    s = s.trim();
	    StringTokenizer st = new StringTokenizer(s,";");
	    while(st.hasMoreTokens()) {
		String toModule = st.nextToken();
		toModule = toModule.trim();
		if(isModuleName(toModule, theNames)) {
		    modelmaker.setTransition(theNames[i], toModule);
		}
		else {
		    printerr(toModule + " is not a specified module");
		    nextModule = false;
		}
	    }
	    if(nextModule) {
		modelmaker.initializeTransitionProbabilities(theNames[i]);
		i++;
	    }
	}
	
    }
    
    private boolean isModuleName(String s, String[] sa)
    {
	for(int i = 0; i < sa.length; i++) {
	    if(s.equals(sa[i])) {
		return true;
	    } 
	}
	return false;
    }

    /********************************************************************************************
     ********************** methods for getting distribution groups ****************************
     ********************************************************************************************/
    private void specifyDistributionGroups()
    {
	int nrModules = modelmaker.getNrModules();
	String[] theNames = new String[nrModules];
	Hashtable addedModules = new Hashtable();
	println("Specify emisssion distribution groups");
	print("(Possible modules are:");
	int j = 0;
	for(ListIterator i = modelmaker.getModules();i.hasNext();) {
	    String name = ((Module)i.next()).getName();
	    print(" " + name);
	    theNames[j] = name;
	    j++;
	}
	print(")");
	newln();

	boolean done = false;
	boolean createDistributionGroup;
	j = 1;
	while(!done) {
	    LinkedList distribGroup = new LinkedList();
	    print("Emission distribution group " + j + " (separate by ';'):");
	    String s = readln();
	    if(s.equals("") || s.equals("d") || s.equals("done")) {
		done = true;
		continue;
	    }
	    s = s.trim();
	    StringTokenizer st = new StringTokenizer(s,";");
	    createDistributionGroup = true;
	    while(st.hasMoreTokens()) {
		String module = st.nextToken();
		module = module.trim();
		if(isModuleName(module, theNames)) {
		    if(!addedModules.containsKey(module)) {
			distribGroup.add(module);
			addedModules.put(module, module);
		    }
		    else {
			printerr("module " + module + " is already in a distribution group");
			createDistributionGroup = false;
			break;
		    }
		}
		else {
		    printerr(module + " is not a specified module");
		    createDistributionGroup = false;
		    break;
		}
	    }
	    if(createDistributionGroup) {
		modelmaker.addDistributionGroup(distribGroup);
		j++;
	    }
	    else {
		/* do not add group, let user try again */
		for(ListIterator i = (ListIterator)distribGroup.iterator();i.hasNext();) {
		    String n = (String)(i.next());
		    addedModules.remove(n);
		}
	    }
	}
    }

    
    /********************************************************************************************
     ********************** methods for getting transition ties ****************************
     ********************************************************************************************/
    private void specifyTransitionTies()
    {
	int nrModules = modelmaker.getNrModules();
	String[] theNames = new String[nrModules];
	Hashtable addedModules = new Hashtable();
	println("Specify transition-tie groups");
	print("(Possible modules are:");
	int j = 0;
	for(ListIterator i = modelmaker.getModules();i.hasNext();) {
	    String name = ((Module)i.next()).getName();
	    print(" " + name);
	    theNames[j] = name;
	    j++;
	}
	print(")");
	newln();

	boolean done = false;
	boolean createTransTieGroup;
	j = 1;
	while(!done) {
	    LinkedList transTieGroup = new LinkedList();
	    print("Transition-tie group " + j + " (separate by ';'):");
	    String s = readln();
	    if(s.equals("") || s.equals("d") || s.equals("done")) {
		done = true;
		continue;
	    }
	    s = s.trim();
	    StringTokenizer st = new StringTokenizer(s,";");
	    createTransTieGroup = true;
	    while(st.hasMoreTokens()) {
		String module = st.nextToken();
		module = module.trim();
		if(isModuleName(module, theNames)) {
		    if(!addedModules.containsKey(module)) {
			transTieGroup.add(module);
			addedModules.put(module, module);
			if(!modelmaker.identicalModules(((String)transTieGroup.get(0)), module)) {
			    printerr("module " + module + " is of incorrect type");
			    createTransTieGroup = false;
			    break;
			}
		    }
		    else {
			printerr("module " + module + " is already in a distribution group");
			createTransTieGroup = false;
			break;
		    }
		}
		else {
		    printerr(module + " is not a specified module");
		    createTransTieGroup = false;
		    break;
		}
	    }
	    if(createTransTieGroup) {
		modelmaker.addTransTieGroup(transTieGroup);
		j++;
	    }
	    else {
		/* do not add group, let user try again */
		for(ListIterator i = (ListIterator)transTieGroup.iterator();i.hasNext();) {
		    String n = (String)(i.next());
		    addedModules.remove(n);
		}
	    }
	}
    }
    
    



    /********************************************************************************************
     ********************** methods for getting initial values ****************************
     ********************************************************************************************/
    private void specifyInitvalues()
    {
	LinkedList restModules = new LinkedList();
	for(ListIterator i = modelmaker.getModules();i.hasNext();) {
	    restModules.add(i.next());
	}
	println("Specify initial emission probabilities and prior distributions for each " + 
		"module/distribution group");
	for(ListIterator i = modelmaker.getDistributionGroups();i.hasNext();) {
	    print("[ ");
	    LinkedList distribGroup = (LinkedList)i.next();
	    for(ListIterator j = (ListIterator)distribGroup.iterator();
		j.hasNext();) {
		Module m = modelmaker.getModule(((String)j.next()));
		print(m.getName() + " ");
		restModules.remove(m);
	    }
	    print("] ");
	    boolean done = false;
	    while(!done) {
		print("(initprobtype, priorfile, emisspriorscaler):");
		String s = readln();
		StringTokenizer st = new StringTokenizer(s,",");
		int initDistribType = HMM.EVEN;
		boolean locked = false;
		double[] initDistrib = null;
		if(st.countTokens() > 3) {
		    printerr("illegal choice");
		    continue;
		}
		else if(st.countTokens() == 0) {
		    s = null;
		    
		}
		else {
		    /* read init distribution instruction */
		    s = st.nextToken();
		    s = s.trim();
		    initDistribType = parseDistribType(s);
		    initDistrib = null;
		    if(initDistribType == HMM.NOTYPE) {
			continue;
		    }
		    else if(initDistribType == HMM.MANUAL || initDistribType == HMM.LOCKED_MANUAL) {
			initDistrib = getInitDistribution();
			if(initDistrib == null) {
			    continue;
			}
			if(initDistribType == HMM.LOCKED_MANUAL) {
			    locked = true;
			}
		    }
		    else if(initDistribType == HMM.RANDOM) {
			initDistrib = getRandomDistrib();
		    }
		    else if(initDistribType == HMM.LOCKED_EVEN) {
			locked = true;
		    }
		    else {
			
		    }
		}
		double priScaleValue = 1.0;
		if(st.countTokens() == 1) {
		    /* read prior file */
		    s = st.nextToken();
		    s = s.trim();
		}
		else if(st.countTokens() == 2) {
		    /* read prior file */
		    s = st.nextToken();
		    s = s.trim();

		    /* read prior scaler */
		    String priScale = st.nextToken();
		    priScale = priScale.trim();
		    priScaleValue = 1.0;
		    try {
			priScaleValue = Double.parseDouble(priScale);
			if(priScaleValue < 0.0) {
			    printerr("illegal value, setting priorscaler to 1.0");
			    priScaleValue = 1.0;
			}
			
		    }
		    catch(NumberFormatException e){
			printerr("illegal value, setting priorscaler to 1.0");
		    }
		}
		else if(st.countTokens() == 0) {
		    s = null;
		}
		/* give info to modules in distribution group */
		for(ListIterator k = (ListIterator)distribGroup.iterator();
		    k.hasNext();) {
		    Module m = modelmaker.getModule((String) k.next());
		    m.setPriorfile(s);
		    m.setEmissPriorScaler(priScaleValue);
		    modelmaker.addPriorfile(s);
		    if(initDistribType == HMM.MANUAL || initDistribType == HMM.RANDOM) {
			m.setDistribType(initDistribType, initDistrib);
		
		    }
		    else {
			m.setDistribType(initDistribType);
		    }
		    if(locked) {
			m.lockVertexEmissions();
		    }
		}
		done = true;
	    }
	}
	for(ListIterator i = (ListIterator)restModules.iterator();i.hasNext();) {
	    Module m = (Module)i.next();
	    if(m.getVertexType() == HMM.START || m.getVertexType() == HMM.END) {
		continue;
	    }
	    print(m.getName() + " ");
	    boolean done = false;
	    while(!done) {
		print("(initprobtype, priorfile, emisspriorscaler):");
		String s = readln();
		StringTokenizer st = new StringTokenizer(s,",");
		int initDistribType = HMM.EVEN;
		boolean locked = false;
		double[] initDistrib = null;
		if(st.countTokens() > 3 ) {
		    printerr("illegal choice");
		    continue;
		}
		else if(st.countTokens() == 0) {
		    s = null;
		    
		}
		else {
		    /* read init distribution instruction */
		    s = st.nextToken();
		    s = s.trim();
		    initDistribType = parseDistribType(s);
		    initDistrib = null;
		    if(initDistribType == HMM.NOTYPE) {
			continue;
		    }
		    else if(initDistribType == HMM.MANUAL || initDistribType == HMM.LOCKED_MANUAL) {
			initDistrib = getInitDistribution();
			if(initDistrib == null) {
			    continue;
			}
			if(initDistribType == HMM.LOCKED_MANUAL) {
			    locked = true;
			}
		    }
		    else if(initDistribType == HMM.RANDOM) {
			initDistrib = getRandomDistrib();
		    }
		    else if(initDistribType == HMM.LOCKED_EVEN) {
			locked = true;
		    }
		    else {
			
		    }
		}   
		double priScaleValue = 1.0;
		if(st.countTokens() == 1) {
		    /* read prior file */
		    s = st.nextToken();
		    s = s.trim();
		}
		else if(st.countTokens() == 2) {
		    /* read prior file */
		    s = st.nextToken();
		    s = s.trim();

		    /* read prior scaler */
		    String priScale = st.nextToken();
		    priScale = priScale.trim();
		    priScaleValue = 1.0;
		    try {
			priScaleValue = Double.parseDouble(priScale);
			if(priScaleValue < 0.0) {
			    printerr("illegal value, setting priorscaler to 1.0");
			    priScaleValue = 1.0;
			}
			
		    }
		    catch(NumberFormatException e){
			printerr("illegal value, setting priorscaler to 1.0");
		    }
		}
		else if(st.countTokens() == 0) {
		    s = null;
		}
		/* give info to module */
		m.setPriorfile(s);
		m.setEmissPriorScaler(priScaleValue);
		modelmaker.addPriorfile(s);
		if(initDistribType == HMM.MANUAL) {
		    m.setDistribType(initDistribType, initDistrib);
		}
		else {
		    m.setDistribType(initDistribType);
		}
		if(locked) {
		    m.lockVertexEmissions();
		}
		done = true;
		
	    }
	}
    }

    private void specifyInitvalues(int nr)
    {
	LinkedList restModules = new LinkedList();
	for(ListIterator i = modelmaker.getModules();i.hasNext();) {
	    restModules.add(i.next());
	}
	println("Specify initial emission probabilities and prior distributions for each " + 
		"module/distribution group");
	for(ListIterator i = modelmaker.getDistributionGroups();i.hasNext();) {
	    print("[ ");
	    LinkedList distribGroup = (LinkedList)i.next();
	    for(ListIterator j = (ListIterator)distribGroup.iterator();
		j.hasNext();) {
		Module m = modelmaker.getModule(((String)j.next()));
		print(m.getName() + " ");
		restModules.remove(m);
	    }
	    print("] ");
	    boolean done = false;
	    while(!done) {
		print(" (alphabet nr " + nr + ") (initprobtype, priorfile, emisspriorscaler):");
		String s = readln();
		StringTokenizer st = new StringTokenizer(s,",");
		int initDistribType = HMM.EVEN;
		boolean locked = false;
		double[] initDistrib = null;
		if(st.countTokens() > 3) {
		    printerr("illegal choice");
		    continue;
		}
		else if(st.countTokens() == 0) {
		    s = null;
		    
		}
		else {
		    /* read init distribution instruction */
		    s = st.nextToken();
		    s = s.trim();
		    initDistribType = parseDistribType(s);
		    initDistrib = null;
		    if(initDistribType == HMM.NOTYPE) {
			continue;
		    }
		    else if(initDistribType == HMM.MANUAL || initDistribType == HMM.LOCKED_MANUAL) {
			initDistrib = getInitDistribution();
			if(initDistrib == null) {
			    continue;
			}
			if(initDistribType == HMM.LOCKED_MANUAL) {
			    locked = true;
			}
		    }
		    else if(initDistribType == HMM.RANDOM) {
			initDistrib = getRandomDistrib(nr);
		    }
		    else if(initDistribType == HMM.LOCKED_EVEN) {
			locked = true;
		    }
		    else {
			
		    }
		}