* * Typical usage (code from the main() method of this class):
*
*
* ...
*
* // Create empty instance with three attribute values
* Instance inst = new DenseInstance(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);
*
* ...
*
*
* All methods that change an instance's attribute values are safe,
* ie. a change of an instance's attribute values does not affect any
* other instances. All methods that change an instance's attribute
* values clone the attribute value vector before it is changed. If
* your application heavily modifies instance values, it may be faster
* to create a new instance from scratch.
*
* @author Eibe Frank (eibe@cs.waikato.ac.nz)
* @version $Revision: 5987 $
*/
public class DenseInstance extends AbstractInstance {
/** for serialization */
static final long serialVersionUID = 1482635194499365122L;
/**
* Constructor that copies the attribute values and the weight from
* the given instance. It does NOT perform a deep copy of the
* attribute values if the instance provided is also of type
* DenseInstance (it simply copies the reference to the array of
* values), otherwise it does. Reference to the dataset is set to
* null. (ie. the instance doesn't have access to information about
* the attribute types)
*
* @param instance the instance from which the attribute
* values and the weight are to be copied
*/
//@ ensures m_Dataset == null;
public DenseInstance(/*@non_null@*/ Instance instance) {
if (instance instanceof DenseInstance) {
m_AttValues = ((DenseInstance)instance).m_AttValues;
} else {
m_AttValues = instance.toDoubleArray();
}
m_Weight = instance.weight();
m_Dataset = null;
}
/**
* Constructor that inititalizes instance variable with given
* values. Reference to the dataset is set to null. (ie. the instance
* doesn't have access to information about the attribute types)
*
* @param weight the instance's weight
* @param attValues a vector of attribute values
*/
//@ ensures m_Dataset == null;
public DenseInstance(double weight, /*@non_null@*/ double[]attValues){
m_AttValues = attValues;
m_Weight = weight;
m_Dataset = null;
}
/**
* Constructor of an instance that sets weight to one, all values to
* be missing, and the reference to the dataset to null. (ie. the instance
* doesn't have access to information about the attribute types)
*
* @param numAttributes the size of the instance
*/
//@ requires numAttributes > 0; // Or maybe == 0 is okay too?
//@ ensures m_Dataset == null;
public DenseInstance(int numAttributes) {
m_AttValues = new double[numAttributes];
for (int i = 0; i < m_AttValues.length; i++) {
m_AttValues[i] = Utils.missingValue();
}
m_Weight = 1;
m_Dataset = null;
}
/**
* Produces a shallow copy of this instance. The copy has
* access to the same dataset. (if you want to make a copy
* that doesn't have access to the dataset, use
* new DenseInstance(instance)
*
* @return the shallow copy
*/
//@ also ensures \result != null;
//@ also ensures \result instanceof DenseInstance;
//@ also ensures ((DenseInstance)\result).m_Dataset == m_Dataset;
public /*@pure@*/ Object copy() {
DenseInstance result = new DenseInstance(this);
result.m_Dataset = m_Dataset;
return result;
}
/**
* Returns the index of the attribute stored at the given position.
* Just returns the given value.
*
* @param position the position
* @return the index of the attribute stored at the given position
*/
public /*@pure@*/ int index(int position) {
return position;
}
/**
* Merges this instance with the given instance and returns
* the result. Dataset is set to null. The returned instance
* is of the same type as this instance.
*
* @param inst the instance to be merged with this one
* @return the merged instances
*/
public Instance mergeInstance(Instance inst) {
int m = 0;
double [] newVals = new double[numAttributes() + inst.numAttributes()];
for (int j = 0; j < numAttributes(); j++, m++) {
newVals[m] = value(j);
}
for (int j = 0; j < inst.numAttributes(); j++, m++) {
newVals[m] = inst.value(j);
}
return new DenseInstance(1.0, newVals);
}
/**
* Returns the number of attributes.
*
* @return the number of attributes as an integer
*/
//@ ensures \result == m_AttValues.length;
public /*@pure@*/ int numAttributes() {
return m_AttValues.length;
}
/**
* Returns the number of values present. Always the same as numAttributes().
*
* @return the number of values
*/
//@ ensures \result == m_AttValues.length;
public /*@pure@*/ int numValues() {
return m_AttValues.length;
}
/**
* Replaces all missing values in the instance with the
* values contained in the given array. A deep copy of
* the vector of attribute values is performed before the
* values are replaced.
*
* @param array containing the means and modes
* @throws IllegalArgumentException if numbers of attributes are unequal
*/
public void replaceMissingValues(double[] array) {
if ((array == null) ||
(array.length != m_AttValues.length)) {
throw new IllegalArgumentException("Unequal number of attributes!");
}
freshAttributeVector();
for (int i = 0; i < m_AttValues.length; i++) {
if (isMissing(i)) {
m_AttValues[i] = array[i];
}
}
}
/**
* Sets a specific value in the instance to the given value
* (internal floating-point format). Performs a deep copy
* of the vector of attribute values before the value is set.
*
* @param attIndex the attribute's index
* @param value the new attribute value (If the corresponding
* attribute is nominal (or a string) then this is the new value's
* index as a double).
*/
public void setValue(int attIndex, double value) {
freshAttributeVector();
m_AttValues[attIndex] = value;
}
/**
* Sets a specific value in the instance to the given value
* (internal floating-point format). Performs a deep copy
* of the vector of attribute values before the value is set.
* Does exactly the same thing as setValue().
*
* @param indexOfIndex the index of the attribute's index
* @param value the new attribute value (If the corresponding
* attribute is nominal (or a string) then this is the new value's
* index as a double).
*/
public void setValueSparse(int indexOfIndex, double value) {
freshAttributeVector();
m_AttValues[indexOfIndex] = value;
}
/**
* 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 (without weight
* appended). If the instance
* doesn't have access to a dataset, it returns the internal
* floating-point values. Quotes string
* values that contain whitespace characters.
*
* This method is used by getRandomNumberGenerator() in
* Instances.java in order to maintain backwards compatibility
* with weka 3.4.
*
* @return the instance's description as a string
*/
public String toStringNoWeight() {
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 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 /*@pure@*/ double value(int attIndex) {
return m_AttValues[attIndex];
}
/**
* Deletes an attribute at the given position (0 to
* numAttributes() - 1).
*
* @param position the attribute's position
*/
protected 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 position the attribute's position
*/
protected void forceInsertAttributeAt(int position) {
double[] newValues = new double[m_AttValues.length + 1];
System.arraycopy(m_AttValues, 0, newValues, 0, position);
newValues[position] = Utils.missingValue();
System.arraycopy(m_AttValues, position, newValues,
position + 1, m_AttValues.length - position);
m_AttValues = newValues;
}
/**
* 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.
*
* @param options the commandline options - ignored
*/
//@ requires options != null;
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"
ArrayList