Laboratoire ICAR » Plateforme TXM

LEXICON_RESULT_TYPE = Lexicon

LexiconDetailsFromCorpus = Lexicon:\n\	Corpus {0}\n\	query {1}\n\	properties {2}\n\	Fmin {3}\n\	Fmax {4}

LexiconDetailsFromPartition = Lexicon:\n\	Partition {0}\n\	query {1}\n\	properties {2}\n\	Fmin {3}\n\	Fmax {4}

Lexicon_0                   = Forms and frequencies tables must be of the same length.

Lexicon_3                   = Lexicon : 

	public static String LEXICON_RESULT_TYPE;

	public static String Lexicon_0;

	public static String Lexicon_3;

	public static String LexiconDetailsFromPartition;

	public static String LexiconDetailsFromCorpus;

LEXICON_RESULT_TYPE = Словарь

LexiconDetailsFromCorpus = Словарь:\n\	Корпус {0}\n\	Запрос {1}\n\	Свойства {2}\n\	Fmin {3}\n\	Fmax {4}

LexiconDetailsFromPartition = Словарь:\n\	Распределение {0}\n\	Запрос {1}\n\	Свойства {2}\n\	Fmin {3}\n\	Fmax {4}

DetailsFromCorpus = Index:\n\	Corpus {0}\n\	Requ�te {1}\n\	propri�t�s {2}\n\	Fmin {3}\n\	Fmax {4}

DetailsFromPartition = Index:\n\	Partition {0}\n\	Requ�te {1}\n\	propri�t�s {2}\n\	Fmin {3}\n\	Fmax {4}

LEXICON_RESULT_TYPE = Lexique

LexiconDetailsFromCorpus = Lexique :\n\	Corpus {0}\n\	Requête {1}\n\	Propriétés {2}\n\	Fmin {3}\n\	Fmax {4}

LexiconDetailsFromPartition = Lexique :\n\	Partition {0}\n\	Requête {1}\n\	Propriétés {2}\n\	Fmin {3}\n\	Fmax {4}

Lexicon_0                   = Le tableau des formes et des fréquences doivent avoir la même longueur.

Lexicon_3                   = Lexique :

// 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-09-19 10:31:00 +0200 (Mon, 19 Sep 2016) $

// $LastChangedRevision: 3298 $

// $LastChangedBy: mdecorde $ 

//

package org.txm.index.core.functions;

import java.io.File;

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.OutputStreamWriter;

import java.io.UnsupportedEncodingException;

import java.util.Arrays;

import java.util.Map;

import org.eclipse.core.runtime.IProgressMonitor;

import org.txm.core.messages.TXMCoreMessages;

import org.txm.core.results.TXMParameters;

import org.txm.core.results.TXMResult;

import org.txm.index.core.messages.IndexCoreMessages;

import org.txm.searchengine.cqp.ICqiClient;

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

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

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

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

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

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

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

import org.txm.statsengine.core.StatException;

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

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

import org.txm.utils.logger.Log;

// TODO: Auto-generated Javadoc

//  TODO should be put into stat.data package ?

/**

 * Represent a frequency list according to a {@link Corpus} (or a.

 *

 * {@link Subcorpus}) and a {@link Property}.

 * @author sloiseau

 */

public class Lexicon extends TXMResult {

	/** The nolex. */

	protected static int nolex = 1;

	/** The prefix r. */

	protected static String prefixR = "Lexicon_"; //$NON-NLS-1$

	/** The forms. */

	private String[] forms;

	/** The freqs. */

	private int[] freqs;

	/** The ids. */

	private int[] ids;

	/** The number of tokens. */

	int numberOfTokens = -1;

	/** The property. */

	private Property pProperty;

	/** The symbol. */

	private String symbol;

	/** The writer. */

	private OutputStreamWriter writer;

	private Corpus corpus;

	public Lexicon(Corpus corpus) {

		super(corpus);

		this.corpus = corpus;

	}

	@Override

	public boolean saveParameters() throws Exception {

		// TODO Auto-generated method stub

		return true;

	}

	@Override

	public boolean loadParameters() throws Exception {

		// TODO Auto-generated method stub

		return true;

	}

	@Override

	public void clean() {

		// TODO Auto-generated method stub

	}

	@Override

	public boolean canCompute() throws Exception {

		return corpus != null && pProperty != null;

	}

	@Override

	protected boolean _compute() throws Exception {

		if (corpus instanceof MainCorpus) {

			return computeWithMainCorpus((MainCorpus)corpus, pProperty, monitor);

		}

		else if (corpus instanceof Subcorpus) {

			return computewithSubCorpus((Subcorpus)corpus, pProperty, monitor);

		}

		else {

			System.out.println("Error: Lexicon parent is neither a Maincorpus nor a Subcorpus.");

			return false;

		}

	}

	/**

	 * Gets the lexicon relative to a given property.

	 * 

	 * @param property

	 *            the property

	 * 

	 * @return the lexicon

	 * 

	 * @throws CqiClientException

	 *             the cqi client exception

	 */

	protected boolean computeWithMainCorpus(MainCorpus corpus, Property property, IProgressMonitor monitor) throws CqiClientException {

		// System.out.println("in "+this.getCqpId()+" look for cached lexicon "+property);

		// System.out.println("not found");

		this.subTask("Computing lexicon size...");

		Log.finest(TXMCoreMessages.LEXICON + corpus.getName());

		int lexiconSize;

		try {

			lexiconSize = CorpusManager.getCorpusManager().getCqiClient().lexiconSize(property.getQualifiedName());

		} catch (Exception e) {

			throw new CqiClientException(e);

		}

		int[] ids = new int[lexiconSize];

		for (int i = 0; i < ids.length; i++) {

			ids[i] = i;

		}

		int[] freqs;

		try {

			this.subTask("Computing lexicon frequencies...");

			freqs = CorpusManager.getCorpusManager().getCqiClient().id2Freq(property.getQualifiedName(), ids);

		} catch (Exception e) {

			throw new CqiClientException(e);

		}

		init(corpus, property, freqs, ids);

		return true;

	}

	/**

	 * 

	 * @param corpus

	 * @param property

	 * @param monitor

	 * @return

	 * @throws CqiClientException

	 */

	protected boolean computewithSubCorpus(Subcorpus corpus, Property property, IProgressMonitor monitor) throws CqiClientException {

		//System.out.println("not found");

		Log.finest(TXMCoreMessages.SUBCORPUS_LEXICON + corpus.getName());

		long start = System.currentTimeMillis();

		int[][] fdist = null;

		Subcorpus tmp = null;

		try {

			this.subTask("Computing lexicon frequencies...");

			tmp = corpus.createSubcorpus(new Query("[]"), "S"+corpus.getNextSubcorpusCounter(), true); //$NON-NLS-1$

			if (tmp != null) {

				fdist = CorpusManager.getCorpusManager().getCqiClient().fdist1(

						tmp.getQualifiedCqpId(), 0,

						ICqiClient.CQI_CONST_FIELD_MATCH, property.getName());

				corpus.dropSubcorpus(tmp); // drop the subcorpus only if correctly created

			}

			//System.out.println("nb lines: "+fdist.length);

		} catch (Exception e) {

			throw new CqiClientException(e);

		} finally {

			if (tmp != null) {

				try {corpus.dropSubcorpus(tmp);}

				catch (Exception e2) {}

			}

		}

		int lexiconSize = fdist.length;

		int[] freqs = new int[lexiconSize];

		int[] ids = new int[lexiconSize];

		for (int i = 0; i < fdist.length; i++) {

			ids[i] = fdist[i][0];

			freqs[i] = fdist[i][1];

		}

		init(corpus, property, freqs, ids);

		return true;

	}

	/**

	 * Convert the Lexicon into a Vector object.

	 *

	 * @return the vector

	 * @throws StatException the stat exception

	 */

	public Vector asVector() throws StatException {

		String symbol = prefixR + (nolex++);

		VectorImpl v = new VectorImpl(freqs, symbol);

		v.setRNames(getForms());

		this.symbol = v.getSymbol();

		return v;

	}

	/**

	 * Compute number of tokens. / this.nbr

	 */

	private void computeNumberOfTokens() {

		numberOfTokens = 0;

		for (int i = 0; i < freqs.length; i++) {

			numberOfTokens += freqs[i];

			// System.out.println(numberOfTokens);

			// if (freqs[i] != 1) System.out.println(freqs[i]);

		}

	}

	@Override

	public boolean delete() {

		if (corpus != null) {

			corpus.removeData(this);

		}

		return true;

	}

	/**

	 * Dump lexicon forms and frequencies in a String.

	 *

	 * @param col the col

	 * @param txt the txt

	 * @return the string

	 */

	public String dump(String col, String txt) {

		StringBuffer buffer = new StringBuffer();

		getForms();

		for (int i = 0; i < forms.length; i++) {

			buffer.append(txt+ forms[i].replace(txt, txt+txt) + txt + col + freqs[i] + "\n"); //$NON-NLS-1$ 

		}

		return buffer.toString();

	}

	/* (non-Javadoc)

	 * @see java.lang.Object#equals(java.lang.Object)

	 */

	@Override

	public boolean equals(Object obj) {

		if (!(obj instanceof Lexicon)) {

			return false;

		}

		Lexicon other = (Lexicon) obj;

		if (other.nbrOfType() != this.nbrOfType()) {

			return false;

		}

		return (Arrays.equals(freqs, other.getFreq()) && Arrays.equals(getForms(), other.getForms()));

	}

	/**

	 * The corpus or subcorpus this lexicon is build on.

	 * 

	 * @return the corpus

	 */

	public Corpus getCorpus() {

		return corpus;

	}

	public String getDetails() {

		return  this.corpus.getName() + " " + this.pProperty.getName(); //$NON-NLS-1$

	}

	//TODO: move this into a Lexicon chart renderer

	//	/**

	//	 * Draw a pareto graphic with this frequency list and record it into the

	//	 * provided filename into svg format.

	//	 *

	//	 * @param file where to save the pareto graphic.

	//	 * @return the pareto graphic

	//	 * @throws StatException if anything goes wrong.

	//	 */

	//	public void getParetoGraphic(File file) throws StatException {

	//		String rName = asVector().getSymbol();

	//		String expr = "pareto(" + rName + ")"; //$NON-NLS-1$ //$NON-NLS-2$

	//		try {

	//			RWorkspace.getRWorkspaceInstance().plot(file, expr, RDevice.SVG);

	//		} catch (Exception e) {

	//			throw new StatException(e);

	//		}

	//	}

	/**

	 * The dif ferent types in the lexicon, the type at the index <code>j</code>

	 * of this array have the frequency at index <code>j</code> in the array

	 * returned by {@link #getFreq()}.

	 * 

	 * @return types as an array of <code>String</code>

	 */

	public String[] getForms() {

		if (forms == null) {

			if(ids == null) {

				return new String[0];

			}

			try {

				forms = CorpusManager.getCorpusManager().getCqiClient().id2Str(pProperty.getQualifiedName(), ids);

			} catch (Exception e) {

				// TODO Auto-generated catch block

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

			}

		}

		return forms;

	}

	/**

	 * The dif ferent types in the lexicon, the type at the index <code>j</code>

	 * of this array have the frequency at index <code>j</code> in the array

	 * returned by {@link #getFreq()}.

	 *

	 * @param number the number

	 * @return types as an array of <code>String</code>

	 */

	public String[] getForms(int number) {

		//System.out.println("Lexicon("+this.property+" get forms. number="+number+", ids len="+ids.length);

		if (forms == null) {

			try {

				number = Math.min(number, ids.length);

				if (number <= 0) {

					return new String[0];

				}

				int[] subpositions = new int[number];

				System.arraycopy(ids, 0, subpositions, 0, number);

				return CorpusManager.getCorpusManager().getCqiClient().id2Str(pProperty.getQualifiedName(), subpositions);

			} catch (Exception e) {

				// TODO Auto-generated catch block

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

				return null;

			}

		} else {

			number = Math.min(number, ids.length);

			if (number <= 0) {

				return new String[0];

			}

			String[] subforms = new String[number];

			System.arraycopy(ids, 0, subforms, 0, number);

			return subforms;

		}

	}

	/**

	 * The dif ferent frequencies in the lexicon. See {@link #getForms()}.

	 * 

	 * @return frequencies as an array of <code>int</code>

	 */

	public int[] getFreq() {

		return freqs;

	}

	/**

	 * return the ids of the entries.

	 *

	 * @return types as an array of <code>String</code>

	 */

	public int[] getIds() {

		return ids;

	}

	public String getName() {

		try {

			return IndexCoreMessages.LEXICON_RESULT_TYPE + ": " + this.corpus.getSimpleName() + ": " + this.getSimpleName();	

		}

		catch(Exception e) {

		}

		return ""; //$NON-NLS-1$

	}

	/**

	 * The property this lexicon is build on.

	 * 

	 * @return the property

	 */

	public Property getProperty() {

		return pProperty;

	}

	public String getSimpleName() {

		try {

			return this.getProperty().getName();

		}

		catch(Exception e) {

		}

		return "";

	}

	/**

	 * Gets the symbol.

	 *

	 * @return the symbol

	 */

	public String getSymbol() {

		return this.symbol;

	}

	/**

	 * Hack frequencies using a map to set forms and frequencies

	 *

	 * @param corpus the corpus

	 * @param pProperty the property

	 * @param map the map

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

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

	 */

	public boolean hack(Map<String, Integer> map) {

		if (map.size() != forms.length) return false;

		//super(corpus);

		int size = map.size();

		int[] freqs = new int[size];

		String[] forms = map.keySet().toArray(new String[] {});

		for (int i = 0; i < forms.length; i++) {

			freqs[i] = map.get(forms[i]);

		}

		this.freqs = freqs;

		return true;

	}

	/**

	 * Protected on purpose: should be accessed through others initializer.

	 *

	 * @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)}.

	 */

	protected void init(TXMResult corpus, Property property, int[] freq, int[] ids) {

		if (freq.length != ids.length) {

			throw new IllegalArgumentException(IndexCoreMessages.Lexicon_0);

		}

		this.freqs = freq;

		this.ids = ids;

		this.forms = null;

		this.pProperty = property;

		this.corpus = (Corpus) corpus;

	}

	/**

	 * Number of tokens (sum of all the frequencies) in the corpus.

	 * 

	 * @return the size of the corpus or subcorpus.

	 */

	public int nbrOfToken() {

		if (numberOfTokens <= 0) {

			computeNumberOfTokens();

		}

		return numberOfTokens;

	}

	/**

	 * Number of dif ferent types in the frequency list.

	 * 

	 * @return number of types in the corpus or subcorpus.

	 */

	public int nbrOfType() {

		return freqs.length;

	}

	public void setParameters(Property property) {

		this.pProperty = property;

	}

	@Override

	public boolean setParameters(TXMParameters parameters) {

		try {

			Property p = (Property) parameters.get("properties");

			this.setParameters(p);

		} catch (Exception e) {

			Log.printStackTrace(e);

			return false;

		}

		return true;

	}

	/**

	 * Sets the symbol.

	 *

	 * @param symbol the new symbol

	 */

	public void setSymbol(String symbol) {

		this.symbol = symbol;

	}

	@Override

	public String toString() {

		return IndexCoreMessages.Lexicon_3 + getName();

	}

	/**

	 * To txt.

	 *

	 * @param outfile the outfile

	 * @param encoding the encoding

	 * @param colseparator the colseparator

	 * @param txtseparator the txtseparator

	 * @return true, if successful

	 */

	@Deprecated

	public boolean toTxt(File outfile, String encoding, String colseparator, String txtseparator) {

		// NK: writer declared as class attribute to perform a clean if the operation is interrupted

		// OutputStreamWriter writer;

		try {

			this.writer = new OutputStreamWriter(new FileOutputStream(outfile),

					encoding); 

		} catch (UnsupportedEncodingException e1) {

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

			return false;

		} catch (FileNotFoundException e1) {

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

			return false;

		}

		try {

			writer.write(this.dump(colseparator, txtseparator));

			writer.close();

		} catch (IOException e) {

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

			return false;

		}

		return true;

	}

	public void setProperty(Property property) {

		this.pProperty = property;

	}

//	/**

//	 * Find or build a lexicon given a Corpus (MainCorpus or SubCorpus).

//	 * 

//	 * @param corpus

//	 * @param property

//	 * @return a Lexicon. May return null if the lexicon forms or freqs are null.

//	 * @throws Exception 

//	 */

//	public static Lexicon getLexicon(Corpus corpus, Property property) throws Exception {

//		HashSet<Object> results = corpus.getStoredData(Lexicon.class);

//		for (Object result : results) {

//			Lexicon lex = (Lexicon)result;

//			if (lex.getProperty().equals(property)) {

//				return lex;

//			}

//		}

//

//		Lexicon lex = new Lexicon(corpus);

//		lex.setParameters(property);

//		if (lex.compute(null) && lex.getForms() != null && lex.getFreq() != null) {

//			corpus.storeData(lex);

//			return lex;

//		} else {

//			return null;

//		}

//	}

}

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

ComputeLexicalTable_0  = Computing the Lexical Table with {0}

ComputeLexicalTable_1  = Computing the Lexical Table {0} with the property {1}

ComputeLexicalTable_10 = Opening the lexical table.

ComputeLexicalTable_2  = No property

ComputeLexicalTable_5  = Can not create a lexical table with an Index created on a Corpus

ComputeLexicalTable_6  = Vocabularies must share the same properties: {0}

ComputeLexicalTable_7  = Vocabularies must share the same partition: {0}

ComputeLexicalTable_9  = LexicalTable dialog, failed to get corpus size: {0}

ComputeLexicalTable_0  = Calcul de la table lexicale avec {0}.

ComputeLexicalTable_1  = Calcul de la table lexicale {0} avec la propriété {1}.

ComputeLexicalTable_10 = Ouverture de la table lexicale.

	public static String ComputeLexicalTable_5;

	public static String ComputeLexicalTable_6;

	public static String ComputeLexicalTable_7;

import org.txm.core.messages.TXMCoreMessages;

import org.txm.rcp.editors.ITablableEditorInput;

						TXMCoreMessages.common_frequency };

		freqColumn.getColumn().setText(TXMCoreMessages.common_frequency); 

			anaPropLabel.setText(TXMCoreMessages.common_properties);

			if (p.getName().equals(TXMPreferences.DEFAULT_UNIT_PROPERTY)) {

import org.eclipse.osgi.util.NLS;

import org.txm.rcp.StatusLine;

import org.txm.rcp.TXMWindows;

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

import org.txm.utils.logger.Log;

			IWorkbenchWindow window = TXMWindows.getActiveWindow();

			if (vocabularies.size() == 0) {

				return false;

			}

			vocabularies = vocabularies.subList(0, 1);

			for (Index voc : vocabularies) {

				if (!voc.isComputedWithPartition()) {

					System.out.println(LexicalTableUIMessages.ComputeLexicalTable_5);

					StatusLine.setMessage(LexicalTableUIMessages.ComputeLexicalTable_5);

					return false;

				}

			}

			List<Property> properties = vocabularies.get(0).getProperties();

			for (Index voc : vocabularies) {

				if (!properties.equals(voc.getProperties())) {

					Log.warning(NLS.bind(LexicalTableUIMessages.ComputeLexicalTable_6, properties));

					return false;

				}

			}

			final Index firstIndex = vocabularies.get(0);

			Partition firstPartition = firstIndex.getPartition();

			for (Index voc : vocabularies) {

				if (!firstPartition.equals(voc.getPartition())) {

					Log.warning(NLS.bind(LexicalTableUIMessages.ComputeLexicalTable_7, firstPartition));

					return false;

				}

			}

			final Property property = properties.get(0);

			lexicalTable = new LexicalTable(firstIndex);

			lexicalTable.setUseAllOccurrences(useAllOccurrences);

			lexicalTable.setUnitProperty(property);

			// FIXME: useless?

			lexicalTable = new LexicalTable((Partition) selection);

		// Error

		else	{

			this.logCanNotCompute(selection);

		}

			if(partition != null) {

				freqColumn.setText(TXMCoreMessages.common_frequency + " T=" + partition.getTotalSize()); //$NON-NLS-1$

			}

			else {

				freqColumn.setText(TXMCoreMessages.common_frequency + " T=" + corpus.getSize()); //$NON-NLS-1$

			}

		freqColumn.setToolTipText(TXMCoreMessages.common_frequency);

import org.txm.core.results.TXMResult;

	 * @param partition

	/**

	 * Creates a partition dimensions result from the specified <link>Partition</link>.

	 * @param UUID

	 * @param partition

	 */

	public PartitionDimensions(String UUID, Partition partition) {

		super(UUID, partition);

	}

SpecificitiesTableEditor_0  = Le calcul des spécificités a échoué.

SpecificitiesTableEditor_0  = Failed to compute specificities.

import org.txm.rcp.swt.widget.structures.PropertiesComboViewer;

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

import org.txm.statsengine.r.core.messages.RCoreMessages;

	 * Unit property.

	 */

	@Parameter(key=SpecificitiesPreferences.UNIT_PROPERTY)

	protected PropertiesComboViewer unitPropertyComboViewer;

	/**

			// max score

			Composite parametersArea = this.getCommandParametersGroup();

			new Label(parametersArea, SWT.NONE).setText("Maximum score");

			this.maxScore = new Spinner(parametersArea, SWT.BORDER);

			this.maxScore.setToolTipText("The maximum score to display");

			this.maxScore.setMinimum(0);

			// unit property

			new Label(parametersArea, SWT.NONE).setText(TXMCoreMessages.common_property);

			this.unitPropertyComboViewer = new PropertiesComboViewer(parametersArea, this, true,

					Corpus.getFirstParentCorpus(this.getResult()).getOrderedProperties(),

					this.getResult().getUnitProperty(), false);

			// result area

			typeFrequencyColumn.setText(TXMCoreMessages.common_frequency + " " + SpecificitiesUIMessages.SpecificitiesTableEditor_11 + " " + this.getResult().getCorpusSize()); //$NON-NLS-1$ //$NON-NLS-2$

			typeFrequencyColumn.setToolTipText(typeFrequencyColumn.getText()); 

				System.err.println(NLS.bind(RCoreMessages.error_unexpectedErrorInRStatisticsEngine, e));

			TXMEditor.initContextMenu(this.specificitesTable, this.getSite(), this.viewer);

		} catch (Exception e) {

command.label = Specificities

command.name = Specificities

command.tooltip = Compute the specific words of each part of the selected item

editor.name = Specificities

page.name = Specificities

command.label = Специфичность

command.name = Специфичность

command.name.0 = Построить гистограмму выделенных строк

command.tooltip = Вычислить специфичные для каждой части слова

editor.name = Специфичность

page.name = Специфичность

command.label = Spécificitiés

command.name = Spécificités

command.name.0 = Calculer le diagramme en bâtons des lignes sélectionnées

command.tooltip = Calculer les mots spécifiques de chaque partie

editor.name = Spécificités

page.name = Spécificités

            categoryId="org.txm.rcp.category.txm"

            locationURI="popup:org.txm.specificities.rcp.editors.SpecificitiesEditor">

               icon="icons/functions/specificities_selection.png"

                  value="org.txm.specificities.rcp.editors.SpecificitiesEditor">

import org.eclipse.osgi.util.NLS;

			Log.info(NLS.bind(RCoreMessages.error_rserveIsAlreadyRunningOnPort, port));

	public static String error_unexpectedErrorInRStatisticsEngine;

error_errorWhileEvaluating                = ** R error: "{0}"\nwhile evaluating: {1} 

error_evaluationError                     = ** Evaluation error: {0}\n{1}.

error_failedToConnectToTheRWorkspace      = ** Failed to connect to the R Workspace.

error_failedToKillRServe                  = Failed to exec 'taskkill /IM Rserve.exe /F'.

error_failedToKillRServe2                 = Failed to exec 'tskill Rserve.exe'.

error_failedToKillRServe3                 = Failed to exec 'killall -9 Rserve-bin.so'.

error_failedToLoadLibrary                 = Failed to load the {0} library: {1}.

error_failedToRunREG                      = ** Failed to run REG to find the location of R program.

error_failedToStartRServe                 = Failed to start RServe.

error_matrixIsEmpty                       = Matrix is empty.

error_rserveIsAlreadyRunningOnPort        = Rserve is already running on port {0}.

error_rservePathNotSet                    = ** The Statistics Engine program path is not set and we could not find it.

error_unexpectedErrorInRStatisticsEngine  = Unexpected error R statistics engine: {0}.

info_connectingToRAt           = Connecting to R at {0}:{1}.

error_unexpectedErrorInRStatisticsEngine = Неожиданная ошибка в статистической машине R : {0}

error_evaluationError                     = ** Erreur d'évaluation : {0}\n{1}.

error_failedToConnectToTheRWorkspace      = ** Echec de connexion à l'espace de travail R.

error_failedToKillRServe                  = Echec de la commande 'taskkill /IM Rserve.exe /F'.

error_failedToKillRServe2                 = Echec de la commande 'tskill Rserve.exe'.

error_failedToKillRServe3                 = Echec de la commande 'killall -9 Rserve-bin.so'.

error_failedToLoadLibrary                 = La librairie {0} n'a pu être chargée : {1}.

error_failedToRunREG                      = ** Echec du lancement de REG pour localiser le programme R.

error_failedToStartRServe                 = Impossible de démarrer RServe.

error_matrixIsEmpty                       = La matrice est vide.

error_rserveIsAlreadyRunningOnPort        = Rserve est déja démarré sur le port {0}.

error_rservePathNotSet                    = ** Le chemin du programme du serveur statistique n'a pas été renseigné et sa recherche a échoué.

error_unexpectedErrorInRStatisticsEngine  = Erreur inattendue dans le moteur statistique R : {0}.

error_youNeedRSoftware                    = Vous avez besoin du logiciel 'R' et de configurer ses chemins via la fenêtre de préférences 'Outils/Préférences'.

info_connectingToRAt           = Connexion à R à {0}:{1}.

			System.out.println(RCoreMessages.error_failedToStartRServe);

			System.out.println(NLS.bind(RCoreMessages.error_evaluationError, e.getMessage(), exp));

import org.txm.index.core.functions.Lexicon;

  org.txm.libs.batik;bundle-version="0.0.0",