All Downloads are FREE. Search and download functionalities are using the official Maven repository.
Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $
You can buy this project and download/modify it how often you want.
weka.core.CheckOptionHandler Maven / Gradle / Ivy
The Waikato Environment for Knowledge Analysis (WEKA), a machine
learning workbench. This is the stable version. Apart from bugfixes, this version
does not receive any other updates.
/*
* 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 3 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, see
*
* Usage:
*
*
* CheckOptionHandler -W optionHandlerClassName -- test options
*
*
*
* Valid options are:
*
*
*
* -D
* Turn on debugging output.
*
*
*
* -S
* Silent mode - prints nothing to stdout.
*
*
*
* -W
* Full name of the OptionHandler analysed.
* eg: weka.classifiers.rules.ZeroR
* (default weka.classifiers.rules.ZeroR)
*
*
*
* Options specific to option handler weka.classifiers.rules.ZeroR:
*
*
*
* -D
* If set, classifier is run in debug mode and
* may output additional info to the console
*
*
*
*
* Options after -- are used as user options in testing the OptionHandler
*
* @author Len Trigg ([email protected] )
* @author FracPete (fracpete at waikato dot ac dot nz)
* @version $Revision: 10203 $
*/
public class CheckOptionHandler extends Check {
/** the optionhandler to test */
protected OptionHandler m_OptionHandler = new weka.classifiers.rules.ZeroR();
/** the user-supplied options */
protected String[] m_UserOptions = new String[0];
/** whether the tests were successful */
protected boolean m_Success;
/**
* Returns an enumeration describing the available options.
*
* @return an enumeration of all the available options.
*/
@Override
public Enumeration listOptions() {
Vector result = new Vector ();
result.addAll(Collections.list(super.listOptions()));
result.addElement(new Option("\tFull name of the OptionHandler analysed.\n"
+ "\teg: weka.classifiers.rules.ZeroR\n"
+ "\t(default weka.classifiers.rules.ZeroR)", "W", 1, "-W"));
if (m_OptionHandler != null) {
result.addElement(new Option("", "", 0,
"\nOptions specific to option handler "
+ m_OptionHandler.getClass().getName() + ":"));
result.addAll(Collections.list(m_OptionHandler.listOptions()));
}
return result.elements();
}
/**
* Parses a given list of options.
*
*
* Valid options are:
*
*
*
* -D
* Turn on debugging output.
*
*
*
* -S
* Silent mode - prints nothing to stdout.
*
*
*
* -W
* Full name of the OptionHandler analysed.
* eg: weka.classifiers.rules.ZeroR
* (default weka.classifiers.rules.ZeroR)
*
*
*
* Options specific to option handler weka.classifiers.rules.ZeroR:
*
*
*
* -D
* If set, classifier is run in debug mode and
* may output additional info to the console
*
*
*
*
* @param options the list of options as an array of strings
* @throws Exception if an option is not supported
*/
@Override
public void setOptions(String[] options) throws Exception {
String tmpStr;
super.setOptions(options);
tmpStr = Utils.getOption('W', options);
if (tmpStr.length() == 0) {
tmpStr = weka.classifiers.rules.ZeroR.class.getName();
}
setUserOptions(Utils.partitionOptions(options));
setOptionHandler((OptionHandler) Utils.forName(OptionHandler.class, tmpStr,
null));
}
/**
* Gets the current settings of the CheckClassifier.
*
* @return an array of strings suitable for passing to setOptions
*/
@Override
public String[] getOptions() {
Vector result = new Vector();
Collections.addAll(result, super.getOptions());
if (getOptionHandler() != null) {
result.add("-W");
result.add(getOptionHandler().getClass().getName());
}
if (m_OptionHandler != null) {
String[] options = m_OptionHandler.getOptions();
result.add("--");
Collections.addAll(result, options);
}
return result.toArray(new String[result.size()]);
}
/**
* Set the OptionHandler to work on..
*
* @param value the OptionHandler to use.
*/
public void setOptionHandler(OptionHandler value) {
m_OptionHandler = value;
}
/**
* Get the OptionHandler used in the tests.
*
* @return the OptionHandler used in the tests.
*/
public OptionHandler getOptionHandler() {
return m_OptionHandler;
}
/**
* Sets the user-supplied options (creates a copy)
*
* @param value the user-supplied options to use
*/
public void setUserOptions(String[] value) {
m_UserOptions = getCopy(value);
}
/**
* Gets the current user-supplied options (creates a copy)
*
* @return the user-supplied options
*/
public String[] getUserOptions() {
return getCopy(m_UserOptions);
}
/**
* returns the success of the tests
*
* @return true if the tests were successful
*/
public boolean getSuccess() {
return m_Success;
}
/**
* Prints the given options to a string.
*
* @param options the options to be joined
* @return the options as one long string
*/
protected String printOptions(String[] options) {
if (options == null) {
return ("");
} else {
return Utils.joinOptions(options);
}
}
/**
* Compares the two given sets of options.
*
* @param options1 the first set of options
* @param options2 the second set of options
* @throws Exception if the two sets of options differ
*/
protected void compareOptions(String[] options1, String[] options2)
throws Exception {
if (options1 == null) {
throw new Exception("first set of options is null!");
}
if (options2 == null) {
throw new Exception("second set of options is null!");
}
if (options1.length != options2.length) {
throw new Exception("problem found!\n" + "First set: "
+ printOptions(options1) + '\n' + "Second set: "
+ printOptions(options2) + '\n' + "options differ in length");
}
for (int i = 0; i < options1.length; i++) {
if (!options1[i].equals(options2[i])) {
throw new Exception("problem found!\n" + "\tFirst set: "
+ printOptions(options1) + '\n' + "\tSecond set: "
+ printOptions(options2) + '\n' + '\t' + options1[i] + " != "
+ options2[i]);
}
}
}
/**
* creates a copy of the given options
*
* @param options the options to copy
* @return the copy
*/
protected String[] getCopy(String[] options) {
String[] result;
result = new String[options.length];
System.arraycopy(options, 0, result, 0, options.length);
return result;
}
/**
* returns a new instance of the OptionHandler's class
*
* @return a new instance
*/
protected OptionHandler getDefaultHandler() {
OptionHandler result;
try {
result = m_OptionHandler.getClass().newInstance();
} catch (Exception e) {
e.printStackTrace();
result = null;
}
return result;
}
/**
* returns the default options the default OptionHandler will return
*
* @return the default options
*/
protected String[] getDefaultOptions() {
String[] result;
OptionHandler o;
o = getDefaultHandler();
if (o == null) {
println("WARNING: couldn't create default handler, cannot use default options!");
result = new String[0];
} else {
result = o.getOptions();
}
return result;
}
/**
* checks whether the listOptions method works
*
* @return index 0 is true if the test was passed, index 1 is always false
*/
public boolean checkListOptions() {
boolean result;
print("ListOptions...");
try {
Enumeration enu = getOptionHandler().listOptions();
if (getDebug() && enu.hasMoreElements()) {
println("");
}
while (enu.hasMoreElements()) {
Option option = enu.nextElement();
if (getDebug()) {
println(option.synopsis());
println(option.description());
}
}
println("yes");
result = true;
} catch (Exception e) {
println("no");
result = false;
if (getDebug()) {
println(e);
}
}
return result;
}
/**
* checks whether the user-supplied options can be processed at all
*
* @return index 0 is true if the test was passed, index 1 is always false
*/
public boolean checkSetOptions() {
boolean result;
print("SetOptions...");
try {
getDefaultHandler().setOptions(getUserOptions());
println("yes");
result = true;
} catch (Exception e) {
println("no");
result = false;
if (getDebug()) {
println(e);
}
}
return result;
}
/**
* checks whether the default options can be processed completely or some
* invalid options are returned by the getOptions() method.
*
* @return index 0 is true if the test was passed, index 1 is always false
*/
public boolean checkDefaultOptions() {
boolean result;
String[] options;
print("Default options...");
options = getDefaultOptions();
try {
getDefaultHandler().setOptions(options);
Utils.checkForRemainingOptions(options);
println("yes");
result = true;
} catch (Exception e) {
println("no");
result = false;
if (getDebug()) {
println(e);
}
}
return result;
}
/**
* checks whether the user-supplied options can be processed completely or
* some "left-over" options remain
*
* @return index 0 is true if the test was passed, index 1 is always false
*/
public boolean checkRemainingOptions() {
boolean result;
String[] options;
print("Remaining options...");
options = getUserOptions();
try {
getDefaultHandler().setOptions(options);
if (getDebug()) {
println("\n remaining: " + printOptions(options));
}
println("yes");
result = true;
} catch (Exception e) {
println("no");
result = false;
if (getDebug()) {
println(e);
}
}
return result;
}
/**
* checks whether the user-supplied options stay the same after settting,
* getting and re-setting again
*
* @return index 0 is true if the test was passed, index 1 is always false
*/
public boolean checkCanonicalUserOptions() {
boolean result;
OptionHandler handler;
String[] userOptions;
String[] userOptionsCheck;
print("Canonical user options...");
try {
handler = getDefaultHandler();
handler.setOptions(getUserOptions());
if (getDebug()) {
print("\n Getting canonical user options: ");
}
userOptions = handler.getOptions();
if (getDebug()) {
println(printOptions(userOptions));
}
if (getDebug()) {
println(" Setting canonical user options");
}
handler.setOptions(userOptions.clone());
if (getDebug()) {
println(" Checking canonical user options");
}
userOptionsCheck = handler.getOptions();
compareOptions(userOptions, userOptionsCheck);
println("yes");
result = true;
} catch (Exception e) {
println("no");
result = false;
if (getDebug()) {
println(e);
}
}
return result;
}
/**
* checks whether the optionhandler can be re-setted again to default options
* after the user-supplied options have been set.
*
* @return index 0 is true if the test was passed, index 1 is always false
*/
public boolean checkResettingOptions() {
boolean result;
String[] defaultOptions;
String[] defaultOptionsCheck;
OptionHandler handler;
print("Resetting options...");
try {
if (getDebug()) {
println("\n Setting user options");
}
handler = getDefaultHandler();
handler.setOptions(getUserOptions());
defaultOptions = getDefaultOptions();
if (getDebug()) {
println(" Resetting to default options");
}
handler.setOptions(getCopy(defaultOptions));
if (getDebug()) {
println(" Checking default options match previous default");
}
defaultOptionsCheck = handler.getOptions();
compareOptions(defaultOptions, defaultOptionsCheck);
println("yes");
result = true;
} catch (Exception e) {
println("no");
result = false;
if (getDebug()) {
println(e);
}
}
return result;
}
/**
* Runs some diagnostic tests on an optionhandler object. Output is printed to
* System.out (if not silent).
*/
@Override
public void doTests() {
println("OptionHandler: " + m_OptionHandler.getClass().getName() + "\n");
if (getDebug()) {
println("--> Info");
print("Default options: ");
println(printOptions(getDefaultOptions()));
print("User options: ");
println(printOptions(getUserOptions()));
}
println("--> Tests");
m_Success = checkListOptions();
if (m_Success) {
m_Success = checkSetOptions();
}
if (m_Success) {
m_Success = checkDefaultOptions();
}
if (m_Success) {
m_Success = checkRemainingOptions();
}
if (m_Success) {
m_Success = checkCanonicalUserOptions();
}
if (m_Success) {
m_Success = checkResettingOptions();
}
}
/**
* Returns the revision string.
*
* @return the revision
*/
@Override
public String getRevision() {
return RevisionUtils.extract("$Revision: 10203 $");
}
/**
* Main method for using the CheckOptionHandler.
*
* @param args the options to the CheckOptionHandler
*/
public static void main(String[] args) {
CheckOptionHandler check = new CheckOptionHandler();
runCheck(check, args);
if (check.getSuccess()) {
System.exit(0);
} else {
System.exit(1);
}
}
}
