Laboratoire ICAR » Plateforme TXM

	 * Display format.

	 */

	public static final String FORMAT = "format"; //$NON-NLS-1$

	// charts

	public static final String CHART_GROUP_BY_LINES = "chart_group_by_lines"; //$NON-NLS-1$

		Preferences preferences = this.getDefaultPreferencesNode();

		preferences.put(FORMAT, "%,.1f"); //$NON-NLS-1$

		preferences.putInt(MAX_SCORE, 1000);

		preferences.putBoolean(CHART_GROUP_BY_LINES, false);

import org.txm.core.messages.TXMCoreMessages;

import org.txm.core.preferences.TXMPreferences;

import org.txm.core.results.Parameter;

import org.txm.core.results.TXMResult;

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

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

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

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

import org.txm.utils.TXMProgressMonitor;

import org.txm.utils.logger.Log;

/**

 * 

 */

public class Specificities extends TXMResult implements RResult {

	public static int MAXSPECIF = 1000;

	/** The indices. */

	private double[][] indices;

	/** The rowindex. */

	private int[] rowindex = null;

	/** The colindex. */

	private int[] colindex = null;

	/** The frequencies. */

	private int[][] frequencies = null;

	/** The colnames. */

	private List<String> colnames = null;

	/** The rownames. */

	private List<String> rownames = null;

	/** The symbol. */

	private String symbol;

	/** The writer. */

	@Deprecated

	private BufferedWriter writer;

	/**

	 * The table. contains **all** the corpus data necessary to compute the

	 * Specificities

	 */

	private LexicalTable lexicalTable;

	/**

	 * Maximum score.

	 */

	@Parameter(key = SpecificitiesPreferences.MAX_SCORE)

	protected int pMaxScore;

	/**

	 * Minimum score.

	 */

	protected int pMinScore;

	/**

	 * Creates a not computed Specificities.

	 * 

	 * @param parent

	public Specificities(LexicalTable parent) {

		super(parent);

	}

	/**

	 * Creates a not computed Specificities.

	 * 

	public Specificities(String parametersNodePath) {

		this(parametersNodePath, null);

	}

	/**

	 * Creates a not computed Specificities.

	 *

	public Specificities(String parametersNodePath, LexicalTable parent) {

		super(parametersNodePath, parent);

	}

	@Override

	public boolean loadParameters() {

		this.lexicalTable = (LexicalTable) this.parent;

		return true;

	}

	@Override

	public boolean saveParameters() {

		// nothing to do

		return true;

	}

	@Override

	protected boolean _compute(TXMProgressMonitor monitor) throws Exception {

		this.frequencies = null;

		// delete the specificities selection chart children since they can not be valid anymore if the unit property has changed

		// FIXME: doesn't work

		ILexicalTable data = this.lexicalTable.getData();

		return true;

	}

	/**

	 * Instantiates a new specificities result.

	 *

	 * @throws Exception the stat exception

	 */

	protected void init(String symbol, double[][] specIndex) throws Exception {

		if (this.symbol != null && this.symbol.equals(symbol)) {

			try {

				RWorkspace.getRWorkspaceInstance().removeVariableFromWorkspace(this.symbol);

			}

		}

		this.symbol = symbol;

		if (this.lexicalTable == null) {

			throw new IllegalArgumentException(SpecificitiesCoreMessages.theLexicalTableCannotBeNull);

		}

		// this.name = name;

		if (specIndex == null || specIndex.length == 0) {

			throw new IllegalArgumentException(SpecificitiesCoreMessages.noSpecificitiesIndexArray);

		}

			throw new IllegalArgumentException(

					SpecificitiesCoreMessages.theSpecificityIndexArrayDoesNotProperlyRepresentAMatrix);

		}

		this.indices = specIndex;

		this.colnames = Arrays.asList(lexicalTable.getColNames().asStringsArray());

		this.rownames = Arrays.asList(lexicalTable.getRowNames().asStringsArray());

		// filter by max&min

		int MAX = MAXSPECIF;

		int MIN = -MAXSPECIF;

		if (pMaxScore > 0) {

			MAX = pMaxScore;

			MIN = -pMaxScore;

		}

		// fixing max and min score values

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

			for (int j = 0; j < indices[i].length; j++) {

				}

			}

		}

		if (this.rownames != null && this.rownames.size() != 0) {

			if (this.rownames.size() != specIndex.length) {

				throw new IllegalArgumentException(

						SpecificitiesCoreMessages.bind(SpecificitiesCoreMessages.numberOfRowsWantedP0AndFoundP1Mismatch,

								this.rownames.size(), specIndex.length));

			}

			rowindex = ArrayIndex.getIndex(this.lexicalTable.getRowNames().asStringsArray(),

					this.rownames.toArray(new String[] {}));

			for (int i : rowindex) {

		// }

		// }

	}

	/**

	 * Utility method to compute the specificity index of a word in a subcorpus.

	 * <br>

		}

		return 0.0d;

	}

	/**

	 * Sets the unit property.

	 * 

	public void setUnitProperty(WordProperty unitProperty) {

		this.getLexicalTable().setUnitProperty(unitProperty);

	}

	/**

	 * Gets the type focus.

	 *

	public List<String> getTypeFocus() {

		return rownames;

	}

	/**

	 * Gets the part focus.

	 *

	public List<String> getPartFocus() {

		return colnames;

	}

	/**

	 * Gets the number of columns of the lexical table.

	 *

			return getColumnsNames().length;

		}

	}

	/**

	 * Gets the sum of all the columns frequencies.

	 *

			return 0;

		}

	}

	/**

	 * Gets the sums of each columns frequencies.

	 *

	 * @throws CqiClientException

	 */

	public int[] getColumnsFrequenciesSums() throws StatException, CqiClientException {

		if (

			Vector colsSizes = lexicalTable.getColMarginsVector();

			if (colindex != null) {

				colsSizes = colsSizes.get(colindex);

		// }

		// }

	}

	@Override

	public LexicalTable getParent() {

		return (LexicalTable) this.parent;

	}

	/**

	 * Gets the specificities index.

	 * 

	public double[][] getSpecificitesIndices() {

		return indices;

	}

	/**

	 * Name of the type for which specificities are computed.

	 *

	public String[] getRowNames() throws Exception {

		return lexicalTable.getRowNames().asStringsArray();

	}

	/**

	 * Gets the names of the lexical table columns.

	 *

	public String[] getColumnsNames() throws StatException {

		return lexicalTable.getColNames().asStringsArray();

	}

	/**

	 * Gets the frequencies of all columns.

	 *

			// if (lexicalTable != null) {

			// System.out.println("FROM TABLE");

			frequencies = RWorkspace.getRWorkspaceInstance().evalToInt2D(lexicalTable.getData().getSymbol());

			// }

			// else {// if table == null : subcorpus specif

			// //System.out.println("FROM LEXICON");

		}

		return frequencies;

	}

	/**

	 * Gets the lexical table.

	 *

	public LexicalTable getLexicalTable() {

		return lexicalTable;

	}

	/**

	 * The frequency in the whole corpus.

	 *

		// }

		return formFrequencies.asIntArray();

	}

	@Override

	public boolean _toTxt(File outfile, String encoding, String colseparator, String txtseparator) throws Exception {

		// NK: Declared as class attribute to perform a clean if the operation is

		// interrupted

		// OutputStreamWriter writer;

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

			return false;

		}

		// int[] T = getPartSize();

		acquireSemaphore();

		try {

		finally {

			releaseSemaphore();

		}

		return true;

	}

	/**

	 * release the R semaphore

	 */

		super.resetComputingState();

		releaseSemaphore();

	}

	@Override

	public void clean() {

		try {

			// TODO Auto-generated catch block

			e.printStackTrace();

		}

		try {

			if (this.writer != null) {

				this.writer.flush();

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

		}

	}

	@Override

	public String getRSymbol() {

		return this.symbol;

	}

	// /**

	// * Gets the sorted part indexes.

	// *

	// }

	// return new int[0];

	// }

	@Override

	public String getName() {

		// FIXME: SJ: to define

		return this.getParent().getParent().getName() + TXMPreferences.PARENT_NAME_SEPARATOR + this.getSimpleName();

	}

	@Override

	public String getSimpleName() {

		// FIXME: SJ: to define

			return this.getEmptyName();

		}

	}

	@Override

	public String getDetails() {

		return NLS.bind(this.getName() + " (max score={0})", this.pMaxScore); //$NON-NLS-1$

	}

	@Override

	public String getComputingStartMessage() {

		// from lexical table

			}

		}

	}

	@Override

	public boolean canCompute() {

		if (this.lexicalTable == null) {

			Log.severe("Specificities.canCompute(): can not compute without a lexical table.");

			return false;

		}

		// if (this.lexicalTable.getNColumns() < 2) {

		// Log.severe(SpecificitiesCoreMessages.ComputeError_NEED_AT_LEAST_2_PARTS);

		// return false;

		// }

		return this.lexicalTable.getProperty() != null;

	}

	/**

	 * @param maxScoreFilter the pMaxScore to set

	 */

	public void setMaxScoreFilter(int maxScoreFilter) {

		this.pMaxScore = maxScoreFilter;

	}

	/**

	 * @return the maxScore

	 */

	public int getMaxScore() {

		return pMaxScore;

	}

	/**

	 * @return the unitProperty

	 */

	public Property getUnitProperty() {

		return this.getLexicalTable().getProperty();

	}

	@Override

	public String getResultType() {

		return SpecificitiesCoreMessages.RESULT_TYPE;

import org.eclipse.swt.widgets.Spinner;

import org.eclipse.swt.widgets.Table;

import org.eclipse.swt.widgets.TableColumn;

import org.txm.Toolbox;

import org.txm.core.messages.TXMCoreMessages;

import org.txm.core.preferences.TXMPreferences;

import org.txm.core.results.Parameter;

import org.txm.rcp.editors.TXMEditor;

	@Parameter(key = TXMPreferences.V_MAX)

	protected Spinner vMaxSpinner;

	@Override

	public void _createPartControl() {

			this.maxScoreFilter.setMinimum(0);

			this.maxScoreFilter.setMaximum(100000);

			// Result area

			GLComposite resultArea = this.getResultArea();