Laboratoire ICAR » Plateforme TXM

 org.txm.index.core;bundle-version="1.0.0"

			lexicon = corpus.getLexicon(property);

import org.txm.lexicaltable.core.statsengine.data.LexicalTable;

import org.txm.specificities.core.functions.Specificites;

	private LexicalTable lt;

		// ALTER THE INDEX IF A REFERENCE CORPUS IS SET

		if(referenceCorpus != null && referenceCorpus.length() > 0) {

		lt = LexicalTableImpl.createLexicalTable(freqs, properties.get(0), rownames, colnames, 1);

		lt.setCorpus(corpus);

		SpecificitesResult specif = Specificites.specificites(lt, 1000);

		String[] specifrownames = specif.getTypeNames();

		double[][] scores = specif.getSpecificitesIndex();

Require-Bundle: org.txm.lexicaltable.core,

// Copyright © 2010-2013 ENS de Lyon.

// Copyright © 2007-2010 ENS de Lyon, CNRS, INRP, University of

// Lyon 2, University of Franche-Comté, University of Nice

// Sophia Antipolis, University of Paris 3.

// 

// The TXM platform is free software: you can redistribute it

// and/or modify it under the terms of the GNU General Public

// License as published by the Free Software Foundation,

// either version 2 of the License, or (at your option) any

// later version.

// 

// The TXM platform is distributed in the hope that it will be

// useful, but WITHOUT ANY WARRANTY; without even the implied

// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR

// PURPOSE. See the GNU General Public License for more

// details.

// 

// You should have received a copy of the GNU General

// Public License along with the TXM platform. If not, see

// http://www.gnu.org/licenses.

// 

// 

// 

// $LastChangedDate: 2016-11-29 16:47:07 +0100 (Tue, 29 Nov 2016) $

// $LastChangedRevision: 3349 $

// $LastChangedBy: mdecorde $ 

//

package org.txm.specificities.core.functions;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.HashSet;

import java.util.List;

import java.util.Set;

import org.txm.lexicaltable.core.functions.LexicalTableFactory;

import org.txm.lexicaltable.core.statsengine.data.LexicalTable;

import org.txm.lexicon.core.corpusengine.cqp.Lexicon;

import org.txm.searchengine.cqp.clientExceptions.CqiClientException;

import org.txm.searchengine.cqp.corpus.Corpus;

import org.txm.searchengine.cqp.corpus.Part;

import org.txm.searchengine.cqp.corpus.Partition;

import org.txm.searchengine.cqp.corpus.Property;

import org.txm.searchengine.cqp.corpus.Subcorpus;

import org.txm.searchengine.cqp.corpus.query.Focus;

import org.txm.specificities.core.messages.SpecificitiesCoreMessages;

import org.txm.statsengine.core.StatException;

import org.txm.statsengine.core.data.Vector;

import org.txm.statsengine.r.core.exceptions.RWorkspaceException;

// TODO: Auto-generated Javadoc

/**

 * High level access to the Specificities.

 * 

 * The methods in this class access the Specificities function through

 * high-level objects (representation of CQP corpus ({@link Corpus},

 * {@link Subcorpus}, {@link Partition}), representation of queries (

 * {@link Focus}, {@link Property}), and lexicon {@link Lexicon})).

 * 

 * @author sloiseau

 * 

 */

public class Specificites {

	/** The specif_counter. */

	private static int specif_counter = 1;

	private static ArrayList<Integer> selectedColIdx;

	/**

	 * Compute the specificity index for all the cells of a complete lexical

	 * table, as defined by a {@link Partition} and a {@link Property}.

	 * 

	 * This may be used for extracting, for all part, the forms the most or the

	 * less specif ic.

	 *

	 * @param partition the partition

	 * @param analysisProperty the analysis property

	 * @param formFocus the form focus

	 * @param partsFocus the parts focus

	 * @param Fmin the fmin

	 * @return the specificites result

	 * @throws CqiClientException the cqi client exception

	 * @throws StatException the stat exception

	 */

	public static SpecificitesResult specificites(Partition partition, Property analysisProperty,

			List<Part> partsFocus, int Fmin, int maxScore) throws CqiClientException, StatException {

		if (partition.getParts().size() < 2) {

			throw new IllegalArgumentException(SpecificitiesCoreMessages.ComputeError_NEED_AT_LEAST_2_PARTS);

		}

		// complication due to Jean-Philippe special interest in usage of Part.

		List<String> partNamesFocus = new ArrayList<String>();

		if (partsFocus != null) {

			partNamesFocus = new ArrayList<String>();

			for (Part p : partsFocus) {

				partNamesFocus.add(p.getShortName());

			}

		}

		// System.out.println("get/create lexical table");

		LexicalTable table = LexicalTableFactory.getLexicalTable(partition, analysisProperty, Fmin);

		partition.addResult(table);

		// Create a set of the existing types

		String[] rownames = table.getRowNames().asStringsArray();

		ArrayList<String> found = new ArrayList<String>(Arrays.asList(rownames));

		String symbol = org.txm.specificities.core.statsengine.r.function.Specificites.prefixR+(specif_counter++);

		//System.out.println("Av specif ");

		double[][] specIndex = org.txm.specificities.core.statsengine.r.function.Specificites

		.specificites(symbol, table, found.toArray(new String[] {}), partNamesFocus.toArray(new String[] {}));

		//System.out.println("Ap specif ");

		return new SpecificitesResult(

				symbol,

				specIndex,

				table,

				found,

				partNamesFocus,

				analysisProperty.getName(),

				maxScore);

	}

	/**

	 * Specificites.

	 *

	 * @param table the table

	 * @return the specificites result

	 * @throws CqiClientException the cqi client exception

	 * @throws StatException the stat exception

	 */

	public static SpecificitesResult specificites(LexicalTable table, int maxScore)

	throws CqiClientException, StatException {

		if (table.getNColumns() < 2) {

			throw new IllegalArgumentException(SpecificitiesCoreMessages.ComputeError_NEED_AT_LEAST_2_PARTS);

		}

		String[] rownames = table.getRowNames().asStringsArray();

		String[] colnames = table.getColNames().asStringsArray();

		String symbol = org.txm.specificities.core.statsengine.r.function.Specificites.prefixR+(specif_counter++);

		double[][] specIndex = org.txm.specificities.core.statsengine.r.function.Specificites.specificites(symbol, table, rownames, colnames);

		if (table.getPartition() != null) {

			return new SpecificitesResult(symbol, specIndex, table, Arrays

					.asList(rownames), Arrays.asList(colnames), table.getProperty().getName(), maxScore); 

		} else {

			return new SpecificitesResult(symbol, specIndex, table, Arrays

					.asList(rownames), Arrays.asList(colnames),

					"TLNONAME: " + table.getProperty().getName(), maxScore); //$NON-NLS-1$

		}

	}

	/**

	 * Specificites.

	 *

	 * @param corpus the corpus

	 * @param subcorpus the subcorpus

	 * @param property the property

	 * @return the specificites result

	 * @throws CqiClientException the cqi client exception

	 * @throws StatException the stat exception

	 */

	public static SpecificitesResult specificites(Corpus corpus,

			Subcorpus subcorpus, Property property, int maxScore) throws CqiClientException,

			StatException {

		Lexicon totalFrequencies = corpus.getLexicon(property);

		Lexicon subFrequencies = subcorpus.getLexicon(property);

		//System.out.println("Send corpus vector");

		Vector totalFSymbol;

		Vector subFSymbol;

		try {

			totalFSymbol = totalFrequencies.asVector();

			subFSymbol = subFrequencies.asVector();

		} catch (StatException e) {

			throw new RWorkspaceException(e);

		}

		//System.out.println("compute specifs");

		String symbol = org.txm.specificities.core.statsengine.r.function.Specificites.prefixR+(specif_counter++);

		double[][] specIndex = org.txm.specificities.core.statsengine.r.function.Specificites.specificites(symbol, totalFSymbol, subFSymbol);

		//System.out.println("build SpecificitesResult");

		SpecificitesResult specif =  new SpecificitesResult(symbol, specIndex, totalFrequencies,

				subFrequencies, property.getName(), maxScore); 

		specif.setCorpus(subcorpus);

		return specif ;

	}

	/**

	 * TODO to be replaced by

	 * "org.apache.commons.collections.CollectionUtils.subtract" when someone

	 * figure out where is the eclipse plugin for apache commons collections. SL

	 *

	 * @param leftoperande the leftoperande

	 * @param rightoperande the rightoperande

	 * @return an array of two sets: the first one contains the element of

	 * leftoperande not in rightoperande, the second the element of

	 * leftoperande present in rightoperande.

	 */

	private static final Set<String>[] subtract(Set<String> leftoperande,

			Set<String> rightoperande) {

		Set<String>[] returned = new HashSet[] { new HashSet<String>(),

				new HashSet<String>() };

		for (String s : leftoperande) {

			if (!rightoperande.contains(s)) {

				returned[0].add(s);

			} else {

				returned[1].add(s);

			}

		}

		return returned;

	}

}

import org.txm.lexicaltable.core.statsengine.data.LexicalTable;

		// TODO Auto-generated constructor stub

		// TODO Auto-generated constructor stub

		// TODO Auto-generated constructor stub

		colNames = table.getColNames().asStringsArray();

		rowNames = table.getRowNames().asStringsArray();

		frequencies = RWorkspace.getRWorkspaceInstance().evalToInt2D(table.getSymbol());

		String cmd = "mat <- "+table.getSymbol()+"\n"+ //$NON-NLS-1$ //$NON-NLS-2$

import org.txm.lexicaltable.core.statsengine.data.LexicalTable;

// TODO: Auto-generated Javadoc

	private final double[][] indices;

	private final LexicalTable table;

	protected SpecificitesResult(String symbol, double[][] specIndex, Lexicon lexicon, Lexicon subLexicon, String name, int maxScore) {

		super(subLexicon.getCorpus());

	protected SpecificitesResult(String symbol, double[][] specIndex, LexicalTable table,

		super(table);

		return table != null ? table.getTotal() : lexicon.nbrOfToken();

				frequencies = RWorkspace.getRWorkspaceInstance().evalToInt2D(table.getSymbol());

import org.txm.lexicaltable.core.statsengine.data.LexicalTable;

		// TODO Auto-generated constructor stub

		// TODO Auto-generated constructor stub

		// TODO Auto-generated constructor stub

	colNames = table.getColNames().asStringsArray();

	rowNames = table.getRowNames().asStringsArray();

	frequencies = RWorkspace.getRWorkspaceInstance().evalToInt2D(table.getSymbol());

	// compute

	indices = org.txm.specificities.core.statsengine.r.function.Specificites.specificites("SYMBOL", table, null, null); //$NON-NLS-1$

	return true;

}

		// TODO Auto-generated method stub

// Copyright © 2010-2013 ENS de Lyon.

// Copyright © 2007-2010 ENS de Lyon, CNRS, INRP, University of

// Lyon 2, University of Franche-Comté, University of Nice

// Sophia Antipolis, University of Paris 3.

// 

// The TXM platform is free software: you can redistribute it

// and/or modify it under the terms of the GNU General Public

// License as published by the Free Software Foundation,

// either version 2 of the License, or (at your option) any

// later version.

// 

// The TXM platform is distributed in the hope that it will be

// useful, but WITHOUT ANY WARRANTY; without even the implied

// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR

// PURPOSE. See the GNU General Public License for more

// details.

// 

// You should have received a copy of the GNU General

// Public License along with the TXM platform. If not, see

// http://www.gnu.org/licenses.

// 

// 

// 

// $LastChangedDate: 2017-01-24 18:11:42 +0100 (Tue, 24 Jan 2017) $

// $LastChangedRevision: 3400 $

// $LastChangedBy: mdecorde $ 

//

package org.txm.specificities.core.statsengine.r.function;

import org.rosuda.REngine.REXP;

import org.rosuda.REngine.REXPMismatchException;

import org.rosuda.REngine.Rserve.RserveException;

import org.txm.lexicaltable.core.statsengine.data.LexicalTable;

import org.txm.specificities.core.messages.SpecificitiesCoreMessages;

import org.txm.statsengine.core.StatException;

import org.txm.statsengine.core.data.QuantitativeDataStructure;

import org.txm.statsengine.core.data.Vector;

import org.txm.statsengine.r.core.RWorkspace;

import org.txm.statsengine.r.core.data.VectorImpl;

import org.txm.utils.logger.Log;

// TODO: Auto-generated Javadoc

/**

 * Bridge between the statistical engine and the high-level specificities

 * function {@link org.txm.functions.specificities.Specificities}.

 * 

 * This class contains only one methods; it takes as input low-level object (a

 * {@link QuantitativeDataStructure}) and return a low level object (a

 * <int>double[][]</int> array of specificities index).

 * 

 * @author sloiseau

 * 

 */

public class Specificites {

	/** The DEFAUL t_ symbol. */

	public static final String prefixR = "SpecifResult"; //$NON-NLS-1$

	/**

	 * Specificites.

	 *

	 * @param lexicon the lexicon

	 * @param subLexicon the sub lexicon

	 * @return the double[][]

	 * @throws StatException the stat exception

	 */

	public static double[][] specificites(String symbol, Vector lexicon, Vector subLexicon)

			throws StatException {

		RWorkspace rw = RWorkspace.getRWorkspaceInstance();

		try {

			// System.out.println("lexicon "+lexicon.getLength());

			//System.out.println(" call specificites.lexicon.new");

			rw.safeEval("library(textometry)");

			REXP r = rw.callFunction(

							"specificities.lexicon.new", new QuantitativeDataStructure[] { lexicon, subLexicon }, symbol); //$NON-NLS-1$

			// double[] res = RWorkspace.toDouble(r);

			//System.out.println(" build double matrix");

			double[][] res;

			try {

				res = r.asDoubleMatrix();

			} catch (REXPMismatchException e) {

				throw new StatException(SpecificitiesCoreMessages.ComputeError_FAILED_TO_GET_SPECIFICITIES

						+ e.getMessage(), e);

			}

			Log.finest(res.length + SpecificitiesCoreMessages.Specificites_2);

			return res;

		} catch (Exception e) {

			System.out.println(e.getLocalizedMessage());

			org.txm.utils.logger.Log.printStackTrace(e);

		}

		return null;

	}

	/**

	 * Specificites.

	 *

	 * @param table the table

	 * @param typeFocus the type focus

	 * @param partFocus the part focus

	 * @return the double[][]

	 * @throws StatException the stat exception

	 */

	public static double[][] specificites(String symbol, LexicalTable table,

			String[] typeFocus, String[] partFocus) throws StatException {

		RWorkspace rw = RWorkspace.getRWorkspaceInstance();

		VectorImpl row = null;

		if (typeFocus != null && typeFocus.length != 0)

			row = new VectorImpl(typeFocus);

		VectorImpl column = null;

		if (partFocus != null && partFocus.length != 0)

			column = new VectorImpl(partFocus);

		try {

			rw.safeEval("library(textometry)");

		} catch (RserveException e1) {

			// TODO Auto-generated catch block

			e1.printStackTrace();

		} catch (REXPMismatchException e1) {

			// 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 (REXPMismatchException e) {

			throw new StatException(SpecificitiesCoreMessages.ComputeError_FAILED_TO_GET_SPECIFICITIES + e.getMessage(), e);

		}

		Log.finest((res.length * res[0].length) + SpecificitiesCoreMessages.Specificites_2);

		return res;

	}

	/**

	 * Gets the default symbol.

	 *

	 * @param symbol the symbol

	 * @return the default symbol

	 */

	public static double[][] getDefaultSymbol(String symbol)

	{

		return null;

	}

}

import org.txm.lexicaltable.core.statsengine.data.LexicalTable;

	protected String symbol;

		Lexicon totalFrequencies = corpus.getLexicon(property);

		Lexicon subFrequencies = subcorpus.getLexicon(property);

		Vector totalFSymbol = totalFrequencies.asVector();

		Vector subFSymbol = subFrequencies.asVector();

		String symbol = RWorkspace.getRandomSymbol();

		RWorkspace.getRWorkspaceInstance().eval(symbol + " <-  lexiconsToLexicalTable("+totalFSymbol.getSymbol()+", "+subFSymbol.getSymbol()+");"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$

		table = new LexicalTableImpl(symbol);

		table.setCorpus(corpus);

		colNames = table.getColNames().asStringsArray();

		rowNames = table.getRowNames().asStringsArray();

		frequencies = RWorkspace.getRWorkspaceInstance().evalToInt2D(table.getSymbol());

import org.txm.lexicaltable.core.statsengine.data.LexicalTable;

		colNames = table.getColNames().asStringsArray();

		rowNames = table.getRowNames().asStringsArray();

		frequencies = RWorkspace.getRWorkspaceInstance().evalToInt2D(table.getSymbol());

		String cmd = symbol +" <- 100*"+table.getSymbol()+" / rowSums("+table.getSymbol()+")"; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$

import org.txm.lexicaltable.core.statsengine.data.LexicalTable;

		// TODO Auto-generated constructor stub

		// TODO Auto-generated constructor stub

		// TODO Auto-generated constructor stub

		colNames = table.getColNames().asStringsArray();

		rowNames = table.getRowNames().asStringsArray();

		frequencies = RWorkspace.getRWorkspaceInstance().evalToInt2D(table.getSymbol());

		String cmd = symbol +" <- "+table.getSymbol(); //$NON-NLS-1$

import org.txm.lexicaltable.core.statsengine.data.LexicalTable;

Require-Bundle: org.txm.statsengine.core;bundle-version="1.0.0",

 org.eclipse.core.runtime;bundle-version="3.10.0",

 org.txm.lexicaltable.core;bundle-version="1.0.0",

 org.txm.lexicon.core;bundle-version="1.0.0"

public class StatsEngineCoreMessages extends Utf8NLS {

import org.txm.core.results.ITXMResult;

// TODO: Auto-generated Javadoc

public interface QuantitativeDataStructure extends ITXMResult {

import org.txm.lexicaltable.core.statsengine.data.LexicalTable;

		this.target = table.getSymbol();

import org.txm.searchengine.cqp.CqpDataProxy;

	private final int[] freqs;

	private final int[] ids;

	private final Property property;

	/** The cache. */

	private Map<Property, CqpDataProxy> cache;

	 * Protected on purpose: should be accessed through.

	 *

	 * @param corpus the corpus

	 * @param property the property

	 * @param freq the freq

	 * @param ids the ids

	 * {@link Corpus#getLexicon(Property)} or

	 * {@link Subcorpus#getLexicon(Property)}.

	public Lexicon(Corpus corpus, Property property, final int[] freq, final int[] ids) {

		super(corpus);

		if (freq.length != ids.length)

			throw new IllegalArgumentException(LexiconCoreMessages.Lexicon_0);

		this.freqs = freq;

		this.ids = ids;

		this.forms = null;

		this.property = property;