Datapoint.java

/**
 * Represents a general datapoint consisting of a name, numerical columns, and their corresponding column names.
 * Implements Comparable to allow ordering based on a specified column.
 * @author Showmick Das
 * @version 1.0
 */
public class Datapoint implements Comparable<Datapoint> {
    protected String name;
    protected double[] columns;
    public String[] columnNames;
    protected int orderColumn;
    protected boolean reverseOrder;

    /**
     * Constructs a Datapoint with the given name, columns, and column names.
     * Any column value outside the range [0, 5] is set to 2.5.
     * @param name The name of the datapoint
     * @param columns Array of numerical values
     * @param columnNames Array of corresponding column names
     */
    public Datapoint(String name, double[] columns, String[] columnNames) {
        this.name = name;
        this.columns = new double[columns.length];
        for (int i = 0; i < columns.length; i++) {
            if (columns[i] < 0 || columns[i] > 5) {
                this.columns[i] = 2.5;
            } else {
                this.columns[i] = columns[i];
            }
        }
        this.columnNames = new String[columnNames.length];
        for (int i = 0; i < columnNames.length; i++) {
            this.columnNames[i] = columnNames[i];
        }
        // Default ordering settings
        this.orderColumn = 0;
        this.reverseOrder = false;
    }

    /**
     * Copy constructor. Creates a deep copy of the given Datapoint.
     * @param other The Datapoint to copy from
     */
    public Datapoint(Datapoint other) {
        this.name = other.name;
        this.columns = new double[other.columns.length];
        for (int i = 0; i < other.columns.length; i++) {
            this.columns[i] = other.columns[i];
        }
        this.columnNames = new String[other.columnNames.length];
        for (int i = 0; i < other.columnNames.length; i++) {
            this.columnNames[i] = other.columnNames[i];
        }
        this.orderColumn = other.orderColumn;
        this.reverseOrder = other.reverseOrder;
    }

    /**
     * Sets the order column used for comparisons.
     * @param column The index of the column to use for ordering
     */
    public void setOrderColumn(int column) {
        if (column >= 0 && column < columnNames.length) {
            this.orderColumn = column;
        }
    }

    /**
     * Sets whether the order should be reversed.
     * @param reverse True for reverse order, false otherwise
     */
    public void setReverseOrder(boolean reverse) {
        this.reverseOrder = reverse;
    }

    /**
     * Returns the name of the datapoint.
     * @return The name of the datapoint
     */
    public String getName() {
        return name;
    }

    /**
     * Compares this Datapoint with the specified Datapoint for order based on the orderColumn.
     * The comparison is based on the value at orderColumn in the columns array.
     * If reverseOrder is true, the comparison result is flipped.
     * @param o The Datapoint to be compared
     * @return a negative integer, zero, or a positive integer as the parameter is considered
     * greater than, equal to, or less than this Datapoint.
     */
    @Override
    public int compareTo(Datapoint o) {
        double thisValue = this.columns[this.orderColumn];
        double otherValue = o.columns[this.orderColumn];
        int cmp = Double.compare(thisValue, otherValue);
        return reverseOrder ? -cmp : cmp;
    }

    /**
     * Returns a string representation of the Datapoint.
     * The format is: {name}| {column0 value}| {column1 value}| ... with each field padded to at least 12 characters.
     * Floating point values are formatted to 2 decimal places.
     * @return A formatted string representation of the datapoint.
     */
    @Override
    public String toString() {
        String result = String.format("%12s", name);
        for (double value : columns) {
            result += "|" + String.format("%12.2f", value);
        }
        return result;
    }
}