source: src/main/java/weka/experiment/ResultMatrix.java @ 4

/*
 *    This program 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.
 *
 *    This program 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 this program; if not, write to the Free Software
 *    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

/*
 * ResultMatrix.java
 * Copyright (C) 2005 University of Waikato, Hamilton, New Zealand
 *
 */

package weka.experiment;

import weka.core.Option;
import weka.core.OptionHandler;
import weka.core.RevisionHandler;
import weka.core.Utils;

import java.io.Serializable;
import java.util.Enumeration;
import java.util.Vector;

/**
 * This matrix is a container for the datasets and classifier setups and 
 * their statistics. Derived classes output the data in different formats.
 * Derived classes need to implement the following methods:
 * <ul>
 *   <li><code>toStringMatrix()</code></li>
 *   <li><code>toStringKey()</code></li>
 *   <li><code>toStringHeader()</code></li>
 *   <li><code>toStringSummary()</code></li>
 *   <li><code>toStringRanking()</code></li>
 * </ul>
 *
 *
 * @author FracPete (fracpete at waikato dot ac dot nz)
 * @version $Revision: 5346 $
 * @see #toStringMatrix()
 * @see #toStringKey()
 * @see #toStringHeader()
 * @see #toStringSummary()
 * @see #toStringRanking()
 */
public abstract class ResultMatrix
  implements Serializable, RevisionHandler, OptionHandler {

  /** for serialization. */
  private static final long serialVersionUID = 4487179306428209739L;
  
  /** tie. */
  public final static int SIGNIFICANCE_TIE = 0;

  /** win. */
  public final static int SIGNIFICANCE_WIN = 1;

  /** loss. */
  public final static int SIGNIFICANCE_LOSS = 2;

  /** tie string. */
  public String TIE_STRING = " ";

  /** win string. */
  public String WIN_STRING = "v";

  /** loss string. */
  public String LOSS_STRING = "*";

  /** the left parentheses for enumerating cols/rows. */
  public String LEFT_PARENTHESES = "(";

  /** the right parentheses for enumerating cols/rows. */
  public String RIGHT_PARENTHESES = ")";

  /** the column names. */
  protected String[] m_ColNames = null;

  /** the row names. */
  protected String[] m_RowNames = null;

  /** whether a column is hidden. */
  protected boolean[] m_ColHidden = null;
  
  /** whether a row is hidden. */
  protected boolean[] m_RowHidden = null;
  
  /** the significance. */
  protected int[][] m_Significance = null;

  /** the values. */
  protected double[][] m_Mean = null;

  /** the standard deviation. */
  protected double[][] m_StdDev = null;

  /** the counts for the different datasets. */
  protected double[] m_Counts = null;

  /** the standard mean precision. */
  protected int m_MeanPrec;

  /** the standard std. deviation preicision. */
  protected int m_StdDevPrec;

  /** whether std. deviations are printed as well. */
  protected boolean m_ShowStdDev;

  /** whether the average for each column should be printed. */
  protected boolean m_ShowAverage;
  
  /** whether the names or numbers are output as column declarations. */
  protected boolean m_PrintColNames;

  /** whether the names or numbers are output as row declarations. */
  protected boolean m_PrintRowNames;

  /** whether a "(x)" is printed before each column name with "x" as the
   * index. */
  protected boolean m_EnumerateColNames;

  /** whether a "(x)" is printed before each row name with "x" as the index. */
  protected boolean m_EnumerateRowNames;

  /** the size of the names of the columns. */
  protected int m_ColNameWidth;

  /** the size of the names of the rows. */
  protected int m_RowNameWidth;

  /** the size of the mean columns. */
  protected int m_MeanWidth;

  /** the size of the std dev columns. */
  protected int m_StdDevWidth;

  /** the size of the significance columns. */
  protected int m_SignificanceWidth;

  /** the size of the counts. */
  protected int m_CountWidth;

  /** contains the keys for the header. */
  protected Vector m_HeaderKeys = null;

  /** contains the values for the header. */
  protected Vector m_HeaderValues = null;

  /** the non-significant wins. */
  protected int[][] m_NonSigWins = null;

  /** the significant wins. */
  protected int[][] m_Wins = null;

  /** the wins in ranking. */
  protected int[] m_RankingWins = null;

  /** the losses in ranking. */
  protected int[] m_RankingLosses = null;

  /** the difference between wins and losses. */
  protected int[] m_RankingDiff = null;

  /** the ordering of the rows. */
  protected int[] m_RowOrder = null;

  /** the ordering of the columns. */
  protected int[] m_ColOrder = null;

  /** whether to remove the filter name from the dataaset name. */
  protected boolean m_RemoveFilterName = false;
  
  /**
   * initializes the matrix as 1x1 matrix.
   */
  public ResultMatrix() {
    this(1, 1);
  }
  
  /**
   * initializes the matrix with the given dimensions.
   * 
   * @param cols        the number of columns
   * @param rows        the number of rows
   */
  public ResultMatrix(int cols, int rows) {
    setSize(cols, rows);
    clear();
  }

  /**
   * initializes the matrix with the values from the given matrix.
   * 
   * @param matrix      the matrix to get the values from
   */
  public ResultMatrix(ResultMatrix matrix) {
    assign(matrix);
  }
  
  /**
   * Returns a string describing the matrix.
   * 
   * @return            a description suitable for
   *                    displaying in the experimenter gui
   */
  public abstract String globalInfo();

  /**
   * Returns an enumeration of all the available options..
   *
   * @return            an enumeration of all available options.
   */
  public Enumeration listOptions() {
    Vector<Option>      result;
    
    result = new Vector<Option>();
    
    result.addElement(new Option(
        "\tThe number of decimals after the decimal point for the mean.\n"
        + "\t(default: " + getDefaultMeanPrec() + ")",
        "mean-prec", 1, "-mean-prec <int>"));
    
    result.addElement(new Option(
        "\tThe number of decimals after the decimal point for the mean.\n"
        + "\t(default: " + getDefaultStdDevPrec() + ")",
        "stddev-prec", 1, "-stddev-prec <int>"));
    
    result.addElement(new Option(
        "\tThe maximum width for the column names (0 = optimal).\n"
        + "\t(default: " + getDefaultColNameWidth() + ")",
        "col-name-width", 1, "-col-name-width <int>"));
    
    result.addElement(new Option(
        "\tThe maximum width for the row names (0 = optimal).\n"
        + "\t(default: " + getDefaultRowNameWidth() + ")",
        "row-name-width", 1, "-row-name-width <int>"));
    
    result.addElement(new Option(
        "\tThe width of the mean (0 = optimal).\n"
        + "\t(default: " + getDefaultMeanWidth() + ")",
        "mean-width", 1, "-mean-width <int>"));
    
    result.addElement(new Option(
        "\tThe width of the standard deviation (0 = optimal).\n"
        + "\t(default: " + getDefaultStdDevWidth() + ")",
        "stddev-width", 1, "-stddev-width <int>"));
    
    result.addElement(new Option(
        "\tThe width of the significance indicator (0 = optimal).\n"
        + "\t(default: " + getDefaultSignificanceWidth() + ")",
        "sig-width", 1, "-sig-width <int>"));
    
    result.addElement(new Option(
        "\tThe width of the counts (0 = optimal).\n"
        + "\t(default: " + getDefaultCountWidth() + ")",
        "count-width", 1, "-count-width <int>"));
    
    result.addElement(new Option(
        "\tWhether to display the standard deviation column.\n"
        + "\t(default: no)",
        "show-stddev", 0, "-show-stddev"));
    
    result.addElement(new Option(
        "\tWhether to show the row with averages.\n"
        + "\t(default: no)",
        "show-avg", 0, "-show-avg"));
    
    result.addElement(new Option(
        "\tWhether to remove the classname package prefixes from the\n"
        + "\tfilter names in datasets.\n"
        + "\t(default: no)",
        "remove-filter", 0, "-remove-filter"));
    
    result.addElement(new Option(
        "\tWhether to output column names or just numbers representing them.\n"
        + "\t(default: no)",
        "print-col-names", 0, "-print-col-names"));
    
    result.addElement(new Option(
        "\tWhether to output row names or just numbers representing them.\n"
        + "\t(default: no)",
        "print-row-names", 0, "-print-row-names"));
    
    result.addElement(new Option(
        "\tWhether to enumerate the column names (prefixing them with \n"
        + "\t'(x)', with 'x' being the index).\n"
        + "\t(default: no)",
        "enum-col-names", 0, "-enum-col-names"));
    
    result.addElement(new Option(
        "\tWhether to enumerate the row names (prefixing them with \n"
        + "\t'(x)', with 'x' being the index).\n"
        + "\t(default: no)",
        "enum-row-names", 0, "-enum-row-names"));
    
    return result.elements();
  }

  /**
   * Sets the OptionHandler's options using the given list. All options
   * will be set (or reset) during this call (i.e. incremental setting
   * of options is not possible).
   *
   * @param options     the list of options as an array of strings
   * @throws Exception  if an option is not supported
   */
  public void setOptions(String[] options) throws Exception {
    String      tmpStr;
    
    tmpStr = Utils.getOption("mean-prec", options);
    if (tmpStr.length() > 0)
      setMeanPrec(Integer.parseInt(tmpStr));
    else
      setMeanPrec(getDefaultMeanPrec());
    
    tmpStr = Utils.getOption("stddev-prec", options);
    if (tmpStr.length() > 0)
      setStdDevPrec(Integer.parseInt(tmpStr));
    else
      setStdDevPrec(getDefaultStdDevPrec());
    
    tmpStr = Utils.getOption("col-name-width", options);
    if (tmpStr.length() > 0)
      setColNameWidth(Integer.parseInt(tmpStr));
    else
      setColNameWidth(getDefaultColNameWidth());
    
    tmpStr = Utils.getOption("row-name-width", options);
    if (tmpStr.length() > 0)
      setRowNameWidth(Integer.parseInt(tmpStr));
    else
      setRowNameWidth(getDefaultRowNameWidth());
    
    tmpStr = Utils.getOption("mean-width", options);
    if (tmpStr.length() > 0)
      setMeanWidth(Integer.parseInt(tmpStr));
    else
      setMeanWidth(getDefaultMeanWidth());
    
    tmpStr = Utils.getOption("stddev-width", options);
    if (tmpStr.length() > 0)
      setStdDevWidth(Integer.parseInt(tmpStr));
    else
      setStdDevWidth(getDefaultStdDevWidth());
    
    tmpStr = Utils.getOption("sig-width", options);
    if (tmpStr.length() > 0)
      setSignificanceWidth(Integer.parseInt(tmpStr));
    else
      setSignificanceWidth(getDefaultSignificanceWidth());
    
    tmpStr = Utils.getOption("count-width", options);
    if (tmpStr.length() > 0)
      setStdDevPrec(Integer.parseInt(tmpStr));
    else
      setStdDevPrec(getDefaultCountWidth());

    setShowStdDev(Utils.getFlag("show-stddev", options));

    setShowAverage(Utils.getFlag("show-avg", options));

    setRemoveFilterName(Utils.getFlag("remove-filter", options));

    setPrintColNames(Utils.getFlag("print-col-names", options));

    setPrintRowNames(Utils.getFlag("print-row-names", options));

    setEnumerateColNames(Utils.getFlag("enum-col-names", options));

    setEnumerateRowNames(Utils.getFlag("enum-row-names", options));
  }

  /**
   * Gets the current option settings for the OptionHandler.
   *
   * @return the list of current option settings as an array of strings
   */
  public String[] getOptions() {
    Vector<String>      result;
    
    result = new Vector<String>();
    
    result.add("-mean-prec");
    result.add("" + getMeanPrec());
    
    result.add("-stddev-prec");
    result.add("" + getStdDevPrec());
    
    result.add("-col-name-width");
    result.add("" + getColNameWidth());
    
    result.add("-row-name-width");
    result.add("" + getRowNameWidth());
    
    result.add("-mean-width");
    result.add("" + getMeanWidth());
    
    result.add("-stddev-width");
    result.add("" + getStdDevWidth());
    
    result.add("-sig-width");
    result.add("" + getSignificanceWidth());
    
    result.add("-count-width");
    result.add("" + getCountWidth());

    if (getShowStdDev())
      result.add("-show-stddev");

    if (getShowAverage())
      result.add("-show-avg");

    if (getRemoveFilterName())
      result.add("-remove-filter");

    if (getPrintColNames())
      result.add("-print-col-names");

    if (getPrintRowNames())
      result.add("-print-row-names");

    if (getEnumerateColNames())
      result.add("-enum-col-names");

    if (getEnumerateRowNames())
      result.add("-enum-row-names");
    
    return result.toArray(new String[result.size()]);
  }

  /**
   * returns the name of the output format.
   * 
   * @return            the display name
   */
  public abstract String getDisplayName();

  /**
   * acquires the data from the given matrix.
   * 
   * @param matrix      the matrix to get the data from
   */
  public void assign(ResultMatrix matrix) {
    int         i;
    int         n;
    
    setSize(matrix.getColCount(), matrix.getRowCount());
    
    // output parameters
    TIE_STRING          = matrix.TIE_STRING;
    WIN_STRING          = matrix.WIN_STRING;
    LOSS_STRING         = matrix.LOSS_STRING;
    LEFT_PARENTHESES    = matrix.LEFT_PARENTHESES;
    RIGHT_PARENTHESES   = matrix.RIGHT_PARENTHESES;
    m_MeanPrec          = matrix.m_MeanPrec;
    m_StdDevPrec        = matrix.m_StdDevPrec;
    m_ShowStdDev        = matrix.m_ShowStdDev;
    m_ShowAverage       = matrix.m_ShowAverage;
    m_PrintColNames     = matrix.m_PrintColNames;
    m_PrintRowNames     = matrix.m_PrintRowNames;
    m_EnumerateColNames = matrix.m_EnumerateColNames;
    m_EnumerateRowNames = matrix.m_EnumerateRowNames;
    m_RowNameWidth      = matrix.m_RowNameWidth;
    m_MeanWidth         = matrix.m_MeanWidth;
    m_StdDevWidth       = matrix.m_StdDevWidth;
    m_SignificanceWidth = matrix.m_SignificanceWidth;
    m_CountWidth        = matrix.m_CountWidth;
    m_RemoveFilterName  = matrix.m_RemoveFilterName;
    
    // header
    m_HeaderKeys   = (Vector) matrix.m_HeaderKeys.clone();
    m_HeaderValues = (Vector) matrix.m_HeaderValues.clone();

    // matrix
    for (i = 0; i < matrix.m_Mean.length; i++) {
      for (n = 0; n < matrix.m_Mean[i].length; n++) {
        m_Mean[i][n]         = matrix.m_Mean[i][n];
        m_StdDev[i][n]       = matrix.m_StdDev[i][n];
        m_Significance[i][n] = matrix.m_Significance[i][n];
      }
    }

    for (i = 0; i < matrix.m_ColNames.length; i++) {
      m_ColNames[i]  = matrix.m_ColNames[i];
      m_ColHidden[i] = matrix.m_ColHidden[i];
    }

    for (i = 0; i < matrix.m_RowNames.length; i++) {
      m_RowNames[i]  = matrix.m_RowNames[i];
      m_RowHidden[i] = matrix.m_RowHidden[i];
    }

    for (i = 0; i < matrix.m_Counts.length; i++)
      m_Counts[i] = matrix.m_Counts[i];

    // summary
    if (matrix.m_NonSigWins != null) {
      m_NonSigWins = new int[matrix.m_NonSigWins.length][];
      m_Wins       = new int[matrix.m_NonSigWins.length][];
      for (i = 0; i < matrix.m_NonSigWins.length; i++) {
        m_NonSigWins[i] = new int[matrix.m_NonSigWins[i].length];
        m_Wins[i]       = new int[matrix.m_NonSigWins[i].length];

        for (n = 0; n < matrix.m_NonSigWins[i].length; n++) {
          m_NonSigWins[i][n] = matrix.m_NonSigWins[i][n];
          m_Wins[i][n]       = matrix.m_Wins[i][n];
        }
      }
    }

    // ranking
    if (matrix.m_RankingWins != null) {
      m_RankingWins   = new int[matrix.m_RankingWins.length];
      m_RankingLosses = new int[matrix.m_RankingWins.length];
      m_RankingDiff   = new int[matrix.m_RankingWins.length];
      for (i = 0; i < matrix.m_RankingWins.length; i++) {
        m_RankingWins[i]   = matrix.m_RankingWins[i];
        m_RankingLosses[i] = matrix.m_RankingLosses[i];
        m_RankingDiff[i]   = matrix.m_RankingDiff[i];
      }
    }
  }

  /**
   * removes the stored data and the ordering, but retains the dimensions of
   * the matrix.
   */
  public void clear() {
    m_MeanPrec          = getDefaultMeanPrec();
    m_StdDevPrec        = getDefaultStdDevPrec();
    m_ShowStdDev        = getDefaultShowStdDev();
    m_ShowAverage       = getDefaultShowAverage();
    m_RemoveFilterName  = getDefaultRemoveFilterName();
    m_PrintColNames     = getDefaultPrintColNames();
    m_PrintRowNames     = getDefaultPrintRowNames();
    m_EnumerateColNames = getDefaultEnumerateColNames();
    m_EnumerateRowNames = getDefaultEnumerateRowNames();
    m_RowNameWidth      = getDefaultRowNameWidth();
    m_ColNameWidth      = getDefaultColNameWidth();
    m_MeanWidth         = getDefaultMeanWidth();
    m_StdDevWidth       = getDefaultStdDevWidth();
    m_SignificanceWidth = getDefaultSignificanceWidth();
    m_CountWidth        = getDefaultCountWidth();

    setSize(getColCount(), getRowCount());
  }

  /**
   * clears the content of the matrix and sets the new size.
   * 
   * @param cols        the number of mean columns
   * @param rows        the number of mean rows
   */
  public void setSize(int cols, int rows) {
    int       i;
    int       n;

    m_ColNames     = new String[cols];
    m_RowNames     = new String[rows];
    m_Counts       = new double[rows];
    m_ColHidden    = new boolean[cols];
    m_RowHidden    = new boolean[rows];
    m_Mean         = new double[rows][cols];
    m_Significance = new int[rows][cols];
    m_StdDev       = new double[rows][cols];
    m_ColOrder     = null;
    m_RowOrder     = null;

    // NaN means that there exists no value! -> toArray()
    for (i = 0; i < m_Mean.length; i++) {
      for (n = 0; n < m_Mean[i].length; n++)
        m_Mean[i][n]   = Double.NaN;
    }

    for (i = 0; i < m_ColNames.length; i++)
      m_ColNames[i] = "col" + i;
    for (i = 0; i < m_RowNames.length; i++)
      m_RowNames[i] = "row" + i;

    clearHeader();
    clearSummary();
    clearRanking();
  }

  /**
   * sets the precision for the means.
   * 
   * @param prec        the number of decimals
   */
  public void setMeanPrec(int prec) {
    if (prec >= 0)
      m_MeanPrec = prec;
  }

  /**
   * returns the current precision for the means.
   * 
   * @return            the number of decimals
   */
  public int getMeanPrec() {
    return m_MeanPrec;
  }

  /**
   * returns the default precision for the means.
   * 
   * @return            the number of decimals
   */
  public int getDefaultMeanPrec() {
    return 2;
  }
  
  /**
   * Returns the tip text for this property.
   * 
   * @return            tip text for this property suitable for
   *                    displaying in the experimenter gui
   */
  public String meanPrecTipText() {
    return "The number of decimals after the decimal point for the mean.";
  }

  /**
   * sets the precision for the standard deviation.
   * 
   * @param prec        the number of decimals
   */
  public void setStdDevPrec(int prec) {
    if (prec >= 0)
      m_StdDevPrec = prec;
  }

  /**
   * returns the current standard deviation precision.
   * 
   * @return            the number of decimals
   */
  public int getStdDevPrec() {
    return m_StdDevPrec;
  }

  /**
   * returns the default standard deviation precision.
   * 
   * @return            the number of decimals
   */
  public int getDefaultStdDevPrec() {
    return 2;
  }
  
  /**
   * Returns the tip text for this property.
   * 
   * @return            tip text for this property suitable for
   *                    displaying in the experimenter gui
   */
  public String stdDevPrecTipText() {
    return "The number of decimals after the decimal point for the standard deviation.";
  }

  /**
   * sets the width for the column names (0 = optimal).
   * 
   * @param width       the width
   */
  public void setColNameWidth(int width) {
    if (width >= 0)
      m_ColNameWidth = width;
  }

  /**
   * returns the current width for the column names.
   * 
   * @return            the width
   */
  public int getColNameWidth() {
    return m_ColNameWidth;
  }

  /**
   * returns the default width for the column names.
   * 
   * @return            the width
   */
  public int getDefaultColNameWidth() {
    return 0;
  }
  
  /**
   * Returns the tip text for this property.
   * 
   * @return            tip text for this property suitable for
   *                    displaying in the experimenter gui
   */
  public String colNameWidthTipText() {
    return "The maximum width of the column names (0 = optimal).";
  }

  /**
   * sets the width for the row names (0 = optimal).
   * 
   * @param width       the width
   */
  public void setRowNameWidth(int width) {
    if (width >= 0)
      m_RowNameWidth = width;
  }

  /**
   * returns the current width for the row names.
   * 
   * @return            the width
   */
  public int getRowNameWidth() {
    return m_RowNameWidth;
  }

  /**
   * returns the default width for the row names.
   * 
   * @return            the width
   */
  public int getDefaultRowNameWidth() {
    return 0;
  }
  
  /**
   * Returns the tip text for this property.
   * 
   * @return            tip text for this property suitable for
   *                    displaying in the experimenter gui
   */
  public String rowNameWidthTipText() {
    return "The maximum width for the row names (0 = optimal).";
  }
  
  /**
   * sets the width for the mean (0 = optimal).
   * 
   * @param width       the width
   */
  public void setMeanWidth(int width) {
    if (width >= 0)
      m_MeanWidth = width;
  }

  /**
   * returns the current width for the mean.
   * 
   * @return            the width
   */
  public int getMeanWidth() {
    return m_MeanWidth;
  }

  /**
   * returns the default width for the mean.
   * 
   * @return            the width
   */
  public int getDefaultMeanWidth() {
    return 0;
  }
  
  /**
   * Returns the tip text for this property.
   * 
   * @return            tip text for this property suitable for
   *                    displaying in the experimenter gui
   */
  public String meanWidthTipText() {
    return "The width of the mean (0 = optimal).";
  }

  /**
   * sets the width for the std dev (0 = optimal).
   * 
   * @param width       the width
   */
  public void setStdDevWidth(int width) {
    if (width >= 0)
      m_StdDevWidth = width;
  }

  /**
   * returns the current width for the std dev.
   * 
   * @return            the width
   */
  public int getStdDevWidth() {
    return m_StdDevWidth;
  }

  /**
   * returns the default width for the std dev.
   * 
   * @return            the width
   */
  public int getDefaultStdDevWidth() {
    return 0;
  }
  
  /**
   * Returns the tip text for this property.
   * 
   * @return            tip text for this property suitable for
   *                    displaying in the experimenter gui
   */
  public String stdDevWidthTipText() {
    return "The width of the standard deviation (0 = optimal).";
  }

  /**
   * sets the width for the significance (0 = optimal).
   * 
   * @param width       the width
   */
  public void setSignificanceWidth(int width) {
    if (width >= 0)
      m_SignificanceWidth = width;
  }

  /**
   * returns the current width for the significance.
   * 
   * @return            the width
   */
  public int getSignificanceWidth() {
    return m_SignificanceWidth;
  }

  /**
   * returns the default width for the significance.
   * 
   * @return            the width
   */
  public int getDefaultSignificanceWidth() {
    return 0;
  }
  
  /**
   * Returns the tip text for this property.
   * 
   * @return            tip text for this property suitable for
   *                    displaying in the experimenter gui
   */
  public String significanceWidthTipText() {
    return "The width of the significance indicator (0 = optimal).";
  }

  /**
   * sets the width for the counts (0 = optimal).
   * 
   * @param width       the width
   */
  public void setCountWidth(int width) {
    if (width >= 0)
      m_CountWidth = width;
  }

  /**
   * returns the current width for the counts.
   * 
   * @return            the width
   */
  public int getCountWidth() {
    return m_CountWidth;
  }

  /**
   * returns the default width for the counts.
   * 
   * @return            the width
   */
  public int getDefaultCountWidth() {
    return 0;
  }
  
  /**
   * Returns the tip text for this property.
   * 
   * @return            tip text for this property suitable for
   *                    displaying in the experimenter gui
   */
  public String countWidthTipText() {
    return "The width of the counts (0 = optimal).";
  }

  /**
   * sets whether to display the std deviations or not.
   * 
   * @param show        if true then the std deviations are displayed
   */
  public void setShowStdDev(boolean show) {
    m_ShowStdDev = show;
  }

  /**
   * returns whether std deviations are displayed or not.
   * 
   * @return            true if the std deviations are displayed
   */
  public boolean getShowStdDev() {
    return m_ShowStdDev;
  }

  /**
   * returns the default of whether std deviations are displayed or not.
   * 
   * @return            true if the std deviations are displayed
   */
  public boolean getDefaultShowStdDev() {
    return false;
  }
  
  /**
   * Returns the tip text for this property.
   * 
   * @return            tip text for this property suitable for
   *                    displaying in the experimenter gui
   */
  public String showStdDevTipText() {
    return "Whether to display the standard deviation column.";
  }

  /**
   * sets whether to display the average per column or not.
   * 
   * @param show        if true then the average is displayed
   */
  public void setShowAverage(boolean show) {
    m_ShowAverage = show;
  }

  /**
   * returns whether average per column is displayed or not.
   * 
   * @return            true if the average is displayed
   */
  public boolean getShowAverage() {
    return m_ShowAverage;
  }

  /**
   * returns the default of whether average per column is displayed or not.
   * 
   * @return            true if the average is displayed
   */
  public boolean getDefaultShowAverage() {
    return false;
  }
  
  /**
   * Returns the tip text for this property.
   * 
   * @return            tip text for this property suitable for
   *                    displaying in the experimenter gui
   */
  public String showAverageTipText() {
    return "Whether to show the row with averages.";
  }

  /**
   * sets whether to remove the filter classname from the dataset name.
   * 
   * @param remove      if true then the filter classnames are shortened
   */
  public void setRemoveFilterName(boolean remove) {
    m_RemoveFilterName = remove;
  }

  /**
   * returns whether the filter classname is removed from the dataset name.
   * 
   * @return            true if the filter classnames are shortened
   */
  public boolean getRemoveFilterName() {
    return m_RemoveFilterName;
  }

  /**
   * returns the default of whether the filter classname is removed from the 
   * dataset name.
   * 
   * @return            true if the filter classnames are shortened
   */
  public boolean getDefaultRemoveFilterName() {
    return false;
  }
  
  /**
   * Returns the tip text for this property.
   * 
   * @return            tip text for this property suitable for
   *                    displaying in the experimenter gui
   */
  public String removeFilterNameTipText() {
    return "Whether to remove the classname package prefixes from the filter names in datasets.";
  }

  /**
   * sets whether the column names or numbers instead are printed.
   * deactivating automatically sets m_EnumerateColNames to TRUE.
   * 
   * @param print       if true then the names are printed instead of numbers
   * @see               #setEnumerateColNames(boolean)
   */
  public void setPrintColNames(boolean print) {
    m_PrintColNames = print;
    if (!print)
      setEnumerateColNames(true);
  }

  /**
   * returns whether column names or numbers instead are printed.
   * 
   * @return            true if names instead of numbers are printed
   */
  public boolean getPrintColNames() {
    return m_PrintColNames;
  }

  /**
   * returns the default of whether column names or numbers instead are printed.
   * 
   * @return            true if names instead of numbers are printed
   */
  public boolean getDefaultPrintColNames() {
    return true;
  }
  
  /**
   * Returns the tip text for this property.
   * 
   * @return            tip text for this property suitable for
   *                    displaying in the experimenter gui
   */
  public String printColNamesTipText() {
    return "Whether to output column names or just numbers representing them.";
  }

  /**
   * sets whether the row names or numbers instead are printed
   * deactivating automatically sets m_EnumerateColNames to TRUE.
   * 
   * @param print       if true then names instead of numbers are printed
   * @see               #setEnumerateRowNames(boolean)
   */
  public void setPrintRowNames(boolean print) {
    m_PrintRowNames = print;
    if (!print)
      setEnumerateRowNames(true);
  }

  /**
   * returns whether row names or numbers instead are printed.
   * 
   * @return            true if names instead of numbers are printed
   */
  public boolean getPrintRowNames() {
    return m_PrintRowNames;
  }

  /**
   * returns the default of whether row names or numbers instead are printed.
   * 
   * @return            true if names instead of numbers are printed
   */
  public boolean getDefaultPrintRowNames() {
    return true;
  }
  
  /**
   * Returns the tip text for this property.
   * 
   * @return            tip text for this property suitable for
   *                    displaying in the experimenter gui
   */
  public String printRowNamesTipText() {
    return "Whether to output row names or just numbers representing them.";
  }

  /**
   * sets whether the column names are prefixed with "(x)" where "x" is
   * the index.
   * 
   * @param enumerate   if true then the names are prefixed
   */
  public void setEnumerateColNames(boolean enumerate) {
    m_EnumerateColNames = enumerate;
  }

  /**
   * returns whether column names are prefixed with the index.
   * 
   * @return            true if the names are prefixed
   */
  public boolean getEnumerateColNames() {
    return m_EnumerateColNames;
  }

  /**
   * returns the default of whether column names are prefixed with the index.
   * 
   * @return            true if the names are prefixed
   */
  public boolean getDefaultEnumerateColNames() {
    return true;
  }
  
  /**
   * Returns the tip text for this property.
   * 
   * @return            tip text for this property suitable for
   *                    displaying in the experimenter gui
   */
  public String enumerateColNamesTipText() {
    return "Whether to enumerate the column names (prefixing them with '(x)', with 'x' being the index).";
  }

  /**
   * sets whether to the row names are prefixed with the index.
   * 
   * @param enumerate   if true then the names will be prefixed
   */
  public void setEnumerateRowNames(boolean enumerate) {
    m_EnumerateRowNames = enumerate;
  }

  /**
   * returns whether row names or prefixed with the index.
   * 
   * @return            true if the names are prefixed
   */
  public boolean getEnumerateRowNames() {
    return m_EnumerateRowNames;
  }

  /**
   * returns theh default of whether row names are prefixed with the index.
   * 
   * @return            true if the names are prefixed
   */
  public boolean getDefaultEnumerateRowNames() {
    return false;
  }
  
  /**
   * Returns the tip text for this property.
   * 
   * @return            tip text for this property suitable for
   *                    displaying in the experimenter gui
   */
  public String enumerateRowNamesTipText() {
    return "Whether to enumerate the row names (prefixing them with '(x)', with 'x' being the index).";
  }

  /**
   * returns the number of columns.
   * 
   * @return            the number of columns
   */
  public int getColCount() {
    return m_ColNames.length;
  }

  /**
   * returns the number of visible columns.
   * 
   * @return            the number of columns
   */
  public int getVisibleColCount() {
    int         cols;
    int         i;
    
    cols = 0;
    for (i = 0; i < getColCount(); i++) {
      if (!getColHidden(i))
        cols++;
    }

    return cols;
  }

  /**
   * returns the number of rows.
   * 
   * @return            the number of rows
   */
  public int getRowCount() {
    return m_RowNames.length;
  }

  /**
   * returns the number of visible rows.
   * 
   * @return            the number of rows
   */
  public int getVisibleRowCount() {
    int         rows;
    int         i;
    
    rows= 0;
    for (i = 0; i < getRowCount(); i++) {
      if (!getRowHidden(i))
        rows++;
    }

    return rows;
  }
  
  /**
   * sets the name of the column (if the index is valid).
   * 
   * @param index       the index of the column
   * @param name        the name of the column
   */
  public void setColName(int index, String name) {
    if ( (index >= 0) && (index < getColCount()) )
      m_ColNames[index] = name;
  }

  /**
   * returns the name of the row, if the index is valid, otherwise null.
   * if getPrintColNames() is FALSE then an empty string is returned or if
   * getEnumerateColNames() is TRUE then the 1-based index surrounded by
   * parentheses.
   * 
   * @param index       the index of the column
   * @return            the name of the column
   * @see               #setPrintColNames(boolean)
   * @see               #getPrintColNames()
   * @see               #setEnumerateColNames(boolean)
   * @see               #getEnumerateColNames()
   */
  public String getColName(int index) {
    String        result;
    
    result = null;
    
    if ( (index >= 0) && (index < getColCount()) ) {
      if (getPrintColNames())
        result = m_ColNames[index];
      else
        result = "";

      if (getEnumerateColNames()) {
        result =   LEFT_PARENTHESES 
                 + Integer.toString(index + 1) 
                 + RIGHT_PARENTHESES
                 + " " + result;
        result = result.trim();
      }
    }

    return result;
  }

  /**
   * sets the name of the row (if the index is valid).
   * 
   * @param index       the index of the row
   * @param name        the name of the row
   */
  public void setRowName(int index, String name) {
    if ( (index >= 0) && (index < getRowCount()) )
      m_RowNames[index] = name;
  }

  /**
   * returns the name of the row, if the index is valid, otherwise null.
   * if getPrintRowNames() is FALSE then an empty string is returned or if
   * getEnumerateRowNames() is TRUE then the 1-based index surrounded by
   * parentheses.
   * 
   * @param index       the index of the row
   * @return            the name of the row
   * @see               #setPrintRowNames(boolean)
   * @see               #getPrintRowNames()
   * @see               #setEnumerateRowNames(boolean)
   * @see               #getEnumerateRowNames()
   */
  public String getRowName(int index) {
    String        result;
    
    result = null;
    
    if ( (index >= 0) && (index < getRowCount()) ) {
      if (getPrintRowNames())
        result = m_RowNames[index];
      else
        result = "";

      if (getEnumerateRowNames()) {
        result =   LEFT_PARENTHESES 
                 + Integer.toString(index + 1) 
                 + RIGHT_PARENTHESES
                 + " " + result;
        result = result.trim();
      }
    }
    
    return result;
  }

  /**
   * sets the hidden status of the column (if the index is valid).
   * 
   * @param index       the index of the column
   * @param hidden      the hidden status of the column
   */
  public void setColHidden(int index, boolean hidden) {
    if ( (index >= 0) && (index < getColCount()) )
      m_ColHidden[index] = hidden;
  }

  /**
   * returns the hidden status of the column, if the index is valid, otherwise
   * false.
   * 
   * @param index       the index of the column
   * @return            true if hidden
   */
  public boolean getColHidden(int index) {
    if ( (index >= 0) && (index < getColCount()) )
      return m_ColHidden[index];
    else
      return false;
  }

  /**
   * sets the hidden status of the row (if the index is valid).
   * 
   * @param index       the index of the row
   * @param hidden      the hidden status of the row
   */
  public void setRowHidden(int index, boolean hidden) {
    if ( (index >= 0) && (index < getRowCount()) )
      m_RowHidden[index] = hidden;
  }

  /**
   * returns the hidden status of the row, if the index is valid, otherwise
   * false.
   * 
   * @param index       the index of the row
   * @return            true if hidden
   */
  public boolean getRowHidden(int index) {
    if ( (index >= 0) && (index < getRowCount()) )
      return m_RowHidden[index];
    else
      return false;
  }

  /**
   * sets the count for the row (if the index is valid).
   * 
   * @param index       the index of the row
   * @param count       the count for the row
   */
  public void setCount(int index, double count) {
    if ( (index >= 0) && (index < getRowCount()) )
      m_Counts[index] = count;
  }

  /**
   * returns the count for the row. if the index is invalid then 0.
   * 
   * @param index       the index of the row
   * @return            the count for the row
   */
  public double getCount(int index) {
    if ( (index >= 0) && (index < getRowCount()) )
      return m_Counts[index];
    else
      return 0;
  }

  /**
   * sets the mean at the given position (if the position is valid).
   * 
   * @param col         the column of the mean
   * @param row         the row of the mean
   * @param value       the value of the mean
   */
  public void setMean(int col, int row, double value) {
    if (    (col >= 0) && (col < getColCount()) 
         && (row >= 0) && (row < getRowCount()) )
      m_Mean[row][col] = value;
  }

  /**
   * returns the mean at the given position, if the position is valid,
   * otherwise 0.
   * 
   * @param col         the column index
   * @param row         the row index
   * @return            the mean
   */
  public double getMean(int col, int row) {
    if (    (col >= 0) && (col < getColCount()) 
         && (row >= 0) && (row < getRowCount()) )
      return m_Mean[row][col];
    else
      return 0;
  }

  /**
   * returns the average of the mean at the given position, if the position is
   * valid, otherwise 0.
   * 
   * @param col         the column index
   * @return            the average
   */
  public double getAverage(int col) {
    int       i;
    double    avg;
    int       count;

    if ( (col >= 0) && (col < getColCount()) ) {
      avg   = 0;
      count = 0;

      for (i = 0; i < getRowCount(); i++) {
        if (!Double.isNaN(getMean(col, i))) {
          avg += getMean(col, i);
          count++;
        }
      }
      
      return avg / (double) count;
    }
    else {
      return 0;
    }
  }

  /**
   * sets the std deviation at the given position (if the position is valid).
   * 
   * @param col         the column of the std. deviation
   * @param row         the row of the std deviation
   * @param value       the value of the std deviation
   */
  public void setStdDev(int col, int row, double value) {
    if (    (col >= 0) && (col < getColCount()) 
         && (row >= 0) && (row < getRowCount()) )
      m_StdDev[row][col] = value;
  }

  /**
   * returns the std deviation at the given position, if the position is valid,
   * otherwise 0.
   * 
   * @param col         the column index
   * @param row         the row index
   * @return            the std deviation
   */
  public double getStdDev(int col, int row) {
    if (    (col >= 0) && (col < getColCount()) 
         && (row >= 0) && (row < getRowCount()) )
      return m_StdDev[row][col];
    else
      return 0;
  }

  /**
   * sets the significance at the given position (if the position is valid).
   * 
   * @param col         the column of the significance
   * @param row         the row of the significance
   * @param value       the value of the significance
   */
  public void setSignificance(int col, int row, int value) {
    if (    (col >= 0) && (col < getColCount()) 
         && (row >= 0) && (row < getRowCount()) )
      m_Significance[row][col] = value;
  }

  /**
   * returns the significance at the given position, if the position is valid,
   * otherwise SIGNIFICANCE_ATIE.
   * 
   * @param col         the column index
   * @param row         the row index
   * @return            the indicator
   */
  public int getSignificance(int col, int row) {
    if (    (col >= 0) && (col < getColCount()) 
         && (row >= 0) && (row < getRowCount()) )
      return m_Significance[row][col];
    else
      return SIGNIFICANCE_TIE;
  }

  /**
   * counts the occurrences of the given significance type in the given
   * column.
   * 
   * @param col         the columnn to gather the information from
   * @param type        the significance type, WIN/TIE/LOSS
   * @return            the count
   */
  public int getSignificanceCount(int col, int type) {
    int       result;
    int       i;

    result = 0;

    if ( (col >= 0) && (col < getColCount()) ) {
      for (i = 0; i < getRowCount(); i++) {
        if (getRowHidden(i))
          continue;

        // no value?
        if (Double.isNaN(getMean(col, i)))
          continue;

        if (getSignificance(col, i) == type)
          result++;
      }
    }

    return result;
  }

  /**
   * sets the ordering of the rows, null means default.
   * 
   * @param order       the new order of the rows
   */
  public void setRowOrder(int[] order) {
    int         i;
    
    // default order?
    if (order == null) {
      m_RowOrder = null;
    }
    else {
      if (order.length == getRowCount()) {
        m_RowOrder = new int[order.length];
        for (i = 0; i < order.length; i++)
          m_RowOrder[i] = order[i];
      }
      else {
        System.err.println("setRowOrder: length does not match (" 
            + order.length + " <> " + getRowCount() + ") - ignored!");
      }
    }
  }

  /**
   * returns the current order of the rows, null means the default order.
   * 
   * @return            the current order of the rows
   */
  public int[] getRowOrder() {
    return m_RowOrder;
  }

  /**
   * returns the displayed index of the given row, depending on the order of
   * rows, returns -1 if index out of bounds.
   * 
   * @param index       the row to get the displayed index for
   * @return            the real index of the row
   */
  public int getDisplayRow(int index) {
    if ( (index >= 0) && (index < getRowCount()) ) {
      if (getRowOrder() == null)
        return index;
      else
        return getRowOrder()[index];
    }
    else {
      return -1;
    }
  }

  /**
   * sets the ordering of the columns, null means default.
   * 
   * @param order       the new order of the columns
   */
  public void setColOrder(int[] order) {
    int         i;
    
    // default order?
    if (order == null) {
      m_ColOrder = null;
    }
    else {
      if (order.length == getColCount()) {
        m_ColOrder = new int[order.length];
        for (i = 0; i < order.length; i++)
          m_ColOrder[i] = order[i];
      }
      else {
        System.err.println("setColOrder: length does not match (" 
            + order.length + " <> " + getColCount() + ") - ignored!");
      }
    }
  }

  /**
   * returns the current order of the columns, null means the default order.
   * 
   * @return            the current order of the columns
   */
  public int[] getColOrder() {
    return m_ColOrder;
  }

  /**
   * returns the displayed index of the given col, depending on the order of
   * columns, returns -1 if index out of bounds.
   * 
   * @param index       the column to get the displayed index for
   * @return            the real index of the column
   */
  public int getDisplayCol(int index) {
    if ( (index >= 0) && (index < getColCount()) ) {
      if (getColOrder() == null)
        return index;
      else
        return getColOrder()[index];
    }
    else {
      return -1;
    }
  }

  /**
   * returns the given number as string rounded to the given number of
   * decimals. additional necessary 0's are added.
   * 
   * @param d           the number to format
   * @param prec        the number of decimals after the point
   * @return            the formatted number
   */
  protected String doubleToString(double d, int prec) {
    String        result;
    int           currentPrec;
    int           i;

    result = Utils.doubleToString(d, prec);

    // decimal point?
    if (result.indexOf(".") == -1)
      result += ".";
    
    // precision so far?
    currentPrec = result.length() - result.indexOf(".") - 1;
    for (i = currentPrec; i < prec; i++)
      result += "0";
    
    return result;
  }

  /**
   * trims the given string down to the given length if longer, otherwise
   * leaves it unchanged. a length of "0" leaves the string always 
   * unchanged.
   * 
   * @param s           the string to trim (if too long)
   * @param length      the max. length (0 means infinity)
   * @return            the trimmed string
   */
  protected String trimString(String s, int length) {
    if ( (length > 0) && (s.length() > length) )
      return s.substring(0, length);
    else
      return s;
  }

  /**
   * pads the given string on the right until it reaches the given length, if
   * longer cuts it down. if length is 0 then nothing is done.
   * 
   * @param s           the string to pad
   * @param length      the max. length of the string
   * @return            the padded string
   */
  protected String padString(String s, int length) {
    return padString(s, length, false);
  }

  /**
   * pads the given string until it reaches the given length, if longer cuts
   * it down. if length is 0 then nothing is done.
   * 
   * @param s           the string to pad
   * @param length      the max. length of the string
   * @param left        whether to pad left or right
   * @return            the padded string
   */
  protected String padString(String s, int length, boolean left) {
    String      result;
    int         i;

    result = s;

    // pad with blanks
    for (i = s.length(); i < length; i++) {
      if (left)
        result = " " + result;
      else
        result = result + " ";
    }
      
    // too long?
    if ( (length > 0) && (result.length() > length) )
      result = result.substring(0, length);

    return result;
  }

  /**
   * returns the length of the longest cell in the given column.
   * 
   * @param data        the data to base the calculation on
   * @param col         the column to check
   * @return            the maximum length
   */
  protected int getColSize(String[][] data, int col) {
    return getColSize(data, col, false, false);
  }

  /**
   * returns the length of the longest cell in the given column.
   * 
   * @param data        the data to base the calculation on
   * @param col         the column to check
   * @param skipFirst   whether to skip the first row
   * @param skipLast    whether to skip the last row
   * @return            the maximum length
   */
  protected int getColSize( String[][] data, int col, 
                            boolean skipFirst, boolean skipLast ) {
    int       result;
    int       i;

    result = 0;

    if ( (col >= 0) && (col < data[0].length) ) {
      for (i = 0; i < data.length; i++) {
        // skip first?
        if ( (i == 0) && (skipFirst) )
          continue;

        // skip last?
        if ( (i == data.length - 1) && (skipLast) )
          continue;
        
        if (data[i][col].length() > result)
          result = data[i][col].length();
      }
    }

    return result;
  }

  /**
   * removes the filter classname from the given string if it should be 
   * removed, otherwise leaves the string alone.
   * 
   * @param s           the string to process
   * @return            the processed string
   * @see               #getRemoveFilterName()
   */
  protected String removeFilterName(String s) {
    if (getRemoveFilterName())
      return s.replaceAll("-weka\\.filters\\..*", "")
              .replaceAll("-unsupervised\\..*",   "")
              .replaceAll("-supervised\\..*",     "");
    else
      return s;
  }

  /**
   * returns a 2-dimensional array with the prepared data. includes the column
   * and row names. hidden cols/rows are already excluded. <br>
   * first row: column names<br>
   * last  row: wins/ties/losses<br>
   * first col: row names<br>
   * 
   * @return            the generated array
   */
  protected String[][] toArray() {
    int               i;
    int               n;
    int               ii;
    int               nn;
    int               x;
    int               y;
    String[][]        result;
    String[][]        tmpResult;
    int               cols;
    int               rows;
    boolean           valueExists;

    // determine visible cols/rows
    rows = getVisibleRowCount();
    if (getShowAverage())
      rows++;
    cols = getVisibleColCount();
    if (getShowStdDev())
      cols = cols*3;   // mean + stddev + sign.
    else
      cols = cols*2;   // mean + stddev

    result = new String[rows + 2][cols + 1];

    // col names
    result[0][0] = trimString("Dataset", getRowNameWidth());
    x = 1;
    for (ii = 0; ii < getColCount(); ii++) {
      i = getDisplayCol(ii);
      if (getColHidden(i))
        continue;
      
      result[0][x] = trimString(
          removeFilterName(getColName(i)), getColNameWidth());
      x++;
      // std dev
      if (getShowStdDev()) {
        result[0][x] = "";
        x++;
      }
      // sign.
      result[0][x] = "";
      x++;
    }

    // row names
    y = 1;
    for (ii = 0; ii < getRowCount(); ii++) {
      i = getDisplayRow(ii);
      if (!getRowHidden(i)) {
        result[y][0] = trimString(
            removeFilterName(getRowName(i)), getRowNameWidth());
        y++;
      }
    }

    // fill in mean/std dev
    y = 1;
    for (ii = 0; ii < getRowCount(); ii++) {
      i = getDisplayRow(ii);
      if (getRowHidden(i))
        continue;

      x = 1;
      for (nn = 0; nn < getColCount(); nn++) {
        n = getDisplayCol(nn);
        if (getColHidden(n))
          continue;

        // do we have a value in the matrix?
        valueExists = (!Double.isNaN(getMean(n, i)));

        // mean
        if (!valueExists)
          result[y][x] = "";
        else
          result[y][x] = doubleToString(getMean(n, i), getMeanPrec());
        x++;
        
        // stddev
        if (getShowStdDev()) {
          if (!valueExists)
            result[y][x] = "";
          else if (Double.isInfinite(getStdDev(n, i)))
            result[y][x] = "Inf";
          else
            result[y][x] = doubleToString(getStdDev(n, i), getStdDevPrec());
          x++;
        }
        
        // significance
        if (!valueExists) {
          result[y][x] = "";
        }
        else {
          switch (getSignificance(n, i)) {
            case SIGNIFICANCE_TIE:
              result[y][x] = TIE_STRING;
              break;
            case SIGNIFICANCE_WIN:
              result[y][x] = WIN_STRING;
              break;
            case SIGNIFICANCE_LOSS:
              result[y][x] = LOSS_STRING;
              break;
          }
        }
        x++;
      }

      y++;
    }

    // the average
    if (getShowAverage()) {
      y = result.length - 2;
      x = 0;
      result[y][0] = "Average";
      x++;
      for (ii = 0; ii < getColCount(); ii++) {
        i = getDisplayCol(ii);
        if (getColHidden(i))
          continue;

        // mean-average
        result[y][x] = doubleToString(getAverage(i), getMeanPrec());
        x++;

        // std dev.
        if (getShowStdDev()) {
          result[y][x] = "";
          x++;
        }

        // significance
        result[y][x] = "";
        x++;
      }
    }

    // wins/ties/losses
    y = result.length - 1;
    x = 0;
    result[y][0] =   LEFT_PARENTHESES 
                   + WIN_STRING + "/" 
                   + TIE_STRING + "/" 
                   + LOSS_STRING 
                   + RIGHT_PARENTHESES;
    x++;
    for (ii = 0; ii < getColCount(); ii++) {
      i = getDisplayCol(ii);
      if (getColHidden(i))
        continue;

      // mean
      result[y][x] = "";
      x++;

      // std dev.
      if (getShowStdDev()) {
        result[y][x] = "";
        x++;
      }

      // significance
      result[y][x] =   LEFT_PARENTHESES 
                     + getSignificanceCount(i, SIGNIFICANCE_WIN) + "/" 
                     + getSignificanceCount(i, SIGNIFICANCE_TIE) + "/" 
                     + getSignificanceCount(i, SIGNIFICANCE_LOSS) 
                     + RIGHT_PARENTHESES;
      x++;
    }

    // base column has no significance -> remove these columns
    tmpResult = new String[result.length][result[0].length - 1];

    x = 0;
    for (i = 0; i < result[0].length; i++) {
      // significance
      if (    ((i == 3) && ( getShowStdDev()))
           || ((i == 2) && (!getShowStdDev())) )
        continue;
      
      for (n = 0; n < result.length; n++)
        tmpResult[n][x] = result[n][i];

      x++;
    }
    result = tmpResult;

    return result;
  }

  /**
   * returns true if the index (in the array produced by toArray(boolean))
   * is the row name.
   * 
   * @param index       the row index
   * @return            true if index represents a row name
   */
  protected boolean isRowName(int index) {
    return (index == 0);
  }

  /**
   * returns true if the index (in the array produced by toArray(boolean))
   * contains a mean.
   * 
   * @param index       the column index
   * @return            true if mean column
   */
  protected boolean isMean(int index) {
    index--;   // dataset
    if (index == 0) {
      return true;   // base column
    }
    else {
      index--;   // base column

      if (index < 0)
        return false;
      
      if (getShowStdDev())
        return (index % 3 == 1);
      else
        return (index % 2 == 0);
    }
  }

  /**
   * returns true if the row index (in the array produced by toArray(boolean))
   * contains the average row.
   * 
   * @param rowIndex    the row index
   * @return            true if average row
   */
  protected boolean isAverage(int rowIndex) {
    if (getShowAverage())
      return (getVisibleRowCount() + 1 == rowIndex);
    else
      return false;
  }

  /**
   * returns true if the index (in the array produced by toArray(boolean))
   * contains a std deviation.
   * 
   * @param index       the column index
   * @return            true if std dev column
   */
  protected boolean isStdDev(int index) {
    index--;   // dataset
    index--;   // base column

    if (getShowStdDev()) {
      if (index == 0) {
        return true;   // stddev of base column
      }
      else {
        index--;   // stddev of base column

        if (index < 0)
          return false;
      
        return (index % 3 == 1);
      }
    }
    else
      return false;
  }

  /**
   * returns true if the index (in the array produced by toArray(boolean))
   * contains a significance column.
   * 
   * @param index       the column index
   * @return            true if significance column
   */
  protected boolean isSignificance(int index) {
    index--;   // dataset
    index--;   // base column
    if (getShowStdDev()) {
      index--;   // stddev of base column

      if (index < 0)
        return false;
      
      return (index % 3 == 2);
    }
    else {
      if (index < 0)
        return false;
      
      return (index % 2 == 1);
    }
  }

  /**
   * returns the matrix as a string.
   * 
   * @return            the matrix as string
   */
  public abstract String toStringMatrix();

  /**
   * returns the matrix as a string.
   * 
   * @return            the matrix as string
   * @see               #toStringMatrix()
   */
  public String toString() {
    return toStringMatrix();
  }

  /**
   * removes all the header information.
   */
  public void clearHeader() {
    m_HeaderKeys   = new Vector();
    m_HeaderValues = new Vector();
  }

  /**
   * adds the key-value pair to the header.
   * 
   * @param key         the name of the header value
   * @param value       the value of the header value
   */
  public void addHeader(String key, String value) {
    int         pos;
    
    pos = m_HeaderKeys.indexOf(key);
    if (pos > -1) {
      m_HeaderValues.set(pos, value);
    }
    else {
      m_HeaderKeys.add(key);
      m_HeaderValues.add(value);
    }
  }

  /**
   * returns the value associated with the given key, null if if cannot be
   * found.
   * 
   * @param key         the key to retrieve the value for
   * @return            the associated value
   */
  public String getHeader(String key) {
    int       pos;

    pos = m_HeaderKeys.indexOf(key);
    if (pos == 0)
      return null;
    else
      return (String) m_HeaderKeys.get(pos);
  }

  /**
   * returns an enumeration of the header keys.
   * 
   * @return            all stored keys
   */
  public Enumeration headerKeys() {
    return m_HeaderKeys.elements();
  }
  
  /**
   * returns the header of the matrix as a string.
   * 
   * @return            the header as string
   * @see               #m_HeaderKeys
   * @see               #m_HeaderValues
   */
  public abstract String toStringHeader();

  /**
   * returns returns a key for all the col names, for better readability if
   * the names got cut off.
   * 
   * @return            the key
   */
  public abstract String toStringKey();

  /**
   * clears the current summary data.
   */
  public void clearSummary() {
    m_NonSigWins = null;
    m_Wins       = null;
  }

  /**
   * sets the non-significant and significant wins of the resultsets.
   * 
   * @param nonSigWins      the non-significant wins
   * @param wins         the significant wins
   */
  public void setSummary(int[][] nonSigWins, int[][] wins) {
    int         i;
    int         n;
    
    m_NonSigWins = new int[nonSigWins.length][nonSigWins[0].length];
    m_Wins       = new int[wins.length][wins[0].length];

    for (i = 0; i < m_NonSigWins.length; i++) {
      for (n = 0; n < m_NonSigWins[i].length; n++) {
        m_NonSigWins[i][n] = nonSigWins[i][n];
        m_Wins[i][n]       = wins[i][n];
      }
    }
  }

  /**
   * returns the character representation of the given column.
   * 
   * @param col         the column index
   * @return            the title of the column
   */
  protected String getSummaryTitle(int col) {
    return "" + (char) ((int) 'a' + col % 26);
  }

  /**
   * returns the summary as string.
   * 
   * @return            the summary
   */
  public abstract String toStringSummary();

  /**
   * clears the currently stored ranking data.
   */
  public void clearRanking() {
    m_RankingWins   = null;
    m_RankingLosses = null;
    m_RankingDiff   = null;
  }

  /**
   * sets the ranking data based on the wins.
   * 
   * @param wins      the wins 
   */
  public void setRanking(int[][] wins) {
    int         i;
    int         j;
    
    m_RankingWins   = new int[wins.length];
    m_RankingLosses = new int[wins.length];
    m_RankingDiff   = new int[wins.length];

    for (i = 0; i < wins.length; i++) {
      for (j = 0; j < wins[i].length; j++) {
        m_RankingWins[j]   += wins[i][j];
        m_RankingDiff[j]   += wins[i][j];
        m_RankingLosses[i] += wins[i][j];
        m_RankingDiff[i]   -= wins[i][j];
      }
    }
  }

  /**
   * returns the ranking in a string representation.
   * 
   * @return            the ranking
   */
  public abstract String toStringRanking();
}