/ - Diff - Plateforme TXM - Forge du Centre Blaise Pascal

     			Subcorpus subcorpus = (Subcorpus) this.parent;
     			CQPCorpus parentCorpus = subcorpus.getMainCorpus();
     			Lexicon l1 = new Lexicon(parentCorpus);
     			l1.setProperty(property);
     			l1.compute(this.monitor);
     			Lexicon l2 = new Lexicon(subcorpus);
     			l2.setProperty(property);
     			l2.compute(this.monitor);
     			Lexicon l1 = Lexicon.findLexiconForParameter(parentCorpus, property);
     			Lexicon l2 = Lexicon.findLexiconForParameter(subcorpus, property);
     			this.statsData = new LexicalTableImpl(getNextName(), l1, l2);
+    		}
     		else if (this.parent instanceof Partition) {
-...
     		// FIXME SJ: new version, to validate
     		this.statsData.filter(this.vMaxFilter, this.fMinFilter);
     		// FIXME SJ: old version
     		//this.statsData.cut(this.vMaxFilter);

     	 * like after updating parameters
     	 */
     	protected boolean dirty = true;
     	/**
     	 * if frozen, the result is not updated when computed
     	 */
     	protected boolean frozen = false;
     	/**
     	 * The result parent. Should not be null except for roots TXMResult
-...
     	 */
     	protected boolean userPersistable;
     	/**
     	 * The visibility state.
     	 */
-...
     		this.userName = name;
+    	}
     	/**
     	 * Froze the result -> cannot be recomputed
     	 */
     	public void froze() {
     		this.frozen = true;
+    	}
     	/**
     	 * Un-Froze the result -> can be recomputed
     	 */
     	public void unfroze() {
     		this.frozen = false;
+    	}
     	/**
     	 * Froze/Un-Froze the result
     	 */
     	public void setFrozen(boolean frozen) {
     		this.frozen = frozen;
+    	}
     	/**
     	 * @return true if the resutl is frozen
     	 */
     	public boolean isFrozen() {
     		return this.frozen;
+    	}
     	/**
     	 * Creates an UUID dedicated to persistence of this result.
     	 * @return
     	 */
-...
     	 */
     	protected boolean compute(IProgressMonitor monitor, boolean deepComputing) {
     		if (hasBeenComputedOnce && frozen) return true; // no changes to do
     		try {
     			Log.finest("*** TXMResult.compute(): " + this.getClass().getSimpleName() + ": starting computing process...");
     			// FIXME: see if this skipComputing tests is still useful? is it possible to directly return instead?

     import java.io.UnsupportedEncodingException;
     import java.util.ArrayList;
     import java.util.Arrays;
     import java.util.List;
     import java.util.Map;
     import org.eclipse.core.runtime.IProgressMonitor;
-...
     		//long start = System.currentTimeMillis();
     		int[][] fdist = null;
     		AbstractCqiClient cqi = CorpusManager.getCorpusManager().getCqiClient();
     		String tmp = "S" + corpus.getNextSubcorpusCounter();
     		String tmp = "TMP" + CQPCorpus.getNextSubcorpusCounter();
     		String qtmp = corpus.getMainCorpus().getQualifiedCqpId()+":"+tmp;
     		try {
     			this.subTask("Computing lexicon frequencies...");
     			System.out.println("subcorpus: "+corpus.getQualifiedCqpId());
     			System.out.println("query subcorpus: "+qtmp);
     			cqi.cqpQuery(corpus.getQualifiedCqpId(), tmp, "[]");
     			fdist = CorpusManager.getCorpusManager().getCqiClient().fdist1(qtmp, 0, ICqiClient.CQI_CONST_FIELD_MATCH, property.getName());
     			//System.out.println("nb lines: "+fdist.length);
-...
     			// if (freqs[i] != 1) System.out.println(freqs[i]);
+    		}
+    	}
     	public static Lexicon findLexiconForParameter(CQPCorpus corpus, Property prop) {
     		List<Lexicon> lexicons = (List<Lexicon>) corpus.getChildren(Lexicon.class);
     		for (Lexicon l : lexicons) {
     			if (l.getProperty().equals(prop)) {
     				return l;
+    			}
+    		}
     		Lexicon newL = new Lexicon(corpus);
     		newL.setProperty(prop);
     		newL.compute();
     		return newL;
+    	}
     	/**
     	 * Dump lexicon forms and frequencies in a String.

     import java.util.ArrayList;
     import java.util.Collection;
     import java.util.Collections;
     import java.util.Comparator;
     import java.util.HashMap;
     import java.util.HashSet;
     import java.util.List;
-...
     		long start = System.currentTimeMillis();
     		try {
     			CorpusManager.getCorpusManager().getCqiClient().cqpQuery(
     					this.getQualifiedCqpId(), subcorpusCqpId,
     					query.getQueryString());
     					this.getQualifiedCqpId(), subcorpusCqpId, query.getQueryString());
     			//System.out.println("SUBCORPUS: "+subcorpusCqpId+" q="+query.getQueryString());
     			subcorpus = new Subcorpus(this);
     			subcorpus.setParameters(subcorpusCqpId, subcorpusName, query);
-...
     		return this.userName;
+    	}
     	public static final Comparator<WordProperty> wordFirstComparator = new Comparator<WordProperty>() {
     		@Override
     		public int compare(WordProperty o1, WordProperty o2) {
     			if (o1.getName().equals("word")) return -1;
     			if (o2.getName().equals("word")) return 1;
     			return o1.compareTo(o2);
+    		}
     	};
     	/**
     	 * Get the ordered properties (by name).
+    	 *
-...
     	@SuppressWarnings("unchecked") //$NON-NLS-1$
     	public List<WordProperty> getOrderedProperties() throws CqiClientException {
     		List<WordProperty> props = this.getProperties();
     		Collections.sort(props);
     		Collections.sort(props, wordFirstComparator);
     		return props;
+    	}

     	public SpecificitiesR(ILexicalTable lt) throws StatException {
     		super(prefixR+(specif_counter++));
     		// Create a set of the existing types
     		String[] rownames = lt.getRowNames().asStringsArray();
     		String[] colnames = lt.getColNames().asStringsArray();
     		//System.out.println("Av specif ");
     		specIndex = compute(symbol, lt, rownames, colnames);
     		specIndex = compute(symbol, lt, null, null);
+    	}
     	/**
-...
     			// TODO Auto-generated catch block
     			e1.printStackTrace();
+    		}
     		REXP r = rw.callFunction("specificities", new QuantitativeDataStructure[] { table, row, column }, symbol); //$NON-NLS-1$
     		double[][] res;
     		try {
     			res = r.asDoubleMatrix();
     		} catch (Exception e) {
     			throw new StatException(TXMCoreMessages.bind(SpecificitiesCoreMessages.failedToGetTheSpecificitesColon, e.getMessage()), e);
     		if (table.getNRows() > 1 && table.getNColumns() > 1) {
     			REXP r = rw.callFunction("specificities", new QuantitativeDataStructure[] { table, row, column }, symbol); //$NON-NLS-1$
     			try {
     				res = r.asDoubleMatrix();
     			} catch (Exception e) {
     				throw new StatException(TXMCoreMessages.bind(SpecificitiesCoreMessages.failedToGetTheSpecificitesColon, e.getMessage()), e);
+    			}
     			Log.finest(TXMCoreMessages.bind(SpecificitiesCoreMessages.specificityIndexComputed, (res.length * res[0].length)));
     		} else {
     			res = new double[table.getNRows()][table.getNColumns()];
+    		}
     		Log.finest(TXMCoreMessages.bind(SpecificitiesCoreMessages.specificityIndexComputed, (res.length * res[0].length)));
     		return res;
+    	}

     import org.txm.core.results.TXMResult;
     import org.txm.index.core.functions.Lexicon;
     import org.txm.lexicaltable.core.functions.LexicalTable;
     import org.txm.lexicaltable.core.statsengine.data.ILexicalTable;
     import org.txm.searchengine.cqp.clientExceptions.CqiClientException;
     import org.txm.searchengine.cqp.corpus.CQPCorpus;
     import org.txm.searchengine.cqp.corpus.Partition;
-...
     			this.deleteChildren(SpecificitiesSelection.class);
+    		}
     		if (this.lexicalTable.hasBeenComputedOnce())	{
     			SpecificitiesR rSpecificities = new SpecificitiesR(this.lexicalTable.getData());
     		//if (this.lexicalTable.hasBeenComputedOnce())	{ // LT should have been computed one because of TXMResult.compute
     		ILexicalTable data = this.lexicalTable.getData();
     			SpecificitiesR rSpecificities = new SpecificitiesR(data);
     			double[][] specIndex = rSpecificities.getScores();
     			String sname = null;
-...
     			} else {
     				init(rSpecificities.getSymbol(), specIndex, sname); //$NON-NLS-1$
+    			}
+    		}
     		//}
     		return true;
+    	}

Laboratoire ICAR » Plateforme TXM

Révision 1390