/** * Input an instance for filtering. * * @param instance the input instance * @return true if the filtered instance may now be collected with output(). * @throws Exception if the input format was not set or the date format cannot be parsed */ public boolean input(Instance instance) throws Exception { if (getInputFormat() == null) { throw new IllegalStateException("No input instance format defined"); } if (m_NewBatch) { resetQueue(); m_NewBatch = false; } Instance newInstance = (Instance) instance.copy(); int index = m_AttIndex.getIndex(); if (!newInstance.isMissing(index)) { double value = instance.value(index); try { // Format and parse under the new format to force any required // loss in precision. value = m_OutputAttribute.parseDate(m_OutputAttribute.formatDate(value)); } catch (ParseException pe) { throw new RuntimeException("Output date format couldn't parse its own output!!"); } newInstance.setValue(index, value); } push(newInstance); return true; }
/** * Sets instances that should be stored. * * @param instances the instances */ @Override public void setInstances(Instances instances) { m_ClassIndex.setUpper(instances.numAttributes() - 1); instances.setClassIndex(m_ClassIndex.getIndex()); super.setInstances(instances); }
/** * Sets the format of the input instances. * * @param instanceInfo an Instances object containing the input instance structure (any instances * contained in the object are ignored - only the structure is required). * @return true if the outputFormat may be collected immediately * @throws UnsupportedAttributeTypeException if the selected attribute is not nominal or if it * only has one value. * @throws Exception if the input format can't be set successfully */ @Override public boolean setInputFormat(Instances instanceInfo) throws Exception { super.setInputFormat(instanceInfo); m_AttIndex.setUpper(instanceInfo.numAttributes() - 1); m_FirstIndex.setUpper(instanceInfo.attribute(m_AttIndex.getIndex()).numValues() - 1); m_SecondIndex.setUpper(instanceInfo.attribute(m_AttIndex.getIndex()).numValues() - 1); if (!instanceInfo.attribute(m_AttIndex.getIndex()).isNominal()) { throw new UnsupportedAttributeTypeException("Chosen attribute not nominal."); } if (instanceInfo.attribute(m_AttIndex.getIndex()).numValues() < 2) { throw new UnsupportedAttributeTypeException( "Chosen attribute has less than " + "two values."); } setOutputFormat(); return true; }
/** Set the output format. Changes the format of the specified date attribute. */ private void setOutputFormat() { // Create new attributes FastVector newAtts = new FastVector(getInputFormat().numAttributes()); for (int j = 0; j < getInputFormat().numAttributes(); j++) { Attribute att = getInputFormat().attribute(j); if (j == m_AttIndex.getIndex()) { newAtts.addElement(new Attribute(att.name(), getDateFormat().toPattern())); } else { newAtts.addElement(att.copy()); } } // Create new header Instances newData = new Instances(getInputFormat().relationName(), newAtts, 0); newData.setClassIndex(getInputFormat().classIndex()); m_OutputAttribute = newData.attribute(m_AttIndex.getIndex()); setOutputFormat(newData); }
/** * Sets the format of the input instances. * * @param instanceInfo an Instances object containing the input instance structure (any instances * contained in the object are ignored - only the structure is required). * @return true if the outputFormat may be collected immediately * @throws Exception if the input format can't be set successfully */ public boolean setInputFormat(Instances instanceInfo) throws Exception { super.setInputFormat(instanceInfo); m_AttIndex.setUpper(instanceInfo.numAttributes() - 1); if (!instanceInfo.attribute(m_AttIndex.getIndex()).isDate()) { throw new UnsupportedAttributeTypeException("Chosen attribute not date."); } setOutputFormat(); return true; }
/** Find the fold attribute within a dataset. */ private Attribute getAttribute(Instances data) { SingleIndex index = new SingleIndex(super.getAttributeIndex()); index.setUpper(data.numAttributes() - 1); Attribute att = data.attribute(index.getIndex()); if (att == null) throw new NoSuchElementException( "attribute #" + super.getAttributeIndex() + " does not exist"); if (!att.isNominal() && !att.isString()) throw new IllegalArgumentException("Attribute '" + att + "' is not nominal"); return att; }
/** * Sets the format of the input instances. * * @param instanceInfo an Instances object containing the input instance structure (any instances * contained in the object are ignored - only the structure is required). * @return true if the outputFormat may be collected immediately * @throws Exception if the format couldn't be set successfully */ public boolean setInputFormat(Instances instanceInfo) throws Exception { super.setInputFormat(instanceInfo); m_Insert.setUpper(instanceInfo.numAttributes()); Instances outputFormat = new Instances(instanceInfo, 0); Attribute newAttribute = null; switch (m_AttributeType) { case Attribute.NUMERIC: newAttribute = new Attribute(m_Name); break; case Attribute.NOMINAL: newAttribute = new Attribute(m_Name, m_Labels); break; case Attribute.STRING: newAttribute = new Attribute(m_Name, (FastVector) null); break; case Attribute.DATE: newAttribute = new Attribute(m_Name, m_DateFormat); break; default: throw new IllegalArgumentException("Unknown attribute type in Add"); } if ((m_Insert.getIndex() < 0) || (m_Insert.getIndex() > getInputFormat().numAttributes())) { throw new IllegalArgumentException("Index out of range"); } outputFormat.insertAttributeAt(newAttribute, m_Insert.getIndex()); setOutputFormat(outputFormat); // all attributes, except index of added attribute // (otherwise the length of the input/output indices differ) Range atts = new Range(m_Insert.getSingleIndex()); atts.setInvert(true); atts.setUpper(outputFormat.numAttributes() - 1); initOutputLocators(outputFormat, atts.getSelection()); return true; }
/** * Set the output format. Swapss the desired nominal attribute values in the header and calls * setOutputFormat(Instances) appropriately. */ private void setOutputFormat() { Instances newData; ArrayList<Attribute> newAtts; ArrayList<String> newVals; // Compute new attributes newAtts = new ArrayList<Attribute>(getInputFormat().numAttributes()); for (int j = 0; j < getInputFormat().numAttributes(); j++) { Attribute att = getInputFormat().attribute(j); if (j != m_AttIndex.getIndex()) { newAtts.add((Attribute) att.copy()); } else { // Compute list of attribute values newVals = new ArrayList<String>(att.numValues()); for (int i = 0; i < att.numValues(); i++) { if (i == m_FirstIndex.getIndex()) { newVals.add(att.value(m_SecondIndex.getIndex())); } else if (i == m_SecondIndex.getIndex()) { newVals.add(att.value(m_FirstIndex.getIndex())); } else { newVals.add(att.value(i)); } } Attribute newAtt = new Attribute(att.name(), newVals); newAtt.setWeight(att.weight()); newAtts.add(newAtt); } } // Construct new header newData = new Instances(getInputFormat().relationName(), newAtts, 0); newData.setClassIndex(getInputFormat().classIndex()); setOutputFormat(newData); }
/** * Sets the format of the input instances. * * @param instanceInfo an Instances object containing the input instance structure (any instances * contained in the object are ignored - only the structure is required). * @return true if the outputFormat may be collected immediately * @throws Exception if the input format can't be set successfully */ public boolean setInputFormat(Instances instanceInfo) throws Exception { super.setInputFormat(instanceInfo); // set input format // m_InputFormat = new Instances(instanceInfo, 0); m_AttIndex.setUpper(getInputFormat().numAttributes() - 1); // set index of attribute to be changed // test if nominal if (!getInputFormat().attribute(m_AttIndex.getIndex()).isNominal()) { throw new Exception("Adding noise is not possible:" + "Chosen attribute is numeric."); } // test if two values are given if ((getInputFormat().attribute(m_AttIndex.getIndex()).numValues() < 2) && (!m_UseMissing)) { throw new Exception( "Adding noise is not possible:" + "Chosen attribute has less than two values."); } setOutputFormat(getInputFormat()); m_NewBatch = true; return false; }
/** * Input an instance for filtering. The instance is processed and made available for output * immediately. * * @param instance the input instance * @return true if the filtered instance may now be collected with output(). * @throws IllegalStateException if no input structure has been defined. */ @Override public boolean input(Instance instance) { if (getInputFormat() == null) { throw new IllegalStateException("No input instance format defined"); } if (m_NewBatch) { resetQueue(); m_NewBatch = false; } Instance newInstance = (Instance) instance.copy(); if (!newInstance.isMissing(m_AttIndex.getIndex())) { if ((int) newInstance.value(m_AttIndex.getIndex()) == m_SecondIndex.getIndex()) { newInstance.setValue(m_AttIndex.getIndex(), m_FirstIndex.getIndex()); } else if ((int) newInstance.value(m_AttIndex.getIndex()) == m_FirstIndex.getIndex()) { newInstance.setValue(m_AttIndex.getIndex(), m_SecondIndex.getIndex()); } } push(newInstance, false); // No need to copy return true; }
/** * Input an instance for filtering. The instance is processed and made available for output * immediately. * * @param instance the input instance * @return true if the filtered instance may now be collected with output(). * @throws IllegalStateException if no input format has been set. */ public boolean input(Instance instance) { if (getInputFormat() == null) { throw new IllegalStateException("No input instance format defined"); } if (m_NewBatch) { resetQueue(); m_NewBatch = false; } Instance newInstance = (Instance) instance.copy(); if ((int) newInstance.value(m_AttIndex.getIndex()) == m_SecondIndex.getIndex()) { newInstance.setValue(m_AttIndex.getIndex(), (double) m_FirstIndex.getIndex()); } else if ((int) newInstance.value(m_AttIndex.getIndex()) > m_SecondIndex.getIndex()) { newInstance.setValue(m_AttIndex.getIndex(), newInstance.value(m_AttIndex.getIndex()) - 1); } push(newInstance); return true; }
/** * Signify that this batch of input to the filter is finished. If the filter requires all * instances prior to filtering, output() may now be called to retrieve the filtered instances. * * @return true if there are instances pending output * @throws Exception if no input structure has been defined */ public boolean batchFinished() throws Exception { if (getInputFormat() == null) { throw new Exception("No input instance format defined"); } // Do the subsample, and clear the input instances. addNoise(getInputFormat(), m_RandomSeed, m_Percent, m_AttIndex.getIndex(), m_UseMissing); for (int i = 0; i < getInputFormat().numInstances(); i++) { push((Instance) getInputFormat().instance(i).copy()); } flushInput(); m_NewBatch = true; m_FirstBatchDone = true; return (numPendingOutput() != 0); }
/** * Input an instance for filtering. Ordinarily the instance is processed and made available for * output immediately. Some filters require all instances be read before producing output. * * @param instance the input instance * @return true if the filtered instance may now be collected with output(). * @throws IllegalStateException if no input format has been defined. */ public boolean input(Instance instance) { if (getInputFormat() == null) { throw new IllegalStateException("No input instance format defined"); } if (m_NewBatch) { resetQueue(); m_NewBatch = false; } Instance inst = (Instance) instance.copy(); // First copy string values from input to output copyValues(inst, true, inst.dataset(), getOutputFormat()); // Insert the new attribute and reassign to output inst.setDataset(null); inst.insertAttributeAt(m_Insert.getIndex()); inst.setDataset(getOutputFormat()); push(inst); return true; }
/** * Sets the format of the input instances. * * @param instanceInfo an Instances object containing the input instance structure (any instances * contained in the object are ignored - only the structure is required). * @return true if the outputFormat may be collected immediately * @throws Exception if the input format can't be set successfully */ public boolean setInputFormat(Instances instanceInfo) throws Exception { super.setInputFormat(instanceInfo); m_AttIndex.setUpper(instanceInfo.numAttributes() - 1); m_FirstIndex.setUpper(instanceInfo.attribute(m_AttIndex.getIndex()).numValues() - 1); m_SecondIndex.setUpper(instanceInfo.attribute(m_AttIndex.getIndex()).numValues() - 1); if ((instanceInfo.classIndex() > -1) && (instanceInfo.classIndex() == m_AttIndex.getIndex())) { throw new Exception("Cannot process class attribute."); } if (!instanceInfo.attribute(m_AttIndex.getIndex()).isNominal()) { throw new UnsupportedAttributeTypeException("Chosen attribute not nominal."); } if (instanceInfo.attribute(m_AttIndex.getIndex()).numValues() < 2) { throw new UnsupportedAttributeTypeException( "Chosen attribute has less than " + "two values."); } if (m_SecondIndex.getIndex() <= m_FirstIndex.getIndex()) { // XXX Maybe we should just swap the values?? throw new Exception("The second index has to be greater " + "than the first."); } setOutputFormat(); return true; }
/** * Set the output format. Takes the current average class values and m_InputFormat and calls * setOutputFormat(Instances) appropriately. */ private void setOutputFormat() { Instances newData; FastVector newAtts, newVals; boolean firstEndsWithPrime = false, secondEndsWithPrime = false; StringBuffer text = new StringBuffer(); // Compute new attributes newAtts = new FastVector(getInputFormat().numAttributes()); for (int j = 0; j < getInputFormat().numAttributes(); j++) { Attribute att = getInputFormat().attribute(j); if (j != m_AttIndex.getIndex()) { newAtts.addElement(att.copy()); } else { // Compute new value if (att.value(m_FirstIndex.getIndex()).endsWith("'")) { firstEndsWithPrime = true; } if (att.value(m_SecondIndex.getIndex()).endsWith("'")) { secondEndsWithPrime = true; } if (firstEndsWithPrime || secondEndsWithPrime) { text.append("'"); } if (firstEndsWithPrime) { text.append( ((String) att.value(m_FirstIndex.getIndex())) .substring(1, ((String) att.value(m_FirstIndex.getIndex())).length() - 1)); } else { text.append((String) att.value(m_FirstIndex.getIndex())); } text.append('_'); if (secondEndsWithPrime) { text.append( ((String) att.value(m_SecondIndex.getIndex())) .substring(1, ((String) att.value(m_SecondIndex.getIndex())).length() - 1)); } else { text.append((String) att.value(m_SecondIndex.getIndex())); } if (firstEndsWithPrime || secondEndsWithPrime) { text.append("'"); } // Compute list of attribute values newVals = new FastVector(att.numValues() - 1); for (int i = 0; i < att.numValues(); i++) { if (i == m_FirstIndex.getIndex()) { newVals.addElement(text.toString()); } else if (i != m_SecondIndex.getIndex()) { newVals.addElement(att.value(i)); } } Attribute newAtt = new Attribute(att.name(), newVals); newAtt.setWeight(getInputFormat().attribute(j).weight()); newAtts.addElement(newAtt); } } // Construct new header newData = new Instances(getInputFormat().relationName(), newAtts, 0); newData.setClassIndex(getInputFormat().classIndex()); setOutputFormat(newData); }