instance.java

一个数据挖掘软件ALPHAMINERR的整个过程的JAVA版源代码

		}
		setValue(att.index(), (double) valIndex);
	}

	/**
	 * Sets the weight of an instance.
	 * 
	 * @param weight
	 *            the weight
	 */
	public final void setWeight(double weight) {
		m_Weight = weight;
	}

	/**
	 * Returns the string value of a nominal, string, or date attribute for the
	 * instance.
	 * 
	 * @param attIndex
	 *            the attribute's index
	 * @return the value as a string
	 * @exception IllegalArgumentException
	 *                if the attribute is not a nominal, string, or date
	 *                attribute.
	 * @exception UnassignedDatasetException
	 *                if the instance doesn't belong to a dataset.
	 */
	public final String stringValue(int attIndex) {
		if (m_Dataset == null) {
			throw new UnassignedDatasetException("Instance doesn't have access to a dataset!");
		}
		return stringValue(m_Dataset.attribute(attIndex));
	}

	/**
	 * Returns the string value of a nominal, string, or date attribute for the
	 * instance.
	 * 
	 * @param att
	 *            the attribute
	 * @return the value as a string
	 * @exception IllegalArgumentException
	 *                if the attribute is not a nominal, string, or date
	 *                attribute.
	 * @exception UnassignedDatasetException
	 *                if the instance doesn't belong to a dataset.
	 */
	public final String stringValue(Attribute att) {
		int attIndex = att.index();
		switch (att.type()) {
		case Attribute.NOMINAL:
		case Attribute.STRING:
			return att.value((int) value(attIndex));
		case Attribute.DATE:
			return att.formatDate(value(attIndex));
		default:
			throw new IllegalArgumentException("Attribute isn't nominal, string or date!");
		}
	}

	/**
	 * Returns the values of each attribute as an array of doubles.
	 * 
	 * @return an array containing all the instance attribute values
	 */
	public double[] toDoubleArray() {
		double[] newValues = new double[m_AttValues.length];
		System.arraycopy(m_AttValues, 0, newValues, 0, m_AttValues.length);
		return newValues;
	}

	/**
	 * Returns the description of one instance. If the instance doesn't have
	 * access to a dataset, it returns the internal floating-point values.
	 * Quotes string values that contain whitespace characters.
	 * 
	 * @return the instance's description as a string
	 */
	public String toString() {
		StringBuffer text = new StringBuffer();
		for (int i = 0; i < m_AttValues.length; i++) {
			if (i > 0)
				text.append(",");
			text.append(toString(i));
		}
		return text.toString();
	}

	/**
	 * Returns the description of one value of the instance as a string. If the
	 * instance doesn't have access to a dataset, it returns the internal
	 * floating-point value. Quotes string values that contain whitespace
	 * characters, or if they are a question mark.
	 * 
	 * @param attIndex
	 *            the attribute's index
	 * @return the value's description as a string
	 */
	public final String toString(int attIndex) {
		StringBuffer text = new StringBuffer();
		if (isMissing(attIndex)) {
			text.append("?");
		} else {
			if (m_Dataset == null) {
				text.append(Utils.doubleToString(m_AttValues[attIndex], 6));
			} else {
				switch (m_Dataset.attribute(attIndex).type()) {
				case Attribute.NOMINAL:
				case Attribute.STRING:
				case Attribute.DATE:
					text.append(Utils.quote(stringValue(attIndex)));
					break;
				case Attribute.NUMERIC:
					text.append(Utils.doubleToString(value(attIndex), 6));
					break;
				default:
					throw new IllegalStateException("Unknown attribute type");
				}
			}
		}
		return text.toString();
	}

	/**
	 * Returns the description of one value of the instance as a string. If the
	 * instance doesn't have access to a dataset it returns the internal
	 * floating-point value. Quotes string values that contain whitespace
	 * characters, or if they are a question mark. The given attribute has to
	 * belong to a dataset.
	 * 
	 * @param att
	 *            the attribute
	 * @return the value's description as a string
	 */
	public final String toString(Attribute att) {
		return toString(att.index());
	}

	/**
	 * Returns an instance's attribute value in internal format.
	 * 
	 * @param attIndex
	 *            the attribute's index
	 * @return the specified value as a double (If the corresponding attribute
	 *         is nominal (or a string) then it returns the value's index as a
	 *         double).
	 */
	public double value(int attIndex) {
		return m_AttValues[attIndex];
	}

	/**
	 * Returns an instance's attribute value in internal format. Does exactly
	 * the same thing as value() if applied to an Instance.
	 * 
	 * @param indexOfIndex
	 *            the index of the attribute's index
	 * @return the specified value as a double (If the corresponding attribute
	 *         is nominal (or a string) then it returns the value's index as a
	 *         double).
	 */
	public double valueSparse(int indexOfIndex) {
		return m_AttValues[indexOfIndex];
	}

	/**
	 * Returns an instance's attribute value in internal format. The given
	 * attribute has to belong to a dataset.
	 * 
	 * @param att
	 *            the attribute
	 * @return the specified value as a double (If the corresponding attribute
	 *         is nominal (or a string) then it returns the value's index as a
	 *         double).
	 */
	public double value(Attribute att) {
		return value(att.index());
	}

	/**
	 * Returns the instance's weight.
	 * 
	 * @return the instance's weight as a double
	 */
	public final double weight() {
		return m_Weight;
	}

	/**
	 * Deletes an attribute at the given position (0 to numAttributes() - 1).
	 * 
	 * @param pos
	 *            the attribute's position
	 */
	void forceDeleteAttributeAt(int position) {
		double[] newValues = new double[m_AttValues.length - 1];
		System.arraycopy(m_AttValues, 0, newValues, 0, position);
		if (position < m_AttValues.length - 1) {
			System.arraycopy(m_AttValues, position + 1, newValues, position, m_AttValues.length - (position + 1));
		}
		m_AttValues = newValues;
	}

	/**
	 * Inserts an attribute at the given position (0 to numAttributes()) and
	 * sets its value to be missing.
	 * 
	 * @param pos
	 *            the attribute's position
	 */
	void forceInsertAttributeAt(int position) {
		double[] newValues = new double[m_AttValues.length + 1];
		System.arraycopy(m_AttValues, 0, newValues, 0, position);
		newValues[position] = MISSING_VALUE;
		System.arraycopy(m_AttValues, position, newValues, position + 1, m_AttValues.length - position);
		m_AttValues = newValues;
	}

	/**
	 * Private constructor for subclasses. Does nothing.
	 */
	protected Instance() {
	}

	/**
	 * Clones the attribute vector of the instance and overwrites it with the
	 * clone.
	 */
	private void freshAttributeVector() {
		m_AttValues = toDoubleArray();
	}

	/**
	 * Main method for testing this class.
	 */
	public static void main(String[] options) {
		try {
			// Create numeric attributes "length" and "weight"
			Attribute length = new Attribute("length");
			Attribute weight = new Attribute("weight");
			// Create vector to hold nominal values "first", "second", "third"
			FastVector my_nominal_values = new FastVector(3);
			my_nominal_values.addElement("first");
			my_nominal_values.addElement("second");
			my_nominal_values.addElement("third");
			// Create nominal attribute "position"
			Attribute position = new Attribute("position", my_nominal_values);
			// Create vector of the above attributes
			FastVector attributes = new FastVector(3);
			attributes.addElement(length);
			attributes.addElement(weight);
			attributes.addElement(position);
			// Create the empty dataset "race" with above attributes
			Instances race = new Instances("race", attributes, 0);
			// Make position the class attribute
			race.setClassIndex(position.index());
			// Create empty instance with three attribute values
			Instance inst = new Instance(3);
			// Set instance's values for the attributes "length", "weight", and
			// "position"
			inst.setValue(length, 5.3);
			inst.setValue(weight, 300);
			inst.setValue(position, "first");
			// Set instance's dataset to be the dataset "race"
			inst.setDataset(race);
			// Print the instance
			System.out.println("The instance: " + inst);
			// Print the first attribute
			System.out.println("First attribute: " + inst.attribute(0));
			// Print the class attribute
			System.out.println("Class attribute: " + inst.classAttribute());
			// Print the class index
			System.out.println("Class index: " + inst.classIndex());
			// Say if class is missing
			System.out.println("Class is missing: " + inst.classIsMissing());
			// Print the instance's class value in internal format
			System.out.println("Class value (internal format): " + inst.classValue());
			// Print a shallow copy of this instance
			Instance copy = (Instance) inst.copy();
			System.out.println("Shallow copy: " + copy);
			// Set dataset for shallow copy
			copy.setDataset(inst.dataset());
			System.out.println("Shallow copy with dataset set: " + copy);
			// Unset dataset for copy, delete first attribute, and insert it
			// again
			copy.setDataset(null);
			copy.deleteAttributeAt(0);
			copy.insertAttributeAt(0);
			copy.setDataset(inst.dataset());
			System.out.println("Copy with first attribute deleted and inserted: " + copy);
			// Enumerate attributes (leaving out the class attribute)
			System.out.println("Enumerating attributes (leaving out class):");
			Enumeration em = inst.emerateAttributes();
			while (em.hasMoreElements()) {
				Attribute att = (Attribute) em.nextElement();
				System.out.println(att);
			}
			// Headers are equivalent?
			System.out.println("Header of original and copy equivalent: " + inst.equalHeaders(copy));
			// Test for missing values
			System.out.println("Length of copy missing: " + copy.isMissing(length));
			System.out.println("Weight of copy missing: " + copy.isMissing(weight.index()));
			System.out.println("Length of copy missing: " + Instance.isMissingValue(copy.value(length)));
			System.out.println("Missing value coded as: " + Instance.missingValue());
			// Prints number of attributes and classes
			System.out.println("Number of attributes: " + copy.numAttributes());
			System.out.println("Number of classes: " + copy.numClasses());
			// Replace missing values
			double[] meansAndModes = { 2, 3, 0 };
			copy.replaceMissingValues(meansAndModes);
			System.out.println("Copy with missing value replaced: " + copy);
			// Setting and getting values and weights
			copy.setClassMissing();
			System.out.println("Copy with missing class: " + copy);
			copy.setClassValue(0);
			System.out.println("Copy with class value set to first value: " + copy);
			copy.setClassValue("third");
			System.out.println("Copy with class value set to \"third\": " + copy);
			copy.setMissing(1);
			System.out.println("Copy with second attribute set to be missing: " + copy);
			copy.setMissing(length);
			System.out.println("Copy with length set to be missing: " + copy);
			copy.setValue(0, 0);
			System.out.println("Copy with first attribute set to 0: " + copy);
			copy.setValue(weight, 1);
			System.out.println("Copy with weight attribute set to 1: " + copy);
			copy.setValue(position, "second");
			System.out.println("Copy with position set to \"second\": " + copy);
			copy.setValue(2, "first");
			System.out.println("Copy with last attribute set to \"first\": " + copy);
			System.out.println("Current weight of instance copy: " + copy.weight());
			copy.setWeight(2);
			System.out.println("Current weight of instance copy (set to 2): " + copy.weight());
			System.out.println("Last value of copy: " + copy.toString(2));
			System.out.println("Value of position for copy: " + copy.toString(position));
			System.out.println("Last value of copy (internal format): " + copy.value(2));
			System.out.println("Value of position for copy (internal format): " + copy.value(position));
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}