index
int64 | repo_id
string | file_path
string | content
string |
|---|---|---|---|
0
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml/Array.java
|
/*
* 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 <http://www.gnu.org/licenses/>.
*/
/*
* Array.java
* Copyright (C) 2009-2012 University of Waikato, Hamilton, New Zealand
*
*/
package weka.core.pmml;
import java.io.Serializable;
import java.io.StreamTokenizer;
import java.io.StringReader;
import java.util.ArrayList;
import java.util.List;
import org.w3c.dom.Element;
/**
* Class for encapsulating a PMML Array element.
*
* @author Mark Hall (mhall{[at]}pentaho{[dot]}com)
* @version $Revision$
*/
public class Array implements Serializable {
/** ID added to avoid warning */
private static final long serialVersionUID = 4286234448957826177L;
/**
* Utility method to check if an XML element is an array.
*
* @param arrayE the XML element to check
* @return returns true if the XML element is an array
*/
public static boolean isArray(Element arrayE) {
String name = arrayE.getTagName();
if (name.equals("Array") || name.equals("NUM-ARRAY")
|| name.equals("INT-ARRAY") || name.equals("REAL-ARRAY")
|| name.equals("STRING-ARRAY") || isSparseArray(arrayE)) {
return true;
}
return false;
}
/**
* Utility method to check if an XML element is a sparse array.
*
* @param arrayE the XML element to check.
* @return true if the XML element is a sparse array.
*/
private static boolean isSparseArray(Element arrayE) {
String name = arrayE.getTagName();
if (name.equals("INT-SparseArray") || name.equals("REAL-SparseArray")) {
return true;
}
return false;
}
public static Array create(List<Object> values, List<Integer> indices)
throws Exception {
ArrayType type = null;
Object first = values.get(0);
if ((first instanceof Double) || (first instanceof Float)) {
type = ArrayType.REAL;
} else if ((first instanceof Integer) || (first instanceof Long)) {
type = ArrayType.INT;
} else if ((first instanceof String)) {
type = ArrayType.STRING;
} else {
throw new Exception("[Array] unsupport type!");
}
if (indices != null) {
// array is sparse
if (indices.size() != values.size()) {
throw new Exception("[Array] num values is not equal to num indices!!");
}
if (type == ArrayType.REAL) {
type = ArrayType.REAL_SPARSE;
} else if (type == ArrayType.INT) {
type = ArrayType.INT_SPARSE;
} else {
throw new Exception(
"[Array] sparse arrays can only be integer, long, float or double!");
}
return new SparseArray(type, values, indices);
}
return new Array(type, values);
}
/**
* Static factory method for creating non-sparse or sparse array types as
* needed.
*
* @param arrayE the XML element encapsulating the array
* @return an appropriate Array type
* @throws Exception if there is a problem when constructing the array
*/
public static Array create(Element arrayE) throws Exception {
if (!isArray(arrayE)) {
throw new Exception(
"[Array] the supplied element does not contain an array!");
}
if (isSparseArray(arrayE)) {
return new SparseArray(arrayE);
}
return new Array(arrayE);
}
public static enum ArrayType {
NUM("NUM-ARRAY"), INT("INT-ARRAY"), REAL("REAL-ARRAY"), STRING(
"STRING-ARRAY"), REAL_SPARSE("REAL-SparseArray"), INT_SPARSE(
"INT-SparseArray");
private final String m_stringVal;
ArrayType(String name) {
m_stringVal = name;
}
@Override
public String toString() {
return m_stringVal;
}
}
/** The values of the array */
protected ArrayList<String> m_values = new ArrayList<String>();
/** The type of the array */
protected ArrayType m_type = ArrayType.NUM;
protected void initialize(Element arrayE) throws Exception {
String arrayS = arrayE.getTagName();
// get the type of the array
if (arrayS.equals("Array")) {
String type = arrayE.getAttribute("type");
if (type.equals("int")) {
m_type = ArrayType.INT;
} else if (type.equals("real")) {
m_type = ArrayType.REAL;
} else if (type.equals("string")) {
m_type = ArrayType.STRING;
}
} else {
for (ArrayType a : ArrayType.values()) {
if (a.toString().equals(arrayS)) {
m_type = a;
break;
}
}
}
// now read the values
String contents = arrayE.getChildNodes().item(0).getNodeValue();
StringReader sr = new StringReader(contents);
StreamTokenizer st = new StreamTokenizer(sr);
st.resetSyntax();
st.whitespaceChars(0, ' ');
st.wordChars(' ' + 1, '\u00FF');
st.whitespaceChars(' ', ' ');
st.quoteChar('"');
st.quoteChar('\'');
// m_Tokenizer.eolIsSignificant(true);
st.nextToken();
while (st.ttype != StreamTokenizer.TT_EOF
&& st.ttype != StreamTokenizer.TT_EOL) {
m_values.add(st.sval);
st.nextToken();
}
}
/**
* Construct an array from an XML node
*
* @param arrayE the Element containing the XML
* @throws Exception if something goes wrong
*/
protected Array(Element arrayE) throws Exception {
initialize(arrayE);
}
/**
* Construct an array from the given values.
*
* @param type the type of the elements.
* @param values the values of the array.
*/
protected Array(ArrayType type, List<Object> values) {
m_values = new ArrayList<String>();
m_type = type;
for (Object o : values) {
m_values.add(o.toString());
}
}
/**
* Get the type of this array.
*
* @return the type of the array.
*/
public ArrayType getType() {
return m_type;
}
/**
* Is this array a SparseArray?
*
* @return true if this array is sparse.
*/
public boolean isSparse() {
return false;
}
/**
* Get the number of values in this array.
*
* @return the number of values in this array.
*/
public int numValues() {
return m_values.size();
}
/**
* Returns true if the array contains this string value.
*
* @param value the value to check for.
* @return true if the array contains this string value
*/
public boolean contains(String value) {
return m_values.contains(value);
}
/**
* Returns true if the array contains this integer value.
*
* @param value the value to check for
* @return true if the array contains this integer value
*/
public boolean contains(int value) {
return contains(new Integer(value).toString());
}
/**
* Returns true if the array contains this real value.
*
* @param value the value to check for
* @return true if the array contains this real value
*/
public boolean contains(double value) {
return contains(new Double(value).toString());
}
/**
* Returns true if the array contains this real value.
*
* @param value the value to check for
* @return true if the array contains this real value
*/
public boolean contains(float value) {
return contains(new Float(value).toString());
}
private void checkInRange(int index) throws Exception {
if (index >= m_values.size() || index < 0) {
throw new IllegalArgumentException("[Array] index out of range " + index);
}
}
/**
* Returns the index of the value stored at the given position
*
* @param position the position
* @return the index of the value stored at the given position
*/
public int index(int position) {
return position; // position is the index for dense arrays
}
/**
* Gets the value at index from the array.
*
* @param index the index of the value to get.
* @return the value at index in the array as as String.
* @throws Exception if index is out of bounds.
*/
public String value(int index) throws Exception {
return actualValue(index);
}
/**
* Gets the value at index from the array
*
* @param index the index of the value to get.
* @return the value at index in the array as as String.
* @throws Exception if index is out of bounds.
*/
protected String actualValue(int index) throws Exception {
checkInRange(index);
return m_values.get(index);
}
/**
* Gets the value at index from the array as a String. Calls value().
*
* @param index the index of the value to get.
* @return the value at index in the array as a String.
* @throws Exception if index is out of bounds.
*/
public String valueString(int index) throws Exception {
return value(index);
}
/**
* Gets the value at index from the array as a double.
*
* @param index the index of the value to get.
* @return the value at index in the array as a double.
* @throws Exception if index is out of bounds.
*/
public double valueDouble(int index) throws Exception {
if (m_type == ArrayType.STRING) {
throw new Exception("[Array] Array does not contain numbers!");
}
return Double.parseDouble(value(index));
}
/**
* Gets the value at index from the array as a float.
*
* @param index the index of the value to get.
* @return the value at index in the array as a float.
* @throws Exception if index is out of bounds.
*/
public float valueFloat(int index) throws Exception {
if (m_type == ArrayType.STRING) {
throw new Exception("[Array] Array does not contain numbers!");
}
return Float.parseFloat(value(index));
}
/**
* Gets the value at index from the array as an int.
*
* @param index the index of the value to get.
* @return the value at index in the array as an int.
* @throws Exception if index is out of bounds.
*/
public int valueInt(int index) throws Exception {
if (m_type != ArrayType.INT && m_type != ArrayType.INT_SPARSE) {
throw new Exception("[Array] Array does not contain integers!");
}
return Integer.parseInt(value(index));
}
/**
* Gets the value at indexOfIndex from the array. Does the same as value() if
* this array is not sparse.
*
* @param indexOfIndex the index of the index of the value to get.
* @return a value from the array as a String.
* @throws Exception if indexOfIndex is out of bounds.
*/
public String valueSparse(int indexOfIndex) throws Exception {
return actualValue(indexOfIndex);
}
/**
* Gets the value at indexOfIndex from the array. Does the same as value() if
* this array is not sparse.
*
* @param indexOfIndex the index of the index of the value to get.
* @return a value from the array as a String.
* @throws Exception if indexOfIndex is out of bounds.
*/
public String valueSparseString(int indexOfIndex) throws Exception {
return valueSparse(indexOfIndex);
}
/**
* Gets the value at indexOfIndex from the array. Does the same as value() if
* this array is not sparse.
*
* @param indexOfIndex the index of the index of the value to get.
* @return a value from the array as a double.
* @throws Exception if indexOfIndex is out of bounds.
*/
public double valueSparseDouble(int indexOfIndex) throws Exception {
return Double.parseDouble(actualValue(indexOfIndex));
}
/**
* Gets the value at indexOfIndex from the array. Does the same as value() if
* this array is not sparse.
*
* @param indexOfIndex the index of the index of the value to get.
* @return a value from the array as a float.
* @throws Exception if indexOfIndex is out of bounds.
*/
public float valueSparseFloat(int indexOfIndex) throws Exception {
return Float.parseFloat(actualValue(indexOfIndex));
}
/**
* Gets the value at indexOfIndex from the array. Does the same as value() if
* this array is not sparse.
*
* @param indexOfIndex the index of the index of the value to get.
* @return a value from the array as an int.
* @throws Exception if indexOfIndex is out of bounds.
*/
public int valueSparseInt(int indexOfIndex) throws Exception {
return Integer.parseInt(actualValue(indexOfIndex));
}
@Override
public String toString() {
StringBuffer text = new StringBuffer();
text.append("<");
for (int i = 0; i < m_values.size(); i++) {
text.append(m_values.get(i));
if (i < m_values.size() - 1) {
text.append(",");
}
}
text.append(">");
return text.toString();
}
}
|
0
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml/BuiltInArithmetic.java
|
/*
* 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 <http://www.gnu.org/licenses/>.
*/
/*
* Arithmetic.java
* Copyright (C) 2008-2012 University of Waikato, Hamilton, New Zealand
*
*/
package weka.core.pmml;
import java.util.ArrayList;
import weka.core.Attribute;
/**
* Built-in function for +, -, *, /.
*
* @author Mark Hall (mhall{[at]}pentaho{[dot]}com)
* @version $Revision 1.0 $
*/
public class BuiltInArithmetic extends Function {
/**
* For serialization.
*/
private static final long serialVersionUID = 2275009453597279459L;
/**
* Enumerated type for the operator.
*/
enum Operator {
ADDITION (" + ") {
double eval(double a, double b) {
return a + b;
}
},
SUBTRACTION (" - ") {
double eval(double a, double b) {
return a - b;
}
},
MULTIPLICATION (" * ") {
double eval(double a, double b) {
return a * b;
}
},
DIVISION (" / ") {
double eval(double a, double b) {
return a / b;
}
};
abstract double eval(double a, double b);
private final String m_stringVal;
Operator(String opName) {
m_stringVal = opName;
}
public String toString() {
return m_stringVal;
}
}
/** The operator for this function */
protected Operator m_operator = Operator.ADDITION;
/**
* Construct a new Arithmetic built-in pmml function.
* @param op the operator to use.
*/
public BuiltInArithmetic(Operator op) {
m_operator = op;
m_functionName = m_operator.toString();
}
/**
* Set the structure of the parameters that are expected as input by
* this function. This must be called before getOutputDef() is called.
*
* @param paramDefs the structure of the input parameters
* @throws Exception if the number or types of parameters are not acceptable by
* this function
*/
public void setParameterDefs(ArrayList<Attribute> paramDefs) throws Exception {
m_parameterDefs = paramDefs;
if (m_parameterDefs.size() != 2) {
throw new Exception("[Arithmetic] wrong number of parameters. Recieved "
+ m_parameterDefs.size() + ", expected 2.");
}
}
/**
* Returns an array of the names of the parameters expected
* as input by this function
*
* @return an array of the parameter names
*/
public String[] getParameterNames() {
String[] result = {"A", "B"};
return result;
}
/**
* Get the structure of the result produced by this function.
* Subclasses must implement.
*
* @return the structure of the result produced by this function.
*/
public Attribute getOutputDef() {
return new Attribute("BuiltInArithmeticResult:" + m_operator.toString());
}
/**
* Get the result of applying this function.
*
* @param incoming the arguments to this function (supplied in order to match that
* of the parameter definitions
* @return the result of applying this function. When the optype is
* categorical or ordinal, an index into the values of the output definition
* is returned.
* @throws Exception if there is a problem computing the result of this function
*/
public double getResult(double[] incoming) throws Exception {
if (m_parameterDefs == null) {
throw new Exception("[BuiltInArithmetic] incoming parameter structure has not been set!");
}
if (m_parameterDefs.size() != 2 || incoming.length != 2) {
throw new Exception("[BuiltInArithmetic] wrong number of parameters!");
}
double result = m_operator.eval(incoming[0], incoming[1]);
return result;
}
public String toString() {
return toString("");
}
public String toString(String pad) {
return pad + m_parameterDefs.get(0).name() + m_functionName
+ m_parameterDefs.get(1).name();
}
}
|
0
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml/BuiltInMath.java
|
/*
* 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 <http://www.gnu.org/licenses/>.
*/
/*
* Arithmetic.java
* Copyright (C) 2008-2012 University of Waikato, Hamilton, New Zealand
*
*/
package weka.core.pmml;
import java.util.ArrayList;
import weka.core.Attribute;
import weka.core.Utils;
/**
* Built-in function for min, max, sum, avg, log10,
* ln, sqrt, abs, exp, pow, threshold, floor, ceil and round.
*
* @author Mark Hall (mhall{[at]}pentaho{[dot]}com)
* @version $Revision 1.0 $
*/
public class BuiltInMath extends Function {
/**
* For serialization
*/
private static final long serialVersionUID = -8092338695602573652L;
/**
* Enum for the math functions.
*/
enum MathFunc {
MIN ("min") {
double eval(double[] args) {
return args[Utils.minIndex(args)];
}
boolean legalNumParams(int num) {
return (num > 0);
}
String[] getParameterNames() {
return null; // unbounded number of parameters
}
},
MAX ("max") {
double eval(double[] args) {
return args[Utils.maxIndex(args)];
}
boolean legalNumParams(int num) {
return (num > 0);
}
String[] getParameterNames() {
return null; // unbounded number of parameters
}
},
SUM ("sum") {
double eval(double[] args) {
return Utils.sum(args);
}
boolean legalNumParams(int num) {
return (num > 0);
}
String[] getParameterNames() {
return null; // unbounded number of parameters
}
},
AVG ("avg") {
double eval(double[] args) {
return Utils.mean(args);
}
boolean legalNumParams(int num) {
return (num > 0);
}
String[] getParameterNames() {
return null; // unbounded number of parameters
}
},
LOG10 ("log10") {
double eval(double[] args) {
return Math.log10(args[0]);
}
boolean legalNumParams(int num) {
return (num == 1);
}
String[] getParameterNames() {
return new String[] {"A"};
}
},
LN ("ln") {
double eval(double[] args) {
return Math.log(args[0]);
}
boolean legalNumParams(int num) {
return (num == 1);
}
String[] getParameterNames() {
return new String[] {"A"};
}
},
SQRT ("sqrt") {
double eval(double[] args) {
return Math.sqrt(args[0]);
}
boolean legalNumParams(int num) {
return (num == 1);
}
String[] getParameterNames() {
return new String[] {"A"};
}
},
ABS ("abs") {
double eval(double[] args) {
return Math.abs(args[0]);
}
boolean legalNumParams(int num) {
return (num == 1);
}
String[] getParameterNames() {
return new String[] {"A"};
}
},
EXP ("exp") {
double eval(double[] args) {
return Math.exp(args[0]);
}
boolean legalNumParams(int num) {
return (num == 1);
}
String[] getParameterNames() {
return new String[] {"A"};
}
},
POW ("pow") {
double eval(double[] args) {
return Math.pow(args[0], args[1]);
}
boolean legalNumParams(int num) {
return (num == 2);
}
String[] getParameterNames() {
return new String[] {"A", "B"};
}
},
THRESHOLD ("threshold") {
double eval(double[] args) {
if (args[0] > args[1]) {
return 1.0;
} else {
return 0.0;
}
}
boolean legalNumParams(int num) {
return (num == 2);
}
String[] getParameterNames() {
return new String[] {"A", "B"};
}
},
FLOOR ("floor") {
double eval(double[] args) {
return Math.floor(args[0]);
}
boolean legalNumParams(int num) {
return (num == 1);
}
String[] getParameterNames() {
return new String[] {"A"};
}
},
CEIL ("ceil") {
double eval(double[] args) {
return Math.ceil(args[0]);
}
boolean legalNumParams(int num) {
return (num == 1);
}
String[] getParameterNames() {
return new String[] {"A"};
}
},
ROUND ("round") {
double eval(double[] args) {
return Math.round(args[0]);
}
boolean legalNumParams(int num) {
return (num == 1);
}
String[] getParameterNames() {
return new String[] {"A"};
}
};
abstract double eval(double[] args);
abstract boolean legalNumParams(int num);
abstract String[] getParameterNames();
private final String m_stringVal;
MathFunc(String funcName) {
m_stringVal = funcName;
}
public String toString() {
return m_stringVal;
}
}
/** The function to apply */
protected MathFunc m_func = MathFunc.ABS;
/**
* Construct a new built-in pmml Math function.
* @param func the math function to use
*/
public BuiltInMath(MathFunc func) {
m_func = func;
m_functionName = m_func.toString();
}
/**
* Set the structure of the parameters that are expected as input by
* this function. This must be called before getOutputDef() is called.
*
* @param paramDefs the structure of the input parameters
* @throws Exception if the number or types of parameters are not acceptable by
* this function
*/
public void setParameterDefs(ArrayList<Attribute> paramDefs) throws Exception {
m_parameterDefs = paramDefs;
if (!m_func.legalNumParams(m_parameterDefs.size())) {
throw new Exception("[BuiltInMath] illegal number of parameters for function: "
+ m_functionName);
}
}
/**
* Get the structure of the result produced by this function.
* Subclasses must implement.
*
* @return the structure of the result produced by this function.
*/
public Attribute getOutputDef() {
return new Attribute("BuiltInMathResult:" + m_func.toString());
}
/**
* Returns an array of the names of the parameters expected
* as input by this function. May return null if the function
* can accept an unbounded number of arguments.
*
* @return an array of the parameter names (or null if the function
* can accept any number of arguments).
*/
public String[] getParameterNames() {
return m_func.getParameterNames();
}
/**
* Get the result of applying this function.
*
* @param incoming the arguments to this function (supplied in order to match that
* of the parameter definitions
* @return the result of applying this function. When the optype is
* categorical or ordinal, an index into the values of the output definition
* is returned.
* @throws Exception if there is a problem computing the result of this function
*/
public double getResult(double[] incoming) throws Exception {
if (m_parameterDefs == null) {
throw new Exception("[BuiltInMath] incoming parameter structure has not been set");
}
if (!m_func.legalNumParams(incoming.length)) {
throw new Exception("[BuiltInMath] wrong number of parameters!");
}
double result = m_func.eval(incoming);
return result;
}
public String toString() {
String result = m_func.toString() + "(";
for (int i = 0; i < m_parameterDefs.size(); i++) {
result += m_parameterDefs.get(i).name();
if (i != m_parameterDefs.size() - 1) {
result += ", ";
} else {
result += ")";
}
}
return result;
}
}
|
0
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml/BuiltInString.java
|
package weka.core.pmml;
import java.util.ArrayList;
import weka.core.Attribute;
/**
* Built-in function for uppercase, substring and trimblanks.
*
* @author Mark Hall (mhall{[at]}pentaho{[dot]}com
* @version $Revision 1.0 $
*/
public class BuiltInString extends Function {
/**
* For serialization
*/
private static final long serialVersionUID = -7391516909331728653L;
/**
* Enum for the string functions
*/
enum StringFunc {
UPPERCASE ("uppercase") {
String eval(Object[] args) {
return ((String)args[0]).toUpperCase();
}
boolean legalNumParams(int num) {
return (num == 1);
}
String[] getParameterNames() {
return new String[] {"input"};
}
},
SUBSTRING ("substring") {
String eval(Object[] args) {
String input = (String)args[0];
int startPos = ((Integer)args[1]).intValue();
int length = ((Integer)args[2]).intValue();
return input.substring(startPos-1, startPos + length);
}
boolean legalNumParams(int num) {
return (num == 3);
}
String[] getParameterNames() {
return new String[] {"input", "startPos", "length"};
}
},
TRIMBLANKS ("trimBlanks") {
String eval(Object[] args) {
return ((String)args[0]).trim();
}
boolean legalNumParams(int num) {
return (num == 1);
}
String[] getParameterNames() {
return new String[] {"input"};
}
};
abstract String eval(Object[] args);
abstract boolean legalNumParams(int num);
abstract String[] getParameterNames();
private String m_stringVal;
StringFunc(String funcName) {
m_stringVal = funcName;
}
public String toString() {
return m_stringVal;
}
}
/** The function to apply */
protected StringFunc m_func;
/** The output structure produced by this function */
protected Attribute m_outputDef = null;
BuiltInString(StringFunc func) {
m_func = func;
m_functionName = m_func.toString();
}
/**
* Get the structure of the result produced by this function.
* Subclasses must implement.
*
* @return the structure of the result produced by this function.
*/
public Attribute getOutputDef() {
if (m_outputDef == null) {
if (m_func == StringFunc.SUBSTRING) {
// there is no way we can compute the legal values for this attribute
// in advance of the application of this function. So return a string attribute
m_outputDef = new Attribute("BuiltInStringResult:substring", (ArrayList<String>)null);
}
// for the other functions we can compute the resulting set of values
Attribute inputVals = m_parameterDefs.get(0);
ArrayList<String> newVals = new ArrayList<String>();
for (int i = 0; i < inputVals.numValues(); i++) {
String inVal = inputVals.value(i);
newVals.add(m_func.eval(new Object[] {inVal}));
}
m_outputDef = new Attribute("BuiltInStringResult:" + m_func.toString(), newVals);
}
return m_outputDef;
}
/**
* Returns an array of the names of the parameters expected
* as input by this function. May return null if the function
* can accept an unbounded number of arguments.
*
* @return an array of the parameter names (or null if the function
* can accept any number of arguments).
*/
public String[] getParameterNames() {
return m_func.getParameterNames();
}
private Object[] setUpArgs(double[] incoming) {
// construct the input to the function
Object[] args = new Object[incoming.length];
Attribute input = m_parameterDefs.get(0);
args[0] = input.value((int)incoming[0]);
for (int i = 1; i < incoming.length; i++) {
args[i] = new Integer((int)incoming[i]);
}
return args;
}
/**
* Get the result of applying this function.
*
* @param incoming the arguments to this function (supplied in order to match that
* of the parameter definitions
* @return the result of applying this function. When the optype is
* categorical or ordinal, an index into the values of the output definition
* is returned.
* @throws Exception if there is a problem computing the result of this function
*/
public double getResult(double[] incoming) throws Exception {
if (m_parameterDefs == null) {
throw new Exception("[BuiltInString] incoming parameter structure has not been set");
}
if (!m_func.legalNumParams(incoming.length)) {
throw new Exception("[BuiltInString] wrong number of parameters!");
}
// construct the input to the function
Object[] args = setUpArgs(incoming);
// get the result
String result = m_func.eval(args);
int resultI = m_outputDef.indexOfValue(result);
if (resultI < 0) {
if (m_outputDef.isString()) {
// add this as a new value
resultI = m_outputDef.addStringValue(result);
} else {
throw new Exception("[BuiltInString] unable to find value " + result
+ " in nominal result type!");
}
}
return resultI;
}
/**
* Get the result of applying this function when the output type categorical.
* Will throw an exception for numeric output. If subclasses output definition
* is a string attribute (i.e. because all legal values can't be computed apriori),
* then the subclass will need to overide this method and return something sensible
* in this case.
*
* @param incoming the incoming arguments to this function (supplied in order to match
* that of the parameter definitions
* @return the result of applying this function as a String.
* @throws Exception if this method is not applicable because the optype is not
* categorical/ordinal
*
public String getResultCategorical(double[] incoming) throws Exception {
if (m_parameterDefs == null) {
throw new Exception("[BuiltInString] incoming parameter structure has not been set");
}
if (!m_func.legalNumParams(incoming.length)) {
throw new Exception("[BuiltInString] wrong number of parameters!");
}
// construct the input to the function
Object[] args = setUpArgs(incoming);
// get the result
String result = m_func.eval(args);
return result;
}*/
/**
* Set the structure of the parameters that are expected as input by
* this function. This must be called before getOutputDef() is called.
*
* @param paramDefs the structure of the input parameters
* @throws Exception if the number or types of parameters are not acceptable by
* this function
*/
public void setParameterDefs(ArrayList<Attribute> paramDefs) throws Exception {
m_parameterDefs = paramDefs;
if (!m_func.legalNumParams(m_parameterDefs.size())) {
throw new Exception("[BuiltInMath] illegal number of parameters for function: "
+ m_functionName);
}
}
public String toString() {
String result = m_func.toString() + "(";
for (int i = 0; i < m_parameterDefs.size(); i++) {
result += m_parameterDefs.get(i).name();
if (i != m_parameterDefs.size() - 1) {
result += ", ";
} else {
result += ")";
}
}
return result;
}
}
|
0
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml/Constant.java
|
/*
* 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 <http://www.gnu.org/licenses/>.
*/
/*
* Constant.java
* Copyright (C) 2008-2012 University of Waikato, Hamilton, New Zealand
*
*/
package weka.core.pmml;
import java.util.ArrayList;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import weka.core.Attribute;
/**
* Class encapsulating a Constant Expression.
*
* @author Mark Hall (mhall{[at]}pentaho{[dot]}com
* @version $Revision 1.0 $
*/
public class Constant extends Expression {
/**
* For serialization
*/
private static final long serialVersionUID = -304829687822452424L;
protected String m_categoricalConst = null;
protected double m_continuousConst = Double.NaN;
/**
* Construct an new Constant Expression.
*
* @param constant the xml Element containing the Constant
* @param opType the optype for the Constant
* @param fieldDefs an ArrayList of Attributes for the fields that this
* Expression might need to access (not needed for a constant!)
* @throws Exception if the optype is specified as continuous
* and there is a problem parsing the value of the Constant
*/
public Constant(Element constant, FieldMetaInfo.Optype opType, ArrayList<Attribute> fieldDefs)
throws Exception {
super(opType, fieldDefs);
NodeList constL = constant.getChildNodes();
String c = constL.item(0).getNodeValue();
if (m_opType == FieldMetaInfo.Optype.CATEGORICAL ||
m_opType == FieldMetaInfo.Optype.ORDINAL) {
m_categoricalConst = c;
} else {
try {
m_continuousConst = Double.parseDouble(c);
} catch (IllegalArgumentException ex) {
throw new Exception("[Constant] Unable to parse continuous constant: "
+ c);
}
}
}
/**
* Return the structure of the result of applying this Expression
* as an Attribute.
*
* @return the structure of the result of applying this Expression as an
* Attribute.
*/
protected Attribute getOutputDef() {
if (m_opType == FieldMetaInfo.Optype.CONTINUOUS) {
return new Attribute("Constant: " + m_continuousConst);
}
ArrayList<String> nom = new ArrayList<String>();
nom.add(m_categoricalConst);
return new Attribute("Constant: " + m_categoricalConst, nom);
}
/**
* Get the result of evaluating the expression. In the case
* of a continuous optype, a real number is returned; in
* the case of a categorical/ordinal optype, the index of the nominal
* value is returned as a double.
*
* @param incoming the incoming parameter values
* @return the result of evaluating the expression
*/
public double getResult(double[] incoming) {
if (m_opType == FieldMetaInfo.Optype.CONTINUOUS) {
return m_continuousConst;
}
return 0; // constant (first and only value of a nominal attribute)
}
/**
* Gets the result of evaluating the expression when the
* optype is categorical or ordinal as the actual String
* value.
*
* @param incoming the incoming parameter values
* @return the result of evaluating the expression
* @throws Exception if the optype is continuous
*/
public String getResultCategorical(double[] incoming)
throws Exception {
if (m_opType == FieldMetaInfo.Optype.CONTINUOUS) {
throw new IllegalArgumentException("[Constant] Cant't return result as "
+"categorical/ordinal as optype is continuous!");
}
return m_categoricalConst;
}
public static void main(String[] args) {
try {
java.io.File f = new java.io.File(args[0]);
javax.xml.parsers.DocumentBuilderFactory dbf = javax.xml.parsers.DocumentBuilderFactory.newInstance();
javax.xml.parsers.DocumentBuilder db = dbf.newDocumentBuilder();
org.w3c.dom.Document doc = db.parse(f);
doc.getDocumentElement().normalize();
NodeList constL = doc.getElementsByTagName("Constant");
Node c = constL.item(0);
if (c.getNodeType() == Node.ELEMENT_NODE) {
Constant constC = new Constant((Element)c, FieldMetaInfo.Optype.CONTINUOUS, null);
System.err.println("Value of first constant: " + constC.getResult(null));
}
} catch (Exception ex) {
ex.printStackTrace();
}
}
public String toString(String pad) {
return pad + "Constant: " + ((m_categoricalConst != null)
? m_categoricalConst
: "" + m_continuousConst);
}
}
|
0
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml/DefineFunction.java
|
/*
* 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 <http://www.gnu.org/licenses/>.
*/
/*
* DefineFunction.java
* Copyright (C) 2008-2012 University of Waikato, Hamilton, New Zealand
*
*/
package weka.core.pmml;
import java.util.ArrayList;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import weka.core.Attribute;
/**
* Class encapsulating DefineFunction (used in TransformationDictionary).
*
* @author Mark Hall (mhall{[at]}pentaho{[dot]}com
* @version $Revision 1.0 $
*/
public class DefineFunction extends Function {
/**
* For serialization
*/
private static final long serialVersionUID = -1976646917527243888L;
/**
* Inner class for handling Parameters
*/
protected class ParameterField extends FieldMetaInfo {
/**
* For serialization
*/
private static final long serialVersionUID = 3918895902507585558L;
protected ParameterField(Element field) {
super(field);
}
public Attribute getFieldAsAttribute() {
if (m_optype == Optype.CONTINUOUS) {
return new Attribute(m_fieldName);
}
// return a string attribute for categorical/ordinal optypes
return new Attribute(m_fieldName, (ArrayList<String>)null);
}
}
/**
* The list of parameters expected by this function. We can use this to do
* some error/type checking when users call setParameterDefs() on us
*/
protected ArrayList<ParameterField> m_parameters = new ArrayList<ParameterField>();
/** The optype for this function */
FieldMetaInfo.Optype m_optype = FieldMetaInfo.Optype.NONE;
/** The Expression for this function to use */
protected Expression m_expression = null;
public DefineFunction(Element container, TransformationDictionary transDict) throws Exception {
m_functionName = container.getAttribute("name");
// get the optype for this function
String opType = container.getAttribute("optype");
if (opType != null && opType.length() > 0) {
for (FieldMetaInfo.Optype o : FieldMetaInfo.Optype.values()) {
if (o.toString().equals(opType)) {
m_optype = o;
break;
}
}
} else {
throw new Exception("[DefineFunction] no optype specified!!");
}
m_parameterDefs = new ArrayList<Attribute>();
// get all the parameters
NodeList paramL = container.getElementsByTagName("ParameterField");
for (int i = 0; i < paramL.getLength(); i++) {
Node paramN = paramL.item(i);
if (paramN.getNodeType() == Node.ELEMENT_NODE) {
ParameterField newP = new ParameterField((Element)paramN);
m_parameters.add(newP);
// set up default parameter definitions - these will probably get replaced
// by more informative ones (i.e. possibly nominal attributes instead of
// string attributes) later
m_parameterDefs.add(newP.getFieldAsAttribute());
}
}
m_expression = Expression.getExpression(container, m_optype, m_parameterDefs, transDict);
// check that the optype of the Expression is compatible with ours
if (m_optype == FieldMetaInfo.Optype.CONTINUOUS &&
m_expression.getOptype() != m_optype) {
throw new Exception("[DefineFunction] optype is continuous but our Expression's optype "
+ "is not.");
}
if ((m_optype == FieldMetaInfo.Optype.CATEGORICAL || m_optype == FieldMetaInfo.Optype.ORDINAL) !=
(m_expression.getOptype() == FieldMetaInfo.Optype.CATEGORICAL ||
m_expression.getOptype() == FieldMetaInfo.Optype.ORDINAL)) {
throw new Exception("[DefineFunction] optype is categorical/ordinal but our Expression's optype "
+ "is not.");
}
}
public void pushParameterDefs() throws Exception {
if (m_parameterDefs == null) {
throw new Exception("[DefineFunction] parameter definitions are null! Can't "
+ "push them to encapsulated expression.");
}
m_expression.setFieldDefs(m_parameterDefs);
}
/**
* Get the structure of the result produced by this function.
*
* @return the structure of the result produced by this function.
*/
public Attribute getOutputDef() {
return m_expression.getOutputDef();
}
/**
* Returns an array of the names of the parameters expected
* as input by this function. May return null if this function
* can take an unbounded number of parameters (i.e. min, max, etc.).
*
* @return an array of the parameter names or null if there are an
* unbounded number of parameters.
*/
public String[] getParameterNames() {
String[] result = new String[m_parameters.size()];
for (int i = 0; i < m_parameters.size(); i++) {
result[i] = m_parameters.get(i).getFieldName();
}
return result;
}
/**
* Get the result of applying this function.
*
* @param incoming the arguments to this function (supplied in order to match that
* of the parameter definitions
* @return the result of applying this function. When the optype is
* categorical or ordinal, an index into the values of the output definition
* is returned.
* @throws Exception if there is a problem computing the result of this function
*/
public double getResult(double[] incoming) throws Exception {
if (incoming.length != m_parameters.size()) {
throw new IllegalArgumentException("[DefineFunction] wrong number of arguments: expected "
+ m_parameters.size() + ", recieved " + incoming.length);
}
return m_expression.getResult(incoming);
}
/**
* Set the structure of the parameters that are expected as input by
* this function. This must be called before getOutputDef() is called.
*
* @param paramDefs the structure of the input parameters
* @throws Exception if the number or types of parameters are not acceptable by
* this function
*/
public void setParameterDefs(ArrayList<Attribute> paramDefs) throws Exception {
if (paramDefs.size() != m_parameters.size()) {
throw new Exception("[DefineFunction] number of parameter definitions does not match "
+ "number of parameters!");
}
// check these defs against the optypes of the parameters
for (int i = 0; i < m_parameters.size(); i++) {
if (m_parameters.get(i).getOptype() == FieldMetaInfo.Optype.CONTINUOUS) {
if (!paramDefs.get(i).isNumeric()) {
throw new Exception("[DefineFunction] parameter "
+ m_parameters.get(i).getFieldName() + " is continuous, but corresponding "
+ "supplied parameter def " + paramDefs.get(i).name() + " is not!");
}
} else {
if (!paramDefs.get(i).isNominal() && !paramDefs.get(i).isString()) {
throw new Exception("[DefineFunction] parameter "
+ m_parameters.get(i).getFieldName() + " is categorical/ordinal, but corresponding "
+ "supplied parameter def " + paramDefs.get(i).name() + " is not!");
}
}
}
// now we need to rename these argument definitions to match the names of
// the actual parameters
ArrayList<Attribute> newParamDefs = new ArrayList<Attribute>();
for (int i = 0; i < paramDefs.size(); i++) {
Attribute a = paramDefs.get(i);
newParamDefs.add(a.copy(m_parameters.get(i).getFieldName()));
}
m_parameterDefs = newParamDefs;
// update the Expression
m_expression.setFieldDefs(m_parameterDefs);
}
public String toString() {
return toString("");
}
public String toString(String pad) {
StringBuffer buff = new StringBuffer();
buff.append(pad + "DefineFunction (" + m_functionName + "):\n"
+ pad + "nparameters:\n");
for (ParameterField p : m_parameters) {
buff.append(pad + p.getFieldAsAttribute() + "\n");
}
buff.append(pad + "expression:\n" + m_expression.toString(pad + " "));
return buff.toString();
}
}
|
0
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml/DerivedFieldMetaInfo.java
|
/*
* 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 <http://www.gnu.org/licenses/>.
*/
/*
* DerivedFieldMetaInfo.java
* Copyright (C) 2008-2012 University of Waikato, Hamilton, New Zealand
*
*/
package weka.core.pmml;
import java.io.Serializable;
import java.util.ArrayList;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import weka.core.Attribute;
import weka.core.Instances;
public class DerivedFieldMetaInfo extends FieldMetaInfo implements Serializable {
/** for serialization */
private static final long serialVersionUID = 875736989396755241L;
/** display name */
protected String m_displayName = null;
/**
* the list of values (if the field is ordinal) - may be of size zero if none
* are specified. If none are specified, we may be able to construct this by
* querying the Expression in this derived field
*/
protected ArrayList<Value> m_values = new ArrayList<Value>();
/** the single expression that defines the value of this field */
protected Expression m_expression;
public DerivedFieldMetaInfo(Element derivedField,
ArrayList<Attribute> fieldDefs, TransformationDictionary transDict) throws Exception {
super(derivedField);
// m_fieldName = derivedField.getAttribute("name");
String displayName = derivedField.getAttribute("displayName");
if (displayName != null && displayName.length() > 0) {
m_displayName = displayName;
}
// get any values
NodeList valL = derivedField.getElementsByTagName("Value");
if (valL.getLength() > 0) {
for (int i = 0; i < valL.getLength(); i++) {
Node valueN = valL.item(i);
if (valueN.getNodeType() == Node.ELEMENT_NODE) {
Value v = new Value((Element) valueN);
m_values.add(v);
}
}
}
// now get the expression
m_expression = Expression.getExpression(derivedField, m_optype, fieldDefs,
transDict);
}
/**
* Upadate the field definitions for this derived field
*
* @param fieldDefs the fields as an ArrayList of Attributes
* @throws Exception if there is a problem setting the field definitions
*/
public void setFieldDefs(ArrayList<Attribute> fieldDefs) throws Exception {
m_expression.setFieldDefs(fieldDefs);
}
/**
* Upadate the field definitions for this derived field
*
* @param fields the fields as an Instances object
* @throws Exception if there is a problem setting the field definitions
*/
public void setFieldDefs(Instances fields) throws Exception {
ArrayList<Attribute> tempDefs = new ArrayList<Attribute>();
for (int i = 0; i < fields.numAttributes(); i++) {
tempDefs.add(fields.attribute(i));
}
setFieldDefs(tempDefs);
}
/**
* Get this derived field as an Attribute.
*
* @return an Attribute for this derived field.
*/
@Override
public Attribute getFieldAsAttribute() {
return m_expression.getOutputDef().copy(m_fieldName);
}
/**
* Get the derived field value for the given incoming vector of values.
* Incoming values are assumed to be in the same order as the attributes
* supplied in the field definitions ArrayList used to construct this
* DerivedField.
*
* If the optype of this derived field is continuous, then a real number is
* returned. Otherwise, the number returned is the index of the
* categorical/ordinal value corresponding to result of computing the derived
* field value.
*
* @param incoming the incoming parameter values
* @return the result of computing the derived value
* @throws Exception if there is a problem computing the value
*/
public double getDerivedValue(double[] incoming) throws Exception {
return m_expression.getResult(incoming);
}
@Override
public String toString() {
StringBuffer buff = new StringBuffer();
buff.append(getFieldAsAttribute() + "\nexpression:\n");
buff.append(m_expression + "\n");
return buff.toString();
}
}
|
0
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml/Discretize.java
|
/*
* 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 <http://www.gnu.org/licenses/>.
*/
/*
* Discretize.java
* Copyright (C) 2008-2012 University of Waikato, Hamilton, New Zealand
*
*/
package weka.core.pmml;
import java.io.Serializable;
import java.util.ArrayList;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import weka.core.Attribute;
import weka.core.Utils;
/**
* Class encapsulating a Discretize Expression.
*
* @author Mark Hall (mhall{[at]}pentaho{[dot]}com)
* @version $Revision 1.0 $
*/
public class Discretize extends Expression {
/** ID added to avoid warning */
private static final long serialVersionUID = -5809107997906180082L;
/**
* Inner class to encapsulate DiscretizeBin elements
*/
protected class DiscretizeBin implements Serializable {
/**
* For serialization
*/
private static final long serialVersionUID = 5810063243316808400L;
/** The intervals for this DiscretizeBin */
private final ArrayList<FieldMetaInfo.Interval> m_intervals = new ArrayList<FieldMetaInfo.Interval>();
/** The bin value for this DiscretizeBin */
private final String m_binValue;
/**
* If the optype is continuous or ordinal, we will attempt to parse the bin
* value as a number and store it here.
*/
private double m_numericBinValue = Utils.missingValue();
protected DiscretizeBin(Element bin, FieldMetaInfo.Optype opType) throws Exception {
NodeList iL = bin.getElementsByTagName("Interval");
for (int i = 0; i < iL.getLength(); i++) {
Node iN = iL.item(i);
if (iN.getNodeType() == Node.ELEMENT_NODE) {
FieldMetaInfo.Interval tempInterval = new FieldMetaInfo.Interval(
(Element) iN);
m_intervals.add(tempInterval);
}
}
m_binValue = bin.getAttribute("binValue");
if (opType == FieldMetaInfo.Optype.CONTINUOUS
|| opType == FieldMetaInfo.Optype.ORDINAL) {
try {
m_numericBinValue = Double.parseDouble(m_binValue);
} catch (NumberFormatException ex) {
// quietly ignore...
}
}
}
/**
* Get the bin value for this DiscretizeBin
*
* @return the bin value
*/
protected String getBinValue() {
return m_binValue;
}
/**
* Get the value of this bin as a number (parsed from the string value).
*
* @return the value of this bin as a number or Double.NaN if the string
* value of the bin could not be interpreted as a number.
*/
protected double getBinValueNumeric() {
return m_numericBinValue;
}
/**
* Returns true if there is an interval that contains the incoming value.
*
* @param value the value to check against
* @return true if there is an interval that containst the supplied value
*/
protected boolean containsValue(double value) {
boolean result = false;
for (FieldMetaInfo.Interval i : m_intervals) {
if (i.containsValue(value)) {
result = true;
break;
}
}
return result;
}
@Override
public String toString() {
StringBuffer buff = new StringBuffer();
buff.append("\"" + m_binValue + "\" if value in: ");
boolean first = true;
for (FieldMetaInfo.Interval i : m_intervals) {
if (!first) {
buff.append(", ");
} else {
first = false;
}
buff.append(i.toString());
}
return buff.toString();
}
}
/** The name of the field to be discretized */
protected String m_fieldName;
/** The index of the field */
protected int m_fieldIndex;
/** True if a replacement for missing values has been specified */
protected boolean m_mapMissingDefined = false;
/** The value of the missing value replacement (if defined) */
protected String m_mapMissingTo;
/** True if a default value has been specified */
protected boolean m_defaultValueDefined = false;
/** The default value (if defined) */
protected String m_defaultValue;
/** The bins for this discretization */
protected ArrayList<DiscretizeBin> m_bins = new ArrayList<DiscretizeBin>();
/** The output structure of this discretization */
protected Attribute m_outputDef;
/**
* Constructs a Discretize Expression
*
* @param discretize the Element containing the discretize expression
* @param opType the optype of this Discretize Expression
* @param fieldDefs the structure of the incoming fields
* @throws Exception if the optype is not categorical/ordinal or if there is a
* problem parsing this element
*/
public Discretize(Element discretize, FieldMetaInfo.Optype opType,
ArrayList<Attribute> fieldDefs) throws Exception {
super(opType, fieldDefs);
/*
* if (m_opType == FieldMetaInfo.Optype.CONTINUOUS) { throw new
* Exception("[Discretize] must have a categorical or ordinal optype"); }
*/
m_fieldName = discretize.getAttribute("field");
m_mapMissingTo = discretize.getAttribute("mapMissingTo");
if (m_mapMissingTo != null && m_mapMissingTo.length() > 0) {
m_mapMissingDefined = true;
}
m_defaultValue = discretize.getAttribute("defaultValue");
if (m_defaultValue != null && m_defaultValue.length() > 0) {
m_defaultValueDefined = true;
}
// get the DiscretizeBin Elements
NodeList dbL = discretize.getElementsByTagName("DiscretizeBin");
for (int i = 0; i < dbL.getLength(); i++) {
Node dbN = dbL.item(i);
if (dbN.getNodeType() == Node.ELEMENT_NODE) {
Element dbE = (Element) dbN;
DiscretizeBin db = new DiscretizeBin(dbE, m_opType);
m_bins.add(db);
}
}
if (fieldDefs != null) {
setUpField();
}
}
/**
* Set the field definitions for this Expression to use
*
* @param fieldDefs the field definitions to use
* @throws Exception if there is a problem setting the field definitions
*/
@Override
public void setFieldDefs(ArrayList<Attribute> fieldDefs) throws Exception {
super.setFieldDefs(fieldDefs);
setUpField();
}
private void setUpField() throws Exception {
m_fieldIndex = -1;
if (m_fieldDefs != null) {
m_fieldIndex = getFieldDefIndex(m_fieldName);
if (m_fieldIndex < 0) {
throw new Exception("[Discretize] Can't find field " + m_fieldName
+ " in the supplied field definitions.");
}
Attribute field = m_fieldDefs.get(m_fieldIndex);
if (!field.isNumeric()) {
throw new Exception("[Discretize] reference field " + m_fieldName
+ " must be continuous.");
}
}
// set up the output structure
Attribute tempAtt = null;
boolean categorical = false;
if (m_opType == FieldMetaInfo.Optype.CONTINUOUS
|| m_opType == FieldMetaInfo.Optype.ORDINAL) {
// check to see if all bin values could be parsed as numbers
for (DiscretizeBin d : m_bins) {
if (Utils.isMissingValue(d.getBinValueNumeric())) {
categorical = true;
break;
}
}
} else {
categorical = true;
}
tempAtt = (categorical) ? new Attribute("temp", (ArrayList<String>) null)
: new Attribute(m_fieldName + "_discretized(optype=continuous)");
if (categorical) {
for (DiscretizeBin d : m_bins) {
tempAtt.addStringValue(d.getBinValue());
}
// add the default value (just in case it is some other value than one
// of the bins
if (m_defaultValueDefined) {
tempAtt.addStringValue(m_defaultValue);
}
// add the map missing to value (just in case it is some other value than
// one
// of the bins
if (m_mapMissingDefined) {
tempAtt.addStringValue(m_mapMissingTo);
}
// now make this into a nominal attribute
ArrayList<String> values = new ArrayList<String>();
for (int i = 0; i < tempAtt.numValues(); i++) {
values.add(tempAtt.value(i));
}
m_outputDef = new Attribute(m_fieldName + "_discretized", values);
} else {
m_outputDef = tempAtt;
}
}
/**
* Return the structure of the result of applying this Expression as an
* Attribute.
*
* @return the structure of the result of applying this Expression as an
* Attribute.
*/
@Override
protected Attribute getOutputDef() {
if (m_outputDef == null) {
// return a "default" output def. This will get replaced
// by a final one when the final field defs are are set
// for all expressions after all derived fields are collected
return (m_opType == FieldMetaInfo.Optype.CATEGORICAL || m_opType == FieldMetaInfo.Optype.ORDINAL) ? new Attribute(
m_fieldName + "_discretized", new ArrayList<String>()) : new Attribute(
m_fieldName + "_discretized(optype=continuous)");
}
return m_outputDef;
}
/**
* Get the result of evaluating the expression. In the case of a continuous
* optype, a real number is returned; in the case of a categorical/ordinal
* optype, the index of the nominal value is returned as a double.
*
* @param incoming the incoming parameter values
* @return the result of evaluating the expression
* @throws Exception if there is a problem computing the result
*/
@Override
public double getResult(double[] incoming) throws Exception {
// default of a missing value for the result if none of the following
// logic applies
double result = Utils.missingValue();
double value = incoming[m_fieldIndex];
if (Utils.isMissingValue(value)) {
if (m_mapMissingDefined) {
if (m_outputDef.isNominal()) {
result = m_outputDef.indexOfValue(m_mapMissingTo);
} else {
try {
result = Double.parseDouble(m_mapMissingTo);
} catch (NumberFormatException ex) {
throw new Exception(
"[Discretize] Optype is continuous but value of mapMissingTo "
+ "can not be parsed as a number!");
}
}
}
} else {
// look for a bin that has an interval that contains this value
boolean found = false;
for (DiscretizeBin b : m_bins) {
if (b.containsValue(value)) {
found = true;
if (m_outputDef.isNominal()) {
result = m_outputDef.indexOfValue(b.getBinValue());
} else {
result = b.getBinValueNumeric();
}
break;
}
}
if (!found) {
if (m_defaultValueDefined) {
if (m_outputDef.isNominal()) {
result = m_outputDef.indexOfValue(m_defaultValue);
} else {
try {
result = Double.parseDouble(m_defaultValue);
} catch (NumberFormatException ex) {
throw new Exception(
"[Discretize] Optype is continuous but value of "
+ "default value can not be parsed as a number!");
}
}
}
}
}
return result;
}
/**
* Gets the result of evaluating the expression when the optype is categorical
* or ordinal as the actual String value.
*
* @param incoming the incoming parameter values
* @return the result of evaluating the expression
* @throws Exception if the optype is continuous
*/
@Override
public String getResultCategorical(double[] incoming) throws Exception {
double index = getResult(incoming);
if (Utils.isMissingValue(index)) {
return "**Missing Value**";
}
return m_outputDef.value((int) index);
}
/*
* (non-Javadoc)
*
* @see weka.core.pmml.Expression#toString(java.lang.String)
*/
@Override
public String toString(String pad) {
StringBuffer buff = new StringBuffer();
buff.append(pad + "Discretize (" + m_fieldName + "):");
for (DiscretizeBin d : m_bins) {
buff.append("\n" + pad + d.toString());
}
if (m_outputDef.isNumeric()) {
buff.append("\n" + pad + "(bin values interpreted as numbers)");
}
if (m_mapMissingDefined) {
buff.append("\n" + pad + "map missing values to: " + m_mapMissingTo);
}
if (m_defaultValueDefined) {
buff.append("\n" + pad + "default value: " + m_defaultValue);
}
return buff.toString();
}
}
|
0
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml/Expression.java
|
/*
* 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 <http://www.gnu.org/licenses/>.
*/
/*
* Expression.java
* Copyright (C) 2008-2012 University of Waikato, Hamilton, New Zealand
*
*/
package weka.core.pmml;
import java.io.Serializable;
import java.util.ArrayList;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import weka.core.Attribute;
public abstract class Expression implements Serializable {
/**
* For serialization
*/
private static final long serialVersionUID = 4448840549804800321L;
/** The optype of this Expression */
protected FieldMetaInfo.Optype m_opType;
/** The field defs */
protected ArrayList<Attribute> m_fieldDefs = null;
// NOTE - might need to pass in mining schema in order
// to determine values for nominal optypes
public Expression(FieldMetaInfo.Optype opType, ArrayList<Attribute> fieldDefs) {
m_opType = opType;
m_fieldDefs = fieldDefs;
}
/**
* Set the field definitions for this Expression to use
*
* @param fieldDefs the field definitions to use
* @throws Exception if there is a problem setting the field definitions
*/
public void setFieldDefs(ArrayList<Attribute> fieldDefs) throws Exception {
m_fieldDefs = fieldDefs;
}
/**
* Get the result of evaluating the expression. In the case
* of a continuous optype, a real number is returned; in
* the case of a categorical/ordinal optype, the index of the nominal
* value is returned as a double.
*
* @param incoming the incoming parameter values
* @return the result of evaluating the expression
* @throws Exception if there is a problem computing the result
*/
public abstract double getResult(double[] incoming) throws Exception;
/**
* Get the result of evaluating the expression for continuous
* optype. Is the same as calling getResult() when the optype
* is continuous.
*
* @param incoming the incoming parameter values
* mining schema
* @return the result of evaluating the expression.
* @throws Exception if the optype is not continuous.
*/
public double getResultContinuous(double[] incoming) throws Exception {
if (!(m_opType == FieldMetaInfo.Optype.CONTINUOUS)) {
throw new Exception("[Expression] Can't return continuous result "
+ "as optype is not continuous");
}
return getResult(incoming);
}
/**
* Gets the result of evaluating the expression when the
* optype is categorical or ordinal as the actual String
* value.
*
* @param incoming the incoming parameter values
* @return the result of evaluating the expression
* @throws Exception if the optype is continuous
*/
public abstract String getResultCategorical(double[] incoming)
throws Exception;
/**
* Return the structure of the result of applying this Expression
* as an Attribute.
*
* @return the structure of the result of applying this Expression as an
* Attribute.
*/
protected abstract Attribute getOutputDef();
/**
* Static factory method that returns a subclass of Expression that
* encapsulates the type of expression contained in the Element
* supplied. Assumes that there is just one expression contained
* in the supplied Element.
*
* @param container the Node containing the expression
* @param opType the optype of the value returned by this Expression.
* @param fieldDefs an ArrayList of Attributes for the fields that this
* Expression may need to access
* Since Expressions are children of either DerivedFields or
* DefineFuntions, they will have the same optype as their parent.
* @param transDict the TransformationDictionary (may be null if there
* is no dictionary)
* @return an Expression object or null if there is no known expression in
* the container
* @throws Exception for unsupported Expression types
*/
public static Expression getExpression(Node container,
FieldMetaInfo.Optype opType,
ArrayList<Attribute> fieldDefs,
TransformationDictionary transDict) throws Exception {
// we need to examine children of this Node to find an expression,
// not the entire subtree (as would be returned by Element.getElementsByTagName()
Expression result = null;
String tagName = "";
NodeList children = container.getChildNodes();
if (children.getLength() == 0) {
throw new Exception("[Expression] container has no children!");
}
// at this level in the tree there should be only one expression type
// specified - look for it here.
for (int i = 0; i < children.getLength(); i++) {
Node child = children.item(i);
if (child.getNodeType() == Node.ELEMENT_NODE) {
tagName = ((Element)child).getTagName();
result = getExpression(tagName, child, opType, fieldDefs, transDict);
if (result != null) {
break;
}
}
}
return result;
}
/**
* Static factory method that returns a subclass of Expression that
* encapsulates the type of expression supplied as an argument.
*
* @param name the name of the Expression to get
* @param expression the Node containing the expression
* @param opType the optype of the value returned by this Expression.
* @param fieldDefs an ArrayList of Attributes for the fields that this
* Expression may need to access
* Since Expressions are children of either DerivedFields or
* DefineFuntions, they will have the same optype as their parent.
* @param transDict the TransformationDictionary (may be null if there
* is no dictionary)
* @return an Expression object or null if there is no known expression in
* the container
* @throws Exception for unsupported Expression types
*/
public static Expression getExpression(String name,
Node expression,
FieldMetaInfo.Optype opType,
ArrayList<Attribute> fieldDefs,
TransformationDictionary transDict) throws Exception {
Expression result = null;
if (name.equals("Constant")) {
// construct a Constant expression
result = new Constant((Element)expression, opType, fieldDefs);
} else if (name.equals("FieldRef")) {
// construct a FieldRef expression
result = new FieldRef((Element)expression, opType, fieldDefs);
} else if (name.equals("Apply")) {
// construct an Apply expression
result = new Apply((Element)expression, opType, fieldDefs, transDict);
} else if (name.equals("NormDiscrete")) {
result = new NormDiscrete((Element)expression, opType, fieldDefs);
} else if (name.equals("NormContinuous")) {
result = new NormContinuous((Element)expression, opType, fieldDefs);
} else if (name.equals("Discretize")) {
result = new Discretize((Element)expression, opType, fieldDefs);
} else if (name.equals("MapValues") ||
name.equals("Aggregate")) {
throw new Exception("[Expression] Unhandled Expression type " + name);
}
return result;
}
/**
* Return the named attribute from the list of reference fields.
*
* @param attName the name of the attribute to retrieve
* @return the named attribute (or null if it can't be found).
*/
public Attribute getFieldDef(String attName) {
Attribute returnV = null;
for (int i = 0; i < m_fieldDefs.size(); i++) {
if (m_fieldDefs.get(i).name().equals(attName)) {
returnV = m_fieldDefs.get(i);
break;
}
}
return returnV;
}
public int getFieldDefIndex(String attName) {
int returnV = -1;
for (int i = 0; i < m_fieldDefs.size(); i++) {
if (m_fieldDefs.get(i).name().equals(attName)) {
returnV = i;
break;
}
}
return returnV;
}
/**
* Get the optype of the result of applying this Expression.
*
* @return the optype of the result of applying this Expression
*/
public FieldMetaInfo.Optype getOptype() {
return m_opType;
}
public String toString() {
return toString("");
}
public String toString(String pad) {
return pad + this.getClass().getName();
}
}
|
0
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml/FieldMetaInfo.java
|
/*
* 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 <http://www.gnu.org/licenses/>.
*/
/*
* FieldMetaInfo.java
* Copyright (C) 2008-2012 University of Waikato, Hamilton, New Zealand
*
*/
package weka.core.pmml;
import java.io.Serializable;
import org.w3c.dom.Element;
import weka.core.Attribute;
/**
* Abstract superclass for various types of field meta data.
*
* @author Mark Hall (mhall{[at]}pentaho{[dot]}com
* @version $Revision 1.0 $
*/
public abstract class FieldMetaInfo implements Serializable {
/** ID added to avoid warning */
private static final long serialVersionUID = -6116715567129830143L;
/**
* Inner class for Values
*/
public static class Value implements Serializable {
/**
* For serialization
*/
private static final long serialVersionUID = -3981030320273649739L;
/** The value */
protected String m_value;
/**
* The display value (might hold a human readable value - e.g. product name
* instead of cryptic code).
*/
protected String m_displayValue;
/**
* Enumerated type for the property. A value can be valid, invalid or
* indicate a value that should be considered as "missing".
*/
public enum Property {
VALID("valid"), INVALID("invalid"), MISSING("missing");
private final String m_stringVal;
Property(String name) {
m_stringVal = name;
}
@Override
public String toString() {
return m_stringVal;
}
}
protected Property m_property = Property.VALID;
/**
* Construct a value.
*
* @param value the Element containing the value
* @throws Exception if there is a problem constucting the value
*/
protected Value(Element value) throws Exception {
m_value = value.getAttribute("value");
String displayV = value.getAttribute("displayValue");
if (displayV != null && displayV.length() > 0) {
m_displayValue = displayV;
}
String property = value.getAttribute("property");
if (property != null && property.length() > 0) {
for (Property p : Property.values()) {
if (p.toString().equals(property)) {
m_property = p;
break;
}
}
}
}
@Override
public String toString() {
String retV = m_value;
if (m_displayValue != null) {
retV += "(" + m_displayValue + "): " + m_property.toString();
}
return retV;
}
public String getValue() {
return m_value;
}
public String getDisplayValue() {
return m_displayValue;
}
public Property getProperty() {
return m_property;
}
}
/**
* Inner class for an Interval.
*/
public static class Interval implements Serializable {
/**
* For serialization
*/
private static final long serialVersionUID = -7339790632684638012L;
/** The left boundary value */
protected double m_leftMargin = Double.NEGATIVE_INFINITY;
/** The right boundary value */
protected double m_rightMargin = Double.POSITIVE_INFINITY;
/**
* Enumerated type for the closure.
*/
public enum Closure {
OPENCLOSED("openClosed", "(", "]"), OPENOPEN("openOpen", "(", ")"), CLOSEDOPEN(
"closedOpen", "[", ")"), CLOSEDCLOSED("closedClosed", "[", "]");
private final String m_stringVal;
private final String m_left;
private final String m_right;
Closure(String name, String left, String right) {
m_stringVal = name;
m_left = left;
m_right = right;
}
@Override
public String toString() {
return m_stringVal;
}
public String toString(double leftMargin, double rightMargin) {
return m_left + leftMargin + "-" + rightMargin + m_right;
}
}
protected Closure m_closure = Closure.OPENOPEN;
/**
* Construct an interval.
*
* @param interval the Element containing the interval
* @throws Exception if there is a problem constructing the interval
*/
protected Interval(Element interval) throws Exception {
String leftM = interval.getAttribute("leftMargin");
try {
m_leftMargin = Double.parseDouble(leftM);
} catch (IllegalArgumentException ex) {
throw new Exception("[Interval] Can't parse left margin as a number");
}
String rightM = interval.getAttribute("rightMargin");
try {
m_rightMargin = Double.parseDouble(rightM);
} catch (IllegalArgumentException ex) {
throw new Exception("[Interval] Can't parse right margin as a number");
}
String closure = interval.getAttribute("closure");
if (closure == null || closure.length() == 0) {
throw new Exception("[Interval] No closure specified!");
}
for (Closure c : Closure.values()) {
if (c.toString().equals(closure)) {
m_closure = c;
break;
}
}
}
/**
* Returns true if this interval contains the supplied value.
*
* @param value the value to check
* @return true if the interval contains the supplied value
*/
public boolean containsValue(double value) {
boolean result = false;
switch (m_closure) {
case OPENCLOSED:
if (value > m_leftMargin && value <= m_rightMargin) {
result = true;
}
break;
case OPENOPEN:
if (value > m_leftMargin && value < m_rightMargin) {
result = true;
}
break;
case CLOSEDOPEN:
if (value >= m_leftMargin && value < m_rightMargin) {
result = true;
}
break;
case CLOSEDCLOSED:
if (value >= m_leftMargin && value <= m_rightMargin) {
result = true;
}
break;
default:
result = false;
break;
}
return result;
}
@Override
public String toString() {
return m_closure.toString(m_leftMargin, m_rightMargin);
}
}
// -----------------------------
/** the name of the field */
protected String m_fieldName;
/**
* Enumerated type for the Optype
*/
public enum Optype {
NONE("none"), CONTINUOUS("continuous"), CATEGORICAL("categorical"), ORDINAL(
"ordinal");
private final String m_stringVal;
Optype(String name) {
m_stringVal = name;
}
@Override
public String toString() {
return m_stringVal;
}
}
/** The optype for the target */
protected Optype m_optype = Optype.NONE;
/**
* Get the optype.
*
* @return the optype
*/
public Optype getOptype() {
return m_optype;
}
/**
* Get the name of this field.
*
* @return the name of this field
*/
public String getFieldName() {
return m_fieldName;
}
/**
* Construct a new FieldMetaInfo.
*
* @param field the Element containing the field
*/
public FieldMetaInfo(Element field) {
m_fieldName = field.getAttribute("name");
String opType = field.getAttribute("optype");
if (opType != null && opType.length() > 0) {
for (Optype o : Optype.values()) {
if (o.toString().equals(opType)) {
m_optype = o;
break;
}
}
}
}
/**
* Return this field as an Attribute.
*
* @return an Attribute for this field.
*/
public abstract Attribute getFieldAsAttribute();
}
|
0
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml/FieldRef.java
|
/*
* 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 <http://www.gnu.org/licenses/>.
*/
/*
* FieldRef.java
* Copyright (C) 2008-2012 University of Waikato, Hamilton, New Zealand
*
*/
package weka.core.pmml;
import java.util.ArrayList;
import org.w3c.dom.Element;
import weka.core.Attribute;
/**
* Class encapsulating a FieldRef Expression. Is simply a
* pass-through to an existing field.
*
* @author Mark Hall (mhall{[at]}pentaho{[dot]}com)
* @version $Revision 1.0 $
*/
public class FieldRef extends Expression {
/**
* For serialization
*/
private static final long serialVersionUID = -8009605897876168409L;
/** The name of the field to reference */
protected String m_fieldName = null;
public FieldRef(Element fieldRef, FieldMetaInfo.Optype opType, ArrayList<Attribute> fieldDefs)
throws Exception {
super(opType, fieldDefs);
m_fieldName = fieldRef.getAttribute("field");
}
public void setFieldDefs(ArrayList<Attribute> fieldDefs) throws Exception {
super.setFieldDefs(fieldDefs);
validateField();
}
protected void validateField() throws Exception {
// do some type checking here
if (m_fieldDefs != null) {
Attribute a = getFieldDef(m_fieldName);
if (a == null) {
throw new Exception("[FieldRef] Can't find field " + m_fieldName
+ " in the supplied field definitions");
}
if ((m_opType == FieldMetaInfo.Optype.CATEGORICAL ||
m_opType == FieldMetaInfo.Optype.ORDINAL) && a.isNumeric()) {
throw new IllegalArgumentException("[FieldRef] Optype is categorical/ordinal but matching "
+ "parameter in the field definitions is not!");
}
if (m_opType == FieldMetaInfo.Optype.CONTINUOUS && a.isNominal()) {
throw new IllegalArgumentException("[FieldRef] Optype is continuous but matching "
+ "parameter in the field definitions is not!");
}
}
}
@Override
public double getResult(double[] incoming) throws Exception {
double result = Double.NaN;
boolean found = false;
for (int i = 0; i < m_fieldDefs.size(); i++) {
Attribute a = m_fieldDefs.get(i);
if (a.name().equals(m_fieldName)) {
if (a.isNumeric()) {
if (m_opType == FieldMetaInfo.Optype.CATEGORICAL ||
m_opType == FieldMetaInfo.Optype.ORDINAL) {
throw new IllegalArgumentException("[FieldRef] Optype is categorical/ordinal but matching "
+ "parameter is not!");
}
} else if (a.isNominal()) {
if (m_opType == FieldMetaInfo.Optype.CONTINUOUS) {
throw new IllegalArgumentException("[FieldRef] Optype is continuous but matching "
+ "parameter is not!");
}
} else {
throw new IllegalArgumentException("[FieldRef] Unhandled attribute type");
}
result = incoming[i];
found = true;
break;
}
}
if (!found) {
throw new Exception("[FieldRef] this field: " + m_fieldName + " is not in the supplied "
+ "list of parameters!");
}
return result;
}
@Override
public String getResultCategorical(double[] incoming)
throws Exception {
if (m_opType == FieldMetaInfo.Optype.CONTINUOUS) {
throw new IllegalArgumentException("[FieldRef] Can't return result as "
+"categorical/ordinal because optype is continuous!");
}
boolean found = false;
String result = null;
for (int i = 0; i < m_fieldDefs.size(); i++) {
Attribute a = m_fieldDefs.get(i);
if (a.name().equals(m_fieldName)) {
found = true;
result = a.value((int)incoming[i]);
break;
}
}
if (!found) {
throw new Exception("[FieldRef] this field: " + m_fieldName + " is not in the supplied "
+ "list of parameters!");
}
return result;
}
/**
* Return the structure of the result of applying this Expression
* as an Attribute.
*
* @return the structure of the result of applying this Expression as an
* Attribute.
*/
public Attribute getOutputDef() {
Attribute a = getFieldDef(m_fieldName);
if (a != null) {
return a;
/* Attribute result = a.copy(attName);
return result; */
}
// If we can't find the reference field in the field definitions then
// we can't return a definition for the result
return null;
}
public String toString(String pad) {
return pad + "FieldRef: " + m_fieldName;
}
}
|
0
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml/Function.java
|
/*
* 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 <http://www.gnu.org/licenses/>.
*/
/*
* Function.java
* Copyright (C) 2008-2012 University of Waikato, Hamilton, New Zealand
*
*/
package weka.core.pmml;
import java.io.Serializable;
import java.util.ArrayList;
import weka.core.Attribute;
/**
* Abstract superclass for PMML built-in and DefineFunctions.
*
* @author Mark Hall (mhall{[at]}pentaho{[dot]}com)
* @version $Revision 1.0 $
*/
public abstract class Function implements Serializable {
/**
* For serialization
*/
private static final long serialVersionUID = -6997738288201933171L;
/** The name of this function */
protected String m_functionName;
/** The structure of the parameters to this function */
protected ArrayList<Attribute> m_parameterDefs = null;
public String getName() {
return m_functionName;
}
/**
* Returns an array of the names of the parameters expected
* as input by this function. May return null if this function
* can take an unbounded number of parameters (i.e. min, max, etc.).
*
* @return an array of the parameter names or null if there are an
* unbounded number of parameters.
*/
public abstract String[] getParameterNames();
/**
* Set the structure of the parameters that are expected as input by
* this function. This must be called before getOutputDef() is called.
*
* @param paramDefs the structure of the input parameters
* @throws Exception if the number or types of parameters are not acceptable by
* this function
*/
public abstract void setParameterDefs(ArrayList<Attribute> paramDefs) throws Exception;
/**
* Get the structure of the result produced by this function.
*
* @return the structure of the result produced by this function.
*/
public abstract Attribute getOutputDef();
/**
* Get the result of applying this function.
*
* @param incoming the arguments to this function (supplied in order to match that
* of the parameter definitions
* @return the result of applying this function. When the optype is
* categorical or ordinal, an index into the values of the output definition
* is returned.
* @throws Exception if there is a problem computing the result of this function
*/
public abstract double getResult(double[] incoming) throws Exception;
/**
* Get the result of applying this function. Subclasses should overide this
* method when they might produce categorical values where the legal set of
* values can't be determined apriori (i.e. by just using the input parameter
* definitions). An example is the substring function - in this case there
* is no way of knowing apriori what all the legal values will be because the
* start position and length parameters are not known until the function is
* invoked. In this scenario, a client could call getResultCategorical()
* repeatedly (in an initialization routine) in order to manually build the
* list of legal values and then call this method at processing time, passing
* in the pre-computed output structure.
*
* This default implementation ignores the supplied output definition argument
* and simply invokes getResult(incoming).
*
* @param incoming the arguments to this function (supplied in order to match that
* of the parameter definitions
* @param outputDef the output definition to use for looking up the index of
* result values (in the case of categorical results)
* @return the result of applying this function. When the optype is
* categorical or ordinal, an index into the values of the output definition
* is returned.
* @throws Exception if there is a problem computing the result of this function
*
public double getResult(double[] incoming, Attribute outputDef) throws Exception {
if (outputDef.isString()) {
throw new Exception("[Function] outputDef argument must not be a String attribute!");
}
return getResult(incoming);
}*/
/**
* Get the result of applying this function when the output type categorical.
* Will throw an exception for numeric output. If subclasses output definition
* is a string attribute (i.e. because all legal values can't be computed apriori),
* then the subclass will need to overide this method and return something sensible
* in this case.
*
* @param incoming the incoming arguments to this function (supplied in order to match
* that of the parameter definitions
* @return the result of applying this function as a String.
* @throws Exception if this method is not applicable because the optype is not
* categorical/ordinal
*
public String getResultCategorical(double[] incoming) throws Exception {
if (getOutputDef().isNumeric()) {
throw new Exception("[Function] can't return nominal value, output is numeric!!");
}
if (getOutputDef().isString()) {
throw new Exception("[Function] subclass neeeds to overide this method and do "
+ "something sensible when the output def is a string attribute.");
}
return getOutputDef().value((int)getResult(incoming));
} */
//public static FieldMetaInfo.Optype
/**
* Get a built-in PMML Function.
*
* @param name the name of the function to get.
* @return a built-in Function or null if the named function is not
* known/supported.
*/
public static Function getFunction(String name) {
Function result = null;
name = name.trim();
if (name.equals("+")) {
result = new BuiltInArithmetic(BuiltInArithmetic.Operator.ADDITION);
} else if (name.equals("-")) {
result = new BuiltInArithmetic(BuiltInArithmetic.Operator.SUBTRACTION);
} else if (name.equals("*")) {
result = new BuiltInArithmetic(BuiltInArithmetic.Operator.MULTIPLICATION);
} else if (name.equals("/")) {
result = new BuiltInArithmetic(BuiltInArithmetic.Operator.DIVISION);
} else if (name.equals(BuiltInMath.MathFunc.MIN.toString())) {
result = new BuiltInMath(BuiltInMath.MathFunc.MIN);
} else if (name.equals(BuiltInMath.MathFunc.MAX.toString())) {
result = new BuiltInMath(BuiltInMath.MathFunc.MAX);
} else if (name.equals(BuiltInMath.MathFunc.SUM.toString())) {
result = new BuiltInMath(BuiltInMath.MathFunc.SUM);
} else if (name.equals(BuiltInMath.MathFunc.AVG.toString())) {
result = new BuiltInMath(BuiltInMath.MathFunc.AVG);
} else if (name.equals(BuiltInMath.MathFunc.LOG10.toString())) {
result = new BuiltInMath(BuiltInMath.MathFunc.LOG10);
} else if (name.equals(BuiltInMath.MathFunc.LN.toString())) {
result = new BuiltInMath(BuiltInMath.MathFunc.LN);
} else if (name.equals(BuiltInMath.MathFunc.SQRT.toString())) {
result = new BuiltInMath(BuiltInMath.MathFunc.SQRT);
} else if (name.equals(BuiltInMath.MathFunc.ABS.toString())) {
result = new BuiltInMath(BuiltInMath.MathFunc.ABS);
} else if (name.equals(BuiltInMath.MathFunc.EXP.toString())) {
result = new BuiltInMath(BuiltInMath.MathFunc.EXP);
} else if (name.equals(BuiltInMath.MathFunc.POW.toString())) {
result = new BuiltInMath(BuiltInMath.MathFunc.POW);
} else if (name.equals(BuiltInMath.MathFunc.THRESHOLD.toString())) {
result = new BuiltInMath(BuiltInMath.MathFunc.THRESHOLD);
} else if (name.equals(BuiltInMath.MathFunc.FLOOR.toString())) {
result = new BuiltInMath(BuiltInMath.MathFunc.FLOOR);
} else if (name.equals(BuiltInMath.MathFunc.CEIL.toString())) {
result = new BuiltInMath(BuiltInMath.MathFunc.CEIL);
} else if (name.equals(BuiltInMath.MathFunc.ROUND.toString())) {
result = new BuiltInMath(BuiltInMath.MathFunc.ROUND);
} else if (name.equals(BuiltInString.StringFunc.UPPERCASE.toString())) {
result = new BuiltInString(BuiltInString.StringFunc.UPPERCASE);
} else if (name.equals(BuiltInString.StringFunc.SUBSTRING.toString())) {
result = new BuiltInString(BuiltInString.StringFunc.SUBSTRING);
} else if (name.equals(BuiltInString.StringFunc.TRIMBLANKS.toString())) {
result = new BuiltInString(BuiltInString.StringFunc.TRIMBLANKS);
}
return result;
}
/**
* Get either a function. Built-in functions are queried first, and then
* DefineFunctions in the TransformationDictionary (if any).
*
* @param name the name of the function to get.
* @param transDict the TransformationDictionary (may be null if there is
* no dictionary).
* @return the function
* @throws Exception if the named function is not known/supported.
*/
public static Function getFunction(String name, TransformationDictionary transDict)
throws Exception {
Function result = getFunction(name);
// try the defined functions in the TransformationDictionary (if any)
if (result == null && transDict != null) {
result = transDict.getFunction(name);
}
if (result == null) {
throw new Exception("[Function] unknown/unsupported function " + name);
}
return result;
}
public String toString() {
return toString("");
}
public String toString(String pad) {
return pad + this.getClass().getName();
}
}
|
0
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml/MappingInfo.java
|
/*
* 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 <http://www.gnu.org/licenses/>.
*/
/*
* MappingInfo.java
* Copyright (C) 2008-2012 University of Waikato, Hamilton, New Zealand
*
*/
package weka.core.pmml;
import java.io.Serializable;
import java.util.ArrayList;
import weka.core.Attribute;
import weka.core.Instance;
import weka.core.Instances;
import weka.core.Utils;
import weka.gui.Logger;
/**
* Class that maintains the mapping between incoming data set structure and that
* of the mining schema.
*
* @author Mark Hall (mhall{[at]}pentaho{[dot]}com
* @version $Revision$
*/
public class MappingInfo implements Serializable {
/** For serialization */
private static final long serialVersionUID = -475467721189397466L;
/**
* Index for incoming nominal values that are not defined in the mining
* schema.
*/
public static final int UNKNOWN_NOMINAL_VALUE = -1;
/**
* Map the incoming attributes to the mining schema attributes. Each entry
* holds the index of the incoming attribute that corresponds to this mining
* schema attribute.
*/
private int[] m_fieldsMap = null;
/**
* Map indexes for nominal values in incoming structure to those in the mining
* schema. There will be as many entries as there are attributes in this
* array. Non-nominal attributes will have null entries. Each non-null entry
* is an array of integer indexes. Each entry in a given array (for a given
* attribute) holds the index of the mining schema value that corresponds to
* this incoming value. UNKNOWN_NOMINAL_VALUE is used as the index for those
* incoming values that are not defined in the mining schema.
*/
private int[][] m_nominalValueMaps = null;
/** Holds a textual description of the fields mapping */
private String m_fieldsMappingText = null;
/** For logging */
private Logger m_log = null;
public MappingInfo(Instances dataSet, MiningSchema miningSchema, Logger log) throws Exception {
m_log = log;
// miningSchema.convertStringAttsToNominal();
Instances fieldsI = miningSchema.getMiningSchemaAsInstances();
m_fieldsMap = new int[fieldsI.numAttributes()];
m_nominalValueMaps = new int[fieldsI.numAttributes()][];
for (int i = 0; i < fieldsI.numAttributes(); i++) {
String schemaAttName = fieldsI.attribute(i).name();
boolean found = false;
for (int j = 0; j < dataSet.numAttributes(); j++) {
if (dataSet.attribute(j).name().equals(schemaAttName)) {
Attribute miningSchemaAtt = fieldsI.attribute(i);
Attribute incomingAtt = dataSet.attribute(j);
// check type match
if (miningSchemaAtt.type() != incomingAtt.type()) {
if (miningSchemaAtt.isString() && incomingAtt.isNominal()) {
// don't worry about String attributes in the mining schema
// (as long as the corresponding incoming is a String or nominal),
// since values for the String attributes are more than likely
// revealed
// by FieldRef elements in the actual model itself
} else {
throw new Exception("[MappingInfo] type mismatch for field "
+ schemaAttName + ". Mining schema type "
+ miningSchemaAtt.toString() + ". Incoming type "
+ incomingAtt.toString() + ".");
}
}
// check nominal values (number, names...)
if (miningSchemaAtt.numValues() != incomingAtt.numValues()) {
String warningString = "[MappingInfo] WARNING: incoming nominal attribute "
+ incomingAtt.name()
+ " does not have the same "
+ "number of values as the corresponding mining "
+ "schema attribute.";
if (m_log != null) {
m_log.logMessage(warningString);
} else {
System.err.println(warningString);
}
}
if (miningSchemaAtt.isNominal() || miningSchemaAtt.isString()) {
int[] valuesMap = new int[incomingAtt.numValues()];
for (int k = 0; k < incomingAtt.numValues(); k++) {
String incomingNomVal = incomingAtt.value(k);
int indexInSchema = miningSchemaAtt.indexOfValue(incomingNomVal);
if (indexInSchema < 0) {
String warningString = "[MappingInfo] WARNING: incoming nominal attribute "
+ incomingAtt.name()
+ " has value "
+ incomingNomVal
+ " that doesn't occur in the mining schema.";
if (m_log != null) {
m_log.logMessage(warningString);
} else {
System.err.println(warningString);
}
valuesMap[k] = UNKNOWN_NOMINAL_VALUE;
} else {
valuesMap[k] = indexInSchema;
}
}
m_nominalValueMaps[i] = valuesMap;
}
/*
* if (miningSchemaAtt.isNominal()) { for (int k = 0; k <
* miningSchemaAtt.numValues(); k++) { if
* (!miningSchemaAtt.value(k).equals(incomingAtt.value(k))) { throw
* new Exception("[PMMLUtils] value " + k + " (" +
* miningSchemaAtt.value(k) + ") does not match " + "incoming value ("
* + incomingAtt.value(k) + ") for attribute " +
* miningSchemaAtt.name() + ".");
*
* } } }
*/
found = true;
m_fieldsMap[i] = j;
}
}
if (!found) {
throw new Exception(
"[MappingInfo] Unable to find a match for mining schema "
+ "attribute " + schemaAttName + " in the " + "incoming instances!");
}
}
// check class attribute (if set)
if (fieldsI.classIndex() >= 0) {
if (dataSet.classIndex() < 0) {
// first see if we can find a matching class
String className = fieldsI.classAttribute().name();
Attribute classMatch = dataSet.attribute(className);
if (classMatch == null) {
throw new Exception(
"[MappingInfo] Can't find match for target field " + className
+ "in incoming instances!");
}
dataSet.setClass(classMatch);
} else if (!fieldsI.classAttribute().name()
.equals(dataSet.classAttribute().name())) {
throw new Exception(
"[MappingInfo] class attribute in mining schema does not match "
+ "class attribute in incoming instances!");
}
}
// Set up the textual description of the mapping
fieldsMappingString(fieldsI, dataSet);
}
private void fieldsMappingString(Instances miningSchemaI, Instances incomingI) {
StringBuffer result = new StringBuffer();
int maxLength = 0;
for (int i = 0; i < miningSchemaI.numAttributes(); i++) {
if (miningSchemaI.attribute(i).name().length() > maxLength) {
maxLength = miningSchemaI.attribute(i).name().length();
}
}
maxLength += 12; // length of " (nominal)"/" (numeric)"
int minLength = 13; // "Mining schema".length()
String headerS = "Mining schema";
String sep = "-------------";
if (maxLength < minLength) {
maxLength = minLength;
}
headerS = PMMLUtils.pad(headerS, " ", maxLength, false);
sep = PMMLUtils.pad(sep, "-", maxLength, false);
sep += "\t ----------------\n";
headerS += "\t Incoming fields\n";
result.append(headerS);
result.append(sep);
for (int i = 0; i < miningSchemaI.numAttributes(); i++) {
Attribute temp = miningSchemaI.attribute(i);
String attName = "(" + ((temp.isNumeric()) ? "numeric)" : "nominal)")
+ " " + temp.name();
attName = PMMLUtils.pad(attName, " ", maxLength, false);
attName += "\t--> ";
result.append(attName);
Attribute incoming = incomingI.attribute(m_fieldsMap[i]);
String fieldName = "" + (m_fieldsMap[i] + 1) + " ("
+ ((incoming.isNumeric()) ? "numeric)" : "nominal)");
fieldName += " " + incoming.name();
result.append(fieldName + "\n");
}
m_fieldsMappingText = result.toString();
}
/**
* Convert an <code>Instance</code> to an array of values that matches the
* format of the mining schema. First maps raw attribute values and then
* applies rules for missing values, outliers etc.
*
* @param inst the <code>Instance</code> to convert
* @param miningSchema the mining schema incoming instance attributes
* @return an array of doubles that are values from the incoming Instances,
* correspond to the format of the mining schema and have had missing
* values, outliers etc. dealt with.
* @throws Exception if something goes wrong
*/
public double[] instanceToSchema(Instance inst, MiningSchema miningSchema)
throws Exception {
Instances miningSchemaI = miningSchema.getMiningSchemaAsInstances();
// allocate enough space for both mining schema fields and any derived
// fields
double[] result = new double[miningSchema.getFieldsAsInstances()
.numAttributes()];
// Copy over the values
for (int i = 0; i < miningSchemaI.numAttributes(); i++) {
// if (miningSchemaI.attribute(i).isNumeric()) {
result[i] = inst.value(m_fieldsMap[i]);
if (miningSchemaI.attribute(i).isNominal()
|| miningSchemaI.attribute(i).isString()) {
// If not missing, look up the index of this incoming categorical value
// in
// the mining schema
if (!Utils.isMissingValue(inst.value(m_fieldsMap[i]))) {
int[] valueMap = m_nominalValueMaps[i];
int index = valueMap[(int) inst.value(m_fieldsMap[i])];
String incomingAttValue = inst.attribute(m_fieldsMap[i]).value(
(int) inst.value(m_fieldsMap[i]));
/*
* int index =
* miningSchemaI.attribute(i).indexOfValue(incomingAttValue);
*/
if (index >= 0) {
result[i] = index;
} else {
// set this to "unknown" (-1) for nominal valued attributes
result[i] = UNKNOWN_NOMINAL_VALUE;
String warningString = "[MappingInfo] WARNING: Can't match nominal value "
+ incomingAttValue;
if (m_log != null) {
m_log.logMessage(warningString);
} else {
System.err.println(warningString);
}
}
}
}
}
// Now deal with missing values and outliers...
miningSchema.applyMissingAndOutlierTreatments(result);
// printInst(result);
// now fill in any derived values
ArrayList<DerivedFieldMetaInfo> derivedFields = miningSchema
.getDerivedFields();
for (int i = 0; i < derivedFields.size(); i++) {
DerivedFieldMetaInfo temp = derivedFields.get(i);
// System.err.println("Applying : " + temp);
double r = temp.getDerivedValue(result);
result[i + miningSchemaI.numAttributes()] = r;
}
/*
* System.err.print("==> "); for (int i = 0; i < result.length; i++) {
* System.err.print(" " + result[i]); } System.err.println();
*/
return result;
}
/**
* Get a textual description of them mapping between mining schema fields and
* incoming data fields.
*
* @return a description of the fields mapping as a String
*/
public String getFieldsMappingString() {
if (m_fieldsMappingText == null) {
return "No fields mapping constructed!";
}
return m_fieldsMappingText;
}
}
|
0
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml/MiningFieldMetaInfo.java
|
/*
* 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 <http://www.gnu.org/licenses/>.
*/
/*
* MiningFieldMetaInfo.java
* Copyright (C) 2008-2012 University of Waikato, Hamilton, New Zealand
*
*/
package weka.core.pmml;
import java.io.Serializable;
import org.w3c.dom.Element;
import weka.core.Attribute;
import weka.core.Instances;
import weka.core.Utils;
/**
* Class encapsulating information about a MiningField.
*
* @author Mark Hall (mhall{[at]}pentaho{[dot]}com)
* @version $Revision$
*/
public class MiningFieldMetaInfo extends FieldMetaInfo implements Serializable {
/** for serialization */
private static final long serialVersionUID = -1256774332779563185L;
enum Usage {
ACTIVE ("active"),
PREDICTED ("predicted"),
SUPPLEMENTARY ("supplementary"),
GROUP ("group"),
ORDER ("order");
private final String m_stringVal;
Usage(String name) {
m_stringVal = name;
}
public String toString() {
return m_stringVal;
}
}
/** usage type */
Usage m_usageType = Usage.ACTIVE;
enum Outlier {
ASIS ("asIs"),
ASMISSINGVALUES ("asMissingValues"),
ASEXTREMEVALUES ("asExtremeValues");
private final String m_stringVal;
Outlier(String name){
m_stringVal = name;
}
public String toString() {
return m_stringVal;
}
}
/** outlier treatmemnt method */
protected Outlier m_outlierTreatmentMethod = Outlier.ASIS;
/** outlier low value */
protected double m_lowValue;
/** outlier high value */
protected double m_highValue;
enum Missing {
ASIS ("asIs"),
ASMEAN ("asMean"),
ASMODE ("asMode"),
ASMEDIAN ("asMedian"),
ASVALUE ("asValue");
private final String m_stringVal;
Missing(String name) {
m_stringVal = name;
}
public String toString() {
return m_stringVal;
}
}
/** missing values treatment method */
protected Missing m_missingValueTreatmentMethod = Missing.ASIS;
/** actual missing value replacements (if specified) */
protected String m_missingValueReplacementNominal;
protected double m_missingValueReplacementNumeric;
/** optype overrides (override data dictionary type - NOT SUPPORTED AT PRESENT) */
protected FieldMetaInfo.Optype m_optypeOverride = FieldMetaInfo.Optype.NONE;
/** the index of the field in the mining schema Instances */
protected int m_index;
/** importance (if defined) */
protected double m_importance;
/** mining schema (needed for toString method) */
Instances m_miningSchemaI = null;
// TO-DO: invalid values?
/**
* Set the Instances that represent the mining schema. Needed so that
* the toString() method for this class can output attribute names
* and values.
*
* @param miningSchemaI the mining schema as an Instances object
*/
protected void setMiningSchemaInstances(Instances miningSchemaI) {
m_miningSchemaI = miningSchemaI;
}
/**
* Get the usage type of this field.
*
* @return the usage type of this field
*/
public Usage getUsageType() {
return m_usageType;
}
/**
* Return a textual representation of this MiningField.
*
* @return a String describing this mining field
*/
public String toString() {
StringBuffer temp = new StringBuffer();
temp.append(m_miningSchemaI.attribute(m_index));
temp.append("\n\tusage: " + m_usageType
+ "\n\toutlier treatment: " + m_outlierTreatmentMethod);
if (m_outlierTreatmentMethod == Outlier.ASEXTREMEVALUES) {
temp.append(" (lowValue = " + m_lowValue + " highValue = " + m_highValue + ")");
}
temp.append("\n\tmissing value treatment: "
+ m_missingValueTreatmentMethod);
if (m_missingValueTreatmentMethod != Missing.ASIS) {
temp.append(" (replacementValue = "
+ ((m_missingValueReplacementNominal != null)
? m_missingValueReplacementNominal
: Utils.doubleToString(m_missingValueReplacementNumeric, 4))
+ ")");
}
return temp.toString();
}
/**
* Set the index of this field in the mining schema Instances
*
* @param index the index of the attribute in the mining schema Instances
* that this field represents
*/
public void setIndex(int index) {
m_index = index;
}
/**
* Get the name of this field.
*
* @return the name of this field
*/
public String getName() {
return m_fieldName;
}
/**
* Get the outlier treatment method used for this field.
*
* @return the outlier treatment method
*/
public Outlier getOutlierTreatmentMethod() {
return m_outlierTreatmentMethod;
}
/**
* Get the missing value treatment method for this field.
*
* @return the missing value treatment method
*/
public Missing getMissingValueTreatmentMethod() {
return m_missingValueTreatmentMethod;
}
/**
* Apply the missing value treatment method for this field.
*
* @param value the incoming value to apply the treatment to
* @return the value after applying the missing value treatment (if any)
* @throws Exception if there is a problem
*/
public double applyMissingValueTreatment(double value) throws Exception {
double newVal = value;
if (m_missingValueTreatmentMethod != Missing.ASIS &&
Utils.isMissingValue(value)) {
if (m_missingValueReplacementNominal != null) {
Attribute att = m_miningSchemaI.attribute(m_index);
int valIndex = att.indexOfValue(m_missingValueReplacementNominal);
if (valIndex < 0) {
throw new Exception("[MiningSchema] Nominal missing value replacement value doesn't "
+ "exist in the mining schema Instances!");
}
newVal = valIndex;
} else {
newVal = m_missingValueReplacementNumeric;
}
}
return newVal;
}
/**
* Apply the outlier treatment method for this field.
*
* @param value the incoming value to apply the treatment to
* @return the value after applying the treatment (if any)
* @throws Exception if there is a problem
*/
public double applyOutlierTreatment(double value) throws Exception {
double newVal = value;
if (m_outlierTreatmentMethod != Outlier.ASIS) {
if (m_outlierTreatmentMethod == Outlier.ASMISSINGVALUES) {
newVal = applyMissingValueTreatment(value);
} else {
if (value < m_lowValue) {
newVal = m_lowValue;
} else if (value > m_highValue) {
newVal = m_highValue;
}
}
}
return newVal;
}
/**
* Return this mining field as an Attribute.
*
* @return an Attribute for this field.
*/
public Attribute getFieldAsAttribute() {
return m_miningSchemaI.attribute(m_index);
}
/**
* Constructs a new MiningFieldMetaInfo object.
*
* @param field the Element that contains the field information
* @throws Exception if there is a problem during construction
*/
public MiningFieldMetaInfo(Element field) throws Exception {
super(field);
// m_fieldName = field.getAttribute("name");
// get the usage type
String usage = field.getAttribute("usageType");
for (MiningFieldMetaInfo.Usage u : Usage.values()) {
if (u.toString().equals(usage)) {
m_usageType = u;
break;
}
}
// optype override
/*String optype = field.getAttribute("optype");
if (optype.length() > 0) {
if (optype.equals("continuous")) {
m_optypeOverride = FieldMetaInfo.Optype.CONTINUOUS;
} else if (optype.equals("categorical")) {
m_optypeOverride = FieldMetaInfo.Optype.CATEGORICAL;
} else if (optype.equals("ordinal")) {
m_optypeOverride = FieldMetaInfo.Optype.ORDINAL;
}
}*/
// importance
String importance = field.getAttribute("importance");
if (importance.length() > 0) {
m_importance = Double.parseDouble(importance);
}
// outliers
String outliers = field.getAttribute("outliers");
for (MiningFieldMetaInfo.Outlier o : Outlier.values()) {
if (o.toString().equals(outliers)) {
m_outlierTreatmentMethod = o;
break;
}
}
if (outliers.length() > 0 && m_outlierTreatmentMethod == Outlier.ASEXTREMEVALUES) {
// low and high values are required for as extreme values handling
String lowValue = field.getAttribute("lowValue");
if (lowValue.length() > 0) {
m_lowValue = Double.parseDouble(lowValue);
} else {
throw new Exception("[MiningFieldMetaInfo] as extreme values outlier treatment "
+ "specified, but no low value defined!");
}
String highValue = field.getAttribute("highValue");
if (highValue.length() > 0) {
m_highValue = Double.parseDouble(highValue);
} else {
throw new Exception("[MiningFieldMetaInfo] as extreme values outlier treatment "
+ "specified, but no high value defined!");
}
}
// missing values
String missingReplacement = field.getAttribute("missingValueReplacement");
if (missingReplacement.length() > 0) {
// try and parse it as a number
try {
m_missingValueReplacementNumeric = Double.parseDouble(missingReplacement);
} catch (IllegalArgumentException ex) {
// must be numeric
m_missingValueReplacementNominal = missingReplacement;
}
// treatment type
String missingTreatment = field.getAttribute("missingValueTreatment");
for (MiningFieldMetaInfo.Missing m : Missing.values()) {
if (m.toString().equals(missingTreatment)) {
m_missingValueTreatmentMethod = m;
break;
}
}
}
}
}
|
0
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml/MiningSchema.java
|
/*
* 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 <http://www.gnu.org/licenses/>.
*/
/*
* MiningSchema.java
* Copyright (C) 2008-2012 University of Waikato, Hamilton, New Zealand
*
*/
package weka.core.pmml;
import java.io.Serializable;
import java.util.ArrayList;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import weka.core.Attribute;
import weka.core.Instances;
/**
* This class encapsulates the mining schema from
* a PMML xml file. Specifically, it contains the
* fields used in the PMML model as an Instances
* object (just the header). It also contains meta
* information such as value ranges and how to handle
* missing values, outliers etc.
*
* We also store various other PMML elements here, such as
* the TransformationDictionary, DerivedFields and Targets
* (if defined). They are not part of the mining schema per se, but
* relate to inputs used by the model and it is convenient to
* store them here.
*
* @author Mark Hall (mhall{[at]}pentaho{[dot]}com)
* @version $Revision$
*/
public class MiningSchema implements Serializable {
/** For serialization */
private static final long serialVersionUID = 7144380586726330455L;
/** The structure of all the fields (both mining schema and derived) as Instances */
protected Instances m_fieldInstancesStructure;
/** Just the mining schema fields as Instances */
protected Instances m_miningSchemaInstancesStructure;
/** Meta information about the mining schema fields */
protected ArrayList<MiningFieldMetaInfo> m_miningMeta =
new ArrayList<MiningFieldMetaInfo>();
/**
* Meta information about derived fields (those defined in
* the TransformationDictionary followed by those defined in
* LocalTransformations)
*/
protected ArrayList<DerivedFieldMetaInfo> m_derivedMeta =
new ArrayList<DerivedFieldMetaInfo>();
/** The transformation dictionary (if defined) */
protected TransformationDictionary m_transformationDictionary = null;
/** target meta info (may be null if not defined) */
protected TargetMetaInfo m_targetMetaInfo = null;
private void getLocalTransformations(Element model) throws Exception {
NodeList temp = model.getElementsByTagName("LocalTransformations");
if (temp.getLength() > 0) {
// should be just one LocalTransformations element
Element localT = (Element)temp.item(0);
// Set up some field defs to pass in
/*ArrayList<Attribute> fieldDefs = new ArrayList<Attribute>();
for (int i = 0; i < m_miningSchemaInstancesStructure.numAttributes(); i++) {
fieldDefs.add(m_miningSchemaInstancesStructure.attribute(i));
} */
NodeList localDerivedL = localT.getElementsByTagName("DerivedField");
for (int i = 0; i < localDerivedL.getLength(); i++) {
Node localDerived = localDerivedL.item(i);
if (localDerived.getNodeType() == Node.ELEMENT_NODE) {
DerivedFieldMetaInfo d =
new DerivedFieldMetaInfo((Element)localDerived, null /*fieldDefs*/, m_transformationDictionary);
m_derivedMeta.add(d);
}
}
}
}
/**
* Constructor for MiningSchema.
*
* @param model the <code>Element</code> encapsulating the pmml model
* @param dataDictionary the data dictionary as an Instances object
* @throws Exception if something goes wrong during construction of the
* mining schema
*/
public MiningSchema(Element model,
Instances dataDictionary,
TransformationDictionary transDict) throws Exception {
/*// First check for transformation dictionary/local transformations and derived fields.
// These are not supported yet.
NodeList temp = model.getElementsByTagName("LocalTransformations");
if (temp.getLength() > 0) {
throw new Exception("[MiningSchema] LocalTransformations "
+ "are not supported yet.");
}*/
ArrayList<Attribute> attInfo = new ArrayList<Attribute>();
NodeList fieldList = model.getElementsByTagName("MiningField");
int classIndex = -1;
int addedCount = 0;
for (int i = 0; i < fieldList.getLength(); i++) {
Node miningField = fieldList.item(i);
if (miningField.getNodeType() == Node.ELEMENT_NODE) {
Element miningFieldEl = (Element)miningField;
MiningFieldMetaInfo mfi = new MiningFieldMetaInfo(miningFieldEl);
if (mfi.getUsageType() == MiningFieldMetaInfo.Usage.ACTIVE ||
mfi.getUsageType() == MiningFieldMetaInfo.Usage.PREDICTED) {
// find this attribute in the dataDictionary
Attribute miningAtt = dataDictionary.attribute(mfi.getName());
if (miningAtt != null) {
mfi.setIndex(addedCount);
attInfo.add(miningAtt);
addedCount++;
if (mfi.getUsageType() == MiningFieldMetaInfo.Usage.PREDICTED) {
classIndex = addedCount - 1;
}
// add to the array list
m_miningMeta.add(mfi);
} else {
throw new Exception("Can't find mining field: " + mfi.getName()
+ " in the data dictionary.");
}
}
}
}
m_miningSchemaInstancesStructure = new Instances("miningSchema", attInfo, 0);
// set these instances on the MiningFieldMetaInfos so that the
// toString() method can operate correctly
for (MiningFieldMetaInfo m : m_miningMeta) {
m.setMiningSchemaInstances(m_miningSchemaInstancesStructure);
}
m_transformationDictionary = transDict;
// Handle transformation dictionary and any local transformations
if (m_transformationDictionary != null) {
ArrayList<DerivedFieldMetaInfo> transDerived = transDict.getDerivedFields();
m_derivedMeta.addAll(transDerived);
}
// Get any local transformations
getLocalTransformations(model);
// Set up the full instances structure: combo of mining schema fields and
// all derived fields
ArrayList<Attribute> newStructure = new ArrayList<Attribute>();
for (MiningFieldMetaInfo m : m_miningMeta) {
newStructure.add(m.getFieldAsAttribute());
}
for (DerivedFieldMetaInfo d : m_derivedMeta) {
newStructure.add(d.getFieldAsAttribute());
}
m_fieldInstancesStructure = new Instances("FieldStructure", newStructure, 0);
if (m_transformationDictionary != null) {
// first update the field defs for any derived fields in the transformation dictionary
// and our complete list of derived fields, now that we have a fixed
// ordering for the mining schema + derived attributes (i.e. could
// be different from the order of attributes in the data dictionary that was
// used when the transformation dictionary was initially constructed
m_transformationDictionary.setFieldDefsForDerivedFields(m_fieldInstancesStructure);
}
// update the field defs for all our derived fields.
for (DerivedFieldMetaInfo d : m_derivedMeta) {
d.setFieldDefs(m_fieldInstancesStructure);
}
if (classIndex != -1) {
m_fieldInstancesStructure.setClassIndex(classIndex);
m_miningSchemaInstancesStructure.setClassIndex(classIndex);
}
// do Targets (if any)
NodeList targetsList = model.getElementsByTagName("Targets");
if (targetsList.getLength() > 0) {
if (targetsList.getLength() > 1) {
throw new Exception("[MiningSchema] Can only handle a single Target");
} else {
Node te = targetsList.item(0);
if (te.getNodeType() == Node.ELEMENT_NODE) {
m_targetMetaInfo = new TargetMetaInfo((Element)te);
// fill in any necessary categorical values in the mining schema
// class attribute
if (m_fieldInstancesStructure.classIndex() >= 0 &&
m_fieldInstancesStructure.classAttribute().isString()) {
ArrayList<String> targetVals = m_targetMetaInfo.getValues();
if (targetVals.size() > 0) {
Attribute classAtt = m_fieldInstancesStructure.classAttribute();
for (int i = 0; i < targetVals.size(); i++) {
classAtt.addStringValue(targetVals.get(i));
}
}
}
}
}
}
}
/**
* Apply the missing value treatments (if any) to an incoming instance.
*
* @param values an array of doubles in order of the fields in the mining schema
* that represents the incoming instance (note: use PMMLUtils.instanceToSchema()
* to generate this).
* @throws Exception if something goes wrong during missing value handling
*/
public void applyMissingValuesTreatment(double[] values) throws Exception {
for (int i = 0; i < m_miningMeta.size(); i++) {
MiningFieldMetaInfo mfi = m_miningMeta.get(i);
values[i] = mfi.applyMissingValueTreatment(values[i]);
}
}
/**
* Apply the outlier treatment methods (if any) to an incoming instance.
*
* @param values an array of doubles in order of the fields in the mining schema
* that represents the incoming instance (note: use PMMLUtils.instanceToSchema()
* to generate this).
* @throws Exception if something goes wrong during outlier treatment handling
*/
public void applyOutlierTreatment(double[] values) throws Exception {
for (int i = 0; i < m_miningMeta.size(); i++) {
MiningFieldMetaInfo mfi = m_miningMeta.get(i);
values[i] = mfi.applyOutlierTreatment(values[i]);
}
}
/**
* Apply both missing and outlier treatments to an incoming instance.
* @param values an array of doubles in order of the fields in the mining schema
* that represents the incoming instance (note: use MappingInfo.instanceToSchema()
* to generate this).
* @throws Exception if something goes wrong during this process
*/
public void applyMissingAndOutlierTreatments(double[] values) throws Exception {
for (int i = 0; i < m_miningMeta.size(); i++) {
MiningFieldMetaInfo mfi = m_miningMeta.get(i);
values[i] = mfi.applyMissingValueTreatment(values[i]);
values[i] = mfi.applyOutlierTreatment(values[i]);
}
}
/**
* Get the all the fields (both mining schema and derived) as Instances.
* Attributes are in order of those in the mining schema, followed by
* derived attributes from the TransformationDictionary followed by
* derived attributes from LocalTransformations.
*
* @return all the fields as an Instances object
*/
public Instances getFieldsAsInstances() {
return m_fieldInstancesStructure;
}
/**
* Get the mining schema fields as an Instances object.
*
* @return the mining schema fields as an Instances object.
*/
public Instances getMiningSchemaAsInstances() {
return m_miningSchemaInstancesStructure;
}
/**
* Get the transformation dictionary .
*
* @return the transformation dictionary or null if none is
* defined.
*/
public TransformationDictionary getTransformationDictionary() {
return m_transformationDictionary;
}
/**
* Returns true if there is Target meta data.
*
* @return true if there is Target meta data
*/
public boolean hasTargetMetaData() {
return (m_targetMetaInfo != null);
}
/**
* Get the Target meta data.
*
* @return the Target meta data
*/
public TargetMetaInfo getTargetMetaData() {
return m_targetMetaInfo;
}
/**
* Method to convert any string attributes in the mining schema
* Instances to nominal attributes. This may be necessary if there are
* no Value elements defined for categorical fields in the data dictionary.
* In this case, elements in the actual model definition will probably reveal
* the valid values for categorical fields.
*/
public void convertStringAttsToNominal() {
Instances miningSchemaI = getFieldsAsInstances();
if (miningSchemaI.checkForStringAttributes()) {
ArrayList<Attribute> attInfo = new ArrayList<Attribute>();
for (int i = 0; i < miningSchemaI.numAttributes(); i++) {
Attribute tempA = miningSchemaI.attribute(i);
if (tempA.isString()) {
ArrayList<String> valueVector = new ArrayList<String>();
for (int j = 0; j < tempA.numValues(); j++) {
valueVector.add(tempA.value(j));
}
Attribute newAtt = new Attribute(tempA.name(), valueVector);
attInfo.add(newAtt);
} else {
attInfo.add(tempA);
}
}
Instances newI = new Instances("miningSchema", attInfo, 0);
if (m_fieldInstancesStructure.classIndex() >= 0) {
newI.setClassIndex(m_fieldInstancesStructure.classIndex());
}
m_fieldInstancesStructure = newI;
/* StringToNominal stn = new StringToNominal();
stn.setInputFormat(miningSchemaI);
Instances newI = Filter.useFilter(miningSchemaI, stn);
m_miningSchema = newI; */
}
}
/**
* Convert a numeric attribute in the mining schema to nominal.
*
* @param index the index of the attribute to convert
* @param newVals an ArrayList of the values of the nominal attribute
*/
public void convertNumericAttToNominal(int index,
ArrayList<String> newVals) {
Instances miningSchemaI = getFieldsAsInstances();
if (miningSchemaI.attribute(index).isNominal()) {
throw new IllegalArgumentException("[MiningSchema] convertNumericAttToNominal: attribute is "
+ "already nominal!");
}
ArrayList<String> newValues = new ArrayList<String>();
for (int i = 0; i < newVals.size(); i++) {
newValues.add(newVals.get(i));
}
ArrayList<Attribute> attInfo = new ArrayList<Attribute>();
for (int i = 0; i < miningSchemaI.numAttributes(); i++) {
Attribute tempA = miningSchemaI.attribute(i);
if (i == index) {
Attribute newAtt = new Attribute(tempA.name(), newValues);
attInfo.add(newAtt);
} else {
attInfo.add(tempA);
}
}
Instances newI = new Instances("miningSchema", attInfo, 0);
if (m_fieldInstancesStructure.classIndex() >= 0) {
newI.setClassIndex(m_fieldInstancesStructure.classIndex());
}
m_fieldInstancesStructure = newI;
}
public ArrayList<DerivedFieldMetaInfo> getDerivedFields() {
return m_derivedMeta;
}
public ArrayList<MiningFieldMetaInfo> getMiningFields() {
return m_miningMeta;
}
/**
* Get a textual description of the mining schema.
*
* @return a textual description of the mining schema
*/
public String toString() {
StringBuffer temp = new StringBuffer();
if (m_transformationDictionary != null) {
temp.append(m_transformationDictionary);
}
temp.append("Mining schema:\n\n");
for (MiningFieldMetaInfo m : m_miningMeta) {
temp.append(m + "\n");
}
if (m_derivedMeta.size() > 0) {
temp.append("\nDerived fields:\n\n");
for (DerivedFieldMetaInfo d : m_derivedMeta) {
temp.append(d + "\n");
}
}
temp.append("\n");
return temp.toString();
}
}
|
0
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml/NormContinuous.java
|
/*
* 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 <http://www.gnu.org/licenses/>.
*/
/*
* NormContinuous.java
* Copyright (C) 2008-2012 University of Waikato, Hamilton, New Zealand
*
*/
package weka.core.pmml;
import java.util.ArrayList;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import weka.core.Attribute;
import weka.core.Utils;
/**
* Class encapsulating a NormContinuous Expression.
*
* @author Mark Hall (mhall{[at]}pentaho{[dot]}com)
* @version $Revision 1.0 $
*/
public class NormContinuous extends Expression {
/**
* For serialization
*/
private static final long serialVersionUID = 4714332374909851542L;
/** The name of the field to use */
protected String m_fieldName;
/** The index of the field */
protected int m_fieldIndex;
/** True if a replacement for missing values has been specified */
protected boolean m_mapMissingDefined = false;
/** The value of the missing value replacement (if defined) */
protected double m_mapMissingTo;
/** Outlier treatment method (default = asIs) */
protected MiningFieldMetaInfo.Outlier m_outlierTreatmentMethod =
MiningFieldMetaInfo.Outlier.ASIS;
/** original values for the LinearNorm entries */
protected double[] m_linearNormOrig;
/** norm values for the LinearNorm entries */
protected double[] m_linearNormNorm;
public NormContinuous(Element normCont, FieldMetaInfo.Optype opType, ArrayList<Attribute> fieldDefs)
throws Exception {
super(opType, fieldDefs);
if (opType != FieldMetaInfo.Optype.CONTINUOUS) {
throw new Exception("[NormContinuous] can only have a continuous optype");
}
m_fieldName = normCont.getAttribute("field");
String mapMissing = normCont.getAttribute("mapMissingTo");
if (mapMissing != null && mapMissing.length() > 0) {
m_mapMissingTo = Double.parseDouble(mapMissing);
m_mapMissingDefined = true;
}
String outliers = normCont.getAttribute("outliers");
if (outliers != null && outliers.length() > 0) {
for (MiningFieldMetaInfo.Outlier o : MiningFieldMetaInfo.Outlier.values()) {
if (o.toString().equals(outliers)) {
m_outlierTreatmentMethod = o;
break;
}
}
}
// get the LinearNorm elements
NodeList lnL = normCont.getElementsByTagName("LinearNorm");
if (lnL.getLength() < 2) {
throw new Exception("[NormContinuous] Must be at least 2 LinearNorm elements!");
}
m_linearNormOrig = new double[lnL.getLength()];
m_linearNormNorm = new double[lnL.getLength()];
for (int i = 0; i < lnL.getLength(); i++) {
Node lnN = lnL.item(i);
if (lnN.getNodeType() == Node.ELEMENT_NODE) {
Element lnE = (Element)lnN;
String orig = lnE.getAttribute("orig");
m_linearNormOrig[i] = Double.parseDouble(orig);
String norm = lnE.getAttribute("norm");
m_linearNormNorm[i] = Double.parseDouble(norm);
}
}
if (fieldDefs != null) {
setUpField();
}
}
/**
* Set the field definitions for this Expression to use
*
* @param fieldDefs the field definitions to use
* @throws Exception if there is a problem setting the field definitions
*/
public void setFieldDefs(ArrayList<Attribute> fieldDefs) throws Exception {
super.setFieldDefs(fieldDefs);
setUpField();
}
private void setUpField() throws Exception {
m_fieldIndex = -1;
if (m_fieldDefs != null) {
m_fieldIndex = getFieldDefIndex(m_fieldName);
// System.err.println("NormCont... index of " + m_fieldName + " " + m_fieldIndex);
if (m_fieldIndex < 0) {
throw new Exception("[NormContinuous] Can't find field " + m_fieldName
+ " in the supplied field definitions.");
}
Attribute field = m_fieldDefs.get(m_fieldIndex);
if (!field.isNumeric()) {
throw new Exception("[NormContinuous] reference field " + m_fieldName
+" must be continuous.");
}
}
}
/**
* Return the structure of the result of applying this Expression
* as an Attribute.
*
* @return the structure of the result of applying this Expression as an
* Attribute.
*/
protected Attribute getOutputDef() {
return new Attribute(m_fieldName + "_normContinuous");
}
/**
* Get the result of evaluating the expression. In the case
* of a continuous optype, a real number is returned; in
* the case of a categorical/ordinal optype, the index of the nominal
* value is returned as a double.
*
* @param incoming the incoming parameter values
* @return the result of normalizing the input field
* @throws Exception if there is a problem computing the result
*/
public double getResult(double[] incoming) throws Exception {
double[] a = m_linearNormOrig;
double[] b = m_linearNormNorm;
return computeNorm(a, b, incoming);
}
/**
* Compute the inverse of the normalization (i.e. map back to a unormalized value).
*
* @param incoming the incoming parameter values
* @return the unormalized value
*/
public double getResultInverse(double[] incoming) {
double[] a = m_linearNormNorm;
double[] b = m_linearNormOrig;
return computeNorm(a, b, incoming);
}
private double computeNorm(double[] a, double[] b, double[] incoming) {
double result = 0.0;
if (Utils.isMissingValue(incoming[m_fieldIndex])) {
if (m_mapMissingDefined) {
result = m_mapMissingTo;
} else {
result = incoming[m_fieldIndex]; // just return the missing value
}
} else {
double x = incoming[m_fieldIndex];
/*System.err.println("NormCont (index): " + m_fieldIndex);
System.err.println("NormCont (input val): " + x); */
// boundary cases first
if (x < a[0]) {
if (m_outlierTreatmentMethod == MiningFieldMetaInfo.Outlier.ASIS) {
double slope = (b[1] - b[0]) /
(a[1] - a[0]);
double offset = b[0] - (slope * a[0]);
result = slope * x + offset;
} else if (m_outlierTreatmentMethod == MiningFieldMetaInfo.Outlier.ASEXTREMEVALUES) {
result = b[0];
} else {
// map to missing replacement value
result = m_mapMissingTo;
}
} else if (x > a[a.length - 1]) {
int length = a.length;
if (m_outlierTreatmentMethod == MiningFieldMetaInfo.Outlier.ASIS) {
double slope = (b[length - 1] - b[length - 2]) /
(a[length - 1] - a[length - 2]);
double offset = b[length - 1] - (slope * a[length - 1]);
result = slope * x + offset;
} else if (m_outlierTreatmentMethod == MiningFieldMetaInfo.Outlier.ASEXTREMEVALUES) {
result = b[length - 1];
} else {
// map to missing replacement value
result = m_mapMissingTo;
}
} else {
// find the segment that this value falls in to
for (int i = 1; i < a.length; i++) {
if (x <= a[i]) {
result = b[i - 1];
result += ((x - a[i - 1])/(a[i] - a[i - 1]) *
(b[i] - b[i - 1]));
break;
}
}
}
}
return result;
}
/**
* Always throws an Exception since the result of NormContinuous must
* be continuous.
*
* @param incoming the incoming parameter values
* @throws Exception always
*/
public String getResultCategorical(double[] incoming) throws Exception {
throw new Exception("[NormContinuous] Can't return the result as a categorical value!");
}
public String toString(String pad) {
StringBuffer buff = new StringBuffer();
buff.append(pad + "NormContinuous (" + m_fieldName + "):\n" + pad + "linearNorm: ");
for (int i = 0; i < m_linearNormOrig.length; i++) {
buff.append("" + m_linearNormOrig[i] + ":" + m_linearNormNorm[i] + " ");
}
buff.append("\n" + pad);
buff.append("outlier treatment: " + m_outlierTreatmentMethod.toString());
if (m_mapMissingDefined) {
buff.append("\n" + pad);
buff.append("map missing values to: " + m_mapMissingTo);
}
return buff.toString();
}
}
|
0
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml/NormDiscrete.java
|
/*
* 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 <http://www.gnu.org/licenses/>.
*/
/*
* NormDiscrete.java
* Copyright (C) 2008-2012 University of Waikato, Hamilton, New Zealand
*
*/
package weka.core.pmml;
import java.util.ArrayList;
import org.w3c.dom.Element;
import weka.core.Attribute;
import weka.core.Utils;
/**
* Class encapsulating a NormDiscrete Expression. Creates an
* indicator for a particular discrete value.
*
* @author Mark Hall (mhall{[at]}pentaho{[dot]}com)
* @version $Revision 1.0 $
*/
public class NormDiscrete extends Expression {
/**
* For serialization
*/
private static final long serialVersionUID = -8854409417983908220L;
/** The name of the field to lookup our value in */
protected String m_fieldName;
/** The actual attribute itself */
protected Attribute m_field;
/** The index of the attribute */
protected int m_fieldIndex = -1;
/** The actual value (as a String) that will correspond to an output of 1 */
protected String m_fieldValue;
/** True if a replacement for missing values has been specified */
protected boolean m_mapMissingDefined = false;
/** The value of the missing value replacement (if defined) */
protected double m_mapMissingTo;
/**
* If we are referring to a nominal (rather than String) attribute
* then this holds the index of the value in question. Will be faster
* than searching for the value each time.
*/
protected int m_fieldValueIndex = -1;
/**
* Constructor. Reads the field name and field value for this NormDiscrete
* Expression.
*
* @param normDisc the Element encapsulating this NormDiscrete
* @param opType the optype for this expression (taken from either the
* enclosing DefineFunction or DerivedField)
* @param fieldDefs an ArrayList of Attributes for the fields that this
* Expression might need to access
* enclosing DefineFunction or DerivedField)
* @throws Exception if there is a problem parsing this Apply Expression
*/
public NormDiscrete(Element normDisc, FieldMetaInfo.Optype opType, ArrayList<Attribute> fieldDefs)
throws Exception {
super(opType, fieldDefs);
if (opType != FieldMetaInfo.Optype.CONTINUOUS) {
throw new Exception("[NormDiscrete] can only have a continuous optype");
}
m_fieldName = normDisc.getAttribute("field");
m_fieldValue = normDisc.getAttribute("value");
String mapMissing = normDisc.getAttribute("mapMissingTo");
if (mapMissing != null && mapMissing.length() > 0) {
m_mapMissingTo = Double.parseDouble(mapMissing);
m_mapMissingDefined = true;
}
if (fieldDefs != null) {
setUpField();
}
}
/**
* Set the field definitions for this Expression to use
*
* @param fieldDefs the field definitions to use
* @throws Exception if there is a problem setting the field definitions
*/
public void setFieldDefs(ArrayList<Attribute> fieldDefs) throws Exception {
super.setFieldDefs(fieldDefs);
setUpField();
}
/**
* Find the named field, set up the index(es) etc.
*
* @throws Exception if a problem occurs.
*/
private void setUpField() throws Exception {
m_fieldIndex = -1;
m_fieldValueIndex = -1;
m_field = null;
if (m_fieldDefs != null) {
m_fieldIndex = getFieldDefIndex(m_fieldName);
if (m_fieldIndex < 0) {
throw new Exception("[NormDiscrete] Can't find field " + m_fieldName
+ " in the supplied field definitions.");
}
m_field = m_fieldDefs.get(m_fieldIndex);
if (!(m_field.isString() || m_field.isNominal())) {
throw new Exception("[NormDiscrete] reference field " + m_fieldName
+" must be categorical");
}
if (m_field.isNominal()) {
// set up the value index
m_fieldValueIndex = m_field.indexOfValue(m_fieldValue);
if (m_fieldValueIndex < 0) {
throw new Exception("[NormDiscrete] Unable to find value " + m_fieldValue
+ " in nominal attribute " + m_field.name());
}
} else if (m_field.isString()) {
// add our value to this attribute (if it is already there
// then this will have no effect).
m_fieldValueIndex = m_field.addStringValue(m_fieldValue);
}
}
}
/**
* Return the structure of the result of applying this Expression
* as an Attribute.
*
* @return the structure of the result of applying this Expression as an
* Attribute.
*/
protected Attribute getOutputDef() {
return new Attribute(m_fieldName + "=" + m_fieldValue);
}
/**
* Get the result of evaluating the expression. In the case
* of a continuous optype, a real number is returned; in
* the case of a categorical/ordinal optype, the index of the nominal
* value is returned as a double.
*
* @param incoming the incoming parameter values
* @return the result of evaluating the expression
* @throws Exception if there is a problem computing the result
*/
public double getResult(double[] incoming) throws Exception {
double result = 0.0;
if (Utils.isMissingValue(incoming[m_fieldIndex])) {
if (m_mapMissingDefined) {
result = m_mapMissingTo; // return the replacement
} else {
result = incoming[m_fieldIndex]; // just return the missing value
}
} else {
if (m_fieldValueIndex == (int)incoming[m_fieldIndex]) {
result = 1.0;
}
}
return result;
}
/**
* Always throws an Exception since the result of NormDiscrete must
* be continuous.
*
* @param incoming the incoming parameter values
* @throws Exception always
*/
public String getResultCategorical(double[] incoming) throws Exception {
throw new Exception("[NormDiscrete] Can't return the result as a categorical value!");
}
public String toString(String pad) {
StringBuffer buff = new StringBuffer();
buff.append("NormDiscrete: " + m_fieldName + "=" + m_fieldValue);
if (m_mapMissingDefined) {
buff.append("\n" + pad + "map missing values to: " + m_mapMissingTo);
}
return buff.toString();
}
}
|
0
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml/PMMLFactory.java
|
/*
* 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 <http://www.gnu.org/licenses/>.
*/
/*
* PMMLFactory.java
* Copyright (C) 2008-2012 University of Waikato, Hamilton, New Zealand
*
*/
package weka.core.pmml;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.util.ArrayList;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import weka.classifiers.AbstractClassifier;
import weka.classifiers.pmml.consumer.GeneralRegression;
import weka.classifiers.pmml.consumer.NeuralNetwork;
import weka.classifiers.pmml.consumer.PMMLClassifier;
import weka.classifiers.pmml.consumer.Regression;
import weka.classifiers.pmml.consumer.RuleSetModel;
import weka.classifiers.pmml.consumer.SupportVectorMachineModel;
import weka.classifiers.pmml.consumer.TreeModel;
import weka.core.Attribute;
import weka.core.Instance;
import weka.core.Instances;
import weka.core.Utils;
import weka.gui.Logger;
/**
* This class is a factory class for reading/writing PMML models
*
* @author Mark Hall (mhall{[at]}pentaho{[dot]}com)
* @version $Revision$
*/
public class PMMLFactory {
/** for serialization */
protected enum ModelType {
UNKNOWN_MODEL("unknown"), REGRESSION_MODEL("Regression"), GENERAL_REGRESSION_MODEL(
"GeneralRegression"), NEURAL_NETWORK_MODEL("NeuralNetwork"), TREE_MODEL(
"TreeModel"), RULESET_MODEL("RuleSetModel"), SVM_MODEL(
"SupportVectorMachineModel");
private final String m_stringVal;
ModelType(String name) {
m_stringVal = name;
}
@Override
public String toString() {
return m_stringVal;
}
}
/**
* Read and return a PMML model.
*
* @param filename the name of the file to read from
* @return a PMML model
* @throws Exception if there is a problem while reading the file
*/
public static PMMLModel getPMMLModel(String filename) throws Exception {
return getPMMLModel(filename, null);
}
/**
* Read and return a PMML model.
*
* @param file a <code>File</code> to read from
* @return a PMML model
* @throws Exception if there is a problem while reading the file
*/
public static PMMLModel getPMMLModel(File file) throws Exception {
return getPMMLModel(file, null);
}
/**
* Read and return a PMML model.
*
* @param stream the <code>InputStream</code> to read from
* @return a PMML model
* @throws Exception if there is a problem while reading from the stream
*/
public static PMMLModel getPMMLModel(InputStream stream) throws Exception {
return getPMMLModel(stream, null);
}
/**
* Read and return a PMML model.
*
* @param filename the name of the file to read from
* @param log the logging object to use (or null if none is to be used)
* @return a PMML model
* @throws Exception if there is a problem while reading the file
*/
public static PMMLModel getPMMLModel(String filename, Logger log)
throws Exception {
return getPMMLModel(new File(filename), log);
}
/**
* Read and return a PMML model.
*
* @param file a <code>File</code> to read from
* @param log the logging object to use (or null if none is to be used)
* @return a PMML model
* @throws Exception if there is a problem while reading the file
*/
public static PMMLModel getPMMLModel(File file, Logger log) throws Exception {
return getPMMLModel(new BufferedInputStream(new FileInputStream(file)), log);
}
private static boolean isPMML(Document doc) {
NodeList tempL = doc.getElementsByTagName("PMML");
if (tempL.getLength() == 0) {
return false;
}
return true;
}
/**
* Read and return a PMML model.
*
* @param stream the <code>InputStream</code> to read from
* @param log the logging object to use (or null if none is to be used)
* @return a PMML model
* @throws Exception if there is a problem while reading from the stream
*/
public static PMMLModel getPMMLModel(InputStream stream, Logger log)
throws Exception {
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
DocumentBuilder db = dbf.newDocumentBuilder();
Document doc = db.parse(stream);
stream.close();
doc.getDocumentElement().normalize();
if (!isPMML(doc)) {
throw new IllegalArgumentException(
"[PMMLFactory] Source is not a PMML file!!");
}
// System.out.println("Root element " +
// doc.getDocumentElement().getNodeName());
Instances dataDictionary = getDataDictionaryAsInstances(doc);
TransformationDictionary transDict = getTransformationDictionary(doc,
dataDictionary);
ModelType modelType = getModelType(doc);
if (modelType == ModelType.UNKNOWN_MODEL) {
throw new Exception("Unsupported PMML model type");
}
Element model = getModelElement(doc, modelType);
// Construct mining schema and meta data
MiningSchema ms = new MiningSchema(model, dataDictionary, transDict);
// System.out.println(ms);
// System.exit(1);
// Instances miningSchema = getMiningSchemaAsInstances(model,
// dataDictionary);
PMMLModel theModel = getModelInstance(doc, modelType, model,
dataDictionary, ms);
if (log != null) {
theModel.setLog(log);
}
return theModel;
}
/**
* Get the transformation dictionary (if there is one).
*
* @param doc the Document containing the PMML model
* @param dataDictionary the data dictionary as an Instances object
* @return the transformation dictionary or null if there is none defined in
* the Document
* @throws Exception if there is a problem getting the transformation
* dictionary
*/
protected static TransformationDictionary getTransformationDictionary(
Document doc, Instances dataDictionary) throws Exception {
TransformationDictionary transDict = null;
NodeList transL = doc.getElementsByTagName("TransformationDictionary");
// should be of size 0 or 1
if (transL.getLength() > 0) {
Node transNode = transL.item(0);
if (transNode.getNodeType() == Node.ELEMENT_NODE) {
transDict = new TransformationDictionary((Element) transNode,
dataDictionary);
}
}
return transDict;
}
/**
* Serialize a <code>PMMLModel</code> object that encapsulates a PMML model
*
* @param model the <code>PMMLModel</code> to serialize
* @param filename the name of the file to save to
* @throws Exception if something goes wrong during serialization
*/
public static void serializePMMLModel(PMMLModel model, String filename)
throws Exception {
serializePMMLModel(model, new File(filename));
}
/**
* Serialize a <code>PMMLModel</code> object that encapsulates a PMML model
*
* @param model the <code>PMMLModel</code> to serialize
* @param file the <code>File</code> to save to
* @throws Exception if something goes wrong during serialization
*/
public static void serializePMMLModel(PMMLModel model, File file)
throws Exception {
serializePMMLModel(model, new BufferedOutputStream(new FileOutputStream(
file)));
}
/**
* Serialize a <code>PMMLModel</code> object that encapsulates a PMML model
*
* @param model the <code>PMMLModel</code> to serialize
* @param stream the <code>OutputStream</code> to serialize to
* @throws Exception if something goes wrong during serialization
*/
public static void serializePMMLModel(PMMLModel model, OutputStream stream)
throws Exception {
ObjectOutputStream oo = new ObjectOutputStream(stream);
Instances header = model.getMiningSchema().getFieldsAsInstances();
oo.writeObject(header);
oo.writeObject(model);
oo.flush();
oo.close();
}
/**
* Get an instance of a PMMLModel from the supplied Document
*
* @param doc the Document holding the pmml
* @param modelType the type of model
* @param model the Element encapsulating the model part of the Document
* @param dataDictionary the data dictionary as an Instances object
* @param miningSchema the mining schema
* @return a PMMLModel object
* @throws Exception if there is a problem constructing the model or if the
* model type is not supported
*/
protected static PMMLModel getModelInstance(Document doc,
ModelType modelType, Element model, Instances dataDictionary,
MiningSchema miningSchema) throws Exception {
PMMLModel pmmlM = null;
switch (modelType) {
case REGRESSION_MODEL:
pmmlM = new Regression(model, dataDictionary, miningSchema);
// System.out.println(pmmlM);
break;
case GENERAL_REGRESSION_MODEL:
pmmlM = new GeneralRegression(model, dataDictionary, miningSchema);
// System.out.println(pmmlM);
break;
case NEURAL_NETWORK_MODEL:
pmmlM = new NeuralNetwork(model, dataDictionary, miningSchema);
break;
case TREE_MODEL:
pmmlM = new TreeModel(model, dataDictionary, miningSchema);
break;
case RULESET_MODEL:
pmmlM = new RuleSetModel(model, dataDictionary, miningSchema);
break;
case SVM_MODEL:
pmmlM = new SupportVectorMachineModel(model, dataDictionary, miningSchema);
break;
default:
throw new Exception("[PMMLFactory] Unknown model type!!");
}
pmmlM.setPMMLVersion(doc);
pmmlM.setCreatorApplication(doc);
return pmmlM;
}
/**
* Get the type of model
*
* @param doc the Document encapsulating the pmml
* @return the type of model
*/
protected static ModelType getModelType(Document doc) {
NodeList temp = doc.getElementsByTagName("RegressionModel");
if (temp.getLength() > 0) {
return ModelType.REGRESSION_MODEL;
}
temp = doc.getElementsByTagName("GeneralRegressionModel");
if (temp.getLength() > 0) {
return ModelType.GENERAL_REGRESSION_MODEL;
}
temp = doc.getElementsByTagName("NeuralNetwork");
if (temp.getLength() > 0) {
return ModelType.NEURAL_NETWORK_MODEL;
}
temp = doc.getElementsByTagName("TreeModel");
if (temp.getLength() > 0) {
return ModelType.TREE_MODEL;
}
temp = doc.getElementsByTagName("RuleSetModel");
if (temp.getLength() > 0) {
return ModelType.RULESET_MODEL;
}
temp = doc.getElementsByTagName("SupportVectorMachineModel");
if (temp.getLength() > 0) {
return ModelType.SVM_MODEL;
}
return ModelType.UNKNOWN_MODEL;
}
/**
* Get the Element that contains the pmml model
*
* @param doc the Document encapsulating the pmml
* @param modelType the type of model
* @throws Exception if the model type is unsupported/unknown
*/
protected static Element getModelElement(Document doc, ModelType modelType)
throws Exception {
NodeList temp = null;
Element model = null;
switch (modelType) {
case REGRESSION_MODEL:
temp = doc.getElementsByTagName("RegressionModel");
break;
case GENERAL_REGRESSION_MODEL:
temp = doc.getElementsByTagName("GeneralRegressionModel");
break;
case NEURAL_NETWORK_MODEL:
temp = doc.getElementsByTagName("NeuralNetwork");
break;
case TREE_MODEL:
temp = doc.getElementsByTagName("TreeModel");
break;
case RULESET_MODEL:
temp = doc.getElementsByTagName("RuleSetModel");
break;
case SVM_MODEL:
temp = doc.getElementsByTagName("SupportVectorMachineModel");
break;
default:
throw new Exception("[PMMLFactory] unknown/unsupported model type.");
}
if (temp != null && temp.getLength() > 0) {
Node modelNode = temp.item(0);
if (modelNode.getNodeType() == Node.ELEMENT_NODE) {
model = (Element) modelNode;
}
}
return model;
}
/**
* Get the mining schema as an Instances object
*
* @param model the Element containing the pmml model
* @param dataDictionary the data dictionary as an Instances object
* @return the mining schema as an Instances object
* @throws Exception if something goes wrong during reading the mining schema
* @deprecated Use the MiningSchema class instead
*/
@Deprecated
protected static Instances getMiningSchemaAsInstances(Element model,
Instances dataDictionary) throws Exception {
ArrayList<Attribute> attInfo = new ArrayList<Attribute>();
NodeList fieldList = model.getElementsByTagName("MiningField");
int classIndex = -1;
int addedCount = 0;
for (int i = 0; i < fieldList.getLength(); i++) {
Node miningField = fieldList.item(i);
if (miningField.getNodeType() == Node.ELEMENT_NODE) {
Element miningFieldEl = (Element) miningField;
String name = miningFieldEl.getAttribute("name");
String usage = miningFieldEl.getAttribute("usageType");
// TO-DO: also missing value replacement etc.
// find this attribute in the dataDictionary
Attribute miningAtt = dataDictionary.attribute(name);
if (miningAtt != null) {
if (usage.length() == 0 || usage.equals("active")
|| usage.equals("predicted")) {
attInfo.add(miningAtt);
addedCount++;
}
if (usage.equals("predicted")) {
classIndex = addedCount - 1;
}
} else {
throw new Exception("Can't find mining field: " + name
+ " in the data dictionary.");
}
}
}
Instances insts = new Instances("miningSchema", attInfo, 0);
// System.out.println(insts);
if (classIndex != -1) {
insts.setClassIndex(classIndex);
}
return insts;
}
/**
* Get the data dictionary as an Instances object
*
* @param doc the Document encapsulating the pmml
* @return the data dictionary as an Instances object
* @throws Exception if there are fields that are not continuous, ordinal or
* categorical in the data dictionary
*/
protected static Instances getDataDictionaryAsInstances(Document doc)
throws Exception {
// TO-DO: definition of missing values (see below)
ArrayList<Attribute> attInfo = new ArrayList<Attribute>();
NodeList dataDictionary = doc.getElementsByTagName("DataField");
for (int i = 0; i < dataDictionary.getLength(); i++) {
Node dataField = dataDictionary.item(i);
if (dataField.getNodeType() == Node.ELEMENT_NODE) {
Element dataFieldEl = (Element) dataField;
String name = dataFieldEl.getAttribute("name");
String type = dataFieldEl.getAttribute("optype");
Attribute tempAtt = null;
if (name != null && type != null) {
if (type.equals("continuous")) {
tempAtt = new Attribute(name);
} else if (type.equals("categorical") || type.equals("ordinal")) {
NodeList valueList = dataFieldEl.getElementsByTagName("Value");
if (valueList == null || valueList.getLength() == 0) {
// assume that categorical values will be revealed in the actual
// model.
// Create a string attribute for now
ArrayList<String> nullV = null;
tempAtt = new Attribute(name, nullV);
} else {
// add the values (if defined as "valid")
ArrayList<String> valueVector = new ArrayList<String>();
for (int j = 0; j < valueList.getLength(); j++) {
Node val = valueList.item(j);
if (val.getNodeType() == Node.ELEMENT_NODE) {
// property is optional (default value is "valid")
String property = ((Element) val).getAttribute("property");
if (property == null || property.length() == 0
|| property.equals("valid")) {
String value = ((Element) val).getAttribute("value");
valueVector.add(value);
} else {
// Just ignore invalid or missing value definitions for
// now...
// TO-DO: implement Value meta data with missing/invalid
// value defs.
}
}
}
tempAtt = new Attribute(name, valueVector);
}
} else {
throw new Exception("[PMMLFactory] can't handle " + type
+ "attributes.");
}
attInfo.add(tempAtt);
}
}
}
// TO-DO: check whether certain values are declared to represent
// missing or invalid values (applies to both categorical and continuous
// attributes
// create the Instances structure
Instances insts = new Instances("dataDictionary", attInfo, 0);
// System.out.println(insts);
return insts;
}
public static String applyClassifier(PMMLModel model, Instances test)
throws Exception {
StringBuffer buff = new StringBuffer();
if (!(model instanceof PMMLClassifier)) {
throw new Exception("PMML model is not a classifier!");
}
double[] preds = null;
PMMLClassifier classifier = (PMMLClassifier) model;
for (int i = 0; i < test.numInstances(); i++) {
buff.append("Actual: ");
Instance temp = test.instance(i);
if (temp.classAttribute().isNumeric()) {
buff.append(temp.value(temp.classIndex()) + " ");
} else {
buff.append(temp.classAttribute().value(
(int) temp.value(temp.classIndex()))
+ " ");
}
preds = classifier.distributionForInstance(temp);
buff.append(" Predicted: ");
for (double pred : preds) {
buff.append("" + pred + " ");
}
buff.append("\n");
}
return buff.toString();
}
private static class PMMLClassifierRunner extends AbstractClassifier {
/** ID added to avoid warning */
private static final long serialVersionUID = -3742334356788083347L;
@Override
public double[] distributionForInstance(Instance test) throws Exception {
throw new Exception("Don't call this method!!");
}
@Override
public void buildClassifier(Instances instances) throws Exception {
throw new Exception("Don't call this method!!");
}
@Override
public String getRevision() {
return weka.core.RevisionUtils.extract("$Revision$");
}
public void evaluatePMMLClassifier(String[] options) {
runClassifier(this, options);
}
}
public static void main(String[] args) {
try {
String[] optionsTmp = new String[args.length];
for (int i = 0; i < args.length; i++) {
optionsTmp[i] = args[i];
}
String pmmlFile = Utils.getOption('l', optionsTmp);
if (pmmlFile.length() == 0) {
throw new Exception(
"[PMMLFactory] must specify a PMML file using the -l option.");
}
// see if it is supported before going any further
getPMMLModel(pmmlFile, null);
PMMLClassifierRunner pcr = new PMMLClassifierRunner();
pcr.evaluatePMMLClassifier(args);
/*
* PMMLModel model = getPMMLModel(args[0], null);
* System.out.println(model); if (args.length == 2) { // load an arff file
* Instances testData = new Instances(new java.io.BufferedReader(new
* java.io.FileReader(args[1]))); Instances miningSchemaI =
* model.getMiningSchema().getFieldsAsInstances(); if
* (miningSchemaI.classIndex() >= 0) { String className =
* miningSchemaI.classAttribute().name(); for (int i = 0; i <
* testData.numAttributes(); i++) { if
* (testData.attribute(i).name().equals(className)) {
* testData.setClassIndex(i); System.out.println("Found class " +
* className + " in test data."); break; } } }
* System.out.println(applyClassifier(model, testData)); }
*/
} catch (Exception ex) {
ex.printStackTrace();
}
}
}
|
0
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml/PMMLModel.java
|
/*
* 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 <http://www.gnu.org/licenses/>.
*/
/*
* PMMLModel.java
* Copyright (C) 2008-2012 University of Waikato, Hamilton, New Zealand
*
*/
package weka.core.pmml;
import org.w3c.dom.Document;
import weka.gui.Logger;
/**
* Interface for all PMML models
*
* @author Mark Hall (mhall{[at]}pentaho{[dot]}com)
* @version $Revision$
*/
public interface PMMLModel {
/**
* Set the version of the PMML.
*
* @param doc the Document encapsulating the pmml
*/
void setPMMLVersion(Document doc);
/**
* Get the version of PMML used to encode this model.
*
* @return the version as a String
*/
String getPMMLVersion();
/**
* Set the name of the application (if specified) that created this.
* model
*
* @param doc the Document encapsulating the pmml
*/
void setCreatorApplication(Document doc);
/**
* Get the name of the application that created this model.
*
* @return the name of the creating application or null
* if not specified in the pmml.
*/
String getCreatorApplication();
/**
* Get the mining schema.
*
* @return the mining schema
*/
MiningSchema getMiningSchema();
/**
* Set a logger to use.
*
* @param log the logger to use
*/
void setLog(Logger log);
/**
* Get the logger.
*
* @return the logger (or null if none is being used)
*/
Logger getLog();
}
|
0
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml/PMMLProducer.java
|
/*
* 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 <http://www.gnu.org/licenses/>.
*/
/*
* PMMLProducer.java
* Copyright (C) 2014 University of Waikato, Hamilton, New Zealand
*
*/
package weka.core.pmml;
import weka.core.Instances;
/**
* Interface to something that can produce a PMML representation of itself.
*
* @author David Persons
* @author Mark Hall (mhall{[at]}pentaho{[dot]}com)
* @version $Revision: $
*/
public interface PMMLProducer {
/**
* Produce a PMML representation
*
* @param train the training data that might have been used by the
* implementer. If it is not needed by the implementer then clients
* can safely pass in null
*
* @return a string containing the PMML representation
*/
String toPMML(Instances train);
}
|
0
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml/PMMLUtils.java
|
/*
* 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 <http://www.gnu.org/licenses/>.
*/
/*
* PMMLUtils.java
* Copyright (C) 2008-2012 University of Waikato, Hamilton, New Zealand
*
*/
package weka.core.pmml;
/**
* Utility routines.
*
* @author Mark Hall (mhall{[at]}pentaho{[dot]}com)
* @version $Revision$
*/
public class PMMLUtils {
/**
* Utility method to left or right pad strings with arbitrary characters.
*
* @param source the source string
* @param padChar the character to pad with
* @param length the length of the resulting string
* @param leftPad pad to the left instead of the right
* @return a padded string
*/
public static String pad(String source, String padChar,
int length, boolean leftPad) {
StringBuffer temp = new StringBuffer();
if (leftPad) {
for (int i = 0; i< length; i++) {
temp.append(padChar);
}
temp.append(source);
} else {
temp.append(source);
for (int i = 0; i< length; i++) {
temp.append(padChar);
}
}
return temp.toString();
}
}
|
0
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml/SparseArray.java
|
/*
* 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 <http://www.gnu.org/licenses/>.
*/
/*
* SparseArray.java
* Copyright (C) 2010-2012 University of Waikato, Hamilton, New Zealand
*
*/
package weka.core.pmml;
import java.io.Serializable;
import java.io.StreamTokenizer;
import java.io.StringReader;
import java.util.ArrayList;
import java.util.List;
import org.w3c.dom.Element;
import org.w3c.dom.NodeList;
/**
* Implementation of a sparse array. Extends Array.
*
* @author Mark Hall (mhall{[at]}pentaho{[dot]}com)
* @version $Revision$
*/
public class SparseArray extends Array implements Serializable {
/** For serialization */
private static final long serialVersionUID = 8129550573612673674L;
/** The size of the array if known */
protected int m_numValues;
/** The number of non-zero elements */
protected int m_numNonZero;
/** The indices of the sparse array */
protected List<Integer> m_indices;// = new ArrayList<Integer>();
/**
* Initializes the array from the supplied XML element.
*
* @param arrayE the XML containing the array
* @throws Exception if something goes wrong
*/
protected void initialize(Element arrayE) throws Exception {
m_indices = new ArrayList<Integer>();
String arrayS = arrayE.getTagName();
String entriesName = null;
if (arrayS.equals(ArrayType.REAL_SPARSE.toString())) {
m_type = ArrayType.REAL_SPARSE;
entriesName = "REAL-Entries";
} else {
m_type = ArrayType.INT_SPARSE;
entriesName = "INT-Entries";
}
// see if we can get the "n" attribute to determine the
// size
String N = arrayE.getAttribute("n");
if (N != null && N.length() > 0) {
m_numValues = Integer.parseInt(N);
}
// get the values
NodeList v = arrayE.getElementsByTagName(entriesName);
if (v == null || v.getLength() == 0) {
// there are no entries (and indices), so this
// array must contain all zeros
m_numNonZero = 0;
} else {
Element entries = (Element)v.item(0);
String contents = entries.getChildNodes().item(0).getNodeValue();
StringReader sr = new StringReader(contents);
StreamTokenizer st = new StreamTokenizer(sr);
st.resetSyntax();
st.whitespaceChars(0, ' ');
st.wordChars(' '+1,'\u00FF');
st.whitespaceChars(' ',' ');
st.quoteChar('"');
st.quoteChar('\'');
//m_Tokenizer.eolIsSignificant(true);
st.nextToken();
while (st.ttype != StreamTokenizer.TT_EOF &&
st.ttype != StreamTokenizer.TT_EOL) {
m_values.add(st.sval);
st.nextToken();
}
// get the indices
NodeList i = arrayE.getElementsByTagName("Indices");
Element indices = (Element)i.item(0);
contents = indices.getChildNodes().item(0).getNodeValue();
sr = new StringReader(contents);
st = new StreamTokenizer(sr);
st.resetSyntax();
st.whitespaceChars(0, ' ');
st.wordChars(' '+1,'\u00FF');
st.whitespaceChars(' ',' ');
st.quoteChar('"');
st.quoteChar('\'');
//m_Tokenizer.eolIsSignificant(true);
st.nextToken();
while (st.ttype != StreamTokenizer.TT_EOF &&
st.ttype != StreamTokenizer.TT_EOL) {
Integer newInt = new Integer(Integer.parseInt(st.sval) - 1);
m_indices.add(newInt);
st.nextToken();
}
m_numNonZero = m_indices.size();
}
}
/**
* Construct a sparse array from an XML node
*
* @param arrayE the Element containing the XML
* @throws Exception if something goes wrong
*/
protected SparseArray(Element arrayE) throws Exception {
super(arrayE);
}
/**
* Construct a sparse array from the given values and indices
*
* @param type the type of the array elements
* @param values the values of the array
* @param indices the indices of the array
*/
protected SparseArray(ArrayType type, List<Object> values,
List<Integer> indices) {
super(type, values);
m_indices = indices;
}
/**
* Overrides isSparse() in Array and always returns true.
*
* @return true always
*/
public boolean isSparse() {
return true;
}
/**
* Get the number of values in this array.
*
* @return the number of values in this array.
*/
public int numValues() {
return m_numValues;
}
/**
* Get the number of non-zero values in this sparse array
*
* @return the number of values that are non-zero
*/
public int numNonZero() {
return m_numNonZero;
}
/**
* Returns the index of the value stored at the given position
*
* @param position the position
* @return the index of the value stored at the given position
*/
public int index(int position) {
return m_indices.get(position);
}
/**
* Locates the greatest index that is not greater than the
* given index.
*
* @return the internal index of the attribute index. Returns
* -1 if no index with this property could be found
*/
public int locateIndex(int index) {
int min = 0, max = m_indices.size() - 1;
if (max == -1) {
return -1;
}
// Binary search
while ((m_indices.get(min) <= index)
&& (m_indices.get(max) >= index)) {
int current = (max + min) / 2;
if (m_indices.get(current) > index) {
max = current - 1;
} else if (m_indices.get(current) < index) {
min = current + 1;
} else {
return current;
}
}
if (m_indices.get(max) < index) {
return max;
} else {
return min - 1;
}
}
/**
* Gets the value at index from the array.
*
* @param index the index of the value to get.
* @return the value at index in the array as as String.
* @throws Exception if index is out of bounds.
*/
public String value(int arrIndex) throws Exception {
int index = locateIndex(arrIndex);
if (index >= 0 && (m_indices.get(index) == arrIndex)) {
return m_values.get(index);
} else {
return "0";
}
}
public String toString() {
StringBuffer text = new StringBuffer();
text.append("<");
for (int i = 0; i < m_indices.size(); i++) {
text.append(m_indices.get(i).toString() + " ");
text.append(m_values.get(i));
if (i < m_indices.size() - 1) {
text.append(",");
}
}
text.append(">");
return text.toString();
}
}
|
0
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml/TargetMetaInfo.java
|
/*
* 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 <http://www.gnu.org/licenses/>.
*/
/*
* TargetMetaInfo.java
* Copyright (C) 2008-2012 University of Waikato, Hamilton, New Zealand
*
*/
package weka.core.pmml;
import java.io.Serializable;
import java.util.ArrayList;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import weka.core.Attribute;
import weka.core.Utils;
/**
* Class to encapsulate information about a Target.
*
* @author Mark Hall (mhall{[at]}pentaho{[dot]}com)
* @version $Revision 1.0 $
*/
public class TargetMetaInfo extends FieldMetaInfo implements Serializable {
/** For serialization */
private static final long serialVersionUID = 863500462237904927L;
/** min and max */
protected double m_min = Double.NaN;
protected double m_max = Double.NaN;
/** re-scaling of target value (if defined) */
protected double m_rescaleConstant = 0;
protected double m_rescaleFactor = 1.0;
/** cast integers (default no casting) */
protected String m_castInteger = "";
// -------------------------------------------------------
/** default value (numeric) or prior distribution (categorical) */
protected double[] m_defaultValueOrPriorProbs;
/** for categorical values. Actual values */
protected ArrayList<String> m_values = new ArrayList<String>();
/** corresponding display values */
protected ArrayList<String> m_displayValues = new ArrayList<String>();
// TODO: toString method.
/**
* Constructor.
*
* @param target the <code>Element</code> encapsulating a Target
* @throws Exception if there is a problem reading the Target
*/
protected TargetMetaInfo(Element target) throws Exception {
super(target);
// check for an OPTYPE
/*String op = target.getAttribute("optype");
if (op != null && op.length() > 0) {
for (int i = 0; i < Optype.values().length; i++) {
if (op.equals(Optype.values()[i].toString())) {
m_optype = Optype.values()[i];
break;
}
}
}*/
// min and max (if defined)
String min = target.getAttribute("min");
if (min != null && min.length() > 0) {
try {
m_min = Double.parseDouble(min);
} catch (IllegalArgumentException ex) {
throw new Exception("[TargetMetaInfo] can't parse min value for target field "
+ m_fieldName);
}
}
String max = target.getAttribute("max");
if (max != null && max.length() > 0) {
try {
m_max = Double.parseDouble(max);
} catch (IllegalArgumentException ex) {
throw new Exception("[TargetMetaInfo] can't parse max value for target field "
+ m_fieldName);
}
}
// Re-scaling (if any)
String rsc = target.getAttribute("rescaleConstant");
if (rsc != null && rsc.length() > 0) {
try {
m_rescaleConstant = Double.parseDouble(rsc);
} catch (IllegalArgumentException ex) {
throw new Exception("[TargetMetaInfo] can't parse rescale constant value for "
+ "target field " + m_fieldName);
}
}
String rsf = target.getAttribute("rescaleFactor");
if (rsf != null && rsf.length() > 0) {
try {
m_rescaleFactor = Double.parseDouble(rsf);
} catch (IllegalArgumentException ex) {
throw new Exception("[TargetMetaInfo] can't parse rescale factor value for "
+ "target field " + m_fieldName);
}
}
// Cast integers
String cstI = target.getAttribute("castInteger");
if (cstI != null && cstI.length() > 0) {
m_castInteger = cstI;
}
// Get the target value(s). Apparently, there doesn't have to
// be any target values defined.
NodeList vals = target.getElementsByTagName("TargetValue");
if (vals.getLength() > 0) {
m_defaultValueOrPriorProbs = new double[vals.getLength()];
for (int i = 0; i < vals.getLength(); i++) {
Node value = vals.item(i);
if (value.getNodeType() == Node.ELEMENT_NODE) {
Element valueE = (Element)value;
String valueName = valueE.getAttribute("value");
if (valueName != null && valueName.length() > 0) {
// we have a categorical value - set optype if it's not
// already set
if (m_optype != Optype.CATEGORICAL &&
m_optype != Optype.NONE) {
throw new Exception("[TargetMetaInfo] TargetValue element has categorical value but "
+ "optype is not categorical!");
}
if (m_optype == Optype.NONE) {
m_optype = Optype.CATEGORICAL;
}
m_values.add(valueName);
// get display value (if any)
String displayValue = valueE.getAttribute("displayValue");
if (displayValue != null && displayValue.length() > 0) {
m_displayValues.add(displayValue);
} else {
// use the value as the display value
m_displayValues.add(valueName);
}
// get prior probability (should be defined!!)
String prior = valueE.getAttribute("priorProbability");
if (prior != null && prior.length() > 0) {
try {
m_defaultValueOrPriorProbs[i] = Double.parseDouble(prior);
} catch (IllegalArgumentException ex) {
throw new Exception("[TargetMetaInfo] Can't parse probability from "
+ "TargetValue element.");
}
} else {
throw new Exception("[TargetMetaInfo] No prior probability defined for value "
+ valueName);
}
} else {
// we have a numeric field
// check the optype
if (m_optype != Optype.CONTINUOUS &&
m_optype != Optype.NONE) {
throw new Exception("[TargetMetaInfo] TargetValue element has continuous value but "
+ "optype is not continuous!");
}
if (m_optype == Optype.NONE) {
m_optype = Optype.CONTINUOUS;
}
// get the default value
String defaultV = valueE.getAttribute("defaultValue");
if (defaultV != null && defaultV.length() > 0) {
try {
m_defaultValueOrPriorProbs[i] = Double.parseDouble(defaultV);
} catch (IllegalArgumentException ex) {
throw new Exception("[TargetMetaInfo] Can't parse default value from "
+ "TargetValue element.");
}
} else {
throw new Exception("[TargetMetaInfo] No default value defined for target "
+ m_fieldName);
}
}
}
}
}
}
/**
* Get the prior probability for the supplied value.
*
* @param value the value to get the probability for
* @return the probability
* @throws Exception if there are no TargetValues defined or
* if the supplied value is not in the list of TargetValues
*/
public double getPriorProbability(String value) throws Exception {
if (m_defaultValueOrPriorProbs == null) {
throw new Exception("[TargetMetaInfo] no TargetValues defined (getPriorProbability)");
}
double result = Double.NaN;
boolean found = false;
for (int i = 0; i < m_values.size(); i++) {
if (value.equals(m_values.get(i))) {
found = true;
result = m_defaultValueOrPriorProbs[i];
break;
}
}
if (!found) {
throw new Exception("[TargetMetaInfo] couldn't find value " + value
+ "(getPriorProbability)");
}
return result;
}
/**
* Get the default value (numeric target)
*
* @return the default value
* @throws Exception if there is no TargetValue defined
*/
public double getDefaultValue() throws Exception {
if (m_defaultValueOrPriorProbs == null) {
throw new Exception("[TargetMetaInfo] no TargetValues defined (getPriorProbability)");
}
return m_defaultValueOrPriorProbs[0];
}
/**
* Get the values (discrete case only) for this Target. Note: the
* list may be empty if the pmml doesn't specify any values.
*
* @return the values of this Target
*/
public ArrayList<String> getValues() {
return new ArrayList<String>(m_values);
}
/**
* Apply min and max, rescaleFactor, rescaleConstant and castInteger - in
* that order (where defined).
*
* @param prediction the prediction to apply these modification to
* @return the modified prediction
* @throws Exception if this target is not a continuous one
*/
public double applyMinMaxRescaleCast(double prediction) throws Exception {
if (m_optype != Optype.CONTINUOUS) {
throw new Exception("[TargetMetaInfo] target must be continuous!");
}
if (!Utils.isMissingValue(m_min) && prediction < m_min) {
prediction = m_min;
}
if (!Utils.isMissingValue(m_max) && prediction > m_max) {
prediction = m_max;
}
prediction *= m_rescaleFactor;
prediction += m_rescaleConstant;
if (m_castInteger.length() > 0) {
if (m_castInteger.equals("round")) {
prediction = Math.round(prediction);
} else if (m_castInteger.equals("ceiling")) {
prediction = Math.ceil(prediction);
} else if (m_castInteger.equals("floor")) {
prediction = Math.floor(prediction);
} else {
throw new Exception("[TargetMetaInfo] unknown castInteger value "
+ m_castInteger);
}
}
return prediction;
}
/**
* Return this field as an Attribute.
*
* @return an Attribute for this field.
*/
public Attribute getFieldAsAttribute() {
if (m_optype == Optype.CONTINUOUS) {
return new Attribute(m_fieldName);
}
if (m_values.size() == 0) {
// return a String attribute
return new Attribute(m_fieldName, (ArrayList<String>)null);
}
ArrayList<String> values = new ArrayList<String>();
for (String val : m_values) {
values.add(val);
}
return new Attribute(m_fieldName, values);
}
}
|
0
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml/TransformationDictionary.java
|
/*
* 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 <http://www.gnu.org/licenses/>.
*/
/*
* TransformationDictionary.java
* Copyright (C) 2008-2012 University of Waikato, Hamilton, New Zealand
*
*/
package weka.core.pmml;
import java.io.Serializable;
import java.util.ArrayList;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import weka.core.Attribute;
import weka.core.Instances;
import weka.core.SerializedObject;
/**
* Class encapsulating the TransformationDictionary element. Contains a list of
* DefineFunctions and DerivedFields (if any).
*
* @author Mark Hall (mhall{[at]}pentaho{[dot]}com
* @version $Revision 1.0 $
*/
class TransformationDictionary implements Serializable {
/** ID added to avoid warning */
private static final long serialVersionUID = -4649092421002319829L;
/** The defined functions (if any) */
protected ArrayList<DefineFunction> m_defineFunctions = new ArrayList<DefineFunction>();
/** The derived fields (if any) */
protected ArrayList<DerivedFieldMetaInfo> m_derivedFields = new ArrayList<DerivedFieldMetaInfo>();
/**
* Construct a new TransformationDictionary
*
* @param dictionary the Element containing the dictionary
* @param dataDictionary the data dictionary as an Instances object
* @throws Exception if there is a problem constructing the transformation
* dictionary
*/
protected TransformationDictionary(Element dictionary,
Instances dataDictionary) throws Exception {
// set up incoming field definitions
/*
* ArrayList<Attribute> incomingFieldDefs = new ArrayList<Attribute>(); for
* (int i = 0; i < dataDictionary.numAttributes(); i++) {
* incomingFieldDefs.add(dataDictionary.attribute(i)); }
*/
// get any derived fields and DefineFunctions
NodeList derivedL = dictionary.getChildNodes();
for (int i = 0; i < derivedL.getLength(); i++) {
Node child = derivedL.item(i);
if (child.getNodeType() == Node.ELEMENT_NODE) {
String tagName = ((Element) child).getTagName();
if (tagName.equals("DerivedField")) {
DerivedFieldMetaInfo df = new DerivedFieldMetaInfo((Element) child,
null /* incomingFieldDefs */, null);
m_derivedFields.add(df);
} else if (tagName.equals("DefineFunction")) {
DefineFunction defF = new DefineFunction((Element) child, null);
m_defineFunctions.add(defF);
}
}
}
}
/**
* Set the field definitions for the derived fields. Usually called once the
* structure of the mining schema + derived fields has been determined.
* Calling this method with an array list of field definitions in the order of
* attributes in the mining schema + derived fields will allow the expressions
* used in the derived fields to access the correct attribute values from the
* incoming instance (also allows for derived fields to reference other
* derived fields). This is necessary because construction of the
* TransformationDictionary uses the data dictionary to reference fields (the
* order of fields in the data dictionary is not guaranteed to be the same as
* the order in the mining schema).
*
* IMPORTANT: for derived field x to be able to reference derived field y, y
* must have been declared before x in the PMML file. This is because the
* process of constructing an input vector of values to the model proceeds in
* a linear left-to-right fashion - so any referenced derived field (e.g.
* field y), must have already computed its value when x is evaluated.
*
* @param fieldDefs the definition of the incoming fields as an array list of
* attributes
* @throws Exception if a problem occurs
*/
protected void setFieldDefsForDerivedFields(ArrayList<Attribute> fieldDefs)
throws Exception {
for (int i = 0; i < m_derivedFields.size(); i++) {
m_derivedFields.get(i).setFieldDefs(fieldDefs);
}
// refresh the define functions - force them to pass on their parameter
// definitions as field defs to their encapsulated expression. Parameter
// defs were not passed on by expressions encapsulated in DefineFunctions
// at construction time because the encapsulated expression does not know
// whether it is contained in a DefineFunction or a DerivedField. Since
// we delay passing on field definitions until all derived fields are
// loaded (in order to allow derived fields to reference other derived
// fields),
// we must tell DefineFunctions to pass on their parameter definitions
for (int i = 0; i < m_defineFunctions.size(); i++) {
m_defineFunctions.get(i).pushParameterDefs();
}
}
/**
* Set the field definitions for the derived fields. Usually called once the
* structure of the mining schema has been determined. Calling this method
* with an array list of field definitions in the order of attributes in the
* mining schema will allow the expressions used in the derived fields to
* access the correct attribute values from the incoming instances. This is
* necessary because construction of the TransformationDictionary uses the
* data dictionary to reference fields (the order of fields in the data
* dictionary is not guaranteed to be the same as the order in the mining
* schema).
*
* @param fieldDefs the definition of the incoming fields as an Instances
* object
* @throws Exception if a problem occurs
*/
protected void setFieldDefsForDerivedFields(Instances fieldDefs)
throws Exception {
ArrayList<Attribute> tempDefs = new ArrayList<Attribute>();
for (int i = 0; i < fieldDefs.numAttributes(); i++) {
tempDefs.add(fieldDefs.attribute(i));
}
setFieldDefsForDerivedFields(tempDefs);
}
protected ArrayList<DerivedFieldMetaInfo> getDerivedFields() {
return new ArrayList<DerivedFieldMetaInfo>(m_derivedFields);
}
/**
* Get a named DefineFunction. Returns a deep copy of the function.
*
* @param functionName the name of the function to get
* @return the named function or null if it cannot be found
* @throws Exception if there is a problem deep copying the function
*/
protected DefineFunction getFunction(String functionName) throws Exception {
DefineFunction copy = null;
DefineFunction match = null;
for (DefineFunction f : m_defineFunctions) {
if (f.getName().equals(functionName)) {
match = f;
// System.err.println("Found a match!!!");
break;
}
}
if (match != null) {
SerializedObject so = new SerializedObject(match, false);
copy = (DefineFunction) so.getObject();
// System.err.println(copy);
}
return copy;
}
@Override
public String toString() {
StringBuffer buff = new StringBuffer();
buff.append("Transformation dictionary:\n");
if (m_derivedFields.size() > 0) {
buff.append("derived fields:\n");
for (DerivedFieldMetaInfo d : m_derivedFields) {
buff.append("" + d.getFieldAsAttribute() + "\n");
}
}
if (m_defineFunctions.size() > 0) {
buff.append("\nfunctions:\n");
for (DefineFunction f : m_defineFunctions) {
buff.append(f.toString(" ") + "\n");
}
}
buff.append("\n");
return buff.toString();
}
}
|
0
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml/VectorDictionary.java
|
/*
* 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 <http://www.gnu.org/licenses/>.
*/
/*
* VectorDictionary.java
* Copyright (C) 2010-2012 University of Waikato, Hamilton, New Zealand
*
*/
package weka.core.pmml;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import weka.core.Attribute;
import weka.core.Instances;
/**
* Class encapsulating the PMML VectorDictionary construct.
*
* @author Mark Hall (mhall{[at]}pentaho{[dot]}com)
* @version $Revision$
*/
public class VectorDictionary implements Serializable {
/**
* For serialization
*/
private static final long serialVersionUID = -5538024467333813123L;
/** The number of support vectors in the dictionary */
protected int m_numberOfVectors;
/** The fields accessed by the support vectors **/
protected List<FieldRef> m_vectorFields = new ArrayList<FieldRef>();
/** The vectors in the dictionary */
protected Map<String, VectorInstance> m_vectorInstances =
new HashMap<String, VectorInstance>();
/**
* Returns a new VectorDictionary constructed from the supplied XML container
*
* @param container the containing XML
* @param ms the mining schema
* @return a VectorDictionary
* @throws Exception if the VectorDictionary can't be read from the XML container
*/
public static VectorDictionary getVectorDictionary(Element container, MiningSchema ms)
throws Exception {
VectorDictionary vectDict = null;
NodeList vecL = container.getElementsByTagName("VectorDictionary");
if (vecL.getLength() > 0) {
Node vecNode = vecL.item(0);
if (vecNode.getNodeType() == Node.ELEMENT_NODE) {
vectDict = new VectorDictionary((Element)vecNode, ms);
}
}
return vectDict;
}
/**
* Convert an incoming instance to an array of values that corresponds
* to the fields referenced by the support vectors in the vector dictionary
*
* @param incoming an incoming instance
* @return an array of values from the incoming instance that corresponds
* to just the fields referenced by the support vectors
* @throws Exception if this array cant be constructed for some reason
*/
public double[] incomingInstanceToVectorFieldVals(double[] incoming)
throws Exception {
double[] newInst = new double[m_vectorFields.size()];
for (int i = 0; i < m_vectorFields.size(); i++) {
FieldRef fr = m_vectorFields.get(i);
newInst[i] = fr.getResult(incoming);
}
return newInst;
}
/**
* Constructor.
*
* @param vectNode the XML containing the VectorDictionary
* @param ms the mining schema
* @throws Exception if something goes wrong
*/
public VectorDictionary(Element vectNode, MiningSchema ms) throws Exception {
NodeList vecFieldsL = vectNode.getElementsByTagName("VectorFields");
if (vecFieldsL.getLength() == 0) {
throw new Exception("[VectorDictionary] there are no VectorFields defined!!");
}
Instances fullStructure = ms.getFieldsAsInstances();
ArrayList<Attribute> fieldDefs = new ArrayList<Attribute>();
for (int i = 0; i < fullStructure.numAttributes(); i++) {
fieldDefs.add(fullStructure.attribute(i));
}
// should be just one VectorFields element
Node fieldsNode = vecFieldsL.item(0);
NodeList fieldRefsL = ((Element)fieldsNode).getElementsByTagName("FieldRef");
// build the list of field refs
for (int i = 0; i < fieldRefsL.getLength(); i++) {
Element fieldR = (Element)fieldRefsL.item(i);
String fieldName = fieldR.getAttribute("field");
Attribute a = fullStructure.attribute(fieldName);
if (a == null) {
throw new Exception("[VectorDictionary] can't find field '" + fieldName
+ "' in the mining schema/derived fields!");
}
FieldMetaInfo.Optype fieldOpt = (a.isNumeric())
? FieldMetaInfo.Optype.CONTINUOUS
: FieldMetaInfo.Optype.CATEGORICAL;
FieldRef fr = new FieldRef(fieldR, fieldOpt, fieldDefs);
m_vectorFields.add(fr);
}
// now get the support vectors
NodeList vecInstL = vectNode.getElementsByTagName("VectorInstance");
if (vecInstL.getLength() == 0) {
throw new Exception("[VectorDictionary] no VectorInstances defined!");
}
for (int i = 0; i < vecInstL.getLength(); i++) {
Element vecInstEl = (Element)vecInstL.item(i);
VectorInstance temp = new VectorInstance(vecInstEl, m_vectorFields);
String id = temp.getID();
if (m_vectorInstances.get(id) != null) {
throw new Exception("[VectorDictionary] : There is already a vector with ID "
+ id + " in the dictionary!");
}
m_vectorInstances.put(id, temp);
}
}
/**
* Gets a vector from the dictionary corresponding to the supplied ID
*
* @param ID the ID of the vector to retrieve
* @return the vector with the given ID or null if no vector with
* that ID exists in the dictionary
*/
public VectorInstance getVector(String ID) {
return m_vectorInstances.get(ID);
}
}
|
0
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml/VectorInstance.java
|
/*
* 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 <http://www.gnu.org/licenses/>.
*/
/*
* VectorInstance.java
* Copyright (C) 2010-2012 University of Waikato, Hamilton, New Zealand
*
*/
package weka.core.pmml;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;
import org.w3c.dom.Element;
import org.w3c.dom.NodeList;
/**
* Class encapsulating a PMML VectorInstance construct
*
* @author Mark Hall (mhall{[at]}pentaho{[dot]}com)
* @version $Revision$
*/
public class VectorInstance implements Serializable {
/** For serialization */
private static final long serialVersionUID = -7543200367512646290L;
/** The ID of this instance */
protected String m_ID;
/** The usually sparse elements of this vector */
protected Array m_values;
/** The fields indexed by this VectorInstance */
protected List<FieldRef> m_vectorFields;
/**
* Constructor
*
* @param values the Array of values for this vector instance
* @param vectorFields the mining fields indexed by this vector instance
*/
public VectorInstance(Array values, List<FieldRef> vectorFields) {
m_values = values;
m_vectorFields = vectorFields;
}
/**
* Constructor
*
* @param vecElement PMML element containing this vector instance
* @param vectorFields the mining fields indexed by this vector instance
* @throws Exception if something goes wrong
*/
public VectorInstance(Element vecElement, List<FieldRef> vectorFields)
throws Exception {
m_vectorFields = vectorFields;
// get the ID
String id = vecElement.getAttribute("id");
if (id == null || id.length() == 0) {
throw new Exception("[VectorInstance] no ID attribute defined!");
}
m_ID = id;
// check for both types of array
NodeList s_arrL = vecElement.getElementsByTagName("REAL-SparseArray");
NodeList d_arrL = vecElement.getElementsByTagName("REAL-ARRAY");
if (s_arrL.getLength() == 0 && d_arrL.getLength() == 0) {
throw new Exception("[VectorInstance] no arrays defined!");
}
NodeList arrL = (s_arrL.getLength() > 0)
? s_arrL
: d_arrL;
// should be just one array per vector instance
Element theArray = (Element)arrL.item(0);
m_values = Array.create(theArray);
}
/**
* Get the ID of this vector instance
*
* @return the ID of this vector instance
*/
public String getID() {
return m_ID;
}
/**
* Get the Array of values encapsulated in this vector instance
*
* @return the Array of values encapsulated in this vector instance
*/
public Array getValues() {
return m_values;
}
/**
* Get the mining fields that are indexed by this vector instance
*
* @return the mining fields that are indexed by this vector instance
*/
public List<FieldRef> getVectorFields() {
return m_vectorFields;
}
/**
* Subtract the values in the supplied array from this vector instance
*
* @param other an array of values
* @return a new VectorInstance containing the result of the subtraction
* @throws Exception if something goes wrong
*/
public VectorInstance subtract(double[] other) throws Exception {
// other is a non-sparse array of values
ArrayList<Object> diffVals = new ArrayList<Object>();
for (int i = 0; i < other.length; i++) {
double x = m_values.valueDouble(i);
double y = other[i];
// System.err.println("x: " + x + " y: " + y);
double result = x - y;
diffVals.add(new Double(result));
}
Array newArray = Array.create(diffVals, null);
return new VectorInstance(newArray, m_vectorFields);
}
/**
* Subtract the supplied VectorInstance from this one and return the
* result as a new VectorInstance
*
* @param other the vector instance to subtract
* @return a new VectorInstance containing the result of the subtraction
* @throws Exception if something goes wrong
*/
public VectorInstance subtract(VectorInstance other) throws Exception {
// IMPORTANT: assumes that other has the same vector fields
// as this vector instance. Otherwise results will be meaningless
if (m_vectorFields.size() != other.getVectorFields().size()) {
throw new Exception("[VectorInstance.dotProduct] supplied vector instance does " +
"not have the same number of vector fields as this vector instance!");
}
ArrayList<Object> diffVals = new ArrayList<Object>();
for (int i = 0; i < m_vectorFields.size(); i++) {
double x = m_values.valueDouble(i);
double y = other.getValues().valueDouble(i);
double result = x - y;
diffVals.add(new Double(result));
}
Array newArray = Array.create(diffVals, null);
return new VectorInstance(newArray, m_vectorFields);
}
/**
* Computes the dot product between this vector instance and the
* argument
*
* @param other the vector instance to perform the dot product with
* @return the dot product of this and the supplied vector instance
* @throws Exception if something goes wrong
*/
public double dotProduct(VectorInstance other) throws Exception {
// IMPORTANT: assumes that other has the same vector fields
// as this vector instance. Otherwise results will be meaningless
if (m_vectorFields.size() != other.getVectorFields().size()) {
throw new Exception("[VectorInstance.dotProduct] supplied vector instance does " +
"not have the same number of vector fields as this vector instance!");
}
double result = 0;
Array otherValues = other.getValues();
// do a fast dot product
int n1 = m_values.numValues();
int n2 = otherValues.numValues();
for (int p1 = 0, p2 = 0; p1 < n1 && p2 < n2;) {
int ind1 = m_values.index(p1);
int ind2 = otherValues.index(p2);
if (ind1 == ind2) {
// System.err.println("Here..." + m_values.valueSparseDouble(p1) + " " + otherValues.valueSparseDouble(p2));
result += m_values.valueSparseDouble(p1) * otherValues.valueSparseDouble(p2);
p1++;
p2++;
} else if (ind1 > ind2) {
p2++;
} else {
p1 ++;
}
}
return result;
}
/**
* Computes the dot product between this vector instance and the
* supplied array of values
*
* @param other an array of values to perform the dot product with
* @return the dot product of this vector instance with the argument
* @throws Exception if something goes wrong
*/
public double dotProduct(double[] other) throws Exception {
// other is a non-sparse array of values
double result = 0;
// do a fast dot product
int n1 = m_values.numValues();
for (int i = 0; i < n1; i++) {
int ind1 = m_values.index(i);
result += m_values.valueSparseDouble(i) * other[ind1];
}
return result;
}
}
|
0
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml/jaxbbindings/ACTIVATIONFUNCTION.java
|
//
// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.0-b52-fcs
// See <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a>
// Any modifications to this file will be lost upon recompilation of the source schema.
// Generated on: 2013.12.20 at 12:48:21 PM GMT
//
package weka.core.pmml.jaxbbindings;
import javax.xml.bind.annotation.XmlEnum;
import javax.xml.bind.annotation.XmlEnumValue;
/**
* <p>Java class for ACTIVATION-FUNCTION.
*
* <p>The following schema fragment specifies the expected content contained within this class.
* <p>
* <pre>
* <simpleType name="ACTIVATION-FUNCTION">
* <restriction base="{http://www.w3.org/2001/XMLSchema}string">
* <enumeration value="threshold"/>
* <enumeration value="logistic"/>
* <enumeration value="tanh"/>
* <enumeration value="identity"/>
* <enumeration value="exponential"/>
* <enumeration value="reciprocal"/>
* <enumeration value="square"/>
* <enumeration value="Gauss"/>
* <enumeration value="sine"/>
* <enumeration value="cosine"/>
* <enumeration value="Elliott"/>
* <enumeration value="arctan"/>
* <enumeration value="radialBasis"/>
* </restriction>
* </simpleType>
* </pre>
*
*/
@XmlEnum
public enum ACTIVATIONFUNCTION {
@XmlEnumValue("arctan")
ARCTAN("arctan"),
@XmlEnumValue("cosine")
COSINE("cosine"),
@XmlEnumValue("Elliott")
ELLIOTT("Elliott"),
@XmlEnumValue("exponential")
EXPONENTIAL("exponential"),
@XmlEnumValue("Gauss")
GAUSS("Gauss"),
@XmlEnumValue("identity")
IDENTITY("identity"),
@XmlEnumValue("logistic")
LOGISTIC("logistic"),
@XmlEnumValue("radialBasis")
RADIAL_BASIS("radialBasis"),
@XmlEnumValue("reciprocal")
RECIPROCAL("reciprocal"),
@XmlEnumValue("sine")
SINE("sine"),
@XmlEnumValue("square")
SQUARE("square"),
@XmlEnumValue("tanh")
TANH("tanh"),
@XmlEnumValue("threshold")
THRESHOLD("threshold");
private final String value;
ACTIVATIONFUNCTION(String v) {
value = v;
}
public String value() {
return value;
}
public static ACTIVATIONFUNCTION fromValue(String v) {
for (ACTIVATIONFUNCTION c: ACTIVATIONFUNCTION.values()) {
if (c.value.equals(v)) {
return c;
}
}
throw new IllegalArgumentException(v.toString());
}
}
|
0
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml/jaxbbindings/Aggregate.java
|
//
// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.0-b52-fcs
// See <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a>
// Any modifications to this file will be lost upon recompilation of the source schema.
// Generated on: 2013.12.20 at 12:48:21 PM GMT
//
package weka.core.pmml.jaxbbindings;
import java.util.ArrayList;
import java.util.List;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlType;
/**
* <p>Java class for Aggregate element declaration.
*
* <p>The following schema fragment specifies the expected content contained within this class.
*
* <pre>
* <element name="Aggregate">
* <complexType>
* <complexContent>
* <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
* <sequence>
* <element ref="{http://www.dmg.org/PMML-4_1}Extension" maxOccurs="unbounded" minOccurs="0"/>
* </sequence>
* <attribute name="field" use="required" type="{http://www.dmg.org/PMML-4_1}FIELD-NAME" />
* <attribute name="function" use="required">
* <simpleType>
* <restriction base="{http://www.w3.org/2001/XMLSchema}string">
* <enumeration value="count"/>
* <enumeration value="sum"/>
* <enumeration value="average"/>
* <enumeration value="min"/>
* <enumeration value="max"/>
* <enumeration value="multiset"/>
* </restriction>
* </simpleType>
* </attribute>
* <attribute name="groupField" type="{http://www.dmg.org/PMML-4_1}FIELD-NAME" />
* <attribute name="sqlWhere" type="{http://www.w3.org/2001/XMLSchema}string" />
* </restriction>
* </complexContent>
* </complexType>
* </element>
* </pre>
*
*
*/
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "", propOrder = {
"extension"
})
@XmlRootElement(name = "Aggregate")
public class Aggregate {
@XmlElement(name = "Extension", namespace = "http://www.dmg.org/PMML-4_1", required = true)
protected List<Extension> extension;
@XmlAttribute(required = true)
protected String field;
@XmlAttribute(required = true)
protected String function;
@XmlAttribute
protected String groupField;
@XmlAttribute
protected String sqlWhere;
/**
* Gets the value of the extension property.
*
* <p>
* This accessor method returns a reference to the live list,
* not a snapshot. Therefore any modification you make to the
* returned list will be present inside the JAXB object.
* This is why there is not a <CODE>set</CODE> method for the extension property.
*
* <p>
* For example, to add a new item, do as follows:
* <pre>
* getExtension().add(newItem);
* </pre>
*
*
* <p>
* Objects of the following type(s) are allowed in the list
* {@link Extension }
*
*
*/
public List<Extension> getExtension() {
if (extension == null) {
extension = new ArrayList<Extension>();
}
return this.extension;
}
/**
* Gets the value of the field property.
*
* @return
* possible object is
* {@link String }
*
*/
public String getField() {
return field;
}
/**
* Sets the value of the field property.
*
* @param value
* allowed object is
* {@link String }
*
*/
public void setField(String value) {
this.field = value;
}
/**
* Gets the value of the function property.
*
* @return
* possible object is
* {@link String }
*
*/
public String getFunction() {
return function;
}
/**
* Sets the value of the function property.
*
* @param value
* allowed object is
* {@link String }
*
*/
public void setFunction(String value) {
this.function = value;
}
/**
* Gets the value of the groupField property.
*
* @return
* possible object is
* {@link String }
*
*/
public String getGroupField() {
return groupField;
}
/**
* Sets the value of the groupField property.
*
* @param value
* allowed object is
* {@link String }
*
*/
public void setGroupField(String value) {
this.groupField = value;
}
/**
* Gets the value of the sqlWhere property.
*
* @return
* possible object is
* {@link String }
*
*/
public String getSqlWhere() {
return sqlWhere;
}
/**
* Sets the value of the sqlWhere property.
*
* @param value
* allowed object is
* {@link String }
*
*/
public void setSqlWhere(String value) {
this.sqlWhere = value;
}
}
|
0
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml/jaxbbindings/Alternate.java
|
//
// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.0-b52-fcs
// See <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a>
// Any modifications to this file will be lost upon recompilation of the source schema.
// Generated on: 2013.12.20 at 12:48:21 PM GMT
//
package weka.core.pmml.jaxbbindings;
import java.util.ArrayList;
import java.util.List;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlType;
/**
* <p>Java class for Alternate element declaration.
*
* <p>The following schema fragment specifies the expected content contained within this class.
*
* <pre>
* <element name="Alternate">
* <complexType>
* <complexContent>
* <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
* <choice>
* <group ref="{http://www.dmg.org/PMML-4_1}CONTINUOUS-DISTRIBUTION-TYPES"/>
* </choice>
* </restriction>
* </complexContent>
* </complexType>
* </element>
* </pre>
*
*
*/
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "", propOrder = {
"anyDistribution",
"gaussianDistribution",
"poissonDistribution",
"uniformDistribution",
"extension"
})
@XmlRootElement(name = "Alternate")
public class Alternate {
@XmlElement(name = "AnyDistribution", namespace = "http://www.dmg.org/PMML-4_1")
protected AnyDistribution anyDistribution;
@XmlElement(name = "GaussianDistribution", namespace = "http://www.dmg.org/PMML-4_1")
protected GaussianDistribution gaussianDistribution;
@XmlElement(name = "PoissonDistribution", namespace = "http://www.dmg.org/PMML-4_1")
protected PoissonDistribution poissonDistribution;
@XmlElement(name = "UniformDistribution", namespace = "http://www.dmg.org/PMML-4_1")
protected UniformDistribution uniformDistribution;
@XmlElement(name = "Extension", namespace = "http://www.dmg.org/PMML-4_1", required = true)
protected List<Extension> extension;
/**
* Gets the value of the anyDistribution property.
*
* @return
* possible object is
* {@link AnyDistribution }
*
*/
public AnyDistribution getAnyDistribution() {
return anyDistribution;
}
/**
* Sets the value of the anyDistribution property.
*
* @param value
* allowed object is
* {@link AnyDistribution }
*
*/
public void setAnyDistribution(AnyDistribution value) {
this.anyDistribution = value;
}
/**
* Gets the value of the gaussianDistribution property.
*
* @return
* possible object is
* {@link GaussianDistribution }
*
*/
public GaussianDistribution getGaussianDistribution() {
return gaussianDistribution;
}
/**
* Sets the value of the gaussianDistribution property.
*
* @param value
* allowed object is
* {@link GaussianDistribution }
*
*/
public void setGaussianDistribution(GaussianDistribution value) {
this.gaussianDistribution = value;
}
/**
* Gets the value of the poissonDistribution property.
*
* @return
* possible object is
* {@link PoissonDistribution }
*
*/
public PoissonDistribution getPoissonDistribution() {
return poissonDistribution;
}
/**
* Sets the value of the poissonDistribution property.
*
* @param value
* allowed object is
* {@link PoissonDistribution }
*
*/
public void setPoissonDistribution(PoissonDistribution value) {
this.poissonDistribution = value;
}
/**
* Gets the value of the uniformDistribution property.
*
* @return
* possible object is
* {@link UniformDistribution }
*
*/
public UniformDistribution getUniformDistribution() {
return uniformDistribution;
}
/**
* Sets the value of the uniformDistribution property.
*
* @param value
* allowed object is
* {@link UniformDistribution }
*
*/
public void setUniformDistribution(UniformDistribution value) {
this.uniformDistribution = value;
}
/**
* Gets the value of the extension property.
*
* <p>
* This accessor method returns a reference to the live list,
* not a snapshot. Therefore any modification you make to the
* returned list will be present inside the JAXB object.
* This is why there is not a <CODE>set</CODE> method for the extension property.
*
* <p>
* For example, to add a new item, do as follows:
* <pre>
* getExtension().add(newItem);
* </pre>
*
*
* <p>
* Objects of the following type(s) are allowed in the list
* {@link Extension }
*
*
*/
public List<Extension> getExtension() {
if (extension == null) {
extension = new ArrayList<Extension>();
}
return this.extension;
}
}
|
0
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml/jaxbbindings/Annotation.java
|
//
// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.0-b52-fcs
// See <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a>
// Any modifications to this file will be lost upon recompilation of the source schema.
// Generated on: 2013.12.20 at 12:48:21 PM GMT
//
package weka.core.pmml.jaxbbindings;
import java.util.ArrayList;
import java.util.List;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElementRef;
import javax.xml.bind.annotation.XmlMixed;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlType;
/**
* <p>Java class for Annotation element declaration.
*
* <p>The following schema fragment specifies the expected content contained within this class.
*
* <pre>
* <element name="Annotation">
* <complexType>
* <complexContent>
* <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
* <sequence>
* <element ref="{http://www.dmg.org/PMML-4_1}Extension" maxOccurs="unbounded" minOccurs="0"/>
* </sequence>
* </restriction>
* </complexContent>
* </complexType>
* </element>
* </pre>
*
*
*/
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "", propOrder = {
"content"
})
@XmlRootElement(name = "Annotation")
public class Annotation {
@XmlElementRef(name = "Extension", namespace = "http://www.dmg.org/PMML-4_1", type = Extension.class)
@XmlMixed
protected List<Object> content;
/**
* Gets the value of the content property.
*
* <p>
* This accessor method returns a reference to the live list,
* not a snapshot. Therefore any modification you make to the
* returned list will be present inside the JAXB object.
* This is why there is not a <CODE>set</CODE> method for the content property.
*
* <p>
* For example, to add a new item, do as follows:
* <pre>
* getContent().add(newItem);
* </pre>
*
*
* <p>
* Objects of the following type(s) are allowed in the list
* {@link String }
* {@link Extension }
*
*
*/
public List<Object> getContent() {
if (content == null) {
content = new ArrayList<Object>();
}
return this.content;
}
}
|
0
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml/jaxbbindings/Anova.java
|
//
// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.0-b52-fcs
// See <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a>
// Any modifications to this file will be lost upon recompilation of the source schema.
// Generated on: 2013.12.20 at 12:48:21 PM GMT
//
package weka.core.pmml.jaxbbindings;
import java.util.ArrayList;
import java.util.List;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlType;
/**
* <p>Java class for Anova element declaration.
*
* <p>The following schema fragment specifies the expected content contained within this class.
*
* <pre>
* <element name="Anova">
* <complexType>
* <complexContent>
* <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
* <sequence>
* <element ref="{http://www.dmg.org/PMML-4_1}Extension" maxOccurs="unbounded" minOccurs="0"/>
* <element ref="{http://www.dmg.org/PMML-4_1}AnovaRow" maxOccurs="3" minOccurs="3"/>
* </sequence>
* <attribute name="target" type="{http://www.dmg.org/PMML-4_1}FIELD-NAME" />
* </restriction>
* </complexContent>
* </complexType>
* </element>
* </pre>
*
*
*/
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "", propOrder = {
"extension",
"anovaRow"
})
@XmlRootElement(name = "Anova")
public class Anova {
@XmlElement(name = "Extension", namespace = "http://www.dmg.org/PMML-4_1", required = true)
protected List<Extension> extension;
@XmlElement(name = "AnovaRow", namespace = "http://www.dmg.org/PMML-4_1", required = true)
protected List<AnovaRow> anovaRow;
@XmlAttribute
protected String target;
/**
* Gets the value of the extension property.
*
* <p>
* This accessor method returns a reference to the live list,
* not a snapshot. Therefore any modification you make to the
* returned list will be present inside the JAXB object.
* This is why there is not a <CODE>set</CODE> method for the extension property.
*
* <p>
* For example, to add a new item, do as follows:
* <pre>
* getExtension().add(newItem);
* </pre>
*
*
* <p>
* Objects of the following type(s) are allowed in the list
* {@link Extension }
*
*
*/
public List<Extension> getExtension() {
if (extension == null) {
extension = new ArrayList<Extension>();
}
return this.extension;
}
/**
* Gets the value of the anovaRow property.
*
* <p>
* This accessor method returns a reference to the live list,
* not a snapshot. Therefore any modification you make to the
* returned list will be present inside the JAXB object.
* This is why there is not a <CODE>set</CODE> method for the anovaRow property.
*
* <p>
* For example, to add a new item, do as follows:
* <pre>
* getAnovaRow().add(newItem);
* </pre>
*
*
* <p>
* Objects of the following type(s) are allowed in the list
* {@link AnovaRow }
*
*
*/
public List<AnovaRow> getAnovaRow() {
if (anovaRow == null) {
anovaRow = new ArrayList<AnovaRow>();
}
return this.anovaRow;
}
/**
* Gets the value of the target property.
*
* @return
* possible object is
* {@link String }
*
*/
public String getTarget() {
return target;
}
/**
* Sets the value of the target property.
*
* @param value
* allowed object is
* {@link String }
*
*/
public void setTarget(String value) {
this.target = value;
}
}
|
0
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml/jaxbbindings/AnovaRow.java
|
//
// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.0-b52-fcs
// See <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a>
// Any modifications to this file will be lost upon recompilation of the source schema.
// Generated on: 2013.12.20 at 12:48:21 PM GMT
//
package weka.core.pmml.jaxbbindings;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlType;
/**
* <p>Java class for AnovaRow element declaration.
*
* <p>The following schema fragment specifies the expected content contained within this class.
*
* <pre>
* <element name="AnovaRow">
* <complexType>
* <complexContent>
* <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
* <sequence>
* <element ref="{http://www.dmg.org/PMML-4_1}Extension" maxOccurs="unbounded" minOccurs="0"/>
* </sequence>
* <attribute name="degreesOfFreedom" use="required" type="{http://www.dmg.org/PMML-4_1}NUMBER" />
* <attribute name="fValue" type="{http://www.dmg.org/PMML-4_1}NUMBER" />
* <attribute name="meanOfSquares" type="{http://www.dmg.org/PMML-4_1}NUMBER" />
* <attribute name="pValue" type="{http://www.dmg.org/PMML-4_1}PROB-NUMBER" />
* <attribute name="sumOfSquares" use="required" type="{http://www.dmg.org/PMML-4_1}NUMBER" />
* <attribute name="type" use="required">
* <simpleType>
* <restriction base="{http://www.w3.org/2001/XMLSchema}string">
* <enumeration value="Model"/>
* <enumeration value="Error"/>
* <enumeration value="Total"/>
* </restriction>
* </simpleType>
* </attribute>
* </restriction>
* </complexContent>
* </complexType>
* </element>
* </pre>
*
*
*/
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "", propOrder = {
"extension"
})
@XmlRootElement(name = "AnovaRow")
public class AnovaRow {
@XmlElement(name = "Extension", namespace = "http://www.dmg.org/PMML-4_1", required = true)
protected List<Extension> extension;
@XmlAttribute(required = true)
protected double degreesOfFreedom;
@XmlAttribute
protected Double fValue;
@XmlAttribute
protected Double meanOfSquares;
@XmlAttribute
protected BigDecimal pValue;
@XmlAttribute(required = true)
protected double sumOfSquares;
@XmlAttribute(required = true)
protected String type;
/**
* Gets the value of the extension property.
*
* <p>
* This accessor method returns a reference to the live list,
* not a snapshot. Therefore any modification you make to the
* returned list will be present inside the JAXB object.
* This is why there is not a <CODE>set</CODE> method for the extension property.
*
* <p>
* For example, to add a new item, do as follows:
* <pre>
* getExtension().add(newItem);
* </pre>
*
*
* <p>
* Objects of the following type(s) are allowed in the list
* {@link Extension }
*
*
*/
public List<Extension> getExtension() {
if (extension == null) {
extension = new ArrayList<Extension>();
}
return this.extension;
}
/**
* Gets the value of the degreesOfFreedom property.
*
*/
public double getDegreesOfFreedom() {
return degreesOfFreedom;
}
/**
* Sets the value of the degreesOfFreedom property.
*
*/
public void setDegreesOfFreedom(double value) {
this.degreesOfFreedom = value;
}
/**
* Gets the value of the fValue property.
*
* @return
* possible object is
* {@link Double }
*
*/
public Double getFValue() {
return fValue;
}
/**
* Sets the value of the fValue property.
*
* @param value
* allowed object is
* {@link Double }
*
*/
public void setFValue(Double value) {
this.fValue = value;
}
/**
* Gets the value of the meanOfSquares property.
*
* @return
* possible object is
* {@link Double }
*
*/
public Double getMeanOfSquares() {
return meanOfSquares;
}
/**
* Sets the value of the meanOfSquares property.
*
* @param value
* allowed object is
* {@link Double }
*
*/
public void setMeanOfSquares(Double value) {
this.meanOfSquares = value;
}
/**
* Gets the value of the pValue property.
*
* @return
* possible object is
* {@link BigDecimal }
*
*/
public BigDecimal getPValue() {
return pValue;
}
/**
* Sets the value of the pValue property.
*
* @param value
* allowed object is
* {@link BigDecimal }
*
*/
public void setPValue(BigDecimal value) {
this.pValue = value;
}
/**
* Gets the value of the sumOfSquares property.
*
*/
public double getSumOfSquares() {
return sumOfSquares;
}
/**
* Sets the value of the sumOfSquares property.
*
*/
public void setSumOfSquares(double value) {
this.sumOfSquares = value;
}
/**
* Gets the value of the type property.
*
* @return
* possible object is
* {@link String }
*
*/
public String getType() {
return type;
}
/**
* Sets the value of the type property.
*
* @param value
* allowed object is
* {@link String }
*
*/
public void setType(String value) {
this.type = value;
}
}
|
0
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml/jaxbbindings/AntecedentSequence.java
|
//
// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.0-b52-fcs
// See <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a>
// Any modifications to this file will be lost upon recompilation of the source schema.
// Generated on: 2013.12.20 at 12:48:21 PM GMT
//
package weka.core.pmml.jaxbbindings;
import java.util.ArrayList;
import java.util.List;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlType;
/**
* <p>Java class for AntecedentSequence element declaration.
*
* <p>The following schema fragment specifies the expected content contained within this class.
*
* <pre>
* <element name="AntecedentSequence">
* <complexType>
* <complexContent>
* <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
* <sequence>
* <group ref="{http://www.dmg.org/PMML-4_1}SEQUENCE"/>
* </sequence>
* </restriction>
* </complexContent>
* </complexType>
* </element>
* </pre>
*
*
*/
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "", propOrder = {
"extension",
"sequenceReference",
"time"
})
@XmlRootElement(name = "AntecedentSequence")
public class AntecedentSequence {
@XmlElement(name = "Extension", namespace = "http://www.dmg.org/PMML-4_1", required = true)
protected List<Extension> extension;
@XmlElement(name = "SequenceReference", namespace = "http://www.dmg.org/PMML-4_1", required = true)
protected SequenceReference sequenceReference;
@XmlElement(name = "Time", namespace = "http://www.dmg.org/PMML-4_1")
protected Time time;
/**
* Gets the value of the extension property.
*
* <p>
* This accessor method returns a reference to the live list,
* not a snapshot. Therefore any modification you make to the
* returned list will be present inside the JAXB object.
* This is why there is not a <CODE>set</CODE> method for the extension property.
*
* <p>
* For example, to add a new item, do as follows:
* <pre>
* getExtension().add(newItem);
* </pre>
*
*
* <p>
* Objects of the following type(s) are allowed in the list
* {@link Extension }
*
*
*/
public List<Extension> getExtension() {
if (extension == null) {
extension = new ArrayList<Extension>();
}
return this.extension;
}
/**
* Gets the value of the sequenceReference property.
*
* @return
* possible object is
* {@link SequenceReference }
*
*/
public SequenceReference getSequenceReference() {
return sequenceReference;
}
/**
* Sets the value of the sequenceReference property.
*
* @param value
* allowed object is
* {@link SequenceReference }
*
*/
public void setSequenceReference(SequenceReference value) {
this.sequenceReference = value;
}
/**
* Gets the value of the time property.
*
* @return
* possible object is
* {@link Time }
*
*/
public Time getTime() {
return time;
}
/**
* Sets the value of the time property.
*
* @param value
* allowed object is
* {@link Time }
*
*/
public void setTime(Time value) {
this.time = value;
}
}
|
0
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml/jaxbbindings/AnyDistribution.java
|
//
// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.0-b52-fcs
// See <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a>
// Any modifications to this file will be lost upon recompilation of the source schema.
// Generated on: 2013.12.20 at 12:48:21 PM GMT
//
package weka.core.pmml.jaxbbindings;
import java.util.ArrayList;
import java.util.List;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlType;
/**
* <p>Java class for AnyDistribution element declaration.
*
* <p>The following schema fragment specifies the expected content contained within this class.
*
* <pre>
* <element name="AnyDistribution">
* <complexType>
* <complexContent>
* <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
* <sequence>
* <element ref="{http://www.dmg.org/PMML-4_1}Extension" maxOccurs="unbounded" minOccurs="0"/>
* </sequence>
* <attribute name="mean" use="required" type="{http://www.dmg.org/PMML-4_1}REAL-NUMBER" />
* <attribute name="variance" use="required" type="{http://www.dmg.org/PMML-4_1}REAL-NUMBER" />
* </restriction>
* </complexContent>
* </complexType>
* </element>
* </pre>
*
*
*/
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "", propOrder = {
"extension"
})
@XmlRootElement(name = "AnyDistribution")
public class AnyDistribution {
@XmlElement(name = "Extension", namespace = "http://www.dmg.org/PMML-4_1", required = true)
protected List<Extension> extension;
@XmlAttribute(required = true)
protected double mean;
@XmlAttribute(required = true)
protected double variance;
/**
* Gets the value of the extension property.
*
* <p>
* This accessor method returns a reference to the live list,
* not a snapshot. Therefore any modification you make to the
* returned list will be present inside the JAXB object.
* This is why there is not a <CODE>set</CODE> method for the extension property.
*
* <p>
* For example, to add a new item, do as follows:
* <pre>
* getExtension().add(newItem);
* </pre>
*
*
* <p>
* Objects of the following type(s) are allowed in the list
* {@link Extension }
*
*
*/
public List<Extension> getExtension() {
if (extension == null) {
extension = new ArrayList<Extension>();
}
return this.extension;
}
/**
* Gets the value of the mean property.
*
*/
public double getMean() {
return mean;
}
/**
* Sets the value of the mean property.
*
*/
public void setMean(double value) {
this.mean = value;
}
/**
* Gets the value of the variance property.
*
*/
public double getVariance() {
return variance;
}
/**
* Sets the value of the variance property.
*
*/
public void setVariance(double value) {
this.variance = value;
}
}
|
0
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml/jaxbbindings/Application.java
|
//
// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.0-b52-fcs
// See <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a>
// Any modifications to this file will be lost upon recompilation of the source schema.
// Generated on: 2013.12.20 at 12:48:21 PM GMT
//
package weka.core.pmml.jaxbbindings;
import java.util.ArrayList;
import java.util.List;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlType;
/**
* <p>Java class for Application element declaration.
*
* <p>The following schema fragment specifies the expected content contained within this class.
*
* <pre>
* <element name="Application">
* <complexType>
* <complexContent>
* <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
* <sequence>
* <element ref="{http://www.dmg.org/PMML-4_1}Extension" maxOccurs="unbounded" minOccurs="0"/>
* </sequence>
* <attribute name="name" use="required" type="{http://www.w3.org/2001/XMLSchema}string" />
* <attribute name="version" type="{http://www.w3.org/2001/XMLSchema}string" />
* </restriction>
* </complexContent>
* </complexType>
* </element>
* </pre>
*
*
*/
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "", propOrder = {
"extension"
})
@XmlRootElement(name = "Application")
public class Application {
@XmlElement(name = "Extension", namespace = "http://www.dmg.org/PMML-4_1", required = true)
protected List<Extension> extension;
@XmlAttribute(required = true)
protected String name;
@XmlAttribute
protected String version;
public Application() {}
public Application(String name, String version) {
this.name = name;
this.version = version;
}
/**
* Gets the value of the extension property.
*
* <p>
* This accessor method returns a reference to the live list,
* not a snapshot. Therefore any modification you make to the
* returned list will be present inside the JAXB object.
* This is why there is not a <CODE>set</CODE> method for the extension property.
*
* <p>
* For example, to add a new item, do as follows:
* <pre>
* getExtension().add(newItem);
* </pre>
*
*
* <p>
* Objects of the following type(s) are allowed in the list
* {@link Extension }
*
*
*/
public List<Extension> getExtension() {
if (extension == null) {
extension = new ArrayList<Extension>();
}
return this.extension;
}
/**
* Gets the value of the name property.
*
* @return
* possible object is
* {@link String }
*
*/
public String getName() {
return name;
}
/**
* Sets the value of the name property.
*
* @param value
* allowed object is
* {@link String }
*
*/
public void setName(String value) {
this.name = value;
}
/**
* Gets the value of the version property.
*
* @return
* possible object is
* {@link String }
*
*/
public String getVersion() {
return version;
}
/**
* Sets the value of the version property.
*
* @param value
* allowed object is
* {@link String }
*
*/
public void setVersion(String value) {
this.version = value;
}
}
|
0
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml/jaxbbindings/Apply.java
|
//
// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.0-b52-fcs
// See <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a>
// Any modifications to this file will be lost upon recompilation of the source schema.
// Generated on: 2013.12.20 at 12:48:21 PM GMT
//
package weka.core.pmml.jaxbbindings;
import java.util.ArrayList;
import java.util.List;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlElements;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlType;
/**
* <p>Java class for Apply element declaration.
*
* <p>The following schema fragment specifies the expected content contained within this class.
*
* <pre>
* <element name="Apply">
* <complexType>
* <complexContent>
* <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
* <sequence>
* <element ref="{http://www.dmg.org/PMML-4_1}Extension" maxOccurs="unbounded" minOccurs="0"/>
* <group ref="{http://www.dmg.org/PMML-4_1}EXPRESSION" maxOccurs="unbounded" minOccurs="0"/>
* </sequence>
* <attribute name="function" use="required" type="{http://www.w3.org/2001/XMLSchema}string" />
* <attribute name="invalidValueTreatment" type="{http://www.dmg.org/PMML-4_1}INVALID-VALUE-TREATMENT-METHOD" default="returnInvalid" />
* <attribute name="mapMissingTo" type="{http://www.w3.org/2001/XMLSchema}string" />
* </restriction>
* </complexContent>
* </complexType>
* </element>
* </pre>
*
*
*/
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "", propOrder = {
"extension",
"expression"
})
@XmlRootElement(name = "Apply")
public class Apply {
@XmlElement(name = "Extension", namespace = "http://www.dmg.org/PMML-4_1", required = true)
protected List<Extension> extension;
@XmlElements({
@XmlElement(name = "Apply", namespace = "http://www.dmg.org/PMML-4_1", required = true, type = Apply.class),
@XmlElement(name = "Discretize", namespace = "http://www.dmg.org/PMML-4_1", required = true, type = Discretize.class),
@XmlElement(name = "NormContinuous", namespace = "http://www.dmg.org/PMML-4_1", required = true, type = NormContinuous.class),
@XmlElement(name = "MapValues", namespace = "http://www.dmg.org/PMML-4_1", required = true, type = MapValues.class),
@XmlElement(name = "Constant", namespace = "http://www.dmg.org/PMML-4_1", required = true, type = Constant.class),
@XmlElement(name = "Aggregate", namespace = "http://www.dmg.org/PMML-4_1", required = true, type = Aggregate.class),
@XmlElement(name = "FieldRef", namespace = "http://www.dmg.org/PMML-4_1", required = true, type = FieldRef.class),
@XmlElement(name = "NormDiscrete", namespace = "http://www.dmg.org/PMML-4_1", required = true, type = NormDiscrete.class)
})
protected List<Object> expression;
@XmlAttribute(required = true)
protected String function;
@XmlAttribute
protected INVALIDVALUETREATMENTMETHOD invalidValueTreatment;
@XmlAttribute
protected String mapMissingTo;
/**
* Gets the value of the extension property.
*
* <p>
* This accessor method returns a reference to the live list,
* not a snapshot. Therefore any modification you make to the
* returned list will be present inside the JAXB object.
* This is why there is not a <CODE>set</CODE> method for the extension property.
*
* <p>
* For example, to add a new item, do as follows:
* <pre>
* getExtension().add(newItem);
* </pre>
*
*
* <p>
* Objects of the following type(s) are allowed in the list
* {@link Extension }
*
*
*/
public List<Extension> getExtension() {
if (extension == null) {
extension = new ArrayList<Extension>();
}
return this.extension;
}
/**
* Gets the value of the expression property.
*
* <p>
* This accessor method returns a reference to the live list,
* not a snapshot. Therefore any modification you make to the
* returned list will be present inside the JAXB object.
* This is why there is not a <CODE>set</CODE> method for the expression property.
*
* <p>
* For example, to add a new item, do as follows:
* <pre>
* getEXPRESSION().add(newItem);
* </pre>
*
*
* <p>
* Objects of the following type(s) are allowed in the list
* {@link Apply }
* {@link Discretize }
* {@link NormContinuous }
* {@link MapValues }
* {@link Constant }
* {@link Aggregate }
* {@link FieldRef }
* {@link NormDiscrete }
*
*
*/
public List<Object> getEXPRESSION() {
if (expression == null) {
expression = new ArrayList<Object>();
}
return this.expression;
}
/**
* Gets the value of the function property.
*
* @return
* possible object is
* {@link String }
*
*/
public String getFunction() {
return function;
}
/**
* Sets the value of the function property.
*
* @param value
* allowed object is
* {@link String }
*
*/
public void setFunction(String value) {
this.function = value;
}
/**
* Gets the value of the invalidValueTreatment property.
*
* @return
* possible object is
* {@link INVALIDVALUETREATMENTMETHOD }
*
*/
public INVALIDVALUETREATMENTMETHOD getInvalidValueTreatment() {
if (invalidValueTreatment == null) {
return INVALIDVALUETREATMENTMETHOD.RETURN_INVALID;
} else {
return invalidValueTreatment;
}
}
/**
* Sets the value of the invalidValueTreatment property.
*
* @param value
* allowed object is
* {@link INVALIDVALUETREATMENTMETHOD }
*
*/
public void setInvalidValueTreatment(INVALIDVALUETREATMENTMETHOD value) {
this.invalidValueTreatment = value;
}
/**
* Gets the value of the mapMissingTo property.
*
* @return
* possible object is
* {@link String }
*
*/
public String getMapMissingTo() {
return mapMissingTo;
}
/**
* Sets the value of the mapMissingTo property.
*
* @param value
* allowed object is
* {@link String }
*
*/
public void setMapMissingTo(String value) {
this.mapMissingTo = value;
}
}
|
0
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml/jaxbbindings/ArrayType.java
|
//
// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.0-b52-fcs
// See <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a>
// Any modifications to this file will be lost upon recompilation of the source schema.
// Generated on: 2013.12.20 at 12:48:21 PM GMT
//
package weka.core.pmml.jaxbbindings;
import java.math.BigInteger;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlType;
import javax.xml.bind.annotation.XmlValue;
/**
* <p>Java class for ArrayType complex type.
*
* <p>The following schema fragment specifies the expected content contained within this class.
*
* <pre>
* <complexType name="ArrayType">
* <complexContent>
* <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
* <attribute name="n" type="{http://www.dmg.org/PMML-4_1}INT-NUMBER" />
* <attribute name="type" use="required">
* <simpleType>
* <restriction base="{http://www.w3.org/2001/XMLSchema}string">
* <enumeration value="int"/>
* <enumeration value="real"/>
* <enumeration value="string"/>
* </restriction>
* </simpleType>
* </attribute>
* </restriction>
* </complexContent>
* </complexType>
* </pre>
*
*
*/
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "ArrayType", propOrder = {
"content"
})
public class ArrayType {
@XmlValue
protected String content;
@XmlAttribute
protected BigInteger n;
@XmlAttribute(required = true)
protected String type;
/**
* Gets the value of the content property.
*
* @return
* possible object is
* {@link String }
*
*/
public String getContent() {
return content;
}
/**
* Sets the value of the content property.
*
* @param value
* allowed object is
* {@link String }
*
*/
public void setContent(String value) {
this.content = value;
}
/**
* Gets the value of the n property.
*
* @return
* possible object is
* {@link BigInteger }
*
*/
public BigInteger getN() {
return n;
}
/**
* Sets the value of the n property.
*
* @param value
* allowed object is
* {@link BigInteger }
*
*/
public void setN(BigInteger value) {
this.n = value;
}
/**
* Gets the value of the type property.
*
* @return
* possible object is
* {@link String }
*
*/
public String getType() {
return type;
}
/**
* Sets the value of the type property.
*
* @param value
* allowed object is
* {@link String }
*
*/
public void setType(String value) {
this.type = value;
}
}
|
0
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml/jaxbbindings/AssociationModel.java
|
//
// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.0-b52-fcs
// See <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a>
// Any modifications to this file will be lost upon recompilation of the source schema.
// Generated on: 2013.12.20 at 12:48:21 PM GMT
//
package weka.core.pmml.jaxbbindings;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.List;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlElementRef;
import javax.xml.bind.annotation.XmlElementRefs;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlType;
/**
* <p>Java class for AssociationModel element declaration.
*
* <p>The following schema fragment specifies the expected content contained within this class.
*
* <pre>
* <element name="AssociationModel">
* <complexType>
* <complexContent>
* <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
* <sequence>
* <element ref="{http://www.dmg.org/PMML-4_1}Extension" maxOccurs="unbounded" minOccurs="0"/>
* <element ref="{http://www.dmg.org/PMML-4_1}MiningSchema"/>
* <element ref="{http://www.dmg.org/PMML-4_1}Output" minOccurs="0"/>
* <element ref="{http://www.dmg.org/PMML-4_1}ModelStats" minOccurs="0"/>
* <element ref="{http://www.dmg.org/PMML-4_1}LocalTransformations" minOccurs="0"/>
* <element ref="{http://www.dmg.org/PMML-4_1}Item" maxOccurs="unbounded" minOccurs="0"/>
* <element ref="{http://www.dmg.org/PMML-4_1}Itemset" maxOccurs="unbounded" minOccurs="0"/>
* <element ref="{http://www.dmg.org/PMML-4_1}AssociationRule" maxOccurs="unbounded" minOccurs="0"/>
* <element ref="{http://www.dmg.org/PMML-4_1}ModelVerification" minOccurs="0"/>
* <element ref="{http://www.dmg.org/PMML-4_1}Extension" maxOccurs="unbounded" minOccurs="0"/>
* </sequence>
* <attribute name="algorithmName" type="{http://www.w3.org/2001/XMLSchema}string" />
* <attribute name="avgNumberOfItemsPerTA" type="{http://www.dmg.org/PMML-4_1}REAL-NUMBER" />
* <attribute name="functionName" use="required" type="{http://www.dmg.org/PMML-4_1}MINING-FUNCTION" />
* <attribute name="isScorable" type="{http://www.w3.org/2001/XMLSchema}boolean" default="true" />
* <attribute name="lengthLimit" type="{http://www.dmg.org/PMML-4_1}INT-NUMBER" />
* <attribute name="maxNumberOfItemsPerTA" type="{http://www.dmg.org/PMML-4_1}INT-NUMBER" />
* <attribute name="minimumConfidence" use="required" type="{http://www.dmg.org/PMML-4_1}PROB-NUMBER" />
* <attribute name="minimumSupport" use="required" type="{http://www.dmg.org/PMML-4_1}PROB-NUMBER" />
* <attribute name="modelName" type="{http://www.w3.org/2001/XMLSchema}string" />
* <attribute name="numberOfItems" use="required" type="{http://www.dmg.org/PMML-4_1}INT-NUMBER" />
* <attribute name="numberOfItemsets" use="required" type="{http://www.dmg.org/PMML-4_1}INT-NUMBER" />
* <attribute name="numberOfRules" use="required" type="{http://www.dmg.org/PMML-4_1}INT-NUMBER" />
* <attribute name="numberOfTransactions" use="required" type="{http://www.dmg.org/PMML-4_1}INT-NUMBER" />
* </restriction>
* </complexContent>
* </complexType>
* </element>
* </pre>
*
*
*/
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "", propOrder = {
"content"
})
@XmlRootElement(name = "AssociationModel")
public class AssociationModel {
@XmlElementRefs({
@XmlElementRef(name = "ModelStats", namespace = "http://www.dmg.org/PMML-4_1", type = ModelStats.class),
@XmlElementRef(name = "Output", namespace = "http://www.dmg.org/PMML-4_1", type = Output.class),
@XmlElementRef(name = "AssociationRule", namespace = "http://www.dmg.org/PMML-4_1", type = AssociationRule.class),
@XmlElementRef(name = "LocalTransformations", namespace = "http://www.dmg.org/PMML-4_1", type = LocalTransformations.class),
@XmlElementRef(name = "MiningSchema", namespace = "http://www.dmg.org/PMML-4_1", type = MiningSchema.class),
@XmlElementRef(name = "Itemset", namespace = "http://www.dmg.org/PMML-4_1", type = Itemset.class),
@XmlElementRef(name = "ModelVerification", namespace = "http://www.dmg.org/PMML-4_1", type = ModelVerification.class),
@XmlElementRef(name = "Item", namespace = "http://www.dmg.org/PMML-4_1", type = Item.class),
@XmlElementRef(name = "Extension", namespace = "http://www.dmg.org/PMML-4_1", type = Extension.class)
})
protected List<Object> content;
@XmlAttribute
protected String algorithmName;
@XmlAttribute
protected Double avgNumberOfItemsPerTA;
@XmlAttribute(required = true)
protected MININGFUNCTION functionName;
@XmlAttribute
protected Boolean isScorable;
@XmlAttribute
protected BigInteger lengthLimit;
@XmlAttribute
protected BigInteger maxNumberOfItemsPerTA;
@XmlAttribute(required = true)
protected BigDecimal minimumConfidence;
@XmlAttribute(required = true)
protected BigDecimal minimumSupport;
@XmlAttribute
protected String modelName;
@XmlAttribute(required = true)
protected BigInteger numberOfItems;
@XmlAttribute(required = true)
protected BigInteger numberOfItemsets;
@XmlAttribute(required = true)
protected BigInteger numberOfRules;
@XmlAttribute(required = true)
protected BigInteger numberOfTransactions;
/**
* Gets the rest of the content model.
*
* <p>
* You are getting this "catch-all" property because of the following reason:
* The field name "Extension" is used by two different parts of a schema. See:
* line 703 of file:/home/david/workspace/weka/pmml-4-1.xsd
* line 694 of file:/home/david/workspace/weka/pmml-4-1.xsd
* <p>
* To get rid of this property, apply a property customization to one
* of both of the following declarations to change their names:
* Gets the value of the content property.
*
* <p>
* This accessor method returns a reference to the live list,
* not a snapshot. Therefore any modification you make to the
* returned list will be present inside the JAXB object.
* This is why there is not a <CODE>set</CODE> method for the content property.
*
* <p>
* For example, to add a new item, do as follows:
* <pre>
* getContent().add(newItem);
* </pre>
*
*
* <p>
* Objects of the following type(s) are allowed in the list
* {@link ModelStats }
* {@link Output }
* {@link AssociationRule }
* {@link LocalTransformations }
* {@link Itemset }
* {@link MiningSchema }
* {@link ModelVerification }
* {@link Extension }
* {@link Item }
*
*
*/
public List<Object> getContent() {
if (content == null) {
content = new ArrayList<Object>();
}
return this.content;
}
/**
* Gets the value of the algorithmName property.
*
* @return
* possible object is
* {@link String }
*
*/
public String getAlgorithmName() {
return algorithmName;
}
/**
* Sets the value of the algorithmName property.
*
* @param value
* allowed object is
* {@link String }
*
*/
public void setAlgorithmName(String value) {
this.algorithmName = value;
}
/**
* Gets the value of the avgNumberOfItemsPerTA property.
*
* @return
* possible object is
* {@link Double }
*
*/
public Double getAvgNumberOfItemsPerTA() {
return avgNumberOfItemsPerTA;
}
/**
* Sets the value of the avgNumberOfItemsPerTA property.
*
* @param value
* allowed object is
* {@link Double }
*
*/
public void setAvgNumberOfItemsPerTA(Double value) {
this.avgNumberOfItemsPerTA = value;
}
/**
* Gets the value of the functionName property.
*
* @return
* possible object is
* {@link MININGFUNCTION }
*
*/
public MININGFUNCTION getFunctionName() {
return functionName;
}
/**
* Sets the value of the functionName property.
*
* @param value
* allowed object is
* {@link MININGFUNCTION }
*
*/
public void setFunctionName(MININGFUNCTION value) {
this.functionName = value;
}
/**
* Gets the value of the isScorable property.
*
* @return
* possible object is
* {@link Boolean }
*
*/
public boolean isIsScorable() {
if (isScorable == null) {
return true;
} else {
return isScorable;
}
}
/**
* Sets the value of the isScorable property.
*
* @param value
* allowed object is
* {@link Boolean }
*
*/
public void setIsScorable(Boolean value) {
this.isScorable = value;
}
/**
* Gets the value of the lengthLimit property.
*
* @return
* possible object is
* {@link BigInteger }
*
*/
public BigInteger getLengthLimit() {
return lengthLimit;
}
/**
* Sets the value of the lengthLimit property.
*
* @param value
* allowed object is
* {@link BigInteger }
*
*/
public void setLengthLimit(BigInteger value) {
this.lengthLimit = value;
}
/**
* Gets the value of the maxNumberOfItemsPerTA property.
*
* @return
* possible object is
* {@link BigInteger }
*
*/
public BigInteger getMaxNumberOfItemsPerTA() {
return maxNumberOfItemsPerTA;
}
/**
* Sets the value of the maxNumberOfItemsPerTA property.
*
* @param value
* allowed object is
* {@link BigInteger }
*
*/
public void setMaxNumberOfItemsPerTA(BigInteger value) {
this.maxNumberOfItemsPerTA = value;
}
/**
* Gets the value of the minimumConfidence property.
*
* @return
* possible object is
* {@link BigDecimal }
*
*/
public BigDecimal getMinimumConfidence() {
return minimumConfidence;
}
/**
* Sets the value of the minimumConfidence property.
*
* @param value
* allowed object is
* {@link BigDecimal }
*
*/
public void setMinimumConfidence(BigDecimal value) {
this.minimumConfidence = value;
}
/**
* Gets the value of the minimumSupport property.
*
* @return
* possible object is
* {@link BigDecimal }
*
*/
public BigDecimal getMinimumSupport() {
return minimumSupport;
}
/**
* Sets the value of the minimumSupport property.
*
* @param value
* allowed object is
* {@link BigDecimal }
*
*/
public void setMinimumSupport(BigDecimal value) {
this.minimumSupport = value;
}
/**
* Gets the value of the modelName property.
*
* @return
* possible object is
* {@link String }
*
*/
public String getModelName() {
return modelName;
}
/**
* Sets the value of the modelName property.
*
* @param value
* allowed object is
* {@link String }
*
*/
public void setModelName(String value) {
this.modelName = value;
}
/**
* Gets the value of the numberOfItems property.
*
* @return
* possible object is
* {@link BigInteger }
*
*/
public BigInteger getNumberOfItems() {
return numberOfItems;
}
/**
* Sets the value of the numberOfItems property.
*
* @param value
* allowed object is
* {@link BigInteger }
*
*/
public void setNumberOfItems(BigInteger value) {
this.numberOfItems = value;
}
/**
* Gets the value of the numberOfItemsets property.
*
* @return
* possible object is
* {@link BigInteger }
*
*/
public BigInteger getNumberOfItemsets() {
return numberOfItemsets;
}
/**
* Sets the value of the numberOfItemsets property.
*
* @param value
* allowed object is
* {@link BigInteger }
*
*/
public void setNumberOfItemsets(BigInteger value) {
this.numberOfItemsets = value;
}
/**
* Gets the value of the numberOfRules property.
*
* @return
* possible object is
* {@link BigInteger }
*
*/
public BigInteger getNumberOfRules() {
return numberOfRules;
}
/**
* Sets the value of the numberOfRules property.
*
* @param value
* allowed object is
* {@link BigInteger }
*
*/
public void setNumberOfRules(BigInteger value) {
this.numberOfRules = value;
}
/**
* Gets the value of the numberOfTransactions property.
*
* @return
* possible object is
* {@link BigInteger }
*
*/
public BigInteger getNumberOfTransactions() {
return numberOfTransactions;
}
/**
* Sets the value of the numberOfTransactions property.
*
* @param value
* allowed object is
* {@link BigInteger }
*
*/
public void setNumberOfTransactions(BigInteger value) {
this.numberOfTransactions = value;
}
}
|
0
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml/jaxbbindings/AssociationRule.java
|
//
// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.0-b52-fcs
// See <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a>
// Any modifications to this file will be lost upon recompilation of the source schema.
// Generated on: 2013.12.20 at 12:48:21 PM GMT
//
package weka.core.pmml.jaxbbindings;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlType;
/**
* <p>Java class for AssociationRule element declaration.
*
* <p>The following schema fragment specifies the expected content contained within this class.
*
* <pre>
* <element name="AssociationRule">
* <complexType>
* <complexContent>
* <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
* <sequence>
* <element ref="{http://www.dmg.org/PMML-4_1}Extension" maxOccurs="unbounded" minOccurs="0"/>
* </sequence>
* <attribute name="affinity" type="{http://www.dmg.org/PMML-4_1}PROB-NUMBER" />
* <attribute name="antecedent" use="required" type="{http://www.w3.org/2001/XMLSchema}string" />
* <attribute name="confidence" use="required" type="{http://www.dmg.org/PMML-4_1}PROB-NUMBER" />
* <attribute name="consequent" use="required" type="{http://www.w3.org/2001/XMLSchema}string" />
* <attribute name="id" type="{http://www.w3.org/2001/XMLSchema}string" />
* <attribute name="leverage" type="{http://www.w3.org/2001/XMLSchema}float" />
* <attribute name="lift" type="{http://www.w3.org/2001/XMLSchema}float" />
* <attribute name="support" use="required" type="{http://www.dmg.org/PMML-4_1}PROB-NUMBER" />
* </restriction>
* </complexContent>
* </complexType>
* </element>
* </pre>
*
*
*/
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "", propOrder = {
"extension"
})
@XmlRootElement(name = "AssociationRule")
public class AssociationRule {
@XmlElement(name = "Extension", namespace = "http://www.dmg.org/PMML-4_1", required = true)
protected List<Extension> extension;
@XmlAttribute
protected BigDecimal affinity;
@XmlAttribute(required = true)
protected String antecedent;
@XmlAttribute(required = true)
protected BigDecimal confidence;
@XmlAttribute(required = true)
protected String consequent;
@XmlAttribute
protected String id;
@XmlAttribute
protected Float leverage;
@XmlAttribute
protected Float lift;
@XmlAttribute(required = true)
protected BigDecimal support;
/**
* Gets the value of the extension property.
*
* <p>
* This accessor method returns a reference to the live list,
* not a snapshot. Therefore any modification you make to the
* returned list will be present inside the JAXB object.
* This is why there is not a <CODE>set</CODE> method for the extension property.
*
* <p>
* For example, to add a new item, do as follows:
* <pre>
* getExtension().add(newItem);
* </pre>
*
*
* <p>
* Objects of the following type(s) are allowed in the list
* {@link Extension }
*
*
*/
public List<Extension> getExtension() {
if (extension == null) {
extension = new ArrayList<Extension>();
}
return this.extension;
}
/**
* Gets the value of the affinity property.
*
* @return
* possible object is
* {@link BigDecimal }
*
*/
public BigDecimal getAffinity() {
return affinity;
}
/**
* Sets the value of the affinity property.
*
* @param value
* allowed object is
* {@link BigDecimal }
*
*/
public void setAffinity(BigDecimal value) {
this.affinity = value;
}
/**
* Gets the value of the antecedent property.
*
* @return
* possible object is
* {@link String }
*
*/
public String getAntecedent() {
return antecedent;
}
/**
* Sets the value of the antecedent property.
*
* @param value
* allowed object is
* {@link String }
*
*/
public void setAntecedent(String value) {
this.antecedent = value;
}
/**
* Gets the value of the confidence property.
*
* @return
* possible object is
* {@link BigDecimal }
*
*/
public BigDecimal getConfidence() {
return confidence;
}
/**
* Sets the value of the confidence property.
*
* @param value
* allowed object is
* {@link BigDecimal }
*
*/
public void setConfidence(BigDecimal value) {
this.confidence = value;
}
/**
* Gets the value of the consequent property.
*
* @return
* possible object is
* {@link String }
*
*/
public String getConsequent() {
return consequent;
}
/**
* Sets the value of the consequent property.
*
* @param value
* allowed object is
* {@link String }
*
*/
public void setConsequent(String value) {
this.consequent = value;
}
/**
* Gets the value of the id property.
*
* @return
* possible object is
* {@link String }
*
*/
public String getId() {
return id;
}
/**
* Sets the value of the id property.
*
* @param value
* allowed object is
* {@link String }
*
*/
public void setId(String value) {
this.id = value;
}
/**
* Gets the value of the leverage property.
*
* @return
* possible object is
* {@link Float }
*
*/
public Float getLeverage() {
return leverage;
}
/**
* Sets the value of the leverage property.
*
* @param value
* allowed object is
* {@link Float }
*
*/
public void setLeverage(Float value) {
this.leverage = value;
}
/**
* Gets the value of the lift property.
*
* @return
* possible object is
* {@link Float }
*
*/
public Float getLift() {
return lift;
}
/**
* Sets the value of the lift property.
*
* @param value
* allowed object is
* {@link Float }
*
*/
public void setLift(Float value) {
this.lift = value;
}
/**
* Gets the value of the support property.
*
* @return
* possible object is
* {@link BigDecimal }
*
*/
public BigDecimal getSupport() {
return support;
}
/**
* Sets the value of the support property.
*
* @param value
* allowed object is
* {@link BigDecimal }
*
*/
public void setSupport(BigDecimal value) {
this.support = value;
}
}
|
0
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml/jaxbbindings/Attribute.java
|
//
// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.0-b52-fcs
// See <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a>
// Any modifications to this file will be lost upon recompilation of the source schema.
// Generated on: 2013.12.20 at 12:48:21 PM GMT
//
package weka.core.pmml.jaxbbindings;
import java.util.ArrayList;
import java.util.List;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlType;
/**
* <p>Java class for Attribute element declaration.
*
* <p>The following schema fragment specifies the expected content contained within this class.
*
* <pre>
* <element name="Attribute">
* <complexType>
* <complexContent>
* <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
* <sequence>
* <element ref="{http://www.dmg.org/PMML-4_1}Extension" maxOccurs="unbounded" minOccurs="0"/>
* <group ref="{http://www.dmg.org/PMML-4_1}PREDICATE"/>
* </sequence>
* <attribute name="partialScore" type="{http://www.dmg.org/PMML-4_1}NUMBER" />
* <attribute name="reasonCode" type="{http://www.w3.org/2001/XMLSchema}string" />
* </restriction>
* </complexContent>
* </complexType>
* </element>
* </pre>
*
*
*/
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "", propOrder = {
"extension",
"simplePredicate",
"compoundPredicate",
"simpleSetPredicate",
"_true",
"_false"
})
@XmlRootElement(name = "Attribute")
public class Attribute {
@XmlElement(name = "Extension", namespace = "http://www.dmg.org/PMML-4_1", required = true)
protected List<Extension> extension;
@XmlElement(name = "SimplePredicate", namespace = "http://www.dmg.org/PMML-4_1")
protected SimplePredicate simplePredicate;
@XmlElement(name = "CompoundPredicate", namespace = "http://www.dmg.org/PMML-4_1")
protected CompoundPredicate compoundPredicate;
@XmlElement(name = "SimpleSetPredicate", namespace = "http://www.dmg.org/PMML-4_1")
protected SimpleSetPredicate simpleSetPredicate;
@XmlElement(name = "True", namespace = "http://www.dmg.org/PMML-4_1")
protected True _true;
@XmlElement(name = "False", namespace = "http://www.dmg.org/PMML-4_1")
protected False _false;
@XmlAttribute
protected Double partialScore;
@XmlAttribute
protected String reasonCode;
/**
* Gets the value of the extension property.
*
* <p>
* This accessor method returns a reference to the live list,
* not a snapshot. Therefore any modification you make to the
* returned list will be present inside the JAXB object.
* This is why there is not a <CODE>set</CODE> method for the extension property.
*
* <p>
* For example, to add a new item, do as follows:
* <pre>
* getExtension().add(newItem);
* </pre>
*
*
* <p>
* Objects of the following type(s) are allowed in the list
* {@link Extension }
*
*
*/
public List<Extension> getExtension() {
if (extension == null) {
extension = new ArrayList<Extension>();
}
return this.extension;
}
/**
* Gets the value of the simplePredicate property.
*
* @return
* possible object is
* {@link SimplePredicate }
*
*/
public SimplePredicate getSimplePredicate() {
return simplePredicate;
}
/**
* Sets the value of the simplePredicate property.
*
* @param value
* allowed object is
* {@link SimplePredicate }
*
*/
public void setSimplePredicate(SimplePredicate value) {
this.simplePredicate = value;
}
/**
* Gets the value of the compoundPredicate property.
*
* @return
* possible object is
* {@link CompoundPredicate }
*
*/
public CompoundPredicate getCompoundPredicate() {
return compoundPredicate;
}
/**
* Sets the value of the compoundPredicate property.
*
* @param value
* allowed object is
* {@link CompoundPredicate }
*
*/
public void setCompoundPredicate(CompoundPredicate value) {
this.compoundPredicate = value;
}
/**
* Gets the value of the simpleSetPredicate property.
*
* @return
* possible object is
* {@link SimpleSetPredicate }
*
*/
public SimpleSetPredicate getSimpleSetPredicate() {
return simpleSetPredicate;
}
/**
* Sets the value of the simpleSetPredicate property.
*
* @param value
* allowed object is
* {@link SimpleSetPredicate }
*
*/
public void setSimpleSetPredicate(SimpleSetPredicate value) {
this.simpleSetPredicate = value;
}
/**
* Gets the value of the true property.
*
* @return
* possible object is
* {@link True }
*
*/
public True getTrue() {
return _true;
}
/**
* Sets the value of the true property.
*
* @param value
* allowed object is
* {@link True }
*
*/
public void setTrue(True value) {
this._true = value;
}
/**
* Gets the value of the false property.
*
* @return
* possible object is
* {@link False }
*
*/
public False getFalse() {
return _false;
}
/**
* Sets the value of the false property.
*
* @param value
* allowed object is
* {@link False }
*
*/
public void setFalse(False value) {
this._false = value;
}
/**
* Gets the value of the partialScore property.
*
* @return
* possible object is
* {@link Double }
*
*/
public Double getPartialScore() {
return partialScore;
}
/**
* Sets the value of the partialScore property.
*
* @param value
* allowed object is
* {@link Double }
*
*/
public void setPartialScore(Double value) {
this.partialScore = value;
}
/**
* Gets the value of the reasonCode property.
*
* @return
* possible object is
* {@link String }
*
*/
public String getReasonCode() {
return reasonCode;
}
/**
* Sets the value of the reasonCode property.
*
* @param value
* allowed object is
* {@link String }
*
*/
public void setReasonCode(String value) {
this.reasonCode = value;
}
}
|
0
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml/jaxbbindings/BASELINETESTSTATISTIC.java
|
//
// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.0-b52-fcs
// See <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a>
// Any modifications to this file will be lost upon recompilation of the source schema.
// Generated on: 2013.12.20 at 12:48:21 PM GMT
//
package weka.core.pmml.jaxbbindings;
import javax.xml.bind.annotation.XmlEnum;
import javax.xml.bind.annotation.XmlEnumValue;
/**
* <p>Java class for BASELINE-TEST-STATISTIC.
*
* <p>The following schema fragment specifies the expected content contained within this class.
* <p>
* <pre>
* <simpleType name="BASELINE-TEST-STATISTIC">
* <restriction base="{http://www.w3.org/2001/XMLSchema}string">
* <enumeration value="zValue"/>
* <enumeration value="chiSquareIndependence"/>
* <enumeration value="chiSquareDistribution"/>
* <enumeration value="CUSUM"/>
* <enumeration value="scalarProduct"/>
* </restriction>
* </simpleType>
* </pre>
*
*/
@XmlEnum
public enum BASELINETESTSTATISTIC {
@XmlEnumValue("chiSquareDistribution")
CHI_SQUARE_DISTRIBUTION("chiSquareDistribution"),
@XmlEnumValue("chiSquareIndependence")
CHI_SQUARE_INDEPENDENCE("chiSquareIndependence"),
CUSUM("CUSUM"),
@XmlEnumValue("scalarProduct")
SCALAR_PRODUCT("scalarProduct"),
@XmlEnumValue("zValue")
Z_VALUE("zValue");
private final String value;
BASELINETESTSTATISTIC(String v) {
value = v;
}
public String value() {
return value;
}
public static BASELINETESTSTATISTIC fromValue(String v) {
for (BASELINETESTSTATISTIC c: BASELINETESTSTATISTIC.values()) {
if (c.value.equals(v)) {
return c;
}
}
throw new IllegalArgumentException(v.toString());
}
}
|
0
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml/jaxbbindings/BaseCumHazardTables.java
|
//
// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.0-b52-fcs
// See <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a>
// Any modifications to this file will be lost upon recompilation of the source schema.
// Generated on: 2013.12.20 at 12:48:21 PM GMT
//
package weka.core.pmml.jaxbbindings;
import java.util.ArrayList;
import java.util.List;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlType;
/**
* <p>Java class for BaseCumHazardTables element declaration.
*
* <p>The following schema fragment specifies the expected content contained within this class.
*
* <pre>
* <element name="BaseCumHazardTables">
* <complexType>
* <complexContent>
* <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
* <sequence>
* <element ref="{http://www.dmg.org/PMML-4_1}Extension" maxOccurs="unbounded" minOccurs="0"/>
* <choice>
* <element ref="{http://www.dmg.org/PMML-4_1}BaselineStratum" maxOccurs="unbounded"/>
* <element ref="{http://www.dmg.org/PMML-4_1}BaselineCell" maxOccurs="unbounded"/>
* </choice>
* </sequence>
* <attribute name="maxTime" type="{http://www.dmg.org/PMML-4_1}REAL-NUMBER" />
* </restriction>
* </complexContent>
* </complexType>
* </element>
* </pre>
*
*
*/
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "", propOrder = {
"extension",
"baselineStratum",
"baselineCell"
})
@XmlRootElement(name = "BaseCumHazardTables")
public class BaseCumHazardTables {
@XmlElement(name = "Extension", namespace = "http://www.dmg.org/PMML-4_1", required = true)
protected List<Extension> extension;
@XmlElement(name = "BaselineStratum", namespace = "http://www.dmg.org/PMML-4_1", required = true)
protected List<BaselineStratum> baselineStratum;
@XmlElement(name = "BaselineCell", namespace = "http://www.dmg.org/PMML-4_1", required = true)
protected List<BaselineCell> baselineCell;
@XmlAttribute
protected Double maxTime;
/**
* Gets the value of the extension property.
*
* <p>
* This accessor method returns a reference to the live list,
* not a snapshot. Therefore any modification you make to the
* returned list will be present inside the JAXB object.
* This is why there is not a <CODE>set</CODE> method for the extension property.
*
* <p>
* For example, to add a new item, do as follows:
* <pre>
* getExtension().add(newItem);
* </pre>
*
*
* <p>
* Objects of the following type(s) are allowed in the list
* {@link Extension }
*
*
*/
public List<Extension> getExtension() {
if (extension == null) {
extension = new ArrayList<Extension>();
}
return this.extension;
}
/**
* Gets the value of the baselineStratum property.
*
* <p>
* This accessor method returns a reference to the live list,
* not a snapshot. Therefore any modification you make to the
* returned list will be present inside the JAXB object.
* This is why there is not a <CODE>set</CODE> method for the baselineStratum property.
*
* <p>
* For example, to add a new item, do as follows:
* <pre>
* getBaselineStratum().add(newItem);
* </pre>
*
*
* <p>
* Objects of the following type(s) are allowed in the list
* {@link BaselineStratum }
*
*
*/
public List<BaselineStratum> getBaselineStratum() {
if (baselineStratum == null) {
baselineStratum = new ArrayList<BaselineStratum>();
}
return this.baselineStratum;
}
/**
* Gets the value of the baselineCell property.
*
* <p>
* This accessor method returns a reference to the live list,
* not a snapshot. Therefore any modification you make to the
* returned list will be present inside the JAXB object.
* This is why there is not a <CODE>set</CODE> method for the baselineCell property.
*
* <p>
* For example, to add a new item, do as follows:
* <pre>
* getBaselineCell().add(newItem);
* </pre>
*
*
* <p>
* Objects of the following type(s) are allowed in the list
* {@link BaselineCell }
*
*
*/
public List<BaselineCell> getBaselineCell() {
if (baselineCell == null) {
baselineCell = new ArrayList<BaselineCell>();
}
return this.baselineCell;
}
/**
* Gets the value of the maxTime property.
*
* @return
* possible object is
* {@link Double }
*
*/
public Double getMaxTime() {
return maxTime;
}
/**
* Sets the value of the maxTime property.
*
* @param value
* allowed object is
* {@link Double }
*
*/
public void setMaxTime(Double value) {
this.maxTime = value;
}
}
|
0
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml/jaxbbindings/Baseline.java
|
//
// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.0-b52-fcs
// See <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a>
// Any modifications to this file will be lost upon recompilation of the source schema.
// Generated on: 2013.12.20 at 12:48:21 PM GMT
//
package weka.core.pmml.jaxbbindings;
import java.util.ArrayList;
import java.util.List;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlType;
/**
* <p>Java class for Baseline element declaration.
*
* <p>The following schema fragment specifies the expected content contained within this class.
*
* <pre>
* <element name="Baseline">
* <complexType>
* <complexContent>
* <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
* <choice>
* <group ref="{http://www.dmg.org/PMML-4_1}CONTINUOUS-DISTRIBUTION-TYPES"/>
* <group ref="{http://www.dmg.org/PMML-4_1}DISCRETE-DISTRIBUTION-TYPES"/>
* </choice>
* </restriction>
* </complexContent>
* </complexType>
* </element>
* </pre>
*
*
*/
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "", propOrder = {
"anyDistribution",
"gaussianDistribution",
"poissonDistribution",
"uniformDistribution",
"extension",
"countTable",
"normalizedCountTable",
"fieldRef"
})
@XmlRootElement(name = "Baseline")
public class Baseline {
@XmlElement(name = "AnyDistribution", namespace = "http://www.dmg.org/PMML-4_1")
protected AnyDistribution anyDistribution;
@XmlElement(name = "GaussianDistribution", namespace = "http://www.dmg.org/PMML-4_1")
protected GaussianDistribution gaussianDistribution;
@XmlElement(name = "PoissonDistribution", namespace = "http://www.dmg.org/PMML-4_1")
protected PoissonDistribution poissonDistribution;
@XmlElement(name = "UniformDistribution", namespace = "http://www.dmg.org/PMML-4_1")
protected UniformDistribution uniformDistribution;
@XmlElement(name = "Extension", namespace = "http://www.dmg.org/PMML-4_1", required = true)
protected List<Extension> extension;
@XmlElement(name = "CountTable", namespace = "http://www.dmg.org/PMML-4_1")
protected COUNTTABLETYPE countTable;
@XmlElement(name = "NormalizedCountTable", namespace = "http://www.dmg.org/PMML-4_1")
protected COUNTTABLETYPE normalizedCountTable;
@XmlElement(name = "FieldRef", namespace = "http://www.dmg.org/PMML-4_1", required = true)
protected List<FieldRef> fieldRef;
/**
* Gets the value of the anyDistribution property.
*
* @return
* possible object is
* {@link AnyDistribution }
*
*/
public AnyDistribution getAnyDistribution() {
return anyDistribution;
}
/**
* Sets the value of the anyDistribution property.
*
* @param value
* allowed object is
* {@link AnyDistribution }
*
*/
public void setAnyDistribution(AnyDistribution value) {
this.anyDistribution = value;
}
/**
* Gets the value of the gaussianDistribution property.
*
* @return
* possible object is
* {@link GaussianDistribution }
*
*/
public GaussianDistribution getGaussianDistribution() {
return gaussianDistribution;
}
/**
* Sets the value of the gaussianDistribution property.
*
* @param value
* allowed object is
* {@link GaussianDistribution }
*
*/
public void setGaussianDistribution(GaussianDistribution value) {
this.gaussianDistribution = value;
}
/**
* Gets the value of the poissonDistribution property.
*
* @return
* possible object is
* {@link PoissonDistribution }
*
*/
public PoissonDistribution getPoissonDistribution() {
return poissonDistribution;
}
/**
* Sets the value of the poissonDistribution property.
*
* @param value
* allowed object is
* {@link PoissonDistribution }
*
*/
public void setPoissonDistribution(PoissonDistribution value) {
this.poissonDistribution = value;
}
/**
* Gets the value of the uniformDistribution property.
*
* @return
* possible object is
* {@link UniformDistribution }
*
*/
public UniformDistribution getUniformDistribution() {
return uniformDistribution;
}
/**
* Sets the value of the uniformDistribution property.
*
* @param value
* allowed object is
* {@link UniformDistribution }
*
*/
public void setUniformDistribution(UniformDistribution value) {
this.uniformDistribution = value;
}
/**
* Gets the value of the extension property.
*
* <p>
* This accessor method returns a reference to the live list,
* not a snapshot. Therefore any modification you make to the
* returned list will be present inside the JAXB object.
* This is why there is not a <CODE>set</CODE> method for the extension property.
*
* <p>
* For example, to add a new item, do as follows:
* <pre>
* getExtension().add(newItem);
* </pre>
*
*
* <p>
* Objects of the following type(s) are allowed in the list
* {@link Extension }
*
*
*/
public List<Extension> getExtension() {
if (extension == null) {
extension = new ArrayList<Extension>();
}
return this.extension;
}
/**
* Gets the value of the countTable property.
*
* @return
* possible object is
* {@link COUNTTABLETYPE }
*
*/
public COUNTTABLETYPE getCountTable() {
return countTable;
}
/**
* Sets the value of the countTable property.
*
* @param value
* allowed object is
* {@link COUNTTABLETYPE }
*
*/
public void setCountTable(COUNTTABLETYPE value) {
this.countTable = value;
}
/**
* Gets the value of the normalizedCountTable property.
*
* @return
* possible object is
* {@link COUNTTABLETYPE }
*
*/
public COUNTTABLETYPE getNormalizedCountTable() {
return normalizedCountTable;
}
/**
* Sets the value of the normalizedCountTable property.
*
* @param value
* allowed object is
* {@link COUNTTABLETYPE }
*
*/
public void setNormalizedCountTable(COUNTTABLETYPE value) {
this.normalizedCountTable = value;
}
/**
* Gets the value of the fieldRef property.
*
* <p>
* This accessor method returns a reference to the live list,
* not a snapshot. Therefore any modification you make to the
* returned list will be present inside the JAXB object.
* This is why there is not a <CODE>set</CODE> method for the fieldRef property.
*
* <p>
* For example, to add a new item, do as follows:
* <pre>
* getFieldRef().add(newItem);
* </pre>
*
*
* <p>
* Objects of the following type(s) are allowed in the list
* {@link FieldRef }
*
*
*/
public List<FieldRef> getFieldRef() {
if (fieldRef == null) {
fieldRef = new ArrayList<FieldRef>();
}
return this.fieldRef;
}
}
|
0
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml/jaxbbindings/BaselineCell.java
|
//
// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.0-b52-fcs
// See <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a>
// Any modifications to this file will be lost upon recompilation of the source schema.
// Generated on: 2013.12.20 at 12:48:21 PM GMT
//
package weka.core.pmml.jaxbbindings;
import java.util.ArrayList;
import java.util.List;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlType;
/**
* <p>Java class for BaselineCell element declaration.
*
* <p>The following schema fragment specifies the expected content contained within this class.
*
* <pre>
* <element name="BaselineCell">
* <complexType>
* <complexContent>
* <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
* <sequence>
* <element ref="{http://www.dmg.org/PMML-4_1}Extension" maxOccurs="unbounded" minOccurs="0"/>
* </sequence>
* <attribute name="cumHazard" use="required" type="{http://www.dmg.org/PMML-4_1}REAL-NUMBER" />
* <attribute name="time" use="required" type="{http://www.dmg.org/PMML-4_1}REAL-NUMBER" />
* </restriction>
* </complexContent>
* </complexType>
* </element>
* </pre>
*
*
*/
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "", propOrder = {
"extension"
})
@XmlRootElement(name = "BaselineCell")
public class BaselineCell {
@XmlElement(name = "Extension", namespace = "http://www.dmg.org/PMML-4_1", required = true)
protected List<Extension> extension;
@XmlAttribute(required = true)
protected double cumHazard;
@XmlAttribute(required = true)
protected double time;
/**
* Gets the value of the extension property.
*
* <p>
* This accessor method returns a reference to the live list,
* not a snapshot. Therefore any modification you make to the
* returned list will be present inside the JAXB object.
* This is why there is not a <CODE>set</CODE> method for the extension property.
*
* <p>
* For example, to add a new item, do as follows:
* <pre>
* getExtension().add(newItem);
* </pre>
*
*
* <p>
* Objects of the following type(s) are allowed in the list
* {@link Extension }
*
*
*/
public List<Extension> getExtension() {
if (extension == null) {
extension = new ArrayList<Extension>();
}
return this.extension;
}
/**
* Gets the value of the cumHazard property.
*
*/
public double getCumHazard() {
return cumHazard;
}
/**
* Sets the value of the cumHazard property.
*
*/
public void setCumHazard(double value) {
this.cumHazard = value;
}
/**
* Gets the value of the time property.
*
*/
public double getTime() {
return time;
}
/**
* Sets the value of the time property.
*
*/
public void setTime(double value) {
this.time = value;
}
}
|
0
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml/jaxbbindings/BaselineModel.java
|
//
// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.0-b52-fcs
// See <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a>
// Any modifications to this file will be lost upon recompilation of the source schema.
// Generated on: 2013.12.20 at 12:48:21 PM GMT
//
package weka.core.pmml.jaxbbindings;
import java.util.ArrayList;
import java.util.List;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlElementRef;
import javax.xml.bind.annotation.XmlElementRefs;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlType;
/**
* <p>Java class for BaselineModel element declaration.
*
* <p>The following schema fragment specifies the expected content contained within this class.
*
* <pre>
* <element name="BaselineModel">
* <complexType>
* <complexContent>
* <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
* <sequence>
* <element ref="{http://www.dmg.org/PMML-4_1}Extension" maxOccurs="unbounded" minOccurs="0"/>
* <element ref="{http://www.dmg.org/PMML-4_1}MiningSchema"/>
* <element ref="{http://www.dmg.org/PMML-4_1}Output" minOccurs="0"/>
* <element ref="{http://www.dmg.org/PMML-4_1}ModelStats" minOccurs="0"/>
* <element ref="{http://www.dmg.org/PMML-4_1}ModelExplanation" minOccurs="0"/>
* <element ref="{http://www.dmg.org/PMML-4_1}Targets" minOccurs="0"/>
* <element ref="{http://www.dmg.org/PMML-4_1}LocalTransformations" minOccurs="0"/>
* <element ref="{http://www.dmg.org/PMML-4_1}TestDistributions"/>
* <element ref="{http://www.dmg.org/PMML-4_1}ModelVerification" minOccurs="0"/>
* <element ref="{http://www.dmg.org/PMML-4_1}Extension" maxOccurs="unbounded" minOccurs="0"/>
* </sequence>
* <attribute name="algorithmName" type="{http://www.w3.org/2001/XMLSchema}string" />
* <attribute name="functionName" use="required" type="{http://www.dmg.org/PMML-4_1}MINING-FUNCTION" />
* <attribute name="isScorable" type="{http://www.w3.org/2001/XMLSchema}boolean" default="true" />
* <attribute name="modelName" type="{http://www.w3.org/2001/XMLSchema}string" />
* </restriction>
* </complexContent>
* </complexType>
* </element>
* </pre>
*
*
*/
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "", propOrder = {
"content"
})
@XmlRootElement(name = "BaselineModel")
public class BaselineModel {
@XmlElementRefs({
@XmlElementRef(name = "ModelExplanation", namespace = "http://www.dmg.org/PMML-4_1", type = ModelExplanation.class),
@XmlElementRef(name = "ModelStats", namespace = "http://www.dmg.org/PMML-4_1", type = ModelStats.class),
@XmlElementRef(name = "Output", namespace = "http://www.dmg.org/PMML-4_1", type = Output.class),
@XmlElementRef(name = "LocalTransformations", namespace = "http://www.dmg.org/PMML-4_1", type = LocalTransformations.class),
@XmlElementRef(name = "TestDistributions", namespace = "http://www.dmg.org/PMML-4_1", type = TestDistributions.class),
@XmlElementRef(name = "Targets", namespace = "http://www.dmg.org/PMML-4_1", type = Targets.class),
@XmlElementRef(name = "MiningSchema", namespace = "http://www.dmg.org/PMML-4_1", type = MiningSchema.class),
@XmlElementRef(name = "ModelVerification", namespace = "http://www.dmg.org/PMML-4_1", type = ModelVerification.class),
@XmlElementRef(name = "Extension", namespace = "http://www.dmg.org/PMML-4_1", type = Extension.class)
})
protected List<Object> content;
@XmlAttribute
protected String algorithmName;
@XmlAttribute(required = true)
protected MININGFUNCTION functionName;
@XmlAttribute
protected Boolean isScorable;
@XmlAttribute
protected String modelName;
/**
* Gets the rest of the content model.
*
* <p>
* You are getting this "catch-all" property because of the following reason:
* The field name "Extension" is used by two different parts of a schema. See:
* line 3034 of file:/home/david/workspace/weka/pmml-4-1.xsd
* line 3025 of file:/home/david/workspace/weka/pmml-4-1.xsd
* <p>
* To get rid of this property, apply a property customization to one
* of both of the following declarations to change their names:
* Gets the value of the content property.
*
* <p>
* This accessor method returns a reference to the live list,
* not a snapshot. Therefore any modification you make to the
* returned list will be present inside the JAXB object.
* This is why there is not a <CODE>set</CODE> method for the content property.
*
* <p>
* For example, to add a new item, do as follows:
* <pre>
* getContent().add(newItem);
* </pre>
*
*
* <p>
* Objects of the following type(s) are allowed in the list
* {@link ModelExplanation }
* {@link ModelStats }
* {@link Output }
* {@link LocalTransformations }
* {@link Targets }
* {@link TestDistributions }
* {@link MiningSchema }
* {@link ModelVerification }
* {@link Extension }
*
*
*/
public List<Object> getContent() {
if (content == null) {
content = new ArrayList<Object>();
}
return this.content;
}
/**
* Gets the value of the algorithmName property.
*
* @return
* possible object is
* {@link String }
*
*/
public String getAlgorithmName() {
return algorithmName;
}
/**
* Sets the value of the algorithmName property.
*
* @param value
* allowed object is
* {@link String }
*
*/
public void setAlgorithmName(String value) {
this.algorithmName = value;
}
/**
* Gets the value of the functionName property.
*
* @return
* possible object is
* {@link MININGFUNCTION }
*
*/
public MININGFUNCTION getFunctionName() {
return functionName;
}
/**
* Sets the value of the functionName property.
*
* @param value
* allowed object is
* {@link MININGFUNCTION }
*
*/
public void setFunctionName(MININGFUNCTION value) {
this.functionName = value;
}
/**
* Gets the value of the isScorable property.
*
* @return
* possible object is
* {@link Boolean }
*
*/
public boolean isIsScorable() {
if (isScorable == null) {
return true;
} else {
return isScorable;
}
}
/**
* Sets the value of the isScorable property.
*
* @param value
* allowed object is
* {@link Boolean }
*
*/
public void setIsScorable(Boolean value) {
this.isScorable = value;
}
/**
* Gets the value of the modelName property.
*
* @return
* possible object is
* {@link String }
*
*/
public String getModelName() {
return modelName;
}
/**
* Sets the value of the modelName property.
*
* @param value
* allowed object is
* {@link String }
*
*/
public void setModelName(String value) {
this.modelName = value;
}
}
|
0
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml/jaxbbindings/BaselineStratum.java
|
//
// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.0-b52-fcs
// See <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a>
// Any modifications to this file will be lost upon recompilation of the source schema.
// Generated on: 2013.12.20 at 12:48:21 PM GMT
//
package weka.core.pmml.jaxbbindings;
import java.util.ArrayList;
import java.util.List;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlType;
/**
* <p>Java class for BaselineStratum element declaration.
*
* <p>The following schema fragment specifies the expected content contained within this class.
*
* <pre>
* <element name="BaselineStratum">
* <complexType>
* <complexContent>
* <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
* <sequence>
* <element ref="{http://www.dmg.org/PMML-4_1}Extension" maxOccurs="unbounded" minOccurs="0"/>
* <element ref="{http://www.dmg.org/PMML-4_1}BaselineCell" maxOccurs="unbounded" minOccurs="0"/>
* </sequence>
* <attribute name="label" type="{http://www.w3.org/2001/XMLSchema}string" />
* <attribute name="maxTime" use="required" type="{http://www.dmg.org/PMML-4_1}REAL-NUMBER" />
* <attribute name="value" use="required" type="{http://www.w3.org/2001/XMLSchema}string" />
* </restriction>
* </complexContent>
* </complexType>
* </element>
* </pre>
*
*
*/
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "", propOrder = {
"extension",
"baselineCell"
})
@XmlRootElement(name = "BaselineStratum")
public class BaselineStratum {
@XmlElement(name = "Extension", namespace = "http://www.dmg.org/PMML-4_1", required = true)
protected List<Extension> extension;
@XmlElement(name = "BaselineCell", namespace = "http://www.dmg.org/PMML-4_1", required = true)
protected List<BaselineCell> baselineCell;
@XmlAttribute
protected String label;
@XmlAttribute(required = true)
protected double maxTime;
@XmlAttribute(required = true)
protected String value;
/**
* Gets the value of the extension property.
*
* <p>
* This accessor method returns a reference to the live list,
* not a snapshot. Therefore any modification you make to the
* returned list will be present inside the JAXB object.
* This is why there is not a <CODE>set</CODE> method for the extension property.
*
* <p>
* For example, to add a new item, do as follows:
* <pre>
* getExtension().add(newItem);
* </pre>
*
*
* <p>
* Objects of the following type(s) are allowed in the list
* {@link Extension }
*
*
*/
public List<Extension> getExtension() {
if (extension == null) {
extension = new ArrayList<Extension>();
}
return this.extension;
}
/**
* Gets the value of the baselineCell property.
*
* <p>
* This accessor method returns a reference to the live list,
* not a snapshot. Therefore any modification you make to the
* returned list will be present inside the JAXB object.
* This is why there is not a <CODE>set</CODE> method for the baselineCell property.
*
* <p>
* For example, to add a new item, do as follows:
* <pre>
* getBaselineCell().add(newItem);
* </pre>
*
*
* <p>
* Objects of the following type(s) are allowed in the list
* {@link BaselineCell }
*
*
*/
public List<BaselineCell> getBaselineCell() {
if (baselineCell == null) {
baselineCell = new ArrayList<BaselineCell>();
}
return this.baselineCell;
}
/**
* Gets the value of the label property.
*
* @return
* possible object is
* {@link String }
*
*/
public String getLabel() {
return label;
}
/**
* Sets the value of the label property.
*
* @param value
* allowed object is
* {@link String }
*
*/
public void setLabel(String value) {
this.label = value;
}
/**
* Gets the value of the maxTime property.
*
*/
public double getMaxTime() {
return maxTime;
}
/**
* Sets the value of the maxTime property.
*
*/
public void setMaxTime(double value) {
this.maxTime = value;
}
/**
* Gets the value of the value property.
*
* @return
* possible object is
* {@link String }
*
*/
public String getValue() {
return value;
}
/**
* Sets the value of the value property.
*
* @param value
* allowed object is
* {@link String }
*
*/
public void setValue(String value) {
this.value = value;
}
}
|
0
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml/jaxbbindings/BayesInput.java
|
//
// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.0-b52-fcs
// See <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a>
// Any modifications to this file will be lost upon recompilation of the source schema.
// Generated on: 2013.12.20 at 12:48:21 PM GMT
//
package weka.core.pmml.jaxbbindings;
import java.util.ArrayList;
import java.util.List;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlType;
/**
* <p>Java class for BayesInput element declaration.
*
* <p>The following schema fragment specifies the expected content contained within this class.
*
* <pre>
* <element name="BayesInput">
* <complexType>
* <complexContent>
* <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
* <sequence>
* <element ref="{http://www.dmg.org/PMML-4_1}Extension" maxOccurs="unbounded" minOccurs="0"/>
* <element ref="{http://www.dmg.org/PMML-4_1}DerivedField" minOccurs="0"/>
* <element ref="{http://www.dmg.org/PMML-4_1}PairCounts" maxOccurs="unbounded"/>
* </sequence>
* <attribute name="fieldName" use="required" type="{http://www.w3.org/2001/XMLSchema}string" />
* </restriction>
* </complexContent>
* </complexType>
* </element>
* </pre>
*
*
*/
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "", propOrder = {
"extension",
"derivedField",
"pairCounts"
})
@XmlRootElement(name = "BayesInput")
public class BayesInput {
@XmlElement(name = "Extension", namespace = "http://www.dmg.org/PMML-4_1", required = true)
protected List<Extension> extension;
@XmlElement(name = "DerivedField", namespace = "http://www.dmg.org/PMML-4_1")
protected DerivedField derivedField;
@XmlElement(name = "PairCounts", namespace = "http://www.dmg.org/PMML-4_1", required = true)
protected List<PairCounts> pairCounts;
@XmlAttribute(required = true)
protected String fieldName;
/**
* Gets the value of the extension property.
*
* <p>
* This accessor method returns a reference to the live list,
* not a snapshot. Therefore any modification you make to the
* returned list will be present inside the JAXB object.
* This is why there is not a <CODE>set</CODE> method for the extension property.
*
* <p>
* For example, to add a new item, do as follows:
* <pre>
* getExtension().add(newItem);
* </pre>
*
*
* <p>
* Objects of the following type(s) are allowed in the list
* {@link Extension }
*
*
*/
public List<Extension> getExtension() {
if (extension == null) {
extension = new ArrayList<Extension>();
}
return this.extension;
}
/**
* Gets the value of the derivedField property.
*
* @return
* possible object is
* {@link DerivedField }
*
*/
public DerivedField getDerivedField() {
return derivedField;
}
/**
* Sets the value of the derivedField property.
*
* @param value
* allowed object is
* {@link DerivedField }
*
*/
public void setDerivedField(DerivedField value) {
this.derivedField = value;
}
/**
* Gets the value of the pairCounts property.
*
* <p>
* This accessor method returns a reference to the live list,
* not a snapshot. Therefore any modification you make to the
* returned list will be present inside the JAXB object.
* This is why there is not a <CODE>set</CODE> method for the pairCounts property.
*
* <p>
* For example, to add a new item, do as follows:
* <pre>
* getPairCounts().add(newItem);
* </pre>
*
*
* <p>
* Objects of the following type(s) are allowed in the list
* {@link PairCounts }
*
*
*/
public List<PairCounts> getPairCounts() {
if (pairCounts == null) {
pairCounts = new ArrayList<PairCounts>();
}
return this.pairCounts;
}
/**
* Gets the value of the fieldName property.
*
* @return
* possible object is
* {@link String }
*
*/
public String getFieldName() {
return fieldName;
}
/**
* Sets the value of the fieldName property.
*
* @param value
* allowed object is
* {@link String }
*
*/
public void setFieldName(String value) {
this.fieldName = value;
}
}
|
0
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml/jaxbbindings/BayesInputs.java
|
//
// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.0-b52-fcs
// See <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a>
// Any modifications to this file will be lost upon recompilation of the source schema.
// Generated on: 2013.12.20 at 12:48:21 PM GMT
//
package weka.core.pmml.jaxbbindings;
import java.util.ArrayList;
import java.util.List;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlType;
/**
* <p>Java class for BayesInputs element declaration.
*
* <p>The following schema fragment specifies the expected content contained within this class.
*
* <pre>
* <element name="BayesInputs">
* <complexType>
* <complexContent>
* <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
* <sequence>
* <element ref="{http://www.dmg.org/PMML-4_1}Extension" maxOccurs="unbounded" minOccurs="0"/>
* <element ref="{http://www.dmg.org/PMML-4_1}BayesInput" maxOccurs="unbounded"/>
* </sequence>
* </restriction>
* </complexContent>
* </complexType>
* </element>
* </pre>
*
*
*/
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "", propOrder = {
"extension",
"bayesInput"
})
@XmlRootElement(name = "BayesInputs")
public class BayesInputs {
@XmlElement(name = "Extension", namespace = "http://www.dmg.org/PMML-4_1", required = true)
protected List<Extension> extension;
@XmlElement(name = "BayesInput", namespace = "http://www.dmg.org/PMML-4_1", required = true)
protected List<BayesInput> bayesInput;
/**
* Gets the value of the extension property.
*
* <p>
* This accessor method returns a reference to the live list,
* not a snapshot. Therefore any modification you make to the
* returned list will be present inside the JAXB object.
* This is why there is not a <CODE>set</CODE> method for the extension property.
*
* <p>
* For example, to add a new item, do as follows:
* <pre>
* getExtension().add(newItem);
* </pre>
*
*
* <p>
* Objects of the following type(s) are allowed in the list
* {@link Extension }
*
*
*/
public List<Extension> getExtension() {
if (extension == null) {
extension = new ArrayList<Extension>();
}
return this.extension;
}
/**
* Gets the value of the bayesInput property.
*
* <p>
* This accessor method returns a reference to the live list,
* not a snapshot. Therefore any modification you make to the
* returned list will be present inside the JAXB object.
* This is why there is not a <CODE>set</CODE> method for the bayesInput property.
*
* <p>
* For example, to add a new item, do as follows:
* <pre>
* getBayesInput().add(newItem);
* </pre>
*
*
* <p>
* Objects of the following type(s) are allowed in the list
* {@link BayesInput }
*
*
*/
public List<BayesInput> getBayesInput() {
if (bayesInput == null) {
bayesInput = new ArrayList<BayesInput>();
}
return this.bayesInput;
}
}
|
0
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml/jaxbbindings/BayesOutput.java
|
//
// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.0-b52-fcs
// See <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a>
// Any modifications to this file will be lost upon recompilation of the source schema.
// Generated on: 2013.12.20 at 12:48:21 PM GMT
//
package weka.core.pmml.jaxbbindings;
import java.util.ArrayList;
import java.util.List;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlType;
/**
* <p>Java class for BayesOutput element declaration.
*
* <p>The following schema fragment specifies the expected content contained within this class.
*
* <pre>
* <element name="BayesOutput">
* <complexType>
* <complexContent>
* <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
* <sequence>
* <element ref="{http://www.dmg.org/PMML-4_1}Extension" maxOccurs="unbounded" minOccurs="0"/>
* <element ref="{http://www.dmg.org/PMML-4_1}TargetValueCounts"/>
* </sequence>
* <attribute name="fieldName" use="required" type="{http://www.w3.org/2001/XMLSchema}string" />
* </restriction>
* </complexContent>
* </complexType>
* </element>
* </pre>
*
*
*/
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "", propOrder = {
"extension",
"targetValueCounts"
})
@XmlRootElement(name = "BayesOutput")
public class BayesOutput {
@XmlElement(name = "Extension", namespace = "http://www.dmg.org/PMML-4_1", required = true)
protected List<Extension> extension;
@XmlElement(name = "TargetValueCounts", namespace = "http://www.dmg.org/PMML-4_1", required = true)
protected TargetValueCounts targetValueCounts;
@XmlAttribute(required = true)
protected String fieldName;
/**
* Gets the value of the extension property.
*
* <p>
* This accessor method returns a reference to the live list,
* not a snapshot. Therefore any modification you make to the
* returned list will be present inside the JAXB object.
* This is why there is not a <CODE>set</CODE> method for the extension property.
*
* <p>
* For example, to add a new item, do as follows:
* <pre>
* getExtension().add(newItem);
* </pre>
*
*
* <p>
* Objects of the following type(s) are allowed in the list
* {@link Extension }
*
*
*/
public List<Extension> getExtension() {
if (extension == null) {
extension = new ArrayList<Extension>();
}
return this.extension;
}
/**
* Gets the value of the targetValueCounts property.
*
* @return
* possible object is
* {@link TargetValueCounts }
*
*/
public TargetValueCounts getTargetValueCounts() {
return targetValueCounts;
}
/**
* Sets the value of the targetValueCounts property.
*
* @param value
* allowed object is
* {@link TargetValueCounts }
*
*/
public void setTargetValueCounts(TargetValueCounts value) {
this.targetValueCounts = value;
}
/**
* Gets the value of the fieldName property.
*
* @return
* possible object is
* {@link String }
*
*/
public String getFieldName() {
return fieldName;
}
/**
* Sets the value of the fieldName property.
*
* @param value
* allowed object is
* {@link String }
*
*/
public void setFieldName(String value) {
this.fieldName = value;
}
}
|
0
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml/jaxbbindings/BinarySimilarity.java
|
//
// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.0-b52-fcs
// See <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a>
// Any modifications to this file will be lost upon recompilation of the source schema.
// Generated on: 2013.12.20 at 12:48:21 PM GMT
//
package weka.core.pmml.jaxbbindings;
import java.util.ArrayList;
import java.util.List;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlType;
/**
* <p>Java class for binarySimilarity element declaration.
*
* <p>The following schema fragment specifies the expected content contained within this class.
*
* <pre>
* <element name="binarySimilarity">
* <complexType>
* <complexContent>
* <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
* <sequence>
* <element ref="{http://www.dmg.org/PMML-4_1}Extension" maxOccurs="unbounded" minOccurs="0"/>
* </sequence>
* <attribute name="c00-parameter" use="required" type="{http://www.dmg.org/PMML-4_1}NUMBER" />
* <attribute name="c01-parameter" use="required" type="{http://www.dmg.org/PMML-4_1}NUMBER" />
* <attribute name="c10-parameter" use="required" type="{http://www.dmg.org/PMML-4_1}NUMBER" />
* <attribute name="c11-parameter" use="required" type="{http://www.dmg.org/PMML-4_1}NUMBER" />
* <attribute name="d00-parameter" use="required" type="{http://www.dmg.org/PMML-4_1}NUMBER" />
* <attribute name="d01-parameter" use="required" type="{http://www.dmg.org/PMML-4_1}NUMBER" />
* <attribute name="d10-parameter" use="required" type="{http://www.dmg.org/PMML-4_1}NUMBER" />
* <attribute name="d11-parameter" use="required" type="{http://www.dmg.org/PMML-4_1}NUMBER" />
* </restriction>
* </complexContent>
* </complexType>
* </element>
* </pre>
*
*
*/
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "", propOrder = {
"extension"
})
@XmlRootElement(name = "binarySimilarity")
public class BinarySimilarity {
@XmlElement(name = "Extension", namespace = "http://www.dmg.org/PMML-4_1", required = true)
protected List<Extension> extension;
@XmlAttribute(name = "c00-parameter", required = true)
protected double c00Parameter;
@XmlAttribute(name = "c01-parameter", required = true)
protected double c01Parameter;
@XmlAttribute(name = "c10-parameter", required = true)
protected double c10Parameter;
@XmlAttribute(name = "c11-parameter", required = true)
protected double c11Parameter;
@XmlAttribute(name = "d00-parameter", required = true)
protected double d00Parameter;
@XmlAttribute(name = "d01-parameter", required = true)
protected double d01Parameter;
@XmlAttribute(name = "d10-parameter", required = true)
protected double d10Parameter;
@XmlAttribute(name = "d11-parameter", required = true)
protected double d11Parameter;
/**
* Gets the value of the extension property.
*
* <p>
* This accessor method returns a reference to the live list,
* not a snapshot. Therefore any modification you make to the
* returned list will be present inside the JAXB object.
* This is why there is not a <CODE>set</CODE> method for the extension property.
*
* <p>
* For example, to add a new item, do as follows:
* <pre>
* getExtension().add(newItem);
* </pre>
*
*
* <p>
* Objects of the following type(s) are allowed in the list
* {@link Extension }
*
*
*/
public List<Extension> getExtension() {
if (extension == null) {
extension = new ArrayList<Extension>();
}
return this.extension;
}
/**
* Gets the value of the c00Parameter property.
*
*/
public double getC00Parameter() {
return c00Parameter;
}
/**
* Sets the value of the c00Parameter property.
*
*/
public void setC00Parameter(double value) {
this.c00Parameter = value;
}
/**
* Gets the value of the c01Parameter property.
*
*/
public double getC01Parameter() {
return c01Parameter;
}
/**
* Sets the value of the c01Parameter property.
*
*/
public void setC01Parameter(double value) {
this.c01Parameter = value;
}
/**
* Gets the value of the c10Parameter property.
*
*/
public double getC10Parameter() {
return c10Parameter;
}
/**
* Sets the value of the c10Parameter property.
*
*/
public void setC10Parameter(double value) {
this.c10Parameter = value;
}
/**
* Gets the value of the c11Parameter property.
*
*/
public double getC11Parameter() {
return c11Parameter;
}
/**
* Sets the value of the c11Parameter property.
*
*/
public void setC11Parameter(double value) {
this.c11Parameter = value;
}
/**
* Gets the value of the d00Parameter property.
*
*/
public double getD00Parameter() {
return d00Parameter;
}
/**
* Sets the value of the d00Parameter property.
*
*/
public void setD00Parameter(double value) {
this.d00Parameter = value;
}
/**
* Gets the value of the d01Parameter property.
*
*/
public double getD01Parameter() {
return d01Parameter;
}
/**
* Sets the value of the d01Parameter property.
*
*/
public void setD01Parameter(double value) {
this.d01Parameter = value;
}
/**
* Gets the value of the d10Parameter property.
*
*/
public double getD10Parameter() {
return d10Parameter;
}
/**
* Sets the value of the d10Parameter property.
*
*/
public void setD10Parameter(double value) {
this.d10Parameter = value;
}
/**
* Gets the value of the d11Parameter property.
*
*/
public double getD11Parameter() {
return d11Parameter;
}
/**
* Sets the value of the d11Parameter property.
*
*/
public void setD11Parameter(double value) {
this.d11Parameter = value;
}
}
|
0
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml/jaxbbindings/BoundaryValueMeans.java
|
//
// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.0-b52-fcs
// See <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a>
// Any modifications to this file will be lost upon recompilation of the source schema.
// Generated on: 2013.12.20 at 12:48:21 PM GMT
//
package weka.core.pmml.jaxbbindings;
import java.util.ArrayList;
import java.util.List;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlType;
/**
* <p>Java class for BoundaryValueMeans element declaration.
*
* <p>The following schema fragment specifies the expected content contained within this class.
*
* <pre>
* <element name="BoundaryValueMeans">
* <complexType>
* <complexContent>
* <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
* <sequence>
* <element ref="{http://www.dmg.org/PMML-4_1}Extension" maxOccurs="unbounded" minOccurs="0"/>
* <group ref="{http://www.dmg.org/PMML-4_1}NUM-ARRAY"/>
* </sequence>
* </restriction>
* </complexContent>
* </complexType>
* </element>
* </pre>
*
*
*/
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "", propOrder = {
"extension",
"array"
})
@XmlRootElement(name = "BoundaryValueMeans")
public class BoundaryValueMeans {
@XmlElement(name = "Extension", namespace = "http://www.dmg.org/PMML-4_1", required = true)
protected List<Extension> extension;
@XmlElement(name = "Array", namespace = "http://www.dmg.org/PMML-4_1")
protected ArrayType array;
/**
* Gets the value of the extension property.
*
* <p>
* This accessor method returns a reference to the live list,
* not a snapshot. Therefore any modification you make to the
* returned list will be present inside the JAXB object.
* This is why there is not a <CODE>set</CODE> method for the extension property.
*
* <p>
* For example, to add a new item, do as follows:
* <pre>
* getExtension().add(newItem);
* </pre>
*
*
* <p>
* Objects of the following type(s) are allowed in the list
* {@link Extension }
*
*
*/
public List<Extension> getExtension() {
if (extension == null) {
extension = new ArrayList<Extension>();
}
return this.extension;
}
/**
* Gets the value of the array property.
*
* @return
* possible object is
* {@link ArrayType }
*
*/
public ArrayType getArray() {
return array;
}
/**
* Sets the value of the array property.
*
* @param value
* allowed object is
* {@link ArrayType }
*
*/
public void setArray(ArrayType value) {
this.array = value;
}
}
|
0
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml/jaxbbindings/BoundaryValues.java
|
//
// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.0-b52-fcs
// See <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a>
// Any modifications to this file will be lost upon recompilation of the source schema.
// Generated on: 2013.12.20 at 12:48:21 PM GMT
//
package weka.core.pmml.jaxbbindings;
import java.util.ArrayList;
import java.util.List;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlType;
/**
* <p>Java class for BoundaryValues element declaration.
*
* <p>The following schema fragment specifies the expected content contained within this class.
*
* <pre>
* <element name="BoundaryValues">
* <complexType>
* <complexContent>
* <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
* <sequence>
* <element ref="{http://www.dmg.org/PMML-4_1}Extension" maxOccurs="unbounded" minOccurs="0"/>
* <group ref="{http://www.dmg.org/PMML-4_1}NUM-ARRAY"/>
* </sequence>
* </restriction>
* </complexContent>
* </complexType>
* </element>
* </pre>
*
*
*/
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "", propOrder = {
"extension",
"array"
})
@XmlRootElement(name = "BoundaryValues")
public class BoundaryValues {
@XmlElement(name = "Extension", namespace = "http://www.dmg.org/PMML-4_1", required = true)
protected List<Extension> extension;
@XmlElement(name = "Array", namespace = "http://www.dmg.org/PMML-4_1")
protected ArrayType array;
/**
* Gets the value of the extension property.
*
* <p>
* This accessor method returns a reference to the live list,
* not a snapshot. Therefore any modification you make to the
* returned list will be present inside the JAXB object.
* This is why there is not a <CODE>set</CODE> method for the extension property.
*
* <p>
* For example, to add a new item, do as follows:
* <pre>
* getExtension().add(newItem);
* </pre>
*
*
* <p>
* Objects of the following type(s) are allowed in the list
* {@link Extension }
*
*
*/
public List<Extension> getExtension() {
if (extension == null) {
extension = new ArrayList<Extension>();
}
return this.extension;
}
/**
* Gets the value of the array property.
*
* @return
* possible object is
* {@link ArrayType }
*
*/
public ArrayType getArray() {
return array;
}
/**
* Sets the value of the array property.
*
* @param value
* allowed object is
* {@link ArrayType }
*
*/
public void setArray(ArrayType value) {
this.array = value;
}
}
|
0
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml/jaxbbindings/CATSCORINGMETHOD.java
|
//
// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.0-b52-fcs
// See <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a>
// Any modifications to this file will be lost upon recompilation of the source schema.
// Generated on: 2013.12.20 at 12:48:21 PM GMT
//
package weka.core.pmml.jaxbbindings;
import javax.xml.bind.annotation.XmlEnum;
import javax.xml.bind.annotation.XmlEnumValue;
/**
* <p>Java class for CAT-SCORING-METHOD.
*
* <p>The following schema fragment specifies the expected content contained within this class.
* <p>
* <pre>
* <simpleType name="CAT-SCORING-METHOD">
* <restriction base="{http://www.w3.org/2001/XMLSchema}string">
* <enumeration value="majorityVote"/>
* <enumeration value="weightedMajorityVote"/>
* </restriction>
* </simpleType>
* </pre>
*
*/
@XmlEnum
public enum CATSCORINGMETHOD {
@XmlEnumValue("majorityVote")
MAJORITY_VOTE("majorityVote"),
@XmlEnumValue("weightedMajorityVote")
WEIGHTED_MAJORITY_VOTE("weightedMajorityVote");
private final String value;
CATSCORINGMETHOD(String v) {
value = v;
}
public String value() {
return value;
}
public static CATSCORINGMETHOD fromValue(String v) {
for (CATSCORINGMETHOD c: CATSCORINGMETHOD.values()) {
if (c.value.equals(v)) {
return c;
}
}
throw new IllegalArgumentException(v.toString());
}
}
|
0
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml/jaxbbindings/COMPAREFUNCTION.java
|
//
// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.0-b52-fcs
// See <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a>
// Any modifications to this file will be lost upon recompilation of the source schema.
// Generated on: 2013.12.20 at 12:48:21 PM GMT
//
package weka.core.pmml.jaxbbindings;
import javax.xml.bind.annotation.XmlEnum;
import javax.xml.bind.annotation.XmlEnumValue;
/**
* <p>Java class for COMPARE-FUNCTION.
*
* <p>The following schema fragment specifies the expected content contained within this class.
* <p>
* <pre>
* <simpleType name="COMPARE-FUNCTION">
* <restriction base="{http://www.w3.org/2001/XMLSchema}string">
* <enumeration value="absDiff"/>
* <enumeration value="gaussSim"/>
* <enumeration value="delta"/>
* <enumeration value="equal"/>
* <enumeration value="table"/>
* </restriction>
* </simpleType>
* </pre>
*
*/
@XmlEnum
public enum COMPAREFUNCTION {
@XmlEnumValue("absDiff")
ABS_DIFF("absDiff"),
@XmlEnumValue("delta")
DELTA("delta"),
@XmlEnumValue("equal")
EQUAL("equal"),
@XmlEnumValue("gaussSim")
GAUSS_SIM("gaussSim"),
@XmlEnumValue("table")
TABLE("table");
private final String value;
COMPAREFUNCTION(String v) {
value = v;
}
public String value() {
return value;
}
public static COMPAREFUNCTION fromValue(String v) {
for (COMPAREFUNCTION c: COMPAREFUNCTION.values()) {
if (c.value.equals(v)) {
return c;
}
}
throw new IllegalArgumentException(v.toString());
}
}
|
0
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml/jaxbbindings/CONTSCORINGMETHOD.java
|
//
// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.0-b52-fcs
// See <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a>
// Any modifications to this file will be lost upon recompilation of the source schema.
// Generated on: 2013.12.20 at 12:48:21 PM GMT
//
package weka.core.pmml.jaxbbindings;
import javax.xml.bind.annotation.XmlEnum;
import javax.xml.bind.annotation.XmlEnumValue;
/**
* <p>Java class for CONT-SCORING-METHOD.
*
* <p>The following schema fragment specifies the expected content contained within this class.
* <p>
* <pre>
* <simpleType name="CONT-SCORING-METHOD">
* <restriction base="{http://www.w3.org/2001/XMLSchema}string">
* <enumeration value="median"/>
* <enumeration value="average"/>
* <enumeration value="weightedAverage"/>
* </restriction>
* </simpleType>
* </pre>
*
*/
@XmlEnum
public enum CONTSCORINGMETHOD {
@XmlEnumValue("average")
AVERAGE("average"),
@XmlEnumValue("median")
MEDIAN("median"),
@XmlEnumValue("weightedAverage")
WEIGHTED_AVERAGE("weightedAverage");
private final String value;
CONTSCORINGMETHOD(String v) {
value = v;
}
public String value() {
return value;
}
public static CONTSCORINGMETHOD fromValue(String v) {
for (CONTSCORINGMETHOD c: CONTSCORINGMETHOD.values()) {
if (c.value.equals(v)) {
return c;
}
}
throw new IllegalArgumentException(v.toString());
}
}
|
0
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml/jaxbbindings/COUNTTABLETYPE.java
|
//
// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.0-b52-fcs
// See <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a>
// Any modifications to this file will be lost upon recompilation of the source schema.
// Generated on: 2013.12.20 at 12:48:21 PM GMT
//
package weka.core.pmml.jaxbbindings;
import java.util.ArrayList;
import java.util.List;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlType;
/**
* <p>Java class for COUNT-TABLE-TYPE complex type.
*
* <p>The following schema fragment specifies the expected content contained within this class.
*
* <pre>
* <complexType name="COUNT-TABLE-TYPE">
* <complexContent>
* <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
* <sequence>
* <element ref="{http://www.dmg.org/PMML-4_1}Extension" maxOccurs="unbounded" minOccurs="0"/>
* <choice>
* <element ref="{http://www.dmg.org/PMML-4_1}FieldValue" maxOccurs="unbounded"/>
* <element ref="{http://www.dmg.org/PMML-4_1}FieldValueCount" maxOccurs="unbounded"/>
* </choice>
* </sequence>
* <attribute name="sample" type="{http://www.dmg.org/PMML-4_1}NUMBER" />
* </restriction>
* </complexContent>
* </complexType>
* </pre>
*
*
*/
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "COUNT-TABLE-TYPE", propOrder = {
"extension",
"fieldValue",
"fieldValueCount"
})
public class COUNTTABLETYPE {
@XmlElement(name = "Extension", namespace = "http://www.dmg.org/PMML-4_1", required = true)
protected List<Extension> extension;
@XmlElement(name = "FieldValue", namespace = "http://www.dmg.org/PMML-4_1", required = true)
protected List<FieldValue> fieldValue;
@XmlElement(name = "FieldValueCount", namespace = "http://www.dmg.org/PMML-4_1", required = true)
protected List<FieldValueCount> fieldValueCount;
@XmlAttribute
protected Double sample;
/**
* Gets the value of the extension property.
*
* <p>
* This accessor method returns a reference to the live list,
* not a snapshot. Therefore any modification you make to the
* returned list will be present inside the JAXB object.
* This is why there is not a <CODE>set</CODE> method for the extension property.
*
* <p>
* For example, to add a new item, do as follows:
* <pre>
* getExtension().add(newItem);
* </pre>
*
*
* <p>
* Objects of the following type(s) are allowed in the list
* {@link Extension }
*
*
*/
public List<Extension> getExtension() {
if (extension == null) {
extension = new ArrayList<Extension>();
}
return this.extension;
}
/**
* Gets the value of the fieldValue property.
*
* <p>
* This accessor method returns a reference to the live list,
* not a snapshot. Therefore any modification you make to the
* returned list will be present inside the JAXB object.
* This is why there is not a <CODE>set</CODE> method for the fieldValue property.
*
* <p>
* For example, to add a new item, do as follows:
* <pre>
* getFieldValue().add(newItem);
* </pre>
*
*
* <p>
* Objects of the following type(s) are allowed in the list
* {@link FieldValue }
*
*
*/
public List<FieldValue> getFieldValue() {
if (fieldValue == null) {
fieldValue = new ArrayList<FieldValue>();
}
return this.fieldValue;
}
/**
* Gets the value of the fieldValueCount property.
*
* <p>
* This accessor method returns a reference to the live list,
* not a snapshot. Therefore any modification you make to the
* returned list will be present inside the JAXB object.
* This is why there is not a <CODE>set</CODE> method for the fieldValueCount property.
*
* <p>
* For example, to add a new item, do as follows:
* <pre>
* getFieldValueCount().add(newItem);
* </pre>
*
*
* <p>
* Objects of the following type(s) are allowed in the list
* {@link FieldValueCount }
*
*
*/
public List<FieldValueCount> getFieldValueCount() {
if (fieldValueCount == null) {
fieldValueCount = new ArrayList<FieldValueCount>();
}
return this.fieldValueCount;
}
/**
* Gets the value of the sample property.
*
* @return
* possible object is
* {@link Double }
*
*/
public Double getSample() {
return sample;
}
/**
* Sets the value of the sample property.
*
* @param value
* allowed object is
* {@link Double }
*
*/
public void setSample(Double value) {
this.sample = value;
}
}
|
0
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml/jaxbbindings/CUMULATIVELINKFUNCTION.java
|
//
// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.0-b52-fcs
// See <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a>
// Any modifications to this file will be lost upon recompilation of the source schema.
// Generated on: 2013.12.20 at 12:48:21 PM GMT
//
package weka.core.pmml.jaxbbindings;
import javax.xml.bind.annotation.XmlEnum;
import javax.xml.bind.annotation.XmlEnumValue;
/**
* <p>Java class for CUMULATIVE-LINK-FUNCTION.
*
* <p>The following schema fragment specifies the expected content contained within this class.
* <p>
* <pre>
* <simpleType name="CUMULATIVE-LINK-FUNCTION">
* <restriction base="{http://www.w3.org/2001/XMLSchema}string">
* <enumeration value="logit"/>
* <enumeration value="probit"/>
* <enumeration value="cloglog"/>
* <enumeration value="loglog"/>
* <enumeration value="cauchit"/>
* </restriction>
* </simpleType>
* </pre>
*
*/
@XmlEnum
public enum CUMULATIVELINKFUNCTION {
@XmlEnumValue("cauchit")
CAUCHIT("cauchit"),
@XmlEnumValue("cloglog")
CLOGLOG("cloglog"),
@XmlEnumValue("logit")
LOGIT("logit"),
@XmlEnumValue("loglog")
LOGLOG("loglog"),
@XmlEnumValue("probit")
PROBIT("probit");
private final String value;
CUMULATIVELINKFUNCTION(String v) {
value = v;
}
public String value() {
return value;
}
public static CUMULATIVELINKFUNCTION fromValue(String v) {
for (CUMULATIVELINKFUNCTION c: CUMULATIVELINKFUNCTION.values()) {
if (c.value.equals(v)) {
return c;
}
}
throw new IllegalArgumentException(v.toString());
}
}
|
0
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml/jaxbbindings/CategoricalPredictor.java
|
//
// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.0-b52-fcs
// See <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a>
// Any modifications to this file will be lost upon recompilation of the source schema.
// Generated on: 2013.12.20 at 12:48:21 PM GMT
//
package weka.core.pmml.jaxbbindings;
import java.util.ArrayList;
import java.util.List;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlType;
/**
* <p>Java class for CategoricalPredictor element declaration.
*
* <p>The following schema fragment specifies the expected content contained within this class.
*
* <pre>
* <element name="CategoricalPredictor">
* <complexType>
* <complexContent>
* <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
* <sequence>
* <element ref="{http://www.dmg.org/PMML-4_1}Extension" maxOccurs="unbounded" minOccurs="0"/>
* </sequence>
* <attribute name="coefficient" use="required" type="{http://www.dmg.org/PMML-4_1}REAL-NUMBER" />
* <attribute name="name" use="required" type="{http://www.dmg.org/PMML-4_1}FIELD-NAME" />
* <attribute name="value" use="required" type="{http://www.w3.org/2001/XMLSchema}string" />
* </restriction>
* </complexContent>
* </complexType>
* </element>
* </pre>
*
*
*/
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "", propOrder = {
"extension"
})
@XmlRootElement(name = "CategoricalPredictor")
public class CategoricalPredictor {
@XmlElement(name = "Extension", namespace = "http://www.dmg.org/PMML-4_1", required = true)
protected List<Extension> extension;
@XmlAttribute(required = true)
protected double coefficient;
@XmlAttribute(required = true)
protected String name;
@XmlAttribute(required = true)
protected String value;
/**
* Gets the value of the extension property.
*
* <p>
* This accessor method returns a reference to the live list,
* not a snapshot. Therefore any modification you make to the
* returned list will be present inside the JAXB object.
* This is why there is not a <CODE>set</CODE> method for the extension property.
*
* <p>
* For example, to add a new item, do as follows:
* <pre>
* getExtension().add(newItem);
* </pre>
*
*
* <p>
* Objects of the following type(s) are allowed in the list
* {@link Extension }
*
*
*/
public List<Extension> getExtension() {
if (extension == null) {
extension = new ArrayList<Extension>();
}
return this.extension;
}
/**
* Gets the value of the coefficient property.
*
*/
public double getCoefficient() {
return coefficient;
}
/**
* Sets the value of the coefficient property.
*
*/
public void setCoefficient(double value) {
this.coefficient = value;
}
/**
* Gets the value of the name property.
*
* @return
* possible object is
* {@link String }
*
*/
public String getName() {
return name;
}
/**
* Sets the value of the name property.
*
* @param value
* allowed object is
* {@link String }
*
*/
public void setName(String value) {
this.name = value;
}
/**
* Gets the value of the value property.
*
* @return
* possible object is
* {@link String }
*
*/
public String getValue() {
return value;
}
/**
* Sets the value of the value property.
*
* @param value
* allowed object is
* {@link String }
*
*/
public void setValue(String value) {
this.value = value;
}
}
|
0
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml/jaxbbindings/Categories.java
|
//
// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.0-b52-fcs
// See <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a>
// Any modifications to this file will be lost upon recompilation of the source schema.
// Generated on: 2013.12.20 at 12:48:21 PM GMT
//
package weka.core.pmml.jaxbbindings;
import java.util.ArrayList;
import java.util.List;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlType;
/**
* <p>Java class for Categories element declaration.
*
* <p>The following schema fragment specifies the expected content contained within this class.
*
* <pre>
* <element name="Categories">
* <complexType>
* <complexContent>
* <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
* <sequence>
* <element ref="{http://www.dmg.org/PMML-4_1}Extension" maxOccurs="unbounded" minOccurs="0"/>
* <element ref="{http://www.dmg.org/PMML-4_1}Category" maxOccurs="unbounded"/>
* </sequence>
* </restriction>
* </complexContent>
* </complexType>
* </element>
* </pre>
*
*
*/
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "", propOrder = {
"extension",
"category"
})
@XmlRootElement(name = "Categories")
public class Categories {
@XmlElement(name = "Extension", namespace = "http://www.dmg.org/PMML-4_1", required = true)
protected List<Extension> extension;
@XmlElement(name = "Category", namespace = "http://www.dmg.org/PMML-4_1", required = true)
protected List<Category> category;
/**
* Gets the value of the extension property.
*
* <p>
* This accessor method returns a reference to the live list,
* not a snapshot. Therefore any modification you make to the
* returned list will be present inside the JAXB object.
* This is why there is not a <CODE>set</CODE> method for the extension property.
*
* <p>
* For example, to add a new item, do as follows:
* <pre>
* getExtension().add(newItem);
* </pre>
*
*
* <p>
* Objects of the following type(s) are allowed in the list
* {@link Extension }
*
*
*/
public List<Extension> getExtension() {
if (extension == null) {
extension = new ArrayList<Extension>();
}
return this.extension;
}
/**
* Gets the value of the category property.
*
* <p>
* This accessor method returns a reference to the live list,
* not a snapshot. Therefore any modification you make to the
* returned list will be present inside the JAXB object.
* This is why there is not a <CODE>set</CODE> method for the category property.
*
* <p>
* For example, to add a new item, do as follows:
* <pre>
* getCategory().add(newItem);
* </pre>
*
*
* <p>
* Objects of the following type(s) are allowed in the list
* {@link Category }
*
*
*/
public List<Category> getCategory() {
if (category == null) {
category = new ArrayList<Category>();
}
return this.category;
}
}
|
0
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml/jaxbbindings/Category.java
|
//
// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.0-b52-fcs
// See <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a>
// Any modifications to this file will be lost upon recompilation of the source schema.
// Generated on: 2013.12.20 at 12:48:21 PM GMT
//
package weka.core.pmml.jaxbbindings;
import java.util.ArrayList;
import java.util.List;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlType;
/**
* <p>Java class for Category element declaration.
*
* <p>The following schema fragment specifies the expected content contained within this class.
*
* <pre>
* <element name="Category">
* <complexType>
* <complexContent>
* <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
* <sequence>
* <element ref="{http://www.dmg.org/PMML-4_1}Extension" maxOccurs="unbounded" minOccurs="0"/>
* </sequence>
* <attribute name="value" use="required" type="{http://www.w3.org/2001/XMLSchema}string" />
* </restriction>
* </complexContent>
* </complexType>
* </element>
* </pre>
*
*
*/
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "", propOrder = {
"extension"
})
@XmlRootElement(name = "Category")
public class Category {
@XmlElement(name = "Extension", namespace = "http://www.dmg.org/PMML-4_1", required = true)
protected List<Extension> extension;
@XmlAttribute(required = true)
protected String value;
/**
* Gets the value of the extension property.
*
* <p>
* This accessor method returns a reference to the live list,
* not a snapshot. Therefore any modification you make to the
* returned list will be present inside the JAXB object.
* This is why there is not a <CODE>set</CODE> method for the extension property.
*
* <p>
* For example, to add a new item, do as follows:
* <pre>
* getExtension().add(newItem);
* </pre>
*
*
* <p>
* Objects of the following type(s) are allowed in the list
* {@link Extension }
*
*
*/
public List<Extension> getExtension() {
if (extension == null) {
extension = new ArrayList<Extension>();
}
return this.extension;
}
/**
* Gets the value of the value property.
*
* @return
* possible object is
* {@link String }
*
*/
public String getValue() {
return value;
}
/**
* Sets the value of the value property.
*
* @param value
* allowed object is
* {@link String }
*
*/
public void setValue(String value) {
this.value = value;
}
}
|
0
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml/jaxbbindings/Characteristic.java
|
//
// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.0-b52-fcs
// See <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a>
// Any modifications to this file will be lost upon recompilation of the source schema.
// Generated on: 2013.12.20 at 12:48:21 PM GMT
//
package weka.core.pmml.jaxbbindings;
import java.util.ArrayList;
import java.util.List;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlType;
/**
* <p>Java class for Characteristic element declaration.
*
* <p>The following schema fragment specifies the expected content contained within this class.
*
* <pre>
* <element name="Characteristic">
* <complexType>
* <complexContent>
* <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
* <sequence>
* <element ref="{http://www.dmg.org/PMML-4_1}Extension" maxOccurs="unbounded" minOccurs="0"/>
* <element ref="{http://www.dmg.org/PMML-4_1}Attribute" maxOccurs="unbounded"/>
* </sequence>
* <attribute name="baselineScore" type="{http://www.dmg.org/PMML-4_1}NUMBER" />
* <attribute name="name" type="{http://www.dmg.org/PMML-4_1}FIELD-NAME" />
* <attribute name="reasonCode" type="{http://www.w3.org/2001/XMLSchema}string" />
* </restriction>
* </complexContent>
* </complexType>
* </element>
* </pre>
*
*
*/
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "", propOrder = {
"extension",
"attribute"
})
@XmlRootElement(name = "Characteristic")
public class Characteristic {
@XmlElement(name = "Extension", namespace = "http://www.dmg.org/PMML-4_1", required = true)
protected List<Extension> extension;
@XmlElement(name = "Attribute", namespace = "http://www.dmg.org/PMML-4_1", required = true)
protected List<Attribute> attribute;
@XmlAttribute
protected Double baselineScore;
@XmlAttribute
protected String name;
@XmlAttribute
protected String reasonCode;
/**
* Gets the value of the extension property.
*
* <p>
* This accessor method returns a reference to the live list,
* not a snapshot. Therefore any modification you make to the
* returned list will be present inside the JAXB object.
* This is why there is not a <CODE>set</CODE> method for the extension property.
*
* <p>
* For example, to add a new item, do as follows:
* <pre>
* getExtension().add(newItem);
* </pre>
*
*
* <p>
* Objects of the following type(s) are allowed in the list
* {@link Extension }
*
*
*/
public List<Extension> getExtension() {
if (extension == null) {
extension = new ArrayList<Extension>();
}
return this.extension;
}
/**
* Gets the value of the attribute property.
*
* <p>
* This accessor method returns a reference to the live list,
* not a snapshot. Therefore any modification you make to the
* returned list will be present inside the JAXB object.
* This is why there is not a <CODE>set</CODE> method for the attribute property.
*
* <p>
* For example, to add a new item, do as follows:
* <pre>
* getAttribute().add(newItem);
* </pre>
*
*
* <p>
* Objects of the following type(s) are allowed in the list
* {@link Attribute }
*
*
*/
public List<Attribute> getAttribute() {
if (attribute == null) {
attribute = new ArrayList<Attribute>();
}
return this.attribute;
}
/**
* Gets the value of the baselineScore property.
*
* @return
* possible object is
* {@link Double }
*
*/
public Double getBaselineScore() {
return baselineScore;
}
/**
* Sets the value of the baselineScore property.
*
* @param value
* allowed object is
* {@link Double }
*
*/
public void setBaselineScore(Double value) {
this.baselineScore = value;
}
/**
* Gets the value of the name property.
*
* @return
* possible object is
* {@link String }
*
*/
public String getName() {
return name;
}
/**
* Sets the value of the name property.
*
* @param value
* allowed object is
* {@link String }
*
*/
public void setName(String value) {
this.name = value;
}
/**
* Gets the value of the reasonCode property.
*
* @return
* possible object is
* {@link String }
*
*/
public String getReasonCode() {
return reasonCode;
}
/**
* Sets the value of the reasonCode property.
*
* @param value
* allowed object is
* {@link String }
*
*/
public void setReasonCode(String value) {
this.reasonCode = value;
}
}
|
0
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml/jaxbbindings/Characteristics.java
|
//
// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.0-b52-fcs
// See <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a>
// Any modifications to this file will be lost upon recompilation of the source schema.
// Generated on: 2013.12.20 at 12:48:21 PM GMT
//
package weka.core.pmml.jaxbbindings;
import java.util.ArrayList;
import java.util.List;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlType;
/**
* <p>Java class for Characteristics element declaration.
*
* <p>The following schema fragment specifies the expected content contained within this class.
*
* <pre>
* <element name="Characteristics">
* <complexType>
* <complexContent>
* <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
* <sequence>
* <element ref="{http://www.dmg.org/PMML-4_1}Extension" maxOccurs="unbounded" minOccurs="0"/>
* <element ref="{http://www.dmg.org/PMML-4_1}Characteristic" maxOccurs="unbounded"/>
* </sequence>
* </restriction>
* </complexContent>
* </complexType>
* </element>
* </pre>
*
*
*/
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "", propOrder = {
"extension",
"characteristic"
})
@XmlRootElement(name = "Characteristics")
public class Characteristics {
@XmlElement(name = "Extension", namespace = "http://www.dmg.org/PMML-4_1", required = true)
protected List<Extension> extension;
@XmlElement(name = "Characteristic", namespace = "http://www.dmg.org/PMML-4_1", required = true)
protected List<Characteristic> characteristic;
/**
* Gets the value of the extension property.
*
* <p>
* This accessor method returns a reference to the live list,
* not a snapshot. Therefore any modification you make to the
* returned list will be present inside the JAXB object.
* This is why there is not a <CODE>set</CODE> method for the extension property.
*
* <p>
* For example, to add a new item, do as follows:
* <pre>
* getExtension().add(newItem);
* </pre>
*
*
* <p>
* Objects of the following type(s) are allowed in the list
* {@link Extension }
*
*
*/
public List<Extension> getExtension() {
if (extension == null) {
extension = new ArrayList<Extension>();
}
return this.extension;
}
/**
* Gets the value of the characteristic property.
*
* <p>
* This accessor method returns a reference to the live list,
* not a snapshot. Therefore any modification you make to the
* returned list will be present inside the JAXB object.
* This is why there is not a <CODE>set</CODE> method for the characteristic property.
*
* <p>
* For example, to add a new item, do as follows:
* <pre>
* getCharacteristic().add(newItem);
* </pre>
*
*
* <p>
* Objects of the following type(s) are allowed in the list
* {@link Characteristic }
*
*
*/
public List<Characteristic> getCharacteristic() {
if (characteristic == null) {
characteristic = new ArrayList<Characteristic>();
}
return this.characteristic;
}
}
|
0
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml/jaxbbindings/Chebychev.java
|
//
// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.0-b52-fcs
// See <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a>
// Any modifications to this file will be lost upon recompilation of the source schema.
// Generated on: 2013.12.20 at 12:48:21 PM GMT
//
package weka.core.pmml.jaxbbindings;
import java.util.ArrayList;
import java.util.List;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlType;
/**
* <p>Java class for chebychev element declaration.
*
* <p>The following schema fragment specifies the expected content contained within this class.
*
* <pre>
* <element name="chebychev">
* <complexType>
* <complexContent>
* <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
* <sequence>
* <element ref="{http://www.dmg.org/PMML-4_1}Extension" maxOccurs="unbounded" minOccurs="0"/>
* </sequence>
* </restriction>
* </complexContent>
* </complexType>
* </element>
* </pre>
*
*
*/
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "", propOrder = {
"extension"
})
@XmlRootElement(name = "chebychev")
public class Chebychev {
@XmlElement(name = "Extension", namespace = "http://www.dmg.org/PMML-4_1", required = true)
protected List<Extension> extension;
/**
* Gets the value of the extension property.
*
* <p>
* This accessor method returns a reference to the live list,
* not a snapshot. Therefore any modification you make to the
* returned list will be present inside the JAXB object.
* This is why there is not a <CODE>set</CODE> method for the extension property.
*
* <p>
* For example, to add a new item, do as follows:
* <pre>
* getExtension().add(newItem);
* </pre>
*
*
* <p>
* Objects of the following type(s) are allowed in the list
* {@link Extension }
*
*
*/
public List<Extension> getExtension() {
if (extension == null) {
extension = new ArrayList<Extension>();
}
return this.extension;
}
}
|
0
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml/jaxbbindings/ChildParent.java
|
//
// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.0-b52-fcs
// See <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a>
// Any modifications to this file will be lost upon recompilation of the source schema.
// Generated on: 2013.12.20 at 12:48:21 PM GMT
//
package weka.core.pmml.jaxbbindings;
import java.util.ArrayList;
import java.util.List;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlType;
/**
* <p>Java class for ChildParent element declaration.
*
* <p>The following schema fragment specifies the expected content contained within this class.
*
* <pre>
* <element name="ChildParent">
* <complexType>
* <complexContent>
* <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
* <sequence>
* <element ref="{http://www.dmg.org/PMML-4_1}Extension" maxOccurs="unbounded" minOccurs="0"/>
* <choice>
* <element ref="{http://www.dmg.org/PMML-4_1}TableLocator"/>
* <element ref="{http://www.dmg.org/PMML-4_1}InlineTable"/>
* </choice>
* </sequence>
* <attribute name="childField" use="required" type="{http://www.w3.org/2001/XMLSchema}string" />
* <attribute name="isRecursive" default="no">
* <simpleType>
* <restriction base="{http://www.w3.org/2001/XMLSchema}string">
* <enumeration value="no"/>
* <enumeration value="yes"/>
* </restriction>
* </simpleType>
* </attribute>
* <attribute name="parentField" use="required" type="{http://www.w3.org/2001/XMLSchema}string" />
* <attribute name="parentLevelField" type="{http://www.w3.org/2001/XMLSchema}string" />
* </restriction>
* </complexContent>
* </complexType>
* </element>
* </pre>
*
*
*/
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "", propOrder = {
"extension",
"tableLocator",
"inlineTable"
})
@XmlRootElement(name = "ChildParent")
public class ChildParent {
@XmlElement(name = "Extension", namespace = "http://www.dmg.org/PMML-4_1", required = true)
protected List<Extension> extension;
@XmlElement(name = "TableLocator", namespace = "http://www.dmg.org/PMML-4_1")
protected TableLocator tableLocator;
@XmlElement(name = "InlineTable", namespace = "http://www.dmg.org/PMML-4_1")
protected InlineTable inlineTable;
@XmlAttribute(required = true)
protected String childField;
@XmlAttribute
protected String isRecursive;
@XmlAttribute(required = true)
protected String parentField;
@XmlAttribute
protected String parentLevelField;
/**
* Gets the value of the extension property.
*
* <p>
* This accessor method returns a reference to the live list,
* not a snapshot. Therefore any modification you make to the
* returned list will be present inside the JAXB object.
* This is why there is not a <CODE>set</CODE> method for the extension property.
*
* <p>
* For example, to add a new item, do as follows:
* <pre>
* getExtension().add(newItem);
* </pre>
*
*
* <p>
* Objects of the following type(s) are allowed in the list
* {@link Extension }
*
*
*/
public List<Extension> getExtension() {
if (extension == null) {
extension = new ArrayList<Extension>();
}
return this.extension;
}
/**
* Gets the value of the tableLocator property.
*
* @return
* possible object is
* {@link TableLocator }
*
*/
public TableLocator getTableLocator() {
return tableLocator;
}
/**
* Sets the value of the tableLocator property.
*
* @param value
* allowed object is
* {@link TableLocator }
*
*/
public void setTableLocator(TableLocator value) {
this.tableLocator = value;
}
/**
* Gets the value of the inlineTable property.
*
* @return
* possible object is
* {@link InlineTable }
*
*/
public InlineTable getInlineTable() {
return inlineTable;
}
/**
* Sets the value of the inlineTable property.
*
* @param value
* allowed object is
* {@link InlineTable }
*
*/
public void setInlineTable(InlineTable value) {
this.inlineTable = value;
}
/**
* Gets the value of the childField property.
*
* @return
* possible object is
* {@link String }
*
*/
public String getChildField() {
return childField;
}
/**
* Sets the value of the childField property.
*
* @param value
* allowed object is
* {@link String }
*
*/
public void setChildField(String value) {
this.childField = value;
}
/**
* Gets the value of the isRecursive property.
*
* @return
* possible object is
* {@link String }
*
*/
public String getIsRecursive() {
if (isRecursive == null) {
return "no";
} else {
return isRecursive;
}
}
/**
* Sets the value of the isRecursive property.
*
* @param value
* allowed object is
* {@link String }
*
*/
public void setIsRecursive(String value) {
this.isRecursive = value;
}
/**
* Gets the value of the parentField property.
*
* @return
* possible object is
* {@link String }
*
*/
public String getParentField() {
return parentField;
}
/**
* Sets the value of the parentField property.
*
* @param value
* allowed object is
* {@link String }
*
*/
public void setParentField(String value) {
this.parentField = value;
}
/**
* Gets the value of the parentLevelField property.
*
* @return
* possible object is
* {@link String }
*
*/
public String getParentLevelField() {
return parentLevelField;
}
/**
* Sets the value of the parentLevelField property.
*
* @param value
* allowed object is
* {@link String }
*
*/
public void setParentLevelField(String value) {
this.parentLevelField = value;
}
}
|
0
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml/jaxbbindings/CityBlock.java
|
//
// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.0-b52-fcs
// See <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a>
// Any modifications to this file will be lost upon recompilation of the source schema.
// Generated on: 2013.12.20 at 12:48:21 PM GMT
//
package weka.core.pmml.jaxbbindings;
import java.util.ArrayList;
import java.util.List;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlType;
/**
* <p>Java class for cityBlock element declaration.
*
* <p>The following schema fragment specifies the expected content contained within this class.
*
* <pre>
* <element name="cityBlock">
* <complexType>
* <complexContent>
* <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
* <sequence>
* <element ref="{http://www.dmg.org/PMML-4_1}Extension" maxOccurs="unbounded" minOccurs="0"/>
* </sequence>
* </restriction>
* </complexContent>
* </complexType>
* </element>
* </pre>
*
*
*/
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "", propOrder = {
"extension"
})
@XmlRootElement(name = "cityBlock")
public class CityBlock {
@XmlElement(name = "Extension", namespace = "http://www.dmg.org/PMML-4_1", required = true)
protected List<Extension> extension;
/**
* Gets the value of the extension property.
*
* <p>
* This accessor method returns a reference to the live list,
* not a snapshot. Therefore any modification you make to the
* returned list will be present inside the JAXB object.
* This is why there is not a <CODE>set</CODE> method for the extension property.
*
* <p>
* For example, to add a new item, do as follows:
* <pre>
* getExtension().add(newItem);
* </pre>
*
*
* <p>
* Objects of the following type(s) are allowed in the list
* {@link Extension }
*
*
*/
public List<Extension> getExtension() {
if (extension == null) {
extension = new ArrayList<Extension>();
}
return this.extension;
}
}
|
0
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml/jaxbbindings/ClassLabels.java
|
//
// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.0-b52-fcs
// See <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a>
// Any modifications to this file will be lost upon recompilation of the source schema.
// Generated on: 2013.12.20 at 12:48:21 PM GMT
//
package weka.core.pmml.jaxbbindings;
import java.util.ArrayList;
import java.util.List;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlType;
/**
* <p>Java class for ClassLabels element declaration.
*
* <p>The following schema fragment specifies the expected content contained within this class.
*
* <pre>
* <element name="ClassLabels">
* <complexType>
* <complexContent>
* <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
* <sequence>
* <element ref="{http://www.dmg.org/PMML-4_1}Extension" maxOccurs="unbounded" minOccurs="0"/>
* <group ref="{http://www.dmg.org/PMML-4_1}STRING-ARRAY"/>
* </sequence>
* </restriction>
* </complexContent>
* </complexType>
* </element>
* </pre>
*
*
*/
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "", propOrder = {
"extension",
"array"
})
@XmlRootElement(name = "ClassLabels")
public class ClassLabels {
@XmlElement(name = "Extension", namespace = "http://www.dmg.org/PMML-4_1", required = true)
protected List<Extension> extension;
@XmlElement(name = "Array", namespace = "http://www.dmg.org/PMML-4_1")
protected ArrayType array;
/**
* Gets the value of the extension property.
*
* <p>
* This accessor method returns a reference to the live list,
* not a snapshot. Therefore any modification you make to the
* returned list will be present inside the JAXB object.
* This is why there is not a <CODE>set</CODE> method for the extension property.
*
* <p>
* For example, to add a new item, do as follows:
* <pre>
* getExtension().add(newItem);
* </pre>
*
*
* <p>
* Objects of the following type(s) are allowed in the list
* {@link Extension }
*
*
*/
public List<Extension> getExtension() {
if (extension == null) {
extension = new ArrayList<Extension>();
}
return this.extension;
}
/**
* Gets the value of the array property.
*
* @return
* possible object is
* {@link ArrayType }
*
*/
public ArrayType getArray() {
return array;
}
/**
* Sets the value of the array property.
*
* @param value
* allowed object is
* {@link ArrayType }
*
*/
public void setArray(ArrayType value) {
this.array = value;
}
}
|
0
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml/jaxbbindings/Cluster.java
|
//
// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.0-b52-fcs
// See <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a>
// Any modifications to this file will be lost upon recompilation of the source schema.
// Generated on: 2013.12.20 at 12:48:21 PM GMT
//
package weka.core.pmml.jaxbbindings;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.List;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlType;
/**
* <p>Java class for Cluster element declaration.
*
* <p>The following schema fragment specifies the expected content contained within this class.
*
* <pre>
* <element name="Cluster">
* <complexType>
* <complexContent>
* <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
* <sequence>
* <element ref="{http://www.dmg.org/PMML-4_1}Extension" maxOccurs="unbounded" minOccurs="0"/>
* <element ref="{http://www.dmg.org/PMML-4_1}KohonenMap" minOccurs="0"/>
* <group ref="{http://www.dmg.org/PMML-4_1}NUM-ARRAY" minOccurs="0"/>
* <element ref="{http://www.dmg.org/PMML-4_1}Partition" minOccurs="0"/>
* <element ref="{http://www.dmg.org/PMML-4_1}Covariances" minOccurs="0"/>
* </sequence>
* <attribute name="id" type="{http://www.w3.org/2001/XMLSchema}string" />
* <attribute name="name" type="{http://www.w3.org/2001/XMLSchema}string" />
* <attribute name="size" type="{http://www.w3.org/2001/XMLSchema}nonNegativeInteger" />
* </restriction>
* </complexContent>
* </complexType>
* </element>
* </pre>
*
*
*/
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "", propOrder = {
"extension",
"kohonenMap",
"array",
"partition",
"covariances"
})
@XmlRootElement(name = "Cluster")
public class Cluster {
@XmlElement(name = "Extension", namespace = "http://www.dmg.org/PMML-4_1", required = true)
protected List<Extension> extension;
@XmlElement(name = "KohonenMap", namespace = "http://www.dmg.org/PMML-4_1")
protected KohonenMap kohonenMap;
@XmlElement(name = "Array", namespace = "http://www.dmg.org/PMML-4_1")
protected ArrayType array;
@XmlElement(name = "Partition", namespace = "http://www.dmg.org/PMML-4_1")
protected Partition partition;
@XmlElement(name = "Covariances", namespace = "http://www.dmg.org/PMML-4_1")
protected Covariances covariances;
@XmlAttribute
protected String id;
@XmlAttribute
protected String name;
@XmlAttribute
protected BigInteger size;
/**
* Gets the value of the extension property.
*
* <p>
* This accessor method returns a reference to the live list,
* not a snapshot. Therefore any modification you make to the
* returned list will be present inside the JAXB object.
* This is why there is not a <CODE>set</CODE> method for the extension property.
*
* <p>
* For example, to add a new item, do as follows:
* <pre>
* getExtension().add(newItem);
* </pre>
*
*
* <p>
* Objects of the following type(s) are allowed in the list
* {@link Extension }
*
*
*/
public List<Extension> getExtension() {
if (extension == null) {
extension = new ArrayList<Extension>();
}
return this.extension;
}
/**
* Gets the value of the kohonenMap property.
*
* @return
* possible object is
* {@link KohonenMap }
*
*/
public KohonenMap getKohonenMap() {
return kohonenMap;
}
/**
* Sets the value of the kohonenMap property.
*
* @param value
* allowed object is
* {@link KohonenMap }
*
*/
public void setKohonenMap(KohonenMap value) {
this.kohonenMap = value;
}
/**
* Gets the value of the array property.
*
* @return
* possible object is
* {@link ArrayType }
*
*/
public ArrayType getArray() {
return array;
}
/**
* Sets the value of the array property.
*
* @param value
* allowed object is
* {@link ArrayType }
*
*/
public void setArray(ArrayType value) {
this.array = value;
}
/**
* Gets the value of the partition property.
*
* @return
* possible object is
* {@link Partition }
*
*/
public Partition getPartition() {
return partition;
}
/**
* Sets the value of the partition property.
*
* @param value
* allowed object is
* {@link Partition }
*
*/
public void setPartition(Partition value) {
this.partition = value;
}
/**
* Gets the value of the covariances property.
*
* @return
* possible object is
* {@link Covariances }
*
*/
public Covariances getCovariances() {
return covariances;
}
/**
* Sets the value of the covariances property.
*
* @param value
* allowed object is
* {@link Covariances }
*
*/
public void setCovariances(Covariances value) {
this.covariances = value;
}
/**
* Gets the value of the id property.
*
* @return
* possible object is
* {@link String }
*
*/
public String getId() {
return id;
}
/**
* Sets the value of the id property.
*
* @param value
* allowed object is
* {@link String }
*
*/
public void setId(String value) {
this.id = value;
}
/**
* Gets the value of the name property.
*
* @return
* possible object is
* {@link String }
*
*/
public String getName() {
return name;
}
/**
* Sets the value of the name property.
*
* @param value
* allowed object is
* {@link String }
*
*/
public void setName(String value) {
this.name = value;
}
/**
* Gets the value of the size property.
*
* @return
* possible object is
* {@link BigInteger }
*
*/
public BigInteger getSize() {
return size;
}
/**
* Sets the value of the size property.
*
* @param value
* allowed object is
* {@link BigInteger }
*
*/
public void setSize(BigInteger value) {
this.size = value;
}
}
|
0
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml/jaxbbindings/ClusteringField.java
|
//
// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.0-b52-fcs
// See <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a>
// Any modifications to this file will be lost upon recompilation of the source schema.
// Generated on: 2013.12.20 at 12:48:21 PM GMT
//
package weka.core.pmml.jaxbbindings;
import java.util.ArrayList;
import java.util.List;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlType;
/**
* <p>Java class for ClusteringField element declaration.
*
* <p>The following schema fragment specifies the expected content contained within this class.
*
* <pre>
* <element name="ClusteringField">
* <complexType>
* <complexContent>
* <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
* <sequence>
* <element ref="{http://www.dmg.org/PMML-4_1}Extension" maxOccurs="unbounded" minOccurs="0"/>
* <element ref="{http://www.dmg.org/PMML-4_1}Comparisons" minOccurs="0"/>
* </sequence>
* <attribute name="compareFunction" type="{http://www.dmg.org/PMML-4_1}COMPARE-FUNCTION" />
* <attribute name="field" use="required" type="{http://www.dmg.org/PMML-4_1}FIELD-NAME" />
* <attribute name="fieldWeight" type="{http://www.dmg.org/PMML-4_1}REAL-NUMBER" default="1" />
* <attribute name="isCenterField" default="true">
* <simpleType>
* <restriction base="{http://www.w3.org/2001/XMLSchema}string">
* <enumeration value="true"/>
* <enumeration value="false"/>
* </restriction>
* </simpleType>
* </attribute>
* <attribute name="similarityScale" type="{http://www.dmg.org/PMML-4_1}REAL-NUMBER" />
* </restriction>
* </complexContent>
* </complexType>
* </element>
* </pre>
*
*
*/
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "", propOrder = {
"extension",
"comparisons"
})
@XmlRootElement(name = "ClusteringField")
public class ClusteringField {
@XmlElement(name = "Extension", namespace = "http://www.dmg.org/PMML-4_1", required = true)
protected List<Extension> extension;
@XmlElement(name = "Comparisons", namespace = "http://www.dmg.org/PMML-4_1")
protected Comparisons comparisons;
@XmlAttribute
protected COMPAREFUNCTION compareFunction;
@XmlAttribute(required = true)
protected String field;
@XmlAttribute
protected Double fieldWeight;
@XmlAttribute
protected String isCenterField;
@XmlAttribute
protected Double similarityScale;
/**
* Gets the value of the extension property.
*
* <p>
* This accessor method returns a reference to the live list,
* not a snapshot. Therefore any modification you make to the
* returned list will be present inside the JAXB object.
* This is why there is not a <CODE>set</CODE> method for the extension property.
*
* <p>
* For example, to add a new item, do as follows:
* <pre>
* getExtension().add(newItem);
* </pre>
*
*
* <p>
* Objects of the following type(s) are allowed in the list
* {@link Extension }
*
*
*/
public List<Extension> getExtension() {
if (extension == null) {
extension = new ArrayList<Extension>();
}
return this.extension;
}
/**
* Gets the value of the comparisons property.
*
* @return
* possible object is
* {@link Comparisons }
*
*/
public Comparisons getComparisons() {
return comparisons;
}
/**
* Sets the value of the comparisons property.
*
* @param value
* allowed object is
* {@link Comparisons }
*
*/
public void setComparisons(Comparisons value) {
this.comparisons = value;
}
/**
* Gets the value of the compareFunction property.
*
* @return
* possible object is
* {@link COMPAREFUNCTION }
*
*/
public COMPAREFUNCTION getCompareFunction() {
return compareFunction;
}
/**
* Sets the value of the compareFunction property.
*
* @param value
* allowed object is
* {@link COMPAREFUNCTION }
*
*/
public void setCompareFunction(COMPAREFUNCTION value) {
this.compareFunction = value;
}
/**
* Gets the value of the field property.
*
* @return
* possible object is
* {@link String }
*
*/
public String getField() {
return field;
}
/**
* Sets the value of the field property.
*
* @param value
* allowed object is
* {@link String }
*
*/
public void setField(String value) {
this.field = value;
}
/**
* Gets the value of the fieldWeight property.
*
* @return
* possible object is
* {@link Double }
*
*/
public double getFieldWeight() {
if (fieldWeight == null) {
return 1.0D;
} else {
return fieldWeight;
}
}
/**
* Sets the value of the fieldWeight property.
*
* @param value
* allowed object is
* {@link Double }
*
*/
public void setFieldWeight(Double value) {
this.fieldWeight = value;
}
/**
* Gets the value of the isCenterField property.
*
* @return
* possible object is
* {@link String }
*
*/
public String getIsCenterField() {
if (isCenterField == null) {
return "true";
} else {
return isCenterField;
}
}
/**
* Sets the value of the isCenterField property.
*
* @param value
* allowed object is
* {@link String }
*
*/
public void setIsCenterField(String value) {
this.isCenterField = value;
}
/**
* Gets the value of the similarityScale property.
*
* @return
* possible object is
* {@link Double }
*
*/
public Double getSimilarityScale() {
return similarityScale;
}
/**
* Sets the value of the similarityScale property.
*
* @param value
* allowed object is
* {@link Double }
*
*/
public void setSimilarityScale(Double value) {
this.similarityScale = value;
}
}
|
0
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml/jaxbbindings/ClusteringModel.java
|
//
// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.0-b52-fcs
// See <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a>
// Any modifications to this file will be lost upon recompilation of the source schema.
// Generated on: 2013.12.20 at 12:48:21 PM GMT
//
package weka.core.pmml.jaxbbindings;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.List;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlElementRef;
import javax.xml.bind.annotation.XmlElementRefs;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlType;
/**
* <p>Java class for ClusteringModel element declaration.
*
* <p>The following schema fragment specifies the expected content contained within this class.
*
* <pre>
* <element name="ClusteringModel">
* <complexType>
* <complexContent>
* <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
* <sequence>
* <element ref="{http://www.dmg.org/PMML-4_1}Extension" maxOccurs="unbounded" minOccurs="0"/>
* <element ref="{http://www.dmg.org/PMML-4_1}MiningSchema"/>
* <element ref="{http://www.dmg.org/PMML-4_1}Output" minOccurs="0"/>
* <element ref="{http://www.dmg.org/PMML-4_1}ModelStats" minOccurs="0"/>
* <element ref="{http://www.dmg.org/PMML-4_1}ModelExplanation" minOccurs="0"/>
* <element ref="{http://www.dmg.org/PMML-4_1}LocalTransformations" minOccurs="0"/>
* <element ref="{http://www.dmg.org/PMML-4_1}ComparisonMeasure"/>
* <element ref="{http://www.dmg.org/PMML-4_1}ClusteringField" maxOccurs="unbounded" minOccurs="0"/>
* <element ref="{http://www.dmg.org/PMML-4_1}MissingValueWeights" minOccurs="0"/>
* <element ref="{http://www.dmg.org/PMML-4_1}Cluster" maxOccurs="unbounded"/>
* <element ref="{http://www.dmg.org/PMML-4_1}ModelVerification" minOccurs="0"/>
* <element ref="{http://www.dmg.org/PMML-4_1}Extension" maxOccurs="unbounded" minOccurs="0"/>
* </sequence>
* <attribute name="algorithmName" type="{http://www.w3.org/2001/XMLSchema}string" />
* <attribute name="functionName" use="required" type="{http://www.dmg.org/PMML-4_1}MINING-FUNCTION" />
* <attribute name="isScorable" type="{http://www.w3.org/2001/XMLSchema}boolean" default="true" />
* <attribute name="modelClass" use="required">
* <simpleType>
* <restriction base="{http://www.w3.org/2001/XMLSchema}string">
* <enumeration value="centerBased"/>
* <enumeration value="distributionBased"/>
* </restriction>
* </simpleType>
* </attribute>
* <attribute name="modelName" type="{http://www.w3.org/2001/XMLSchema}string" />
* <attribute name="numberOfClusters" use="required" type="{http://www.dmg.org/PMML-4_1}INT-NUMBER" />
* </restriction>
* </complexContent>
* </complexType>
* </element>
* </pre>
*
*
*/
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "", propOrder = {
"content"
})
@XmlRootElement(name = "ClusteringModel")
public class ClusteringModel {
@XmlElementRefs({
@XmlElementRef(name = "ModelExplanation", namespace = "http://www.dmg.org/PMML-4_1", type = ModelExplanation.class),
@XmlElementRef(name = "ModelStats", namespace = "http://www.dmg.org/PMML-4_1", type = ModelStats.class),
@XmlElementRef(name = "MissingValueWeights", namespace = "http://www.dmg.org/PMML-4_1", type = MissingValueWeights.class),
@XmlElementRef(name = "ClusteringField", namespace = "http://www.dmg.org/PMML-4_1", type = ClusteringField.class),
@XmlElementRef(name = "Output", namespace = "http://www.dmg.org/PMML-4_1", type = Output.class),
@XmlElementRef(name = "ComparisonMeasure", namespace = "http://www.dmg.org/PMML-4_1", type = ComparisonMeasure.class),
@XmlElementRef(name = "LocalTransformations", namespace = "http://www.dmg.org/PMML-4_1", type = LocalTransformations.class),
@XmlElementRef(name = "Cluster", namespace = "http://www.dmg.org/PMML-4_1", type = Cluster.class),
@XmlElementRef(name = "MiningSchema", namespace = "http://www.dmg.org/PMML-4_1", type = MiningSchema.class),
@XmlElementRef(name = "ModelVerification", namespace = "http://www.dmg.org/PMML-4_1", type = ModelVerification.class),
@XmlElementRef(name = "Extension", namespace = "http://www.dmg.org/PMML-4_1", type = Extension.class)
})
protected List<Object> content;
@XmlAttribute
protected String algorithmName;
@XmlAttribute(required = true)
protected MININGFUNCTION functionName;
@XmlAttribute
protected Boolean isScorable;
@XmlAttribute(required = true)
protected String modelClass;
@XmlAttribute
protected String modelName;
@XmlAttribute(required = true)
protected BigInteger numberOfClusters;
/**
* Gets the rest of the content model.
*
* <p>
* You are getting this "catch-all" property because of the following reason:
* The field name "Extension" is used by two different parts of a schema. See:
* line 16 of file:/home/david/workspace/weka/pmml-4-1.xsd
* line 5 of file:/home/david/workspace/weka/pmml-4-1.xsd
* <p>
* To get rid of this property, apply a property customization to one
* of both of the following declarations to change their names:
* Gets the value of the content property.
*
* <p>
* This accessor method returns a reference to the live list,
* not a snapshot. Therefore any modification you make to the
* returned list will be present inside the JAXB object.
* This is why there is not a <CODE>set</CODE> method for the content property.
*
* <p>
* For example, to add a new item, do as follows:
* <pre>
* getContent().add(newItem);
* </pre>
*
*
* <p>
* Objects of the following type(s) are allowed in the list
* {@link ModelExplanation }
* {@link MissingValueWeights }
* {@link ModelStats }
* {@link ClusteringField }
* {@link Output }
* {@link ComparisonMeasure }
* {@link Cluster }
* {@link LocalTransformations }
* {@link MiningSchema }
* {@link ModelVerification }
* {@link Extension }
*
*
*/
public List<Object> getContent() {
if (content == null) {
content = new ArrayList<Object>();
}
return this.content;
}
/**
* Gets the value of the algorithmName property.
*
* @return
* possible object is
* {@link String }
*
*/
public String getAlgorithmName() {
return algorithmName;
}
/**
* Sets the value of the algorithmName property.
*
* @param value
* allowed object is
* {@link String }
*
*/
public void setAlgorithmName(String value) {
this.algorithmName = value;
}
/**
* Gets the value of the functionName property.
*
* @return
* possible object is
* {@link MININGFUNCTION }
*
*/
public MININGFUNCTION getFunctionName() {
return functionName;
}
/**
* Sets the value of the functionName property.
*
* @param value
* allowed object is
* {@link MININGFUNCTION }
*
*/
public void setFunctionName(MININGFUNCTION value) {
this.functionName = value;
}
/**
* Gets the value of the isScorable property.
*
* @return
* possible object is
* {@link Boolean }
*
*/
public boolean isIsScorable() {
if (isScorable == null) {
return true;
} else {
return isScorable;
}
}
/**
* Sets the value of the isScorable property.
*
* @param value
* allowed object is
* {@link Boolean }
*
*/
public void setIsScorable(Boolean value) {
this.isScorable = value;
}
/**
* Gets the value of the modelClass property.
*
* @return
* possible object is
* {@link String }
*
*/
public String getModelClass() {
return modelClass;
}
/**
* Sets the value of the modelClass property.
*
* @param value
* allowed object is
* {@link String }
*
*/
public void setModelClass(String value) {
this.modelClass = value;
}
/**
* Gets the value of the modelName property.
*
* @return
* possible object is
* {@link String }
*
*/
public String getModelName() {
return modelName;
}
/**
* Sets the value of the modelName property.
*
* @param value
* allowed object is
* {@link String }
*
*/
public void setModelName(String value) {
this.modelName = value;
}
/**
* Gets the value of the numberOfClusters property.
*
* @return
* possible object is
* {@link BigInteger }
*
*/
public BigInteger getNumberOfClusters() {
return numberOfClusters;
}
/**
* Sets the value of the numberOfClusters property.
*
* @param value
* allowed object is
* {@link BigInteger }
*
*/
public void setNumberOfClusters(BigInteger value) {
this.numberOfClusters = value;
}
}
|
0
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml/jaxbbindings/ClusteringModelQuality.java
|
//
// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.0-b52-fcs
// See <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a>
// Any modifications to this file will be lost upon recompilation of the source schema.
// Generated on: 2013.12.20 at 12:48:21 PM GMT
//
package weka.core.pmml.jaxbbindings;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlType;
/**
* <p>Java class for ClusteringModelQuality element declaration.
*
* <p>The following schema fragment specifies the expected content contained within this class.
*
* <pre>
* <element name="ClusteringModelQuality">
* <complexType>
* <complexContent>
* <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
* <attribute name="SSB" type="{http://www.dmg.org/PMML-4_1}NUMBER" />
* <attribute name="SSE" type="{http://www.dmg.org/PMML-4_1}NUMBER" />
* <attribute name="dataName" type="{http://www.w3.org/2001/XMLSchema}string" />
* </restriction>
* </complexContent>
* </complexType>
* </element>
* </pre>
*
*
*/
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "")
@XmlRootElement(name = "ClusteringModelQuality")
public class ClusteringModelQuality {
@XmlAttribute(name = "SSB")
protected Double ssb;
@XmlAttribute(name = "SSE")
protected Double sse;
@XmlAttribute
protected String dataName;
/**
* Gets the value of the ssb property.
*
* @return
* possible object is
* {@link Double }
*
*/
public Double getSSB() {
return ssb;
}
/**
* Sets the value of the ssb property.
*
* @param value
* allowed object is
* {@link Double }
*
*/
public void setSSB(Double value) {
this.ssb = value;
}
/**
* Gets the value of the sse property.
*
* @return
* possible object is
* {@link Double }
*
*/
public Double getSSE() {
return sse;
}
/**
* Sets the value of the sse property.
*
* @param value
* allowed object is
* {@link Double }
*
*/
public void setSSE(Double value) {
this.sse = value;
}
/**
* Gets the value of the dataName property.
*
* @return
* possible object is
* {@link String }
*
*/
public String getDataName() {
return dataName;
}
/**
* Sets the value of the dataName property.
*
* @param value
* allowed object is
* {@link String }
*
*/
public void setDataName(String value) {
this.dataName = value;
}
}
|
0
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml/jaxbbindings/Coefficient.java
|
//
// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.0-b52-fcs
// See <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a>
// Any modifications to this file will be lost upon recompilation of the source schema.
// Generated on: 2013.12.20 at 12:48:21 PM GMT
//
package weka.core.pmml.jaxbbindings;
import java.util.ArrayList;
import java.util.List;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlType;
/**
* <p>Java class for Coefficient element declaration.
*
* <p>The following schema fragment specifies the expected content contained within this class.
*
* <pre>
* <element name="Coefficient">
* <complexType>
* <complexContent>
* <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
* <sequence>
* <element ref="{http://www.dmg.org/PMML-4_1}Extension" maxOccurs="unbounded" minOccurs="0"/>
* </sequence>
* <attribute name="value" type="{http://www.dmg.org/PMML-4_1}REAL-NUMBER" default="0" />
* </restriction>
* </complexContent>
* </complexType>
* </element>
* </pre>
*
*
*/
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "", propOrder = {
"extension"
})
@XmlRootElement(name = "Coefficient")
public class Coefficient {
@XmlElement(name = "Extension", namespace = "http://www.dmg.org/PMML-4_1", required = true)
protected List<Extension> extension;
@XmlAttribute
protected Double value;
/**
* Gets the value of the extension property.
*
* <p>
* This accessor method returns a reference to the live list,
* not a snapshot. Therefore any modification you make to the
* returned list will be present inside the JAXB object.
* This is why there is not a <CODE>set</CODE> method for the extension property.
*
* <p>
* For example, to add a new item, do as follows:
* <pre>
* getExtension().add(newItem);
* </pre>
*
*
* <p>
* Objects of the following type(s) are allowed in the list
* {@link Extension }
*
*
*/
public List<Extension> getExtension() {
if (extension == null) {
extension = new ArrayList<Extension>();
}
return this.extension;
}
/**
* Gets the value of the value property.
*
* @return
* possible object is
* {@link Double }
*
*/
public double getValue() {
if (value == null) {
return 0.0D;
} else {
return value;
}
}
/**
* Sets the value of the value property.
*
* @param value
* allowed object is
* {@link Double }
*
*/
public void setValue(Double value) {
this.value = value;
}
}
|
0
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml/jaxbbindings/Coefficients.java
|
//
// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.0-b52-fcs
// See <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a>
// Any modifications to this file will be lost upon recompilation of the source schema.
// Generated on: 2013.12.20 at 12:48:21 PM GMT
//
package weka.core.pmml.jaxbbindings;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.List;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlType;
/**
* <p>Java class for Coefficients element declaration.
*
* <p>The following schema fragment specifies the expected content contained within this class.
*
* <pre>
* <element name="Coefficients">
* <complexType>
* <complexContent>
* <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
* <sequence>
* <element ref="{http://www.dmg.org/PMML-4_1}Extension" maxOccurs="unbounded" minOccurs="0"/>
* <element ref="{http://www.dmg.org/PMML-4_1}Coefficient" maxOccurs="unbounded"/>
* </sequence>
* <attribute name="absoluteValue" type="{http://www.dmg.org/PMML-4_1}REAL-NUMBER" default="0" />
* <attribute name="numberOfCoefficients" type="{http://www.dmg.org/PMML-4_1}INT-NUMBER" />
* </restriction>
* </complexContent>
* </complexType>
* </element>
* </pre>
*
*
*/
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "", propOrder = {
"extension",
"coefficient"
})
@XmlRootElement(name = "Coefficients")
public class Coefficients {
@XmlElement(name = "Extension", namespace = "http://www.dmg.org/PMML-4_1", required = true)
protected List<Extension> extension;
@XmlElement(name = "Coefficient", namespace = "http://www.dmg.org/PMML-4_1", required = true)
protected List<Coefficient> coefficient;
@XmlAttribute
protected Double absoluteValue;
@XmlAttribute
protected BigInteger numberOfCoefficients;
/**
* Gets the value of the extension property.
*
* <p>
* This accessor method returns a reference to the live list,
* not a snapshot. Therefore any modification you make to the
* returned list will be present inside the JAXB object.
* This is why there is not a <CODE>set</CODE> method for the extension property.
*
* <p>
* For example, to add a new item, do as follows:
* <pre>
* getExtension().add(newItem);
* </pre>
*
*
* <p>
* Objects of the following type(s) are allowed in the list
* {@link Extension }
*
*
*/
public List<Extension> getExtension() {
if (extension == null) {
extension = new ArrayList<Extension>();
}
return this.extension;
}
/**
* Gets the value of the coefficient property.
*
* <p>
* This accessor method returns a reference to the live list,
* not a snapshot. Therefore any modification you make to the
* returned list will be present inside the JAXB object.
* This is why there is not a <CODE>set</CODE> method for the coefficient property.
*
* <p>
* For example, to add a new item, do as follows:
* <pre>
* getCoefficient().add(newItem);
* </pre>
*
*
* <p>
* Objects of the following type(s) are allowed in the list
* {@link Coefficient }
*
*
*/
public List<Coefficient> getCoefficient() {
if (coefficient == null) {
coefficient = new ArrayList<Coefficient>();
}
return this.coefficient;
}
/**
* Gets the value of the absoluteValue property.
*
* @return
* possible object is
* {@link Double }
*
*/
public double getAbsoluteValue() {
if (absoluteValue == null) {
return 0.0D;
} else {
return absoluteValue;
}
}
/**
* Sets the value of the absoluteValue property.
*
* @param value
* allowed object is
* {@link Double }
*
*/
public void setAbsoluteValue(Double value) {
this.absoluteValue = value;
}
/**
* Gets the value of the numberOfCoefficients property.
*
* @return
* possible object is
* {@link BigInteger }
*
*/
public BigInteger getNumberOfCoefficients() {
return numberOfCoefficients;
}
/**
* Sets the value of the numberOfCoefficients property.
*
* @param value
* allowed object is
* {@link BigInteger }
*
*/
public void setNumberOfCoefficients(BigInteger value) {
this.numberOfCoefficients = value;
}
}
|
0
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml/jaxbbindings/ComparisonMeasure.java
|
//
// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.0-b52-fcs
// See <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a>
// Any modifications to this file will be lost upon recompilation of the source schema.
// Generated on: 2013.12.20 at 12:48:21 PM GMT
//
package weka.core.pmml.jaxbbindings;
import java.util.ArrayList;
import java.util.List;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlType;
/**
* <p>Java class for ComparisonMeasure element declaration.
*
* <p>The following schema fragment specifies the expected content contained within this class.
*
* <pre>
* <element name="ComparisonMeasure">
* <complexType>
* <complexContent>
* <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
* <sequence>
* <element ref="{http://www.dmg.org/PMML-4_1}Extension" maxOccurs="unbounded" minOccurs="0"/>
* <choice>
* <element ref="{http://www.dmg.org/PMML-4_1}euclidean"/>
* <element ref="{http://www.dmg.org/PMML-4_1}squaredEuclidean"/>
* <element ref="{http://www.dmg.org/PMML-4_1}chebychev"/>
* <element ref="{http://www.dmg.org/PMML-4_1}cityBlock"/>
* <element ref="{http://www.dmg.org/PMML-4_1}minkowski"/>
* <element ref="{http://www.dmg.org/PMML-4_1}simpleMatching"/>
* <element ref="{http://www.dmg.org/PMML-4_1}jaccard"/>
* <element ref="{http://www.dmg.org/PMML-4_1}tanimoto"/>
* <element ref="{http://www.dmg.org/PMML-4_1}binarySimilarity"/>
* </choice>
* </sequence>
* <attribute name="compareFunction" type="{http://www.dmg.org/PMML-4_1}COMPARE-FUNCTION" default="absDiff" />
* <attribute name="kind" use="required">
* <simpleType>
* <restriction base="{http://www.w3.org/2001/XMLSchema}string">
* <enumeration value="distance"/>
* <enumeration value="similarity"/>
* </restriction>
* </simpleType>
* </attribute>
* <attribute name="maximum" type="{http://www.dmg.org/PMML-4_1}NUMBER" />
* <attribute name="minimum" type="{http://www.dmg.org/PMML-4_1}NUMBER" />
* </restriction>
* </complexContent>
* </complexType>
* </element>
* </pre>
*
*
*/
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "", propOrder = {
"extension",
"euclidean",
"squaredEuclidean",
"chebychev",
"cityBlock",
"minkowski",
"simpleMatching",
"jaccard",
"tanimoto",
"binarySimilarity"
})
@XmlRootElement(name = "ComparisonMeasure")
public class ComparisonMeasure {
@XmlElement(name = "Extension", namespace = "http://www.dmg.org/PMML-4_1", required = true)
protected List<Extension> extension;
@XmlElement(namespace = "http://www.dmg.org/PMML-4_1")
protected Euclidean euclidean;
@XmlElement(namespace = "http://www.dmg.org/PMML-4_1")
protected SquaredEuclidean squaredEuclidean;
@XmlElement(namespace = "http://www.dmg.org/PMML-4_1")
protected Chebychev chebychev;
@XmlElement(namespace = "http://www.dmg.org/PMML-4_1")
protected CityBlock cityBlock;
@XmlElement(namespace = "http://www.dmg.org/PMML-4_1")
protected Minkowski minkowski;
@XmlElement(namespace = "http://www.dmg.org/PMML-4_1")
protected SimpleMatching simpleMatching;
@XmlElement(namespace = "http://www.dmg.org/PMML-4_1")
protected Jaccard jaccard;
@XmlElement(namespace = "http://www.dmg.org/PMML-4_1")
protected Tanimoto tanimoto;
@XmlElement(namespace = "http://www.dmg.org/PMML-4_1")
protected BinarySimilarity binarySimilarity;
@XmlAttribute
protected COMPAREFUNCTION compareFunction;
@XmlAttribute(required = true)
protected String kind;
@XmlAttribute
protected Double maximum;
@XmlAttribute
protected Double minimum;
/**
* Gets the value of the extension property.
*
* <p>
* This accessor method returns a reference to the live list,
* not a snapshot. Therefore any modification you make to the
* returned list will be present inside the JAXB object.
* This is why there is not a <CODE>set</CODE> method for the extension property.
*
* <p>
* For example, to add a new item, do as follows:
* <pre>
* getExtension().add(newItem);
* </pre>
*
*
* <p>
* Objects of the following type(s) are allowed in the list
* {@link Extension }
*
*
*/
public List<Extension> getExtension() {
if (extension == null) {
extension = new ArrayList<Extension>();
}
return this.extension;
}
/**
* Gets the value of the euclidean property.
*
* @return
* possible object is
* {@link Euclidean }
*
*/
public Euclidean getEuclidean() {
return euclidean;
}
/**
* Sets the value of the euclidean property.
*
* @param value
* allowed object is
* {@link Euclidean }
*
*/
public void setEuclidean(Euclidean value) {
this.euclidean = value;
}
/**
* Gets the value of the squaredEuclidean property.
*
* @return
* possible object is
* {@link SquaredEuclidean }
*
*/
public SquaredEuclidean getSquaredEuclidean() {
return squaredEuclidean;
}
/**
* Sets the value of the squaredEuclidean property.
*
* @param value
* allowed object is
* {@link SquaredEuclidean }
*
*/
public void setSquaredEuclidean(SquaredEuclidean value) {
this.squaredEuclidean = value;
}
/**
* Gets the value of the chebychev property.
*
* @return
* possible object is
* {@link Chebychev }
*
*/
public Chebychev getChebychev() {
return chebychev;
}
/**
* Sets the value of the chebychev property.
*
* @param value
* allowed object is
* {@link Chebychev }
*
*/
public void setChebychev(Chebychev value) {
this.chebychev = value;
}
/**
* Gets the value of the cityBlock property.
*
* @return
* possible object is
* {@link CityBlock }
*
*/
public CityBlock getCityBlock() {
return cityBlock;
}
/**
* Sets the value of the cityBlock property.
*
* @param value
* allowed object is
* {@link CityBlock }
*
*/
public void setCityBlock(CityBlock value) {
this.cityBlock = value;
}
/**
* Gets the value of the minkowski property.
*
* @return
* possible object is
* {@link Minkowski }
*
*/
public Minkowski getMinkowski() {
return minkowski;
}
/**
* Sets the value of the minkowski property.
*
* @param value
* allowed object is
* {@link Minkowski }
*
*/
public void setMinkowski(Minkowski value) {
this.minkowski = value;
}
/**
* Gets the value of the simpleMatching property.
*
* @return
* possible object is
* {@link SimpleMatching }
*
*/
public SimpleMatching getSimpleMatching() {
return simpleMatching;
}
/**
* Sets the value of the simpleMatching property.
*
* @param value
* allowed object is
* {@link SimpleMatching }
*
*/
public void setSimpleMatching(SimpleMatching value) {
this.simpleMatching = value;
}
/**
* Gets the value of the jaccard property.
*
* @return
* possible object is
* {@link Jaccard }
*
*/
public Jaccard getJaccard() {
return jaccard;
}
/**
* Sets the value of the jaccard property.
*
* @param value
* allowed object is
* {@link Jaccard }
*
*/
public void setJaccard(Jaccard value) {
this.jaccard = value;
}
/**
* Gets the value of the tanimoto property.
*
* @return
* possible object is
* {@link Tanimoto }
*
*/
public Tanimoto getTanimoto() {
return tanimoto;
}
/**
* Sets the value of the tanimoto property.
*
* @param value
* allowed object is
* {@link Tanimoto }
*
*/
public void setTanimoto(Tanimoto value) {
this.tanimoto = value;
}
/**
* Gets the value of the binarySimilarity property.
*
* @return
* possible object is
* {@link BinarySimilarity }
*
*/
public BinarySimilarity getBinarySimilarity() {
return binarySimilarity;
}
/**
* Sets the value of the binarySimilarity property.
*
* @param value
* allowed object is
* {@link BinarySimilarity }
*
*/
public void setBinarySimilarity(BinarySimilarity value) {
this.binarySimilarity = value;
}
/**
* Gets the value of the compareFunction property.
*
* @return
* possible object is
* {@link COMPAREFUNCTION }
*
*/
public COMPAREFUNCTION getCompareFunction() {
if (compareFunction == null) {
return COMPAREFUNCTION.ABS_DIFF;
} else {
return compareFunction;
}
}
/**
* Sets the value of the compareFunction property.
*
* @param value
* allowed object is
* {@link COMPAREFUNCTION }
*
*/
public void setCompareFunction(COMPAREFUNCTION value) {
this.compareFunction = value;
}
/**
* Gets the value of the kind property.
*
* @return
* possible object is
* {@link String }
*
*/
public String getKind() {
return kind;
}
/**
* Sets the value of the kind property.
*
* @param value
* allowed object is
* {@link String }
*
*/
public void setKind(String value) {
this.kind = value;
}
/**
* Gets the value of the maximum property.
*
* @return
* possible object is
* {@link Double }
*
*/
public Double getMaximum() {
return maximum;
}
/**
* Sets the value of the maximum property.
*
* @param value
* allowed object is
* {@link Double }
*
*/
public void setMaximum(Double value) {
this.maximum = value;
}
/**
* Gets the value of the minimum property.
*
* @return
* possible object is
* {@link Double }
*
*/
public Double getMinimum() {
return minimum;
}
/**
* Sets the value of the minimum property.
*
* @param value
* allowed object is
* {@link Double }
*
*/
public void setMinimum(Double value) {
this.minimum = value;
}
}
|
0
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml/jaxbbindings/Comparisons.java
|
//
// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.0-b52-fcs
// See <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a>
// Any modifications to this file will be lost upon recompilation of the source schema.
// Generated on: 2013.12.20 at 12:48:21 PM GMT
//
package weka.core.pmml.jaxbbindings;
import java.util.ArrayList;
import java.util.List;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlType;
/**
* <p>Java class for Comparisons element declaration.
*
* <p>The following schema fragment specifies the expected content contained within this class.
*
* <pre>
* <element name="Comparisons">
* <complexType>
* <complexContent>
* <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
* <sequence>
* <element ref="{http://www.dmg.org/PMML-4_1}Extension" maxOccurs="unbounded" minOccurs="0"/>
* <element ref="{http://www.dmg.org/PMML-4_1}Matrix"/>
* </sequence>
* </restriction>
* </complexContent>
* </complexType>
* </element>
* </pre>
*
*
*/
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "", propOrder = {
"extension",
"matrix"
})
@XmlRootElement(name = "Comparisons")
public class Comparisons {
@XmlElement(name = "Extension", namespace = "http://www.dmg.org/PMML-4_1", required = true)
protected List<Extension> extension;
@XmlElement(name = "Matrix", namespace = "http://www.dmg.org/PMML-4_1", required = true)
protected Matrix matrix;
/**
* Gets the value of the extension property.
*
* <p>
* This accessor method returns a reference to the live list,
* not a snapshot. Therefore any modification you make to the
* returned list will be present inside the JAXB object.
* This is why there is not a <CODE>set</CODE> method for the extension property.
*
* <p>
* For example, to add a new item, do as follows:
* <pre>
* getExtension().add(newItem);
* </pre>
*
*
* <p>
* Objects of the following type(s) are allowed in the list
* {@link Extension }
*
*
*/
public List<Extension> getExtension() {
if (extension == null) {
extension = new ArrayList<Extension>();
}
return this.extension;
}
/**
* Gets the value of the matrix property.
*
* @return
* possible object is
* {@link Matrix }
*
*/
public Matrix getMatrix() {
return matrix;
}
/**
* Sets the value of the matrix property.
*
* @param value
* allowed object is
* {@link Matrix }
*
*/
public void setMatrix(Matrix value) {
this.matrix = value;
}
}
|
0
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml/jaxbbindings/CompoundPredicate.java
|
//
// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.0-b52-fcs
// See <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a>
// Any modifications to this file will be lost upon recompilation of the source schema.
// Generated on: 2013.12.20 at 12:48:21 PM GMT
//
package weka.core.pmml.jaxbbindings;
import java.util.ArrayList;
import java.util.List;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlElements;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlType;
/**
* <p>Java class for CompoundPredicate element declaration.
*
* <p>The following schema fragment specifies the expected content contained within this class.
*
* <pre>
* <element name="CompoundPredicate">
* <complexType>
* <complexContent>
* <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
* <sequence>
* <element ref="{http://www.dmg.org/PMML-4_1}Extension" maxOccurs="unbounded" minOccurs="0"/>
* <sequence maxOccurs="unbounded" minOccurs="2">
* <group ref="{http://www.dmg.org/PMML-4_1}PREDICATE"/>
* </sequence>
* </sequence>
* <attribute name="booleanOperator" use="required">
* <simpleType>
* <restriction base="{http://www.w3.org/2001/XMLSchema}string">
* <enumeration value="or"/>
* <enumeration value="and"/>
* <enumeration value="xor"/>
* <enumeration value="surrogate"/>
* </restriction>
* </simpleType>
* </attribute>
* </restriction>
* </complexContent>
* </complexType>
* </element>
* </pre>
*
*
*/
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "", propOrder = {
"extension",
"simplePredicateOrCompoundPredicateOrSimpleSetPredicate"
})
@XmlRootElement(name = "CompoundPredicate")
public class CompoundPredicate {
@XmlElement(name = "Extension", namespace = "http://www.dmg.org/PMML-4_1", required = true)
protected List<Extension> extension;
@XmlElements({
@XmlElement(name = "SimpleSetPredicate", namespace = "http://www.dmg.org/PMML-4_1", required = true, type = SimpleSetPredicate.class),
@XmlElement(name = "SimplePredicate", namespace = "http://www.dmg.org/PMML-4_1", required = true, type = SimplePredicate.class),
@XmlElement(name = "False", namespace = "http://www.dmg.org/PMML-4_1", required = true, type = False.class),
@XmlElement(name = "True", namespace = "http://www.dmg.org/PMML-4_1", required = true, type = True.class),
@XmlElement(name = "CompoundPredicate", namespace = "http://www.dmg.org/PMML-4_1", required = true, type = CompoundPredicate.class)
})
protected List<Object> simplePredicateOrCompoundPredicateOrSimpleSetPredicate;
@XmlAttribute(required = true)
protected String booleanOperator;
/**
* Gets the value of the extension property.
*
* <p>
* This accessor method returns a reference to the live list,
* not a snapshot. Therefore any modification you make to the
* returned list will be present inside the JAXB object.
* This is why there is not a <CODE>set</CODE> method for the extension property.
*
* <p>
* For example, to add a new item, do as follows:
* <pre>
* getExtension().add(newItem);
* </pre>
*
*
* <p>
* Objects of the following type(s) are allowed in the list
* {@link Extension }
*
*
*/
public List<Extension> getExtension() {
if (extension == null) {
extension = new ArrayList<Extension>();
}
return this.extension;
}
/**
* Gets the value of the simplePredicateOrCompoundPredicateOrSimpleSetPredicate property.
*
* <p>
* This accessor method returns a reference to the live list,
* not a snapshot. Therefore any modification you make to the
* returned list will be present inside the JAXB object.
* This is why there is not a <CODE>set</CODE> method for the simplePredicateOrCompoundPredicateOrSimpleSetPredicate property.
*
* <p>
* For example, to add a new item, do as follows:
* <pre>
* getSimplePredicateOrCompoundPredicateOrSimpleSetPredicate().add(newItem);
* </pre>
*
*
* <p>
* Objects of the following type(s) are allowed in the list
* {@link SimpleSetPredicate }
* {@link SimplePredicate }
* {@link False }
* {@link True }
* {@link CompoundPredicate }
*
*
*/
public List<Object> getSimplePredicateOrCompoundPredicateOrSimpleSetPredicate() {
if (simplePredicateOrCompoundPredicateOrSimpleSetPredicate == null) {
simplePredicateOrCompoundPredicateOrSimpleSetPredicate = new ArrayList<Object>();
}
return this.simplePredicateOrCompoundPredicateOrSimpleSetPredicate;
}
/**
* Gets the value of the booleanOperator property.
*
* @return
* possible object is
* {@link String }
*
*/
public String getBooleanOperator() {
return booleanOperator;
}
/**
* Sets the value of the booleanOperator property.
*
* @param value
* allowed object is
* {@link String }
*
*/
public void setBooleanOperator(String value) {
this.booleanOperator = value;
}
}
|
0
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml/jaxbbindings/CompoundRule.java
|
//
// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.0-b52-fcs
// See <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a>
// Any modifications to this file will be lost upon recompilation of the source schema.
// Generated on: 2013.12.20 at 12:48:21 PM GMT
//
package weka.core.pmml.jaxbbindings;
import java.util.ArrayList;
import java.util.List;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlElements;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlType;
/**
* <p>Java class for CompoundRule element declaration.
*
* <p>The following schema fragment specifies the expected content contained within this class.
*
* <pre>
* <element name="CompoundRule">
* <complexType>
* <complexContent>
* <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
* <sequence>
* <element ref="{http://www.dmg.org/PMML-4_1}Extension" maxOccurs="unbounded" minOccurs="0"/>
* <group ref="{http://www.dmg.org/PMML-4_1}PREDICATE"/>
* <group ref="{http://www.dmg.org/PMML-4_1}Rule" maxOccurs="unbounded"/>
* </sequence>
* </restriction>
* </complexContent>
* </complexType>
* </element>
* </pre>
*
*
*/
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "", propOrder = {
"extension",
"simplePredicate",
"compoundPredicate",
"simpleSetPredicate",
"_true",
"_false",
"rule"
})
@XmlRootElement(name = "CompoundRule")
public class CompoundRule {
@XmlElement(name = "Extension", namespace = "http://www.dmg.org/PMML-4_1", required = true)
protected List<Extension> extension;
@XmlElement(name = "SimplePredicate", namespace = "http://www.dmg.org/PMML-4_1")
protected SimplePredicate simplePredicate;
@XmlElement(name = "CompoundPredicate", namespace = "http://www.dmg.org/PMML-4_1")
protected CompoundPredicate compoundPredicate;
@XmlElement(name = "SimpleSetPredicate", namespace = "http://www.dmg.org/PMML-4_1")
protected SimpleSetPredicate simpleSetPredicate;
@XmlElement(name = "True", namespace = "http://www.dmg.org/PMML-4_1")
protected True _true;
@XmlElement(name = "False", namespace = "http://www.dmg.org/PMML-4_1")
protected False _false;
@XmlElements({
@XmlElement(name = "CompoundRule", namespace = "http://www.dmg.org/PMML-4_1", required = true, type = CompoundRule.class),
@XmlElement(name = "SimpleRule", namespace = "http://www.dmg.org/PMML-4_1", required = true, type = SimpleRule.class)
})
protected List<Object> rule;
/**
* Gets the value of the extension property.
*
* <p>
* This accessor method returns a reference to the live list,
* not a snapshot. Therefore any modification you make to the
* returned list will be present inside the JAXB object.
* This is why there is not a <CODE>set</CODE> method for the extension property.
*
* <p>
* For example, to add a new item, do as follows:
* <pre>
* getExtension().add(newItem);
* </pre>
*
*
* <p>
* Objects of the following type(s) are allowed in the list
* {@link Extension }
*
*
*/
public List<Extension> getExtension() {
if (extension == null) {
extension = new ArrayList<Extension>();
}
return this.extension;
}
/**
* Gets the value of the simplePredicate property.
*
* @return
* possible object is
* {@link SimplePredicate }
*
*/
public SimplePredicate getSimplePredicate() {
return simplePredicate;
}
/**
* Sets the value of the simplePredicate property.
*
* @param value
* allowed object is
* {@link SimplePredicate }
*
*/
public void setSimplePredicate(SimplePredicate value) {
this.simplePredicate = value;
}
/**
* Gets the value of the compoundPredicate property.
*
* @return
* possible object is
* {@link CompoundPredicate }
*
*/
public CompoundPredicate getCompoundPredicate() {
return compoundPredicate;
}
/**
* Sets the value of the compoundPredicate property.
*
* @param value
* allowed object is
* {@link CompoundPredicate }
*
*/
public void setCompoundPredicate(CompoundPredicate value) {
this.compoundPredicate = value;
}
/**
* Gets the value of the simpleSetPredicate property.
*
* @return
* possible object is
* {@link SimpleSetPredicate }
*
*/
public SimpleSetPredicate getSimpleSetPredicate() {
return simpleSetPredicate;
}
/**
* Sets the value of the simpleSetPredicate property.
*
* @param value
* allowed object is
* {@link SimpleSetPredicate }
*
*/
public void setSimpleSetPredicate(SimpleSetPredicate value) {
this.simpleSetPredicate = value;
}
/**
* Gets the value of the true property.
*
* @return
* possible object is
* {@link True }
*
*/
public True getTrue() {
return _true;
}
/**
* Sets the value of the true property.
*
* @param value
* allowed object is
* {@link True }
*
*/
public void setTrue(True value) {
this._true = value;
}
/**
* Gets the value of the false property.
*
* @return
* possible object is
* {@link False }
*
*/
public False getFalse() {
return _false;
}
/**
* Sets the value of the false property.
*
* @param value
* allowed object is
* {@link False }
*
*/
public void setFalse(False value) {
this._false = value;
}
/**
* Gets the value of the rule property.
*
* <p>
* This accessor method returns a reference to the live list,
* not a snapshot. Therefore any modification you make to the
* returned list will be present inside the JAXB object.
* This is why there is not a <CODE>set</CODE> method for the rule property.
*
* <p>
* For example, to add a new item, do as follows:
* <pre>
* getRule().add(newItem);
* </pre>
*
*
* <p>
* Objects of the following type(s) are allowed in the list
* {@link CompoundRule }
* {@link SimpleRule }
*
*
*/
public List<Object> getRule() {
if (rule == null) {
rule = new ArrayList<Object>();
}
return this.rule;
}
}
|
0
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml/jaxbbindings/Con1.java
|
//
// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.0-b52-fcs
// See <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a>
// Any modifications to this file will be lost upon recompilation of the source schema.
// Generated on: 2013.12.20 at 12:48:21 PM GMT
//
package weka.core.pmml.jaxbbindings;
import java.util.ArrayList;
import java.util.List;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlType;
/**
* <p>
* Java class for Con element declaration.
*
* <p>
* The following schema fragment specifies the expected content contained within
* this class.
*
* <pre>
* <element name="Con">
* <complexType>
* <complexContent>
* <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
* <sequence>
* <element ref="{http://www.dmg.org/PMML-4_1}Extension" maxOccurs="unbounded" minOccurs="0"/>
* </sequence>
* <attribute name="from" use="required" type="{http://www.dmg.org/PMML-4_1}NN-NEURON-IDREF" />
* <attribute name="weight" use="required" type="{http://www.dmg.org/PMML-4_1}REAL-NUMBER" />
* </restriction>
* </complexContent>
* </complexType>
* </element>
* </pre>
*
*
*/
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "", propOrder = { "extension" })
// Note - this auto-generated class has been renamed from Con.java to Con1.java
// because Con is a reserved name under Windows!
@XmlRootElement(name = "Con")
public class Con1 {
@XmlElement(name = "Extension", namespace = "http://www.dmg.org/PMML-4_1", required = true)
protected List<Extension> extension;
@XmlAttribute(required = true)
protected String from;
@XmlAttribute(required = true)
protected double weight;
/**
* Gets the value of the extension property.
*
* <p>
* This accessor method returns a reference to the live list, not a snapshot.
* Therefore any modification you make to the returned list will be present
* inside the JAXB object. This is why there is not a <CODE>set</CODE> method
* for the extension property.
*
* <p>
* For example, to add a new item, do as follows:
*
* <pre>
* getExtension().add(newItem);
* </pre>
*
*
* <p>
* Objects of the following type(s) are allowed in the list {@link Extension }
*
*
*/
public List<Extension> getExtension() {
if (extension == null) {
extension = new ArrayList<Extension>();
}
return this.extension;
}
/**
* Gets the value of the from property.
*
* @return possible object is {@link String }
*
*/
public String getFrom() {
return from;
}
/**
* Sets the value of the from property.
*
* @param value allowed object is {@link String }
*
*/
public void setFrom(String value) {
this.from = value;
}
/**
* Gets the value of the weight property.
*
*/
public double getWeight() {
return weight;
}
/**
* Sets the value of the weight property.
*
*/
public void setWeight(double value) {
this.weight = value;
}
}
|
0
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml/jaxbbindings/ConfusionMatrix.java
|
//
// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.0-b52-fcs
// See <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a>
// Any modifications to this file will be lost upon recompilation of the source schema.
// Generated on: 2013.12.20 at 12:48:21 PM GMT
//
package weka.core.pmml.jaxbbindings;
import java.util.ArrayList;
import java.util.List;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlType;
/**
* <p>Java class for ConfusionMatrix element declaration.
*
* <p>The following schema fragment specifies the expected content contained within this class.
*
* <pre>
* <element name="ConfusionMatrix">
* <complexType>
* <complexContent>
* <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
* <sequence>
* <element ref="{http://www.dmg.org/PMML-4_1}Extension" maxOccurs="unbounded" minOccurs="0"/>
* <element ref="{http://www.dmg.org/PMML-4_1}ClassLabels"/>
* <element ref="{http://www.dmg.org/PMML-4_1}Matrix"/>
* </sequence>
* </restriction>
* </complexContent>
* </complexType>
* </element>
* </pre>
*
*
*/
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "", propOrder = {
"extension",
"classLabels",
"matrix"
})
@XmlRootElement(name = "ConfusionMatrix")
public class ConfusionMatrix {
@XmlElement(name = "Extension", namespace = "http://www.dmg.org/PMML-4_1", required = true)
protected List<Extension> extension;
@XmlElement(name = "ClassLabels", namespace = "http://www.dmg.org/PMML-4_1", required = true)
protected ClassLabels classLabels;
@XmlElement(name = "Matrix", namespace = "http://www.dmg.org/PMML-4_1", required = true)
protected Matrix matrix;
/**
* Gets the value of the extension property.
*
* <p>
* This accessor method returns a reference to the live list,
* not a snapshot. Therefore any modification you make to the
* returned list will be present inside the JAXB object.
* This is why there is not a <CODE>set</CODE> method for the extension property.
*
* <p>
* For example, to add a new item, do as follows:
* <pre>
* getExtension().add(newItem);
* </pre>
*
*
* <p>
* Objects of the following type(s) are allowed in the list
* {@link Extension }
*
*
*/
public List<Extension> getExtension() {
if (extension == null) {
extension = new ArrayList<Extension>();
}
return this.extension;
}
/**
* Gets the value of the classLabels property.
*
* @return
* possible object is
* {@link ClassLabels }
*
*/
public ClassLabels getClassLabels() {
return classLabels;
}
/**
* Sets the value of the classLabels property.
*
* @param value
* allowed object is
* {@link ClassLabels }
*
*/
public void setClassLabels(ClassLabels value) {
this.classLabels = value;
}
/**
* Gets the value of the matrix property.
*
* @return
* possible object is
* {@link Matrix }
*
*/
public Matrix getMatrix() {
return matrix;
}
/**
* Sets the value of the matrix property.
*
* @param value
* allowed object is
* {@link Matrix }
*
*/
public void setMatrix(Matrix value) {
this.matrix = value;
}
}
|
0
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml/jaxbbindings/ConsequentSequence.java
|
//
// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.0-b52-fcs
// See <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a>
// Any modifications to this file will be lost upon recompilation of the source schema.
// Generated on: 2013.12.20 at 12:48:21 PM GMT
//
package weka.core.pmml.jaxbbindings;
import java.util.ArrayList;
import java.util.List;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlType;
/**
* <p>Java class for ConsequentSequence element declaration.
*
* <p>The following schema fragment specifies the expected content contained within this class.
*
* <pre>
* <element name="ConsequentSequence">
* <complexType>
* <complexContent>
* <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
* <sequence>
* <group ref="{http://www.dmg.org/PMML-4_1}SEQUENCE"/>
* </sequence>
* </restriction>
* </complexContent>
* </complexType>
* </element>
* </pre>
*
*
*/
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "", propOrder = {
"extension",
"sequenceReference",
"time"
})
@XmlRootElement(name = "ConsequentSequence")
public class ConsequentSequence {
@XmlElement(name = "Extension", namespace = "http://www.dmg.org/PMML-4_1", required = true)
protected List<Extension> extension;
@XmlElement(name = "SequenceReference", namespace = "http://www.dmg.org/PMML-4_1", required = true)
protected SequenceReference sequenceReference;
@XmlElement(name = "Time", namespace = "http://www.dmg.org/PMML-4_1")
protected Time time;
/**
* Gets the value of the extension property.
*
* <p>
* This accessor method returns a reference to the live list,
* not a snapshot. Therefore any modification you make to the
* returned list will be present inside the JAXB object.
* This is why there is not a <CODE>set</CODE> method for the extension property.
*
* <p>
* For example, to add a new item, do as follows:
* <pre>
* getExtension().add(newItem);
* </pre>
*
*
* <p>
* Objects of the following type(s) are allowed in the list
* {@link Extension }
*
*
*/
public List<Extension> getExtension() {
if (extension == null) {
extension = new ArrayList<Extension>();
}
return this.extension;
}
/**
* Gets the value of the sequenceReference property.
*
* @return
* possible object is
* {@link SequenceReference }
*
*/
public SequenceReference getSequenceReference() {
return sequenceReference;
}
/**
* Sets the value of the sequenceReference property.
*
* @param value
* allowed object is
* {@link SequenceReference }
*
*/
public void setSequenceReference(SequenceReference value) {
this.sequenceReference = value;
}
/**
* Gets the value of the time property.
*
* @return
* possible object is
* {@link Time }
*
*/
public Time getTime() {
return time;
}
/**
* Sets the value of the time property.
*
* @param value
* allowed object is
* {@link Time }
*
*/
public void setTime(Time value) {
this.time = value;
}
}
|
0
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml/jaxbbindings/Constant.java
|
//
// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.0-b52-fcs
// See <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a>
// Any modifications to this file will be lost upon recompilation of the source schema.
// Generated on: 2013.12.20 at 12:48:21 PM GMT
//
package weka.core.pmml.jaxbbindings;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlType;
import javax.xml.bind.annotation.XmlValue;
/**
* <p>Java class for Constant element declaration.
*
* <p>The following schema fragment specifies the expected content contained within this class.
*
* <pre>
* <element name="Constant">
* <complexType>
* <simpleContent>
* <extension base="<http://www.w3.org/2001/XMLSchema>string">
* <attribute name="dataType" type="{http://www.dmg.org/PMML-4_1}DATATYPE" />
* </extension>
* </simpleContent>
* </complexType>
* </element>
* </pre>
*
*
*/
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "", propOrder = {
"value"
})
@XmlRootElement(name = "Constant")
public class Constant {
@XmlValue
protected String value;
@XmlAttribute
protected DATATYPE dataType;
/**
* Gets the value of the value property.
*
* @return
* possible object is
* {@link String }
*
*/
public String getValue() {
return value;
}
/**
* Sets the value of the value property.
*
* @param value
* allowed object is
* {@link String }
*
*/
public void setValue(String value) {
this.value = value;
}
/**
* Gets the value of the dataType property.
*
* @return
* possible object is
* {@link DATATYPE }
*
*/
public DATATYPE getDataType() {
return dataType;
}
/**
* Sets the value of the dataType property.
*
* @param value
* allowed object is
* {@link DATATYPE }
*
*/
public void setDataType(DATATYPE value) {
this.dataType = value;
}
}
|
0
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml/jaxbbindings/Constraints.java
|
//
// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.0-b52-fcs
// See <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a>
// Any modifications to this file will be lost upon recompilation of the source schema.
// Generated on: 2013.12.20 at 12:48:21 PM GMT
//
package weka.core.pmml.jaxbbindings;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.List;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlType;
/**
* <p>Java class for Constraints element declaration.
*
* <p>The following schema fragment specifies the expected content contained within this class.
*
* <pre>
* <element name="Constraints">
* <complexType>
* <complexContent>
* <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
* <sequence>
* <element ref="{http://www.dmg.org/PMML-4_1}Extension" maxOccurs="unbounded" minOccurs="0"/>
* </sequence>
* <attribute name="maximumAntConsSeparationTime" type="{http://www.dmg.org/PMML-4_1}REAL-NUMBER" />
* <attribute name="maximumItemsetSeparationTime" type="{http://www.dmg.org/PMML-4_1}REAL-NUMBER" />
* <attribute name="maximumNumberOfAntecedentItems" type="{http://www.dmg.org/PMML-4_1}INT-NUMBER" />
* <attribute name="maximumNumberOfConsequentItems" type="{http://www.dmg.org/PMML-4_1}INT-NUMBER" />
* <attribute name="maximumNumberOfItems" type="{http://www.dmg.org/PMML-4_1}INT-NUMBER" />
* <attribute name="maximumTotalSequenceTime" type="{http://www.dmg.org/PMML-4_1}REAL-NUMBER" />
* <attribute name="minimumAntConsSeparationTime" type="{http://www.dmg.org/PMML-4_1}REAL-NUMBER" default="0" />
* <attribute name="minimumConfidence" type="{http://www.dmg.org/PMML-4_1}REAL-NUMBER" default="0" />
* <attribute name="minimumItemsetSeparationTime" type="{http://www.dmg.org/PMML-4_1}REAL-NUMBER" default="0" />
* <attribute name="minimumLift" type="{http://www.dmg.org/PMML-4_1}REAL-NUMBER" default="0" />
* <attribute name="minimumNumberOfAntecedentItems" type="{http://www.dmg.org/PMML-4_1}INT-NUMBER" default="1" />
* <attribute name="minimumNumberOfConsequentItems" type="{http://www.dmg.org/PMML-4_1}INT-NUMBER" default="1" />
* <attribute name="minimumNumberOfItems" type="{http://www.dmg.org/PMML-4_1}INT-NUMBER" default="1" />
* <attribute name="minimumSupport" type="{http://www.dmg.org/PMML-4_1}REAL-NUMBER" default="0" />
* <attribute name="minimumTotalSequenceTime" type="{http://www.dmg.org/PMML-4_1}REAL-NUMBER" default="0" />
* </restriction>
* </complexContent>
* </complexType>
* </element>
* </pre>
*
*
*/
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "", propOrder = {
"extension"
})
@XmlRootElement(name = "Constraints")
public class Constraints {
@XmlElement(name = "Extension", namespace = "http://www.dmg.org/PMML-4_1", required = true)
protected List<Extension> extension;
@XmlAttribute
protected Double maximumAntConsSeparationTime;
@XmlAttribute
protected Double maximumItemsetSeparationTime;
@XmlAttribute
protected BigInteger maximumNumberOfAntecedentItems;
@XmlAttribute
protected BigInteger maximumNumberOfConsequentItems;
@XmlAttribute
protected BigInteger maximumNumberOfItems;
@XmlAttribute
protected Double maximumTotalSequenceTime;
@XmlAttribute
protected Double minimumAntConsSeparationTime;
@XmlAttribute
protected Double minimumConfidence;
@XmlAttribute
protected Double minimumItemsetSeparationTime;
@XmlAttribute
protected Double minimumLift;
@XmlAttribute
protected BigInteger minimumNumberOfAntecedentItems;
@XmlAttribute
protected BigInteger minimumNumberOfConsequentItems;
@XmlAttribute
protected BigInteger minimumNumberOfItems;
@XmlAttribute
protected Double minimumSupport;
@XmlAttribute
protected Double minimumTotalSequenceTime;
/**
* Gets the value of the extension property.
*
* <p>
* This accessor method returns a reference to the live list,
* not a snapshot. Therefore any modification you make to the
* returned list will be present inside the JAXB object.
* This is why there is not a <CODE>set</CODE> method for the extension property.
*
* <p>
* For example, to add a new item, do as follows:
* <pre>
* getExtension().add(newItem);
* </pre>
*
*
* <p>
* Objects of the following type(s) are allowed in the list
* {@link Extension }
*
*
*/
public List<Extension> getExtension() {
if (extension == null) {
extension = new ArrayList<Extension>();
}
return this.extension;
}
/**
* Gets the value of the maximumAntConsSeparationTime property.
*
* @return
* possible object is
* {@link Double }
*
*/
public Double getMaximumAntConsSeparationTime() {
return maximumAntConsSeparationTime;
}
/**
* Sets the value of the maximumAntConsSeparationTime property.
*
* @param value
* allowed object is
* {@link Double }
*
*/
public void setMaximumAntConsSeparationTime(Double value) {
this.maximumAntConsSeparationTime = value;
}
/**
* Gets the value of the maximumItemsetSeparationTime property.
*
* @return
* possible object is
* {@link Double }
*
*/
public Double getMaximumItemsetSeparationTime() {
return maximumItemsetSeparationTime;
}
/**
* Sets the value of the maximumItemsetSeparationTime property.
*
* @param value
* allowed object is
* {@link Double }
*
*/
public void setMaximumItemsetSeparationTime(Double value) {
this.maximumItemsetSeparationTime = value;
}
/**
* Gets the value of the maximumNumberOfAntecedentItems property.
*
* @return
* possible object is
* {@link BigInteger }
*
*/
public BigInteger getMaximumNumberOfAntecedentItems() {
return maximumNumberOfAntecedentItems;
}
/**
* Sets the value of the maximumNumberOfAntecedentItems property.
*
* @param value
* allowed object is
* {@link BigInteger }
*
*/
public void setMaximumNumberOfAntecedentItems(BigInteger value) {
this.maximumNumberOfAntecedentItems = value;
}
/**
* Gets the value of the maximumNumberOfConsequentItems property.
*
* @return
* possible object is
* {@link BigInteger }
*
*/
public BigInteger getMaximumNumberOfConsequentItems() {
return maximumNumberOfConsequentItems;
}
/**
* Sets the value of the maximumNumberOfConsequentItems property.
*
* @param value
* allowed object is
* {@link BigInteger }
*
*/
public void setMaximumNumberOfConsequentItems(BigInteger value) {
this.maximumNumberOfConsequentItems = value;
}
/**
* Gets the value of the maximumNumberOfItems property.
*
* @return
* possible object is
* {@link BigInteger }
*
*/
public BigInteger getMaximumNumberOfItems() {
return maximumNumberOfItems;
}
/**
* Sets the value of the maximumNumberOfItems property.
*
* @param value
* allowed object is
* {@link BigInteger }
*
*/
public void setMaximumNumberOfItems(BigInteger value) {
this.maximumNumberOfItems = value;
}
/**
* Gets the value of the maximumTotalSequenceTime property.
*
* @return
* possible object is
* {@link Double }
*
*/
public Double getMaximumTotalSequenceTime() {
return maximumTotalSequenceTime;
}
/**
* Sets the value of the maximumTotalSequenceTime property.
*
* @param value
* allowed object is
* {@link Double }
*
*/
public void setMaximumTotalSequenceTime(Double value) {
this.maximumTotalSequenceTime = value;
}
/**
* Gets the value of the minimumAntConsSeparationTime property.
*
* @return
* possible object is
* {@link Double }
*
*/
public double getMinimumAntConsSeparationTime() {
if (minimumAntConsSeparationTime == null) {
return 0.0D;
} else {
return minimumAntConsSeparationTime;
}
}
/**
* Sets the value of the minimumAntConsSeparationTime property.
*
* @param value
* allowed object is
* {@link Double }
*
*/
public void setMinimumAntConsSeparationTime(Double value) {
this.minimumAntConsSeparationTime = value;
}
/**
* Gets the value of the minimumConfidence property.
*
* @return
* possible object is
* {@link Double }
*
*/
public double getMinimumConfidence() {
if (minimumConfidence == null) {
return 0.0D;
} else {
return minimumConfidence;
}
}
/**
* Sets the value of the minimumConfidence property.
*
* @param value
* allowed object is
* {@link Double }
*
*/
public void setMinimumConfidence(Double value) {
this.minimumConfidence = value;
}
/**
* Gets the value of the minimumItemsetSeparationTime property.
*
* @return
* possible object is
* {@link Double }
*
*/
public double getMinimumItemsetSeparationTime() {
if (minimumItemsetSeparationTime == null) {
return 0.0D;
} else {
return minimumItemsetSeparationTime;
}
}
/**
* Sets the value of the minimumItemsetSeparationTime property.
*
* @param value
* allowed object is
* {@link Double }
*
*/
public void setMinimumItemsetSeparationTime(Double value) {
this.minimumItemsetSeparationTime = value;
}
/**
* Gets the value of the minimumLift property.
*
* @return
* possible object is
* {@link Double }
*
*/
public double getMinimumLift() {
if (minimumLift == null) {
return 0.0D;
} else {
return minimumLift;
}
}
/**
* Sets the value of the minimumLift property.
*
* @param value
* allowed object is
* {@link Double }
*
*/
public void setMinimumLift(Double value) {
this.minimumLift = value;
}
/**
* Gets the value of the minimumNumberOfAntecedentItems property.
*
* @return
* possible object is
* {@link BigInteger }
*
*/
public BigInteger getMinimumNumberOfAntecedentItems() {
if (minimumNumberOfAntecedentItems == null) {
return new BigInteger("1");
} else {
return minimumNumberOfAntecedentItems;
}
}
/**
* Sets the value of the minimumNumberOfAntecedentItems property.
*
* @param value
* allowed object is
* {@link BigInteger }
*
*/
public void setMinimumNumberOfAntecedentItems(BigInteger value) {
this.minimumNumberOfAntecedentItems = value;
}
/**
* Gets the value of the minimumNumberOfConsequentItems property.
*
* @return
* possible object is
* {@link BigInteger }
*
*/
public BigInteger getMinimumNumberOfConsequentItems() {
if (minimumNumberOfConsequentItems == null) {
return new BigInteger("1");
} else {
return minimumNumberOfConsequentItems;
}
}
/**
* Sets the value of the minimumNumberOfConsequentItems property.
*
* @param value
* allowed object is
* {@link BigInteger }
*
*/
public void setMinimumNumberOfConsequentItems(BigInteger value) {
this.minimumNumberOfConsequentItems = value;
}
/**
* Gets the value of the minimumNumberOfItems property.
*
* @return
* possible object is
* {@link BigInteger }
*
*/
public BigInteger getMinimumNumberOfItems() {
if (minimumNumberOfItems == null) {
return new BigInteger("1");
} else {
return minimumNumberOfItems;
}
}
/**
* Sets the value of the minimumNumberOfItems property.
*
* @param value
* allowed object is
* {@link BigInteger }
*
*/
public void setMinimumNumberOfItems(BigInteger value) {
this.minimumNumberOfItems = value;
}
/**
* Gets the value of the minimumSupport property.
*
* @return
* possible object is
* {@link Double }
*
*/
public double getMinimumSupport() {
if (minimumSupport == null) {
return 0.0D;
} else {
return minimumSupport;
}
}
/**
* Sets the value of the minimumSupport property.
*
* @param value
* allowed object is
* {@link Double }
*
*/
public void setMinimumSupport(Double value) {
this.minimumSupport = value;
}
/**
* Gets the value of the minimumTotalSequenceTime property.
*
* @return
* possible object is
* {@link Double }
*
*/
public double getMinimumTotalSequenceTime() {
if (minimumTotalSequenceTime == null) {
return 0.0D;
} else {
return minimumTotalSequenceTime;
}
}
/**
* Sets the value of the minimumTotalSequenceTime property.
*
* @param value
* allowed object is
* {@link Double }
*
*/
public void setMinimumTotalSequenceTime(Double value) {
this.minimumTotalSequenceTime = value;
}
}
|
0
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml/jaxbbindings/ContStats.java
|
//
// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.0-b52-fcs
// See <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a>
// Any modifications to this file will be lost upon recompilation of the source schema.
// Generated on: 2013.12.20 at 12:48:21 PM GMT
//
package weka.core.pmml.jaxbbindings;
import java.util.ArrayList;
import java.util.List;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlType;
/**
* <p>Java class for ContStats element declaration.
*
* <p>The following schema fragment specifies the expected content contained within this class.
*
* <pre>
* <element name="ContStats">
* <complexType>
* <complexContent>
* <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
* <sequence>
* <element ref="{http://www.dmg.org/PMML-4_1}Extension" maxOccurs="unbounded" minOccurs="0"/>
* <element ref="{http://www.dmg.org/PMML-4_1}Interval" maxOccurs="unbounded" minOccurs="0"/>
* <group ref="{http://www.dmg.org/PMML-4_1}FrequenciesType" minOccurs="0"/>
* </sequence>
* <attribute name="totalSquaresSum" type="{http://www.dmg.org/PMML-4_1}NUMBER" />
* <attribute name="totalValuesSum" type="{http://www.dmg.org/PMML-4_1}NUMBER" />
* </restriction>
* </complexContent>
* </complexType>
* </element>
* </pre>
*
*
*/
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "", propOrder = {
"extension",
"interval",
"numarray"
})
@XmlRootElement(name = "ContStats")
public class ContStats {
@XmlElement(name = "Extension", namespace = "http://www.dmg.org/PMML-4_1", required = true)
protected List<Extension> extension;
@XmlElement(name = "Interval", namespace = "http://www.dmg.org/PMML-4_1", required = true)
protected List<Interval> interval;
@XmlElement(name = "Array", namespace = "http://www.dmg.org/PMML-4_1", required = true)
protected List<ArrayType> numarray;
@XmlAttribute
protected Double totalSquaresSum;
@XmlAttribute
protected Double totalValuesSum;
/**
* Gets the value of the extension property.
*
* <p>
* This accessor method returns a reference to the live list,
* not a snapshot. Therefore any modification you make to the
* returned list will be present inside the JAXB object.
* This is why there is not a <CODE>set</CODE> method for the extension property.
*
* <p>
* For example, to add a new item, do as follows:
* <pre>
* getExtension().add(newItem);
* </pre>
*
*
* <p>
* Objects of the following type(s) are allowed in the list
* {@link Extension }
*
*
*/
public List<Extension> getExtension() {
if (extension == null) {
extension = new ArrayList<Extension>();
}
return this.extension;
}
/**
* Gets the value of the interval property.
*
* <p>
* This accessor method returns a reference to the live list,
* not a snapshot. Therefore any modification you make to the
* returned list will be present inside the JAXB object.
* This is why there is not a <CODE>set</CODE> method for the interval property.
*
* <p>
* For example, to add a new item, do as follows:
* <pre>
* getInterval().add(newItem);
* </pre>
*
*
* <p>
* Objects of the following type(s) are allowed in the list
* {@link Interval }
*
*
*/
public List<Interval> getInterval() {
if (interval == null) {
interval = new ArrayList<Interval>();
}
return this.interval;
}
/**
* Gets the value of the numarray property.
*
* <p>
* This accessor method returns a reference to the live list,
* not a snapshot. Therefore any modification you make to the
* returned list will be present inside the JAXB object.
* This is why there is not a <CODE>set</CODE> method for the numarray property.
*
* <p>
* For example, to add a new item, do as follows:
* <pre>
* getNUMARRAY().add(newItem);
* </pre>
*
*
* <p>
* Objects of the following type(s) are allowed in the list
* {@link ArrayType }
*
*
*/
public List<ArrayType> getNUMARRAY() {
if (numarray == null) {
numarray = new ArrayList<ArrayType>();
}
return this.numarray;
}
/**
* Gets the value of the totalSquaresSum property.
*
* @return
* possible object is
* {@link Double }
*
*/
public Double getTotalSquaresSum() {
return totalSquaresSum;
}
/**
* Sets the value of the totalSquaresSum property.
*
* @param value
* allowed object is
* {@link Double }
*
*/
public void setTotalSquaresSum(Double value) {
this.totalSquaresSum = value;
}
/**
* Gets the value of the totalValuesSum property.
*
* @return
* possible object is
* {@link Double }
*
*/
public Double getTotalValuesSum() {
return totalValuesSum;
}
/**
* Sets the value of the totalValuesSum property.
*
* @param value
* allowed object is
* {@link Double }
*
*/
public void setTotalValuesSum(Double value) {
this.totalValuesSum = value;
}
}
|
0
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml/jaxbbindings/CorrelationFields.java
|
//
// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.0-b52-fcs
// See <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a>
// Any modifications to this file will be lost upon recompilation of the source schema.
// Generated on: 2013.12.20 at 12:48:21 PM GMT
//
package weka.core.pmml.jaxbbindings;
import java.util.ArrayList;
import java.util.List;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlType;
/**
* <p>Java class for CorrelationFields element declaration.
*
* <p>The following schema fragment specifies the expected content contained within this class.
*
* <pre>
* <element name="CorrelationFields">
* <complexType>
* <complexContent>
* <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
* <sequence>
* <element ref="{http://www.dmg.org/PMML-4_1}Extension" maxOccurs="unbounded" minOccurs="0"/>
* <group ref="{http://www.dmg.org/PMML-4_1}STRING-ARRAY"/>
* </sequence>
* </restriction>
* </complexContent>
* </complexType>
* </element>
* </pre>
*
*
*/
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "", propOrder = {
"extension",
"array"
})
@XmlRootElement(name = "CorrelationFields")
public class CorrelationFields {
@XmlElement(name = "Extension", namespace = "http://www.dmg.org/PMML-4_1", required = true)
protected List<Extension> extension;
@XmlElement(name = "Array", namespace = "http://www.dmg.org/PMML-4_1")
protected ArrayType array;
/**
* Gets the value of the extension property.
*
* <p>
* This accessor method returns a reference to the live list,
* not a snapshot. Therefore any modification you make to the
* returned list will be present inside the JAXB object.
* This is why there is not a <CODE>set</CODE> method for the extension property.
*
* <p>
* For example, to add a new item, do as follows:
* <pre>
* getExtension().add(newItem);
* </pre>
*
*
* <p>
* Objects of the following type(s) are allowed in the list
* {@link Extension }
*
*
*/
public List<Extension> getExtension() {
if (extension == null) {
extension = new ArrayList<Extension>();
}
return this.extension;
}
/**
* Gets the value of the array property.
*
* @return
* possible object is
* {@link ArrayType }
*
*/
public ArrayType getArray() {
return array;
}
/**
* Sets the value of the array property.
*
* @param value
* allowed object is
* {@link ArrayType }
*
*/
public void setArray(ArrayType value) {
this.array = value;
}
}
|
0
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml/jaxbbindings/CorrelationMethods.java
|
//
// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.0-b52-fcs
// See <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a>
// Any modifications to this file will be lost upon recompilation of the source schema.
// Generated on: 2013.12.20 at 12:48:21 PM GMT
//
package weka.core.pmml.jaxbbindings;
import java.util.ArrayList;
import java.util.List;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlType;
/**
* <p>Java class for CorrelationMethods element declaration.
*
* <p>The following schema fragment specifies the expected content contained within this class.
*
* <pre>
* <element name="CorrelationMethods">
* <complexType>
* <complexContent>
* <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
* <sequence>
* <element ref="{http://www.dmg.org/PMML-4_1}Extension" maxOccurs="unbounded" minOccurs="0"/>
* <element ref="{http://www.dmg.org/PMML-4_1}Matrix"/>
* </sequence>
* </restriction>
* </complexContent>
* </complexType>
* </element>
* </pre>
*
*
*/
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "", propOrder = {
"extension",
"matrix"
})
@XmlRootElement(name = "CorrelationMethods")
public class CorrelationMethods {
@XmlElement(name = "Extension", namespace = "http://www.dmg.org/PMML-4_1", required = true)
protected List<Extension> extension;
@XmlElement(name = "Matrix", namespace = "http://www.dmg.org/PMML-4_1", required = true)
protected Matrix matrix;
/**
* Gets the value of the extension property.
*
* <p>
* This accessor method returns a reference to the live list,
* not a snapshot. Therefore any modification you make to the
* returned list will be present inside the JAXB object.
* This is why there is not a <CODE>set</CODE> method for the extension property.
*
* <p>
* For example, to add a new item, do as follows:
* <pre>
* getExtension().add(newItem);
* </pre>
*
*
* <p>
* Objects of the following type(s) are allowed in the list
* {@link Extension }
*
*
*/
public List<Extension> getExtension() {
if (extension == null) {
extension = new ArrayList<Extension>();
}
return this.extension;
}
/**
* Gets the value of the matrix property.
*
* @return
* possible object is
* {@link Matrix }
*
*/
public Matrix getMatrix() {
return matrix;
}
/**
* Sets the value of the matrix property.
*
* @param value
* allowed object is
* {@link Matrix }
*
*/
public void setMatrix(Matrix value) {
this.matrix = value;
}
}
|
0
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml/jaxbbindings/CorrelationValues.java
|
//
// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.0-b52-fcs
// See <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a>
// Any modifications to this file will be lost upon recompilation of the source schema.
// Generated on: 2013.12.20 at 12:48:21 PM GMT
//
package weka.core.pmml.jaxbbindings;
import java.util.ArrayList;
import java.util.List;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlType;
/**
* <p>Java class for CorrelationValues element declaration.
*
* <p>The following schema fragment specifies the expected content contained within this class.
*
* <pre>
* <element name="CorrelationValues">
* <complexType>
* <complexContent>
* <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
* <sequence>
* <element ref="{http://www.dmg.org/PMML-4_1}Extension" maxOccurs="unbounded" minOccurs="0"/>
* <element ref="{http://www.dmg.org/PMML-4_1}Matrix"/>
* </sequence>
* </restriction>
* </complexContent>
* </complexType>
* </element>
* </pre>
*
*
*/
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "", propOrder = {
"extension",
"matrix"
})
@XmlRootElement(name = "CorrelationValues")
public class CorrelationValues {
@XmlElement(name = "Extension", namespace = "http://www.dmg.org/PMML-4_1", required = true)
protected List<Extension> extension;
@XmlElement(name = "Matrix", namespace = "http://www.dmg.org/PMML-4_1", required = true)
protected Matrix matrix;
/**
* Gets the value of the extension property.
*
* <p>
* This accessor method returns a reference to the live list,
* not a snapshot. Therefore any modification you make to the
* returned list will be present inside the JAXB object.
* This is why there is not a <CODE>set</CODE> method for the extension property.
*
* <p>
* For example, to add a new item, do as follows:
* <pre>
* getExtension().add(newItem);
* </pre>
*
*
* <p>
* Objects of the following type(s) are allowed in the list
* {@link Extension }
*
*
*/
public List<Extension> getExtension() {
if (extension == null) {
extension = new ArrayList<Extension>();
}
return this.extension;
}
/**
* Gets the value of the matrix property.
*
* @return
* possible object is
* {@link Matrix }
*
*/
public Matrix getMatrix() {
return matrix;
}
/**
* Sets the value of the matrix property.
*
* @param value
* allowed object is
* {@link Matrix }
*
*/
public void setMatrix(Matrix value) {
this.matrix = value;
}
}
|
0
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml/jaxbbindings/Correlations.java
|
//
// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.0-b52-fcs
// See <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a>
// Any modifications to this file will be lost upon recompilation of the source schema.
// Generated on: 2013.12.20 at 12:48:21 PM GMT
//
package weka.core.pmml.jaxbbindings;
import java.util.ArrayList;
import java.util.List;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlType;
/**
* <p>Java class for Correlations element declaration.
*
* <p>The following schema fragment specifies the expected content contained within this class.
*
* <pre>
* <element name="Correlations">
* <complexType>
* <complexContent>
* <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
* <sequence>
* <element ref="{http://www.dmg.org/PMML-4_1}Extension" maxOccurs="unbounded" minOccurs="0"/>
* <element ref="{http://www.dmg.org/PMML-4_1}CorrelationFields"/>
* <element ref="{http://www.dmg.org/PMML-4_1}CorrelationValues"/>
* <element ref="{http://www.dmg.org/PMML-4_1}CorrelationMethods" minOccurs="0"/>
* </sequence>
* </restriction>
* </complexContent>
* </complexType>
* </element>
* </pre>
*
*
*/
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "", propOrder = {
"extension",
"correlationFields",
"correlationValues",
"correlationMethods"
})
@XmlRootElement(name = "Correlations")
public class Correlations {
@XmlElement(name = "Extension", namespace = "http://www.dmg.org/PMML-4_1", required = true)
protected List<Extension> extension;
@XmlElement(name = "CorrelationFields", namespace = "http://www.dmg.org/PMML-4_1", required = true)
protected CorrelationFields correlationFields;
@XmlElement(name = "CorrelationValues", namespace = "http://www.dmg.org/PMML-4_1", required = true)
protected CorrelationValues correlationValues;
@XmlElement(name = "CorrelationMethods", namespace = "http://www.dmg.org/PMML-4_1")
protected CorrelationMethods correlationMethods;
/**
* Gets the value of the extension property.
*
* <p>
* This accessor method returns a reference to the live list,
* not a snapshot. Therefore any modification you make to the
* returned list will be present inside the JAXB object.
* This is why there is not a <CODE>set</CODE> method for the extension property.
*
* <p>
* For example, to add a new item, do as follows:
* <pre>
* getExtension().add(newItem);
* </pre>
*
*
* <p>
* Objects of the following type(s) are allowed in the list
* {@link Extension }
*
*
*/
public List<Extension> getExtension() {
if (extension == null) {
extension = new ArrayList<Extension>();
}
return this.extension;
}
/**
* Gets the value of the correlationFields property.
*
* @return
* possible object is
* {@link CorrelationFields }
*
*/
public CorrelationFields getCorrelationFields() {
return correlationFields;
}
/**
* Sets the value of the correlationFields property.
*
* @param value
* allowed object is
* {@link CorrelationFields }
*
*/
public void setCorrelationFields(CorrelationFields value) {
this.correlationFields = value;
}
/**
* Gets the value of the correlationValues property.
*
* @return
* possible object is
* {@link CorrelationValues }
*
*/
public CorrelationValues getCorrelationValues() {
return correlationValues;
}
/**
* Sets the value of the correlationValues property.
*
* @param value
* allowed object is
* {@link CorrelationValues }
*
*/
public void setCorrelationValues(CorrelationValues value) {
this.correlationValues = value;
}
/**
* Gets the value of the correlationMethods property.
*
* @return
* possible object is
* {@link CorrelationMethods }
*
*/
public CorrelationMethods getCorrelationMethods() {
return correlationMethods;
}
/**
* Sets the value of the correlationMethods property.
*
* @param value
* allowed object is
* {@link CorrelationMethods }
*
*/
public void setCorrelationMethods(CorrelationMethods value) {
this.correlationMethods = value;
}
}
|
0
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml/jaxbbindings/Counts.java
|
//
// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.0-b52-fcs
// See <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a>
// Any modifications to this file will be lost upon recompilation of the source schema.
// Generated on: 2013.12.20 at 12:48:21 PM GMT
//
package weka.core.pmml.jaxbbindings;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.List;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlType;
/**
* <p>Java class for Counts element declaration.
*
* <p>The following schema fragment specifies the expected content contained within this class.
*
* <pre>
* <element name="Counts">
* <complexType>
* <complexContent>
* <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
* <sequence>
* <element ref="{http://www.dmg.org/PMML-4_1}Extension" maxOccurs="unbounded" minOccurs="0"/>
* </sequence>
* <attribute name="cardinality" type="{http://www.w3.org/2001/XMLSchema}nonNegativeInteger" />
* <attribute name="invalidFreq" type="{http://www.dmg.org/PMML-4_1}NUMBER" />
* <attribute name="missingFreq" type="{http://www.dmg.org/PMML-4_1}NUMBER" />
* <attribute name="totalFreq" use="required" type="{http://www.dmg.org/PMML-4_1}NUMBER" />
* </restriction>
* </complexContent>
* </complexType>
* </element>
* </pre>
*
*
*/
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "", propOrder = {
"extension"
})
@XmlRootElement(name = "Counts")
public class Counts {
@XmlElement(name = "Extension", namespace = "http://www.dmg.org/PMML-4_1", required = true)
protected List<Extension> extension;
@XmlAttribute
protected BigInteger cardinality;
@XmlAttribute
protected Double invalidFreq;
@XmlAttribute
protected Double missingFreq;
@XmlAttribute(required = true)
protected double totalFreq;
/**
* Gets the value of the extension property.
*
* <p>
* This accessor method returns a reference to the live list,
* not a snapshot. Therefore any modification you make to the
* returned list will be present inside the JAXB object.
* This is why there is not a <CODE>set</CODE> method for the extension property.
*
* <p>
* For example, to add a new item, do as follows:
* <pre>
* getExtension().add(newItem);
* </pre>
*
*
* <p>
* Objects of the following type(s) are allowed in the list
* {@link Extension }
*
*
*/
public List<Extension> getExtension() {
if (extension == null) {
extension = new ArrayList<Extension>();
}
return this.extension;
}
/**
* Gets the value of the cardinality property.
*
* @return
* possible object is
* {@link BigInteger }
*
*/
public BigInteger getCardinality() {
return cardinality;
}
/**
* Sets the value of the cardinality property.
*
* @param value
* allowed object is
* {@link BigInteger }
*
*/
public void setCardinality(BigInteger value) {
this.cardinality = value;
}
/**
* Gets the value of the invalidFreq property.
*
* @return
* possible object is
* {@link Double }
*
*/
public Double getInvalidFreq() {
return invalidFreq;
}
/**
* Sets the value of the invalidFreq property.
*
* @param value
* allowed object is
* {@link Double }
*
*/
public void setInvalidFreq(Double value) {
this.invalidFreq = value;
}
/**
* Gets the value of the missingFreq property.
*
* @return
* possible object is
* {@link Double }
*
*/
public Double getMissingFreq() {
return missingFreq;
}
/**
* Sets the value of the missingFreq property.
*
* @param value
* allowed object is
* {@link Double }
*
*/
public void setMissingFreq(Double value) {
this.missingFreq = value;
}
/**
* Gets the value of the totalFreq property.
*
*/
public double getTotalFreq() {
return totalFreq;
}
/**
* Sets the value of the totalFreq property.
*
*/
public void setTotalFreq(double value) {
this.totalFreq = value;
}
}
|
0
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml/jaxbbindings/Covariances.java
|
//
// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.0-b52-fcs
// See <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a>
// Any modifications to this file will be lost upon recompilation of the source schema.
// Generated on: 2013.12.20 at 12:48:21 PM GMT
//
package weka.core.pmml.jaxbbindings;
import java.util.ArrayList;
import java.util.List;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlType;
/**
* <p>Java class for Covariances element declaration.
*
* <p>The following schema fragment specifies the expected content contained within this class.
*
* <pre>
* <element name="Covariances">
* <complexType>
* <complexContent>
* <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
* <sequence>
* <element ref="{http://www.dmg.org/PMML-4_1}Extension" maxOccurs="unbounded" minOccurs="0"/>
* <element ref="{http://www.dmg.org/PMML-4_1}Matrix"/>
* </sequence>
* </restriction>
* </complexContent>
* </complexType>
* </element>
* </pre>
*
*
*/
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "", propOrder = {
"extension",
"matrix"
})
@XmlRootElement(name = "Covariances")
public class Covariances {
@XmlElement(name = "Extension", namespace = "http://www.dmg.org/PMML-4_1", required = true)
protected List<Extension> extension;
@XmlElement(name = "Matrix", namespace = "http://www.dmg.org/PMML-4_1", required = true)
protected Matrix matrix;
/**
* Gets the value of the extension property.
*
* <p>
* This accessor method returns a reference to the live list,
* not a snapshot. Therefore any modification you make to the
* returned list will be present inside the JAXB object.
* This is why there is not a <CODE>set</CODE> method for the extension property.
*
* <p>
* For example, to add a new item, do as follows:
* <pre>
* getExtension().add(newItem);
* </pre>
*
*
* <p>
* Objects of the following type(s) are allowed in the list
* {@link Extension }
*
*
*/
public List<Extension> getExtension() {
if (extension == null) {
extension = new ArrayList<Extension>();
}
return this.extension;
}
/**
* Gets the value of the matrix property.
*
* @return
* possible object is
* {@link Matrix }
*
*/
public Matrix getMatrix() {
return matrix;
}
/**
* Sets the value of the matrix property.
*
* @param value
* allowed object is
* {@link Matrix }
*
*/
public void setMatrix(Matrix value) {
this.matrix = value;
}
}
|
0
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml/jaxbbindings/CovariateList.java
|
//
// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.0-b52-fcs
// See <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a>
// Any modifications to this file will be lost upon recompilation of the source schema.
// Generated on: 2013.12.20 at 12:48:21 PM GMT
//
package weka.core.pmml.jaxbbindings;
import java.util.ArrayList;
import java.util.List;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlType;
/**
* <p>Java class for CovariateList element declaration.
*
* <p>The following schema fragment specifies the expected content contained within this class.
*
* <pre>
* <element name="CovariateList">
* <complexType>
* <complexContent>
* <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
* <sequence>
* <element ref="{http://www.dmg.org/PMML-4_1}Extension" maxOccurs="unbounded" minOccurs="0"/>
* <element ref="{http://www.dmg.org/PMML-4_1}Predictor" maxOccurs="unbounded" minOccurs="0"/>
* </sequence>
* </restriction>
* </complexContent>
* </complexType>
* </element>
* </pre>
*
*
*/
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "", propOrder = {
"extension",
"predictor"
})
@XmlRootElement(name = "CovariateList")
public class CovariateList {
@XmlElement(name = "Extension", namespace = "http://www.dmg.org/PMML-4_1", required = true)
protected List<Extension> extension;
@XmlElement(name = "Predictor", namespace = "http://www.dmg.org/PMML-4_1", required = true)
protected List<Predictor> predictor;
/**
* Gets the value of the extension property.
*
* <p>
* This accessor method returns a reference to the live list,
* not a snapshot. Therefore any modification you make to the
* returned list will be present inside the JAXB object.
* This is why there is not a <CODE>set</CODE> method for the extension property.
*
* <p>
* For example, to add a new item, do as follows:
* <pre>
* getExtension().add(newItem);
* </pre>
*
*
* <p>
* Objects of the following type(s) are allowed in the list
* {@link Extension }
*
*
*/
public List<Extension> getExtension() {
if (extension == null) {
extension = new ArrayList<Extension>();
}
return this.extension;
}
/**
* Gets the value of the predictor property.
*
* <p>
* This accessor method returns a reference to the live list,
* not a snapshot. Therefore any modification you make to the
* returned list will be present inside the JAXB object.
* This is why there is not a <CODE>set</CODE> method for the predictor property.
*
* <p>
* For example, to add a new item, do as follows:
* <pre>
* getPredictor().add(newItem);
* </pre>
*
*
* <p>
* Objects of the following type(s) are allowed in the list
* {@link Predictor }
*
*
*/
public List<Predictor> getPredictor() {
if (predictor == null) {
predictor = new ArrayList<Predictor>();
}
return this.predictor;
}
}
|
0
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml/jaxbbindings/DATATYPE.java
|
//
// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.0-b52-fcs
// See <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a>
// Any modifications to this file will be lost upon recompilation of the source schema.
// Generated on: 2013.12.20 at 12:48:21 PM GMT
//
package weka.core.pmml.jaxbbindings;
import javax.xml.bind.annotation.XmlEnum;
import javax.xml.bind.annotation.XmlEnumValue;
/**
* <p>Java class for DATATYPE.
*
* <p>The following schema fragment specifies the expected content contained within this class.
* <p>
* <pre>
* <simpleType name="DATATYPE">
* <restriction base="{http://www.w3.org/2001/XMLSchema}string">
* <enumeration value="string"/>
* <enumeration value="integer"/>
* <enumeration value="float"/>
* <enumeration value="double"/>
* <enumeration value="boolean"/>
* <enumeration value="date"/>
* <enumeration value="time"/>
* <enumeration value="dateTime"/>
* <enumeration value="dateDaysSince[0]"/>
* <enumeration value="dateDaysSince[1960]"/>
* <enumeration value="dateDaysSince[1970]"/>
* <enumeration value="dateDaysSince[1980]"/>
* <enumeration value="timeSeconds"/>
* <enumeration value="dateTimeSecondsSince[0]"/>
* <enumeration value="dateTimeSecondsSince[1960]"/>
* <enumeration value="dateTimeSecondsSince[1970]"/>
* <enumeration value="dateTimeSecondsSince[1980]"/>
* </restriction>
* </simpleType>
* </pre>
*
*/
@XmlEnum
public enum DATATYPE {
@XmlEnumValue("boolean")
BOOLEAN("boolean"),
@XmlEnumValue("date")
DATE("date"),
@XmlEnumValue("dateDaysSince[0]")
DATE_DAYS_SINCE_0("dateDaysSince[0]"),
@XmlEnumValue("dateDaysSince[1960]")
DATE_DAYS_SINCE_1960("dateDaysSince[1960]"),
@XmlEnumValue("dateDaysSince[1970]")
DATE_DAYS_SINCE_1970("dateDaysSince[1970]"),
@XmlEnumValue("dateDaysSince[1980]")
DATE_DAYS_SINCE_1980("dateDaysSince[1980]"),
@XmlEnumValue("dateTime")
DATE_TIME("dateTime"),
@XmlEnumValue("dateTimeSecondsSince[0]")
DATE_TIME_SECONDS_SINCE_0("dateTimeSecondsSince[0]"),
@XmlEnumValue("dateTimeSecondsSince[1960]")
DATE_TIME_SECONDS_SINCE_1960("dateTimeSecondsSince[1960]"),
@XmlEnumValue("dateTimeSecondsSince[1970]")
DATE_TIME_SECONDS_SINCE_1970("dateTimeSecondsSince[1970]"),
@XmlEnumValue("dateTimeSecondsSince[1980]")
DATE_TIME_SECONDS_SINCE_1980("dateTimeSecondsSince[1980]"),
@XmlEnumValue("double")
DOUBLE("double"),
@XmlEnumValue("float")
FLOAT("float"),
@XmlEnumValue("integer")
INTEGER("integer"),
@XmlEnumValue("string")
STRING("string"),
@XmlEnumValue("time")
TIME("time"),
@XmlEnumValue("timeSeconds")
TIME_SECONDS("timeSeconds");
private final String value;
DATATYPE(String v) {
value = v;
}
public String value() {
return value;
}
public static DATATYPE fromValue(String v) {
for (DATATYPE c: DATATYPE.values()) {
if (c.value.equals(v)) {
return c;
}
}
throw new IllegalArgumentException(v.toString());
}
}
|
0
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml/jaxbbindings/DELIMITER2.java
|
//
// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.0-b52-fcs
// See <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a>
// Any modifications to this file will be lost upon recompilation of the source schema.
// Generated on: 2013.12.20 at 12:48:21 PM GMT
//
package weka.core.pmml.jaxbbindings;
import javax.xml.bind.annotation.XmlEnum;
import javax.xml.bind.annotation.XmlEnumValue;
/**
* <p>Java class for DELIMITER.
*
* <p>The following schema fragment specifies the expected content contained within this class.
* <p>
* <pre>
* <simpleType name="DELIMITER">
* <restriction base="{http://www.w3.org/2001/XMLSchema}string">
* <enumeration value="sameTimeWindow"/>
* <enumeration value="acrossTimeWindows"/>
* </restriction>
* </simpleType>
* </pre>
*
*/
@XmlEnum
public enum DELIMITER2 {
@XmlEnumValue("acrossTimeWindows")
ACROSS_TIME_WINDOWS("acrossTimeWindows"),
@XmlEnumValue("sameTimeWindow")
SAME_TIME_WINDOW("sameTimeWindow");
private final String value;
DELIMITER2(String v) {
value = v;
}
public String value() {
return value;
}
public static DELIMITER2 fromValue(String v) {
for (DELIMITER2 c: DELIMITER2.values()) {
if (c.value.equals(v)) {
return c;
}
}
throw new IllegalArgumentException(v.toString());
}
}
|
0
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml/jaxbbindings/DataDictionary.java
|
//
// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.0-b52-fcs
// See <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a>
// Any modifications to this file will be lost upon recompilation of the source schema.
// Generated on: 2013.12.20 at 12:48:21 PM GMT
//
package weka.core.pmml.jaxbbindings;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.List;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlType;
/**
* <p>Java class for DataDictionary element declaration.
*
* <p>The following schema fragment specifies the expected content contained within this class.
*
* <pre>
* <element name="DataDictionary">
* <complexType>
* <complexContent>
* <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
* <sequence>
* <element ref="{http://www.dmg.org/PMML-4_1}Extension" maxOccurs="unbounded" minOccurs="0"/>
* <element ref="{http://www.dmg.org/PMML-4_1}DataField" maxOccurs="unbounded"/>
* <element ref="{http://www.dmg.org/PMML-4_1}Taxonomy" maxOccurs="unbounded" minOccurs="0"/>
* </sequence>
* <attribute name="numberOfFields" type="{http://www.w3.org/2001/XMLSchema}nonNegativeInteger" />
* </restriction>
* </complexContent>
* </complexType>
* </element>
* </pre>
*
*
*/
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "", propOrder = {
"extension",
"dataField",
"taxonomy"
})
@XmlRootElement(name = "DataDictionary")
public class DataDictionary {
@XmlElement(name = "Extension", namespace = "http://www.dmg.org/PMML-4_1", required = true)
protected List<Extension> extension;
@XmlElement(name = "DataField", namespace = "http://www.dmg.org/PMML-4_1", required = true)
protected List<DataField> dataField;
@XmlElement(name = "Taxonomy", namespace = "http://www.dmg.org/PMML-4_1", required = true)
protected List<Taxonomy> taxonomy;
@XmlAttribute
protected BigInteger numberOfFields;
/**
* Gets the value of the extension property.
*
* <p>
* This accessor method returns a reference to the live list,
* not a snapshot. Therefore any modification you make to the
* returned list will be present inside the JAXB object.
* This is why there is not a <CODE>set</CODE> method for the extension property.
*
* <p>
* For example, to add a new item, do as follows:
* <pre>
* getExtension().add(newItem);
* </pre>
*
*
* <p>
* Objects of the following type(s) are allowed in the list
* {@link Extension }
*
*
*/
public List<Extension> getExtension() {
if (extension == null) {
extension = new ArrayList<Extension>();
}
return this.extension;
}
/**
* Gets the value of the dataField property.
*
* <p>
* This accessor method returns a reference to the live list,
* not a snapshot. Therefore any modification you make to the
* returned list will be present inside the JAXB object.
* This is why there is not a <CODE>set</CODE> method for the dataField property.
*
* <p>
* For example, to add a new item, do as follows:
* <pre>
* getDataField().add(newItem);
* </pre>
*
*
* <p>
* Objects of the following type(s) are allowed in the list
* {@link DataField }
*
*/
public List<DataField> getDataFields() {
if (dataField == null) {
dataField = new ArrayList<DataField>();
}
return this.dataField;
}
public void addDataField(DataField field) {
if (dataField == null) {
dataField = new ArrayList<DataField>();
}
dataField.add(field);
}
/**
* Gets the value of the taxonomy property.
*
* <p>
* This accessor method returns a reference to the live list,
* not a snapshot. Therefore any modification you make to the
* returned list will be present inside the JAXB object.
* This is why there is not a <CODE>set</CODE> method for the taxonomy property.
*
* <p>
* For example, to add a new item, do as follows:
* <pre>
* getTaxonomy().add(newItem);
* </pre>
*
*
* <p>
* Objects of the following type(s) are allowed in the list
* {@link Taxonomy }
*
*
*/
public List<Taxonomy> getTaxonomy() {
if (taxonomy == null) {
taxonomy = new ArrayList<Taxonomy>();
}
return this.taxonomy;
}
/**
* Gets the value of the numberOfFields property.
*
* @return
* possible object is
* {@link BigInteger }
*
*/
public BigInteger getNumberOfFields() {
return numberOfFields;
}
/**
* Sets the value of the numberOfFields property.
*
* @param value
* allowed object is
* {@link BigInteger }
*
*/
public void setNumberOfFields(BigInteger value) {
this.numberOfFields = value;
}
}
|
0
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml/jaxbbindings/DataField.java
|
//
// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.0-b52-fcs
// See <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a>
// Any modifications to this file will be lost upon recompilation of the source schema.
// Generated on: 2013.12.20 at 12:48:21 PM GMT
//
package weka.core.pmml.jaxbbindings;
import java.util.ArrayList;
import java.util.List;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlType;
/**
* <p>Java class for DataField element declaration.
*
* <p>The following schema fragment specifies the expected content contained within this class.
*
* <pre>
* <element name="DataField">
* <complexType>
* <complexContent>
* <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
* <sequence>
* <element ref="{http://www.dmg.org/PMML-4_1}Extension" maxOccurs="unbounded" minOccurs="0"/>
* <sequence>
* <element ref="{http://www.dmg.org/PMML-4_1}Interval" maxOccurs="unbounded" minOccurs="0"/>
* <element ref="{http://www.dmg.org/PMML-4_1}Value" maxOccurs="unbounded" minOccurs="0"/>
* </sequence>
* </sequence>
* <attribute name="dataType" use="required" type="{http://www.dmg.org/PMML-4_1}DATATYPE" />
* <attribute name="displayName" type="{http://www.w3.org/2001/XMLSchema}string" />
* <attribute name="isCyclic" default="0">
* <simpleType>
* <restriction base="{http://www.w3.org/2001/XMLSchema}string">
* <enumeration value="0"/>
* <enumeration value="1"/>
* </restriction>
* </simpleType>
* </attribute>
* <attribute name="name" use="required" type="{http://www.dmg.org/PMML-4_1}FIELD-NAME" />
* <attribute name="optype" use="required" type="{http://www.dmg.org/PMML-4_1}OPTYPE" />
* <attribute name="taxonomy" type="{http://www.w3.org/2001/XMLSchema}string" />
* </restriction>
* </complexContent>
* </complexType>
* </element>
* </pre>
*
*
*/
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "", propOrder = {
"extension",
"interval",
"value"
})
@XmlRootElement(name = "DataField")
public class DataField {
@XmlElement(name = "Extension", namespace = "http://www.dmg.org/PMML-4_1", required = true)
protected List<Extension> extension;
@XmlElement(name = "Interval", namespace = "http://www.dmg.org/PMML-4_1", required = true)
protected List<Interval> interval;
@XmlElement(name = "Value", namespace = "http://www.dmg.org/PMML-4_1", required = true)
protected List<Value> value;
@XmlAttribute(required = true)
protected DATATYPE dataType;
@XmlAttribute
protected String displayName;
@XmlAttribute
protected String isCyclic;
@XmlAttribute(required = true)
protected String name;
@XmlAttribute(required = true)
protected OPTYPE optype;
@XmlAttribute
protected String taxonomy;
public DataField() {}
public DataField(String name, OPTYPE optype) {
this.name = name;
this.optype = optype;
}
/**
* Gets the value of the extension property.
*
* <p>
* This accessor method returns a reference to the live list,
* not a snapshot. Therefore any modification you make to the
* returned list will be present inside the JAXB object.
* This is why there is not a <CODE>set</CODE> method for the extension property.
*
* <p>
* For example, to add a new item, do as follows:
* <pre>
* getExtension().add(newItem);
* </pre>
*
*
* <p>
* Objects of the following type(s) are allowed in the list
* {@link Extension }
*
*
*/
public List<Extension> getExtension() {
if (extension == null) {
extension = new ArrayList<Extension>();
}
return this.extension;
}
/**
* Gets the value of the interval property.
*
* <p>
* This accessor method returns a reference to the live list,
* not a snapshot. Therefore any modification you make to the
* returned list will be present inside the JAXB object.
* This is why there is not a <CODE>set</CODE> method for the interval property.
*
* <p>
* For example, to add a new item, do as follows:
* <pre>
* getInterval().add(newItem);
* </pre>
*
*
* <p>
* Objects of the following type(s) are allowed in the list
* {@link Interval }
*
*
*/
public List<Interval> getInterval() {
if (interval == null) {
interval = new ArrayList<Interval>();
}
return this.interval;
}
/**
* Gets the value of the value property.
*
* <p>
* This accessor method returns a reference to the live list,
* not a snapshot. Therefore any modification you make to the
* returned list will be present inside the JAXB object.
* This is why there is not a <CODE>set</CODE> method for the value property.
*
* <p>
* For example, to add a new item, do as follows:
* <pre>
* getValue().add(newItem);
* </pre>
*
*
* <p>
* Objects of the following type(s) are allowed in the list
* {@link Value }
*
*/
public List<Value> getValues() {
if (value == null) {
value = new ArrayList<Value>();
}
return this.value;
}
public void addValue(Value v) {
if (value == null) {
value = new ArrayList<Value>();
}
value.add(v);
}
/**
* Gets the value of the dataType property.
*
* @return
* possible object is
* {@link DATATYPE }
*
*/
public DATATYPE getDataType() {
return dataType;
}
/**
* Sets the value of the dataType property.
*
* @param value
* allowed object is
* {@link DATATYPE }
*
*/
public void setDataType(DATATYPE value) {
this.dataType = value;
}
/**
* Gets the value of the displayName property.
*
* @return
* possible object is
* {@link String }
*
*/
public String getDisplayName() {
return displayName;
}
/**
* Sets the value of the displayName property.
*
* @param value
* allowed object is
* {@link String }
*
*/
public void setDisplayName(String value) {
this.displayName = value;
}
/**
* Gets the value of the isCyclic property.
*
* @return
* possible object is
* {@link String }
*
*/
public String getIsCyclic() {
if (isCyclic == null) {
return "0";
} else {
return isCyclic;
}
}
/**
* Sets the value of the isCyclic property.
*
* @param value
* allowed object is
* {@link String }
*
*/
public void setIsCyclic(String value) {
this.isCyclic = value;
}
/**
* Gets the value of the name property.
*
* @return
* possible object is
* {@link String }
*
*/
public String getName() {
return name;
}
/**
* Sets the value of the name property.
*
* @param value
* allowed object is
* {@link String }
*
*/
public void setName(String value) {
this.name = value;
}
/**
* Gets the value of the optype property.
*
* @return
* possible object is
* {@link OPTYPE }
*
*/
public OPTYPE getOptype() {
return optype;
}
/**
* Sets the value of the optype property.
*
* @param value
* allowed object is
* {@link OPTYPE }
*
*/
public void setOptype(OPTYPE value) {
this.optype = value;
}
/**
* Gets the value of the taxonomy property.
*
* @return
* possible object is
* {@link String }
*
*/
public String getTaxonomy() {
return taxonomy;
}
/**
* Sets the value of the taxonomy property.
*
* @param value
* allowed object is
* {@link String }
*
*/
public void setTaxonomy(String value) {
this.taxonomy = value;
}
}
|
0
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml/jaxbbindings/Decision.java
|
//
// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.0-b52-fcs
// See <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a>
// Any modifications to this file will be lost upon recompilation of the source schema.
// Generated on: 2013.12.20 at 12:48:21 PM GMT
//
package weka.core.pmml.jaxbbindings;
import java.util.ArrayList;
import java.util.List;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlType;
/**
* <p>Java class for Decision element declaration.
*
* <p>The following schema fragment specifies the expected content contained within this class.
*
* <pre>
* <element name="Decision">
* <complexType>
* <complexContent>
* <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
* <sequence>
* <element ref="{http://www.dmg.org/PMML-4_1}Extension" maxOccurs="unbounded" minOccurs="0"/>
* </sequence>
* <attribute name="description" type="{http://www.w3.org/2001/XMLSchema}string" />
* <attribute name="displayValue" type="{http://www.w3.org/2001/XMLSchema}string" />
* <attribute name="value" use="required" type="{http://www.w3.org/2001/XMLSchema}string" />
* </restriction>
* </complexContent>
* </complexType>
* </element>
* </pre>
*
*
*/
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "", propOrder = {
"extension"
})
@XmlRootElement(name = "Decision")
public class Decision {
@XmlElement(name = "Extension", namespace = "http://www.dmg.org/PMML-4_1", required = true)
protected List<Extension> extension;
@XmlAttribute
protected String description;
@XmlAttribute
protected String displayValue;
@XmlAttribute(required = true)
protected String value;
/**
* Gets the value of the extension property.
*
* <p>
* This accessor method returns a reference to the live list,
* not a snapshot. Therefore any modification you make to the
* returned list will be present inside the JAXB object.
* This is why there is not a <CODE>set</CODE> method for the extension property.
*
* <p>
* For example, to add a new item, do as follows:
* <pre>
* getExtension().add(newItem);
* </pre>
*
*
* <p>
* Objects of the following type(s) are allowed in the list
* {@link Extension }
*
*
*/
public List<Extension> getExtension() {
if (extension == null) {
extension = new ArrayList<Extension>();
}
return this.extension;
}
/**
* Gets the value of the description property.
*
* @return
* possible object is
* {@link String }
*
*/
public String getDescription() {
return description;
}
/**
* Sets the value of the description property.
*
* @param value
* allowed object is
* {@link String }
*
*/
public void setDescription(String value) {
this.description = value;
}
/**
* Gets the value of the displayValue property.
*
* @return
* possible object is
* {@link String }
*
*/
public String getDisplayValue() {
return displayValue;
}
/**
* Sets the value of the displayValue property.
*
* @param value
* allowed object is
* {@link String }
*
*/
public void setDisplayValue(String value) {
this.displayValue = value;
}
/**
* Gets the value of the value property.
*
* @return
* possible object is
* {@link String }
*
*/
public String getValue() {
return value;
}
/**
* Sets the value of the value property.
*
* @param value
* allowed object is
* {@link String }
*
*/
public void setValue(String value) {
this.value = value;
}
}
|
0
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml/jaxbbindings/DecisionTree.java
|
//
// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.0-b52-fcs
// See <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a>
// Any modifications to this file will be lost upon recompilation of the source schema.
// Generated on: 2013.12.20 at 12:48:21 PM GMT
//
package weka.core.pmml.jaxbbindings;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlType;
/**
* <p>Java class for DecisionTree element declaration.
*
* <p>The following schema fragment specifies the expected content contained within this class.
*
* <pre>
* <element name="DecisionTree">
* <complexType>
* <complexContent>
* <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
* <sequence>
* <element ref="{http://www.dmg.org/PMML-4_1}Extension" maxOccurs="unbounded" minOccurs="0"/>
* <element ref="{http://www.dmg.org/PMML-4_1}Output" minOccurs="0"/>
* <element ref="{http://www.dmg.org/PMML-4_1}ModelStats" minOccurs="0"/>
* <element ref="{http://www.dmg.org/PMML-4_1}Targets" minOccurs="0"/>
* <element ref="{http://www.dmg.org/PMML-4_1}LocalTransformations" minOccurs="0"/>
* <element ref="{http://www.dmg.org/PMML-4_1}ResultField" maxOccurs="unbounded" minOccurs="0"/>
* <element ref="{http://www.dmg.org/PMML-4_1}Node"/>
* </sequence>
* <attribute name="algorithmName" type="{http://www.w3.org/2001/XMLSchema}string" />
* <attribute name="functionName" use="required" type="{http://www.dmg.org/PMML-4_1}MINING-FUNCTION" />
* <attribute name="missingValuePenalty" type="{http://www.dmg.org/PMML-4_1}PROB-NUMBER" default="1.0" />
* <attribute name="missingValueStrategy" type="{http://www.dmg.org/PMML-4_1}MISSING-VALUE-STRATEGY" default="none" />
* <attribute name="modelName" type="{http://www.w3.org/2001/XMLSchema}string" />
* <attribute name="noTrueChildStrategy" type="{http://www.dmg.org/PMML-4_1}NO-TRUE-CHILD-STRATEGY" default="returnNullPrediction" />
* <attribute name="splitCharacteristic" default="multiSplit">
* <simpleType>
* <restriction base="{http://www.w3.org/2001/XMLSchema}string">
* <enumeration value="binarySplit"/>
* <enumeration value="multiSplit"/>
* </restriction>
* </simpleType>
* </attribute>
* </restriction>
* </complexContent>
* </complexType>
* </element>
* </pre>
*
*
*/
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "", propOrder = {
"extension",
"output",
"modelStats",
"targets",
"localTransformations",
"resultField",
"node"
})
@XmlRootElement(name = "DecisionTree")
public class DecisionTree {
@XmlElement(name = "Extension", namespace = "http://www.dmg.org/PMML-4_1", required = true)
protected List<Extension> extension;
@XmlElement(name = "Output", namespace = "http://www.dmg.org/PMML-4_1")
protected Output output;
@XmlElement(name = "ModelStats", namespace = "http://www.dmg.org/PMML-4_1")
protected ModelStats modelStats;
@XmlElement(name = "Targets", namespace = "http://www.dmg.org/PMML-4_1")
protected Targets targets;
@XmlElement(name = "LocalTransformations", namespace = "http://www.dmg.org/PMML-4_1")
protected LocalTransformations localTransformations;
@XmlElement(name = "ResultField", namespace = "http://www.dmg.org/PMML-4_1", required = true)
protected List<ResultField> resultField;
@XmlElement(name = "Node", namespace = "http://www.dmg.org/PMML-4_1", required = true)
protected Node node;
@XmlAttribute
protected String algorithmName;
@XmlAttribute(required = true)
protected MININGFUNCTION functionName;
@XmlAttribute
protected BigDecimal missingValuePenalty;
@XmlAttribute
protected MISSINGVALUESTRATEGY missingValueStrategy;
@XmlAttribute
protected String modelName;
@XmlAttribute
protected NOTRUECHILDSTRATEGY noTrueChildStrategy;
@XmlAttribute
protected String splitCharacteristic;
/**
* Gets the value of the extension property.
*
* <p>
* This accessor method returns a reference to the live list,
* not a snapshot. Therefore any modification you make to the
* returned list will be present inside the JAXB object.
* This is why there is not a <CODE>set</CODE> method for the extension property.
*
* <p>
* For example, to add a new item, do as follows:
* <pre>
* getExtension().add(newItem);
* </pre>
*
*
* <p>
* Objects of the following type(s) are allowed in the list
* {@link Extension }
*
*
*/
public List<Extension> getExtension() {
if (extension == null) {
extension = new ArrayList<Extension>();
}
return this.extension;
}
/**
* Gets the value of the output property.
*
* @return
* possible object is
* {@link Output }
*
*/
public Output getOutput() {
return output;
}
/**
* Sets the value of the output property.
*
* @param value
* allowed object is
* {@link Output }
*
*/
public void setOutput(Output value) {
this.output = value;
}
/**
* Gets the value of the modelStats property.
*
* @return
* possible object is
* {@link ModelStats }
*
*/
public ModelStats getModelStats() {
return modelStats;
}
/**
* Sets the value of the modelStats property.
*
* @param value
* allowed object is
* {@link ModelStats }
*
*/
public void setModelStats(ModelStats value) {
this.modelStats = value;
}
/**
* Gets the value of the targets property.
*
* @return
* possible object is
* {@link Targets }
*
*/
public Targets getTargets() {
return targets;
}
/**
* Sets the value of the targets property.
*
* @param value
* allowed object is
* {@link Targets }
*
*/
public void setTargets(Targets value) {
this.targets = value;
}
/**
* Gets the value of the localTransformations property.
*
* @return
* possible object is
* {@link LocalTransformations }
*
*/
public LocalTransformations getLocalTransformations() {
return localTransformations;
}
/**
* Sets the value of the localTransformations property.
*
* @param value
* allowed object is
* {@link LocalTransformations }
*
*/
public void setLocalTransformations(LocalTransformations value) {
this.localTransformations = value;
}
/**
* Gets the value of the resultField property.
*
* <p>
* This accessor method returns a reference to the live list,
* not a snapshot. Therefore any modification you make to the
* returned list will be present inside the JAXB object.
* This is why there is not a <CODE>set</CODE> method for the resultField property.
*
* <p>
* For example, to add a new item, do as follows:
* <pre>
* getResultField().add(newItem);
* </pre>
*
*
* <p>
* Objects of the following type(s) are allowed in the list
* {@link ResultField }
*
*
*/
public List<ResultField> getResultField() {
if (resultField == null) {
resultField = new ArrayList<ResultField>();
}
return this.resultField;
}
/**
* Gets the value of the node property.
*
* @return
* possible object is
* {@link Node }
*
*/
public Node getNode() {
return node;
}
/**
* Sets the value of the node property.
*
* @param value
* allowed object is
* {@link Node }
*
*/
public void setNode(Node value) {
this.node = value;
}
/**
* Gets the value of the algorithmName property.
*
* @return
* possible object is
* {@link String }
*
*/
public String getAlgorithmName() {
return algorithmName;
}
/**
* Sets the value of the algorithmName property.
*
* @param value
* allowed object is
* {@link String }
*
*/
public void setAlgorithmName(String value) {
this.algorithmName = value;
}
/**
* Gets the value of the functionName property.
*
* @return
* possible object is
* {@link MININGFUNCTION }
*
*/
public MININGFUNCTION getFunctionName() {
return functionName;
}
/**
* Sets the value of the functionName property.
*
* @param value
* allowed object is
* {@link MININGFUNCTION }
*
*/
public void setFunctionName(MININGFUNCTION value) {
this.functionName = value;
}
/**
* Gets the value of the missingValuePenalty property.
*
* @return
* possible object is
* {@link BigDecimal }
*
*/
public BigDecimal getMissingValuePenalty() {
if (missingValuePenalty == null) {
return new BigDecimal("1.0");
} else {
return missingValuePenalty;
}
}
/**
* Sets the value of the missingValuePenalty property.
*
* @param value
* allowed object is
* {@link BigDecimal }
*
*/
public void setMissingValuePenalty(BigDecimal value) {
this.missingValuePenalty = value;
}
/**
* Gets the value of the missingValueStrategy property.
*
* @return
* possible object is
* {@link MISSINGVALUESTRATEGY }
*
*/
public MISSINGVALUESTRATEGY getMissingValueStrategy() {
if (missingValueStrategy == null) {
return MISSINGVALUESTRATEGY.NONE;
} else {
return missingValueStrategy;
}
}
/**
* Sets the value of the missingValueStrategy property.
*
* @param value
* allowed object is
* {@link MISSINGVALUESTRATEGY }
*
*/
public void setMissingValueStrategy(MISSINGVALUESTRATEGY value) {
this.missingValueStrategy = value;
}
/**
* Gets the value of the modelName property.
*
* @return
* possible object is
* {@link String }
*
*/
public String getModelName() {
return modelName;
}
/**
* Sets the value of the modelName property.
*
* @param value
* allowed object is
* {@link String }
*
*/
public void setModelName(String value) {
this.modelName = value;
}
/**
* Gets the value of the noTrueChildStrategy property.
*
* @return
* possible object is
* {@link NOTRUECHILDSTRATEGY }
*
*/
public NOTRUECHILDSTRATEGY getNoTrueChildStrategy() {
if (noTrueChildStrategy == null) {
return NOTRUECHILDSTRATEGY.RETURN_NULL_PREDICTION;
} else {
return noTrueChildStrategy;
}
}
/**
* Sets the value of the noTrueChildStrategy property.
*
* @param value
* allowed object is
* {@link NOTRUECHILDSTRATEGY }
*
*/
public void setNoTrueChildStrategy(NOTRUECHILDSTRATEGY value) {
this.noTrueChildStrategy = value;
}
/**
* Gets the value of the splitCharacteristic property.
*
* @return
* possible object is
* {@link String }
*
*/
public String getSplitCharacteristic() {
if (splitCharacteristic == null) {
return "multiSplit";
} else {
return splitCharacteristic;
}
}
/**
* Sets the value of the splitCharacteristic property.
*
* @param value
* allowed object is
* {@link String }
*
*/
public void setSplitCharacteristic(String value) {
this.splitCharacteristic = value;
}
}
|
0
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml/jaxbbindings/Decisions.java
|
//
// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.0-b52-fcs
// See <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a>
// Any modifications to this file will be lost upon recompilation of the source schema.
// Generated on: 2013.12.20 at 12:48:21 PM GMT
//
package weka.core.pmml.jaxbbindings;
import java.util.ArrayList;
import java.util.List;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlType;
/**
* <p>Java class for Decisions element declaration.
*
* <p>The following schema fragment specifies the expected content contained within this class.
*
* <pre>
* <element name="Decisions">
* <complexType>
* <complexContent>
* <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
* <sequence>
* <element ref="{http://www.dmg.org/PMML-4_1}Extension" maxOccurs="unbounded" minOccurs="0"/>
* <element ref="{http://www.dmg.org/PMML-4_1}Decision" maxOccurs="unbounded"/>
* </sequence>
* <attribute name="businessProblem" type="{http://www.w3.org/2001/XMLSchema}string" />
* <attribute name="description" type="{http://www.w3.org/2001/XMLSchema}string" />
* </restriction>
* </complexContent>
* </complexType>
* </element>
* </pre>
*
*
*/
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "", propOrder = {
"extension",
"decision"
})
@XmlRootElement(name = "Decisions")
public class Decisions {
@XmlElement(name = "Extension", namespace = "http://www.dmg.org/PMML-4_1", required = true)
protected List<Extension> extension;
@XmlElement(name = "Decision", namespace = "http://www.dmg.org/PMML-4_1", required = true)
protected List<Decision> decision;
@XmlAttribute
protected String businessProblem;
@XmlAttribute
protected String description;
/**
* Gets the value of the extension property.
*
* <p>
* This accessor method returns a reference to the live list,
* not a snapshot. Therefore any modification you make to the
* returned list will be present inside the JAXB object.
* This is why there is not a <CODE>set</CODE> method for the extension property.
*
* <p>
* For example, to add a new item, do as follows:
* <pre>
* getExtension().add(newItem);
* </pre>
*
*
* <p>
* Objects of the following type(s) are allowed in the list
* {@link Extension }
*
*
*/
public List<Extension> getExtension() {
if (extension == null) {
extension = new ArrayList<Extension>();
}
return this.extension;
}
/**
* Gets the value of the decision property.
*
* <p>
* This accessor method returns a reference to the live list,
* not a snapshot. Therefore any modification you make to the
* returned list will be present inside the JAXB object.
* This is why there is not a <CODE>set</CODE> method for the decision property.
*
* <p>
* For example, to add a new item, do as follows:
* <pre>
* getDecision().add(newItem);
* </pre>
*
*
* <p>
* Objects of the following type(s) are allowed in the list
* {@link Decision }
*
*
*/
public List<Decision> getDecision() {
if (decision == null) {
decision = new ArrayList<Decision>();
}
return this.decision;
}
/**
* Gets the value of the businessProblem property.
*
* @return
* possible object is
* {@link String }
*
*/
public String getBusinessProblem() {
return businessProblem;
}
/**
* Sets the value of the businessProblem property.
*
* @param value
* allowed object is
* {@link String }
*
*/
public void setBusinessProblem(String value) {
this.businessProblem = value;
}
/**
* Gets the value of the description property.
*
* @return
* possible object is
* {@link String }
*
*/
public String getDescription() {
return description;
}
/**
* Sets the value of the description property.
*
* @param value
* allowed object is
* {@link String }
*
*/
public void setDescription(String value) {
this.description = value;
}
}
|
0
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml/jaxbbindings/DefineFunction.java
|
//
// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.0-b52-fcs
// See <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a>
// Any modifications to this file will be lost upon recompilation of the source schema.
// Generated on: 2013.12.20 at 12:48:21 PM GMT
//
package weka.core.pmml.jaxbbindings;
import java.util.ArrayList;
import java.util.List;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlType;
/**
* <p>Java class for DefineFunction element declaration.
*
* <p>The following schema fragment specifies the expected content contained within this class.
*
* <pre>
* <element name="DefineFunction">
* <complexType>
* <complexContent>
* <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
* <sequence>
* <element ref="{http://www.dmg.org/PMML-4_1}Extension" maxOccurs="unbounded" minOccurs="0"/>
* <element ref="{http://www.dmg.org/PMML-4_1}ParameterField" maxOccurs="unbounded"/>
* <group ref="{http://www.dmg.org/PMML-4_1}EXPRESSION"/>
* </sequence>
* <attribute name="dataType" type="{http://www.dmg.org/PMML-4_1}DATATYPE" />
* <attribute name="name" use="required" type="{http://www.w3.org/2001/XMLSchema}string" />
* <attribute name="optype" use="required" type="{http://www.dmg.org/PMML-4_1}OPTYPE" />
* </restriction>
* </complexContent>
* </complexType>
* </element>
* </pre>
*
*
*/
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "", propOrder = {
"extension",
"parameterField",
"constant",
"fieldRef",
"normContinuous",
"normDiscrete",
"discretize",
"mapValues",
"apply",
"aggregate"
})
@XmlRootElement(name = "DefineFunction")
public class DefineFunction {
@XmlElement(name = "Extension", namespace = "http://www.dmg.org/PMML-4_1", required = true)
protected List<Extension> extension;
@XmlElement(name = "ParameterField", namespace = "http://www.dmg.org/PMML-4_1", required = true)
protected List<ParameterField> parameterField;
@XmlElement(name = "Constant", namespace = "http://www.dmg.org/PMML-4_1")
protected Constant constant;
@XmlElement(name = "FieldRef", namespace = "http://www.dmg.org/PMML-4_1")
protected FieldRef fieldRef;
@XmlElement(name = "NormContinuous", namespace = "http://www.dmg.org/PMML-4_1")
protected NormContinuous normContinuous;
@XmlElement(name = "NormDiscrete", namespace = "http://www.dmg.org/PMML-4_1")
protected NormDiscrete normDiscrete;
@XmlElement(name = "Discretize", namespace = "http://www.dmg.org/PMML-4_1")
protected Discretize discretize;
@XmlElement(name = "MapValues", namespace = "http://www.dmg.org/PMML-4_1")
protected MapValues mapValues;
@XmlElement(name = "Apply", namespace = "http://www.dmg.org/PMML-4_1")
protected Apply apply;
@XmlElement(name = "Aggregate", namespace = "http://www.dmg.org/PMML-4_1")
protected Aggregate aggregate;
@XmlAttribute
protected DATATYPE dataType;
@XmlAttribute(required = true)
protected String name;
@XmlAttribute(required = true)
protected OPTYPE optype;
/**
* Gets the value of the extension property.
*
* <p>
* This accessor method returns a reference to the live list,
* not a snapshot. Therefore any modification you make to the
* returned list will be present inside the JAXB object.
* This is why there is not a <CODE>set</CODE> method for the extension property.
*
* <p>
* For example, to add a new item, do as follows:
* <pre>
* getExtension().add(newItem);
* </pre>
*
*
* <p>
* Objects of the following type(s) are allowed in the list
* {@link Extension }
*
*
*/
public List<Extension> getExtension() {
if (extension == null) {
extension = new ArrayList<Extension>();
}
return this.extension;
}
/**
* Gets the value of the parameterField property.
*
* <p>
* This accessor method returns a reference to the live list,
* not a snapshot. Therefore any modification you make to the
* returned list will be present inside the JAXB object.
* This is why there is not a <CODE>set</CODE> method for the parameterField property.
*
* <p>
* For example, to add a new item, do as follows:
* <pre>
* getParameterField().add(newItem);
* </pre>
*
*
* <p>
* Objects of the following type(s) are allowed in the list
* {@link ParameterField }
*
*
*/
public List<ParameterField> getParameterField() {
if (parameterField == null) {
parameterField = new ArrayList<ParameterField>();
}
return this.parameterField;
}
/**
* Gets the value of the constant property.
*
* @return
* possible object is
* {@link Constant }
*
*/
public Constant getConstant() {
return constant;
}
/**
* Sets the value of the constant property.
*
* @param value
* allowed object is
* {@link Constant }
*
*/
public void setConstant(Constant value) {
this.constant = value;
}
/**
* Gets the value of the fieldRef property.
*
* @return
* possible object is
* {@link FieldRef }
*
*/
public FieldRef getFieldRef() {
return fieldRef;
}
/**
* Sets the value of the fieldRef property.
*
* @param value
* allowed object is
* {@link FieldRef }
*
*/
public void setFieldRef(FieldRef value) {
this.fieldRef = value;
}
/**
* Gets the value of the normContinuous property.
*
* @return
* possible object is
* {@link NormContinuous }
*
*/
public NormContinuous getNormContinuous() {
return normContinuous;
}
/**
* Sets the value of the normContinuous property.
*
* @param value
* allowed object is
* {@link NormContinuous }
*
*/
public void setNormContinuous(NormContinuous value) {
this.normContinuous = value;
}
/**
* Gets the value of the normDiscrete property.
*
* @return
* possible object is
* {@link NormDiscrete }
*
*/
public NormDiscrete getNormDiscrete() {
return normDiscrete;
}
/**
* Sets the value of the normDiscrete property.
*
* @param value
* allowed object is
* {@link NormDiscrete }
*
*/
public void setNormDiscrete(NormDiscrete value) {
this.normDiscrete = value;
}
/**
* Gets the value of the discretize property.
*
* @return
* possible object is
* {@link Discretize }
*
*/
public Discretize getDiscretize() {
return discretize;
}
/**
* Sets the value of the discretize property.
*
* @param value
* allowed object is
* {@link Discretize }
*
*/
public void setDiscretize(Discretize value) {
this.discretize = value;
}
/**
* Gets the value of the mapValues property.
*
* @return
* possible object is
* {@link MapValues }
*
*/
public MapValues getMapValues() {
return mapValues;
}
/**
* Sets the value of the mapValues property.
*
* @param value
* allowed object is
* {@link MapValues }
*
*/
public void setMapValues(MapValues value) {
this.mapValues = value;
}
/**
* Gets the value of the apply property.
*
* @return
* possible object is
* {@link Apply }
*
*/
public Apply getApply() {
return apply;
}
/**
* Sets the value of the apply property.
*
* @param value
* allowed object is
* {@link Apply }
*
*/
public void setApply(Apply value) {
this.apply = value;
}
/**
* Gets the value of the aggregate property.
*
* @return
* possible object is
* {@link Aggregate }
*
*/
public Aggregate getAggregate() {
return aggregate;
}
/**
* Sets the value of the aggregate property.
*
* @param value
* allowed object is
* {@link Aggregate }
*
*/
public void setAggregate(Aggregate value) {
this.aggregate = value;
}
/**
* Gets the value of the dataType property.
*
* @return
* possible object is
* {@link DATATYPE }
*
*/
public DATATYPE getDataType() {
return dataType;
}
/**
* Sets the value of the dataType property.
*
* @param value
* allowed object is
* {@link DATATYPE }
*
*/
public void setDataType(DATATYPE value) {
this.dataType = value;
}
/**
* Gets the value of the name property.
*
* @return
* possible object is
* {@link String }
*
*/
public String getName() {
return name;
}
/**
* Sets the value of the name property.
*
* @param value
* allowed object is
* {@link String }
*
*/
public void setName(String value) {
this.name = value;
}
/**
* Gets the value of the optype property.
*
* @return
* possible object is
* {@link OPTYPE }
*
*/
public OPTYPE getOptype() {
return optype;
}
/**
* Sets the value of the optype property.
*
* @param value
* allowed object is
* {@link OPTYPE }
*
*/
public void setOptype(OPTYPE value) {
this.optype = value;
}
}
|
0
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml/jaxbbindings/Delimiter.java
|
//
// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.0-b52-fcs
// See <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a>
// Any modifications to this file will be lost upon recompilation of the source schema.
// Generated on: 2013.12.20 at 12:48:21 PM GMT
//
package weka.core.pmml.jaxbbindings;
import java.util.ArrayList;
import java.util.List;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlType;
/**
* <p>Java class for Delimiter element declaration.
*
* <p>The following schema fragment specifies the expected content contained within this class.
*
* <pre>
* <element name="Delimiter">
* <complexType>
* <complexContent>
* <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
* <sequence>
* <element ref="{http://www.dmg.org/PMML-4_1}Extension" maxOccurs="unbounded" minOccurs="0"/>
* </sequence>
* <attribute name="delimiter" use="required" type="{http://www.dmg.org/PMML-4_1}DELIMITER" />
* <attribute name="gap" use="required" type="{http://www.dmg.org/PMML-4_1}GAP" />
* </restriction>
* </complexContent>
* </complexType>
* </element>
* </pre>
*
*
*/
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "", propOrder = {
"extension"
})
@XmlRootElement(name = "Delimiter")
public class Delimiter {
@XmlElement(name = "Extension", namespace = "http://www.dmg.org/PMML-4_1", required = true)
protected List<Extension> extension;
@XmlAttribute(required = true)
protected DELIMITER2 delimiter;
@XmlAttribute(required = true)
protected GAP gap;
/**
* Gets the value of the extension property.
*
* <p>
* This accessor method returns a reference to the live list,
* not a snapshot. Therefore any modification you make to the
* returned list will be present inside the JAXB object.
* This is why there is not a <CODE>set</CODE> method for the extension property.
*
* <p>
* For example, to add a new item, do as follows:
* <pre>
* getExtension().add(newItem);
* </pre>
*
*
* <p>
* Objects of the following type(s) are allowed in the list
* {@link Extension }
*
*
*/
public List<Extension> getExtension() {
if (extension == null) {
extension = new ArrayList<Extension>();
}
return this.extension;
}
/**
* Gets the value of the delimiter property.
*
* @return
* possible object is
* {@link DELIMITER }
*
*/
public DELIMITER2 getDelimiter() {
return delimiter;
}
/**
* Sets the value of the delimiter property.
*
* @param value
* allowed object is
* {@link DELIMITER }
*
*/
public void setDelimiter(DELIMITER2 value) {
this.delimiter = value;
}
/**
* Gets the value of the gap property.
*
* @return
* possible object is
* {@link GAP }
*
*/
public GAP getGap() {
return gap;
}
/**
* Sets the value of the gap property.
*
* @param value
* allowed object is
* {@link GAP }
*
*/
public void setGap(GAP value) {
this.gap = value;
}
}
|
0
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml/jaxbbindings/DerivedField.java
|
//
// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.0-b52-fcs
// See <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a>
// Any modifications to this file will be lost upon recompilation of the source schema.
// Generated on: 2013.12.20 at 12:48:21 PM GMT
//
package weka.core.pmml.jaxbbindings;
import java.util.ArrayList;
import java.util.List;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlType;
/**
* <p>Java class for DerivedField element declaration.
*
* <p>The following schema fragment specifies the expected content contained within this class.
*
* <pre>
* <element name="DerivedField">
* <complexType>
* <complexContent>
* <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
* <sequence>
* <element ref="{http://www.dmg.org/PMML-4_1}Extension" maxOccurs="unbounded" minOccurs="0"/>
* <group ref="{http://www.dmg.org/PMML-4_1}EXPRESSION"/>
* <element ref="{http://www.dmg.org/PMML-4_1}Value" maxOccurs="unbounded" minOccurs="0"/>
* </sequence>
* <attribute name="dataType" use="required" type="{http://www.dmg.org/PMML-4_1}DATATYPE" />
* <attribute name="displayName" type="{http://www.w3.org/2001/XMLSchema}string" />
* <attribute name="name" type="{http://www.dmg.org/PMML-4_1}FIELD-NAME" />
* <attribute name="optype" use="required" type="{http://www.dmg.org/PMML-4_1}OPTYPE" />
* </restriction>
* </complexContent>
* </complexType>
* </element>
* </pre>
*
*
*/
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "", propOrder = {
"extension",
"constant",
"fieldRef",
"normContinuous",
"normDiscrete",
"discretize",
"mapValues",
"apply",
"aggregate",
"value"
})
@XmlRootElement(name = "DerivedField")
public class DerivedField {
@XmlElement(name = "Extension", namespace = "http://www.dmg.org/PMML-4_1", required = true)
protected List<Extension> extension;
@XmlElement(name = "Constant", namespace = "http://www.dmg.org/PMML-4_1")
protected Constant constant;
@XmlElement(name = "FieldRef", namespace = "http://www.dmg.org/PMML-4_1")
protected FieldRef fieldRef;
@XmlElement(name = "NormContinuous", namespace = "http://www.dmg.org/PMML-4_1")
protected NormContinuous normContinuous;
@XmlElement(name = "NormDiscrete", namespace = "http://www.dmg.org/PMML-4_1")
protected NormDiscrete normDiscrete;
@XmlElement(name = "Discretize", namespace = "http://www.dmg.org/PMML-4_1")
protected Discretize discretize;
@XmlElement(name = "MapValues", namespace = "http://www.dmg.org/PMML-4_1")
protected MapValues mapValues;
@XmlElement(name = "Apply", namespace = "http://www.dmg.org/PMML-4_1")
protected Apply apply;
@XmlElement(name = "Aggregate", namespace = "http://www.dmg.org/PMML-4_1")
protected Aggregate aggregate;
@XmlElement(name = "Value", namespace = "http://www.dmg.org/PMML-4_1", required = true)
protected List<Value> value;
@XmlAttribute(required = true)
protected DATATYPE dataType;
@XmlAttribute
protected String displayName;
@XmlAttribute
protected String name;
@XmlAttribute(required = true)
protected OPTYPE optype;
public DerivedField() {}
public DerivedField(String name, DATATYPE dataType, OPTYPE optype) {
this.name = name;
this.dataType = dataType;
this.optype = optype;
}
/**
* Gets the value of the extension property.
*
* <p>
* This accessor method returns a reference to the live list,
* not a snapshot. Therefore any modification you make to the
* returned list will be present inside the JAXB object.
* This is why there is not a <CODE>set</CODE> method for the extension property.
*
* <p>
* For example, to add a new item, do as follows:
* <pre>
* getExtension().add(newItem);
* </pre>
*
*
* <p>
* Objects of the following type(s) are allowed in the list
* {@link Extension }
*
*
*/
public List<Extension> getExtension() {
if (extension == null) {
extension = new ArrayList<Extension>();
}
return this.extension;
}
/**
* Gets the value of the constant property.
*
* @return
* possible object is
* {@link Constant }
*
*/
public Constant getConstant() {
return constant;
}
/**
* Sets the value of the constant property.
*
* @param value
* allowed object is
* {@link Constant }
*
*/
public void setConstant(Constant value) {
this.constant = value;
}
/**
* Gets the value of the fieldRef property.
*
* @return
* possible object is
* {@link FieldRef }
*
*/
public FieldRef getFieldRef() {
return fieldRef;
}
/**
* Sets the value of the fieldRef property.
*
* @param value
* allowed object is
* {@link FieldRef }
*
*/
public void setFieldRef(FieldRef value) {
this.fieldRef = value;
}
/**
* Gets the value of the normContinuous property.
*
* @return
* possible object is
* {@link NormContinuous }
*
*/
public NormContinuous getNormContinuous() {
return normContinuous;
}
/**
* Sets the value of the normContinuous property.
*
* @param value
* allowed object is
* {@link NormContinuous }
*
*/
public void setNormContinuous(NormContinuous value) {
this.normContinuous = value;
}
/**
* Gets the value of the normDiscrete property.
*
* @return
* possible object is
* {@link NormDiscrete }
*
*/
public NormDiscrete getNormDiscrete() {
return normDiscrete;
}
/**
* Sets the value of the normDiscrete property.
*
* @param value
* allowed object is
* {@link NormDiscrete }
*
*/
public void setNormDiscrete(NormDiscrete value) {
this.normDiscrete = value;
}
/**
* Gets the value of the discretize property.
*
* @return
* possible object is
* {@link Discretize }
*
*/
public Discretize getDiscretize() {
return discretize;
}
/**
* Sets the value of the discretize property.
*
* @param value
* allowed object is
* {@link Discretize }
*
*/
public void setDiscretize(Discretize value) {
this.discretize = value;
}
/**
* Gets the value of the mapValues property.
*
* @return
* possible object is
* {@link MapValues }
*
*/
public MapValues getMapValues() {
return mapValues;
}
/**
* Sets the value of the mapValues property.
*
* @param value
* allowed object is
* {@link MapValues }
*
*/
public void setMapValues(MapValues value) {
this.mapValues = value;
}
/**
* Gets the value of the apply property.
*
* @return
* possible object is
* {@link Apply }
*
*/
public Apply getApply() {
return apply;
}
/**
* Sets the value of the apply property.
*
* @param value
* allowed object is
* {@link Apply }
*
*/
public void setApply(Apply value) {
this.apply = value;
}
/**
* Gets the value of the aggregate property.
*
* @return
* possible object is
* {@link Aggregate }
*
*/
public Aggregate getAggregate() {
return aggregate;
}
/**
* Sets the value of the aggregate property.
*
* @param value
* allowed object is
* {@link Aggregate }
*
*/
public void setAggregate(Aggregate value) {
this.aggregate = value;
}
/**
* Gets the value of the value property.
*
* <p>
* This accessor method returns a reference to the live list,
* not a snapshot. Therefore any modification you make to the
* returned list will be present inside the JAXB object.
* This is why there is not a <CODE>set</CODE> method for the value property.
*
* <p>
* For example, to add a new item, do as follows:
* <pre>
* getValue().add(newItem);
* </pre>
*
*
* <p>
* Objects of the following type(s) are allowed in the list
* {@link Value }
*
*
*/
public List<Value> getValue() {
if (value == null) {
value = new ArrayList<Value>();
}
return this.value;
}
/**
* Gets the value of the dataType property.
*
* @return
* possible object is
* {@link DATATYPE }
*
*/
public DATATYPE getDataType() {
return dataType;
}
/**
* Sets the value of the dataType property.
*
* @param value
* allowed object is
* {@link DATATYPE }
*
*/
public void setDataType(DATATYPE value) {
this.dataType = value;
}
/**
* Gets the value of the displayName property.
*
* @return
* possible object is
* {@link String }
*
*/
public String getDisplayName() {
return displayName;
}
/**
* Sets the value of the displayName property.
*
* @param value
* allowed object is
* {@link String }
*
*/
public void setDisplayName(String value) {
this.displayName = value;
}
/**
* Gets the value of the name property.
*
* @return
* possible object is
* {@link String }
*
*/
public String getName() {
return name;
}
/**
* Sets the value of the name property.
*
* @param value
* allowed object is
* {@link String }
*
*/
public void setName(String value) {
this.name = value;
}
/**
* Gets the value of the optype property.
*
* @return
* possible object is
* {@link OPTYPE }
*
*/
public OPTYPE getOptype() {
return optype;
}
/**
* Sets the value of the optype property.
*
* @param value
* allowed object is
* {@link OPTYPE }
*
*/
public void setOptype(OPTYPE value) {
this.optype = value;
}
}
|
0
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml
|
java-sources/ai/libs/thirdparty/interruptible-weka/0.1.6/weka/core/pmml/jaxbbindings/DiscrStats.java
|
//
// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.0-b52-fcs
// See <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a>
// Any modifications to this file will be lost upon recompilation of the source schema.
// Generated on: 2013.12.20 at 12:48:21 PM GMT
//
package weka.core.pmml.jaxbbindings;
import java.util.ArrayList;
import java.util.List;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlType;
/**
* <p>Java class for DiscrStats element declaration.
*
* <p>The following schema fragment specifies the expected content contained within this class.
*
* <pre>
* <element name="DiscrStats">
* <complexType>
* <complexContent>
* <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
* <sequence>
* <element ref="{http://www.dmg.org/PMML-4_1}Extension" maxOccurs="unbounded" minOccurs="0"/>
* <element ref="{http://www.dmg.org/PMML-4_1}Array" maxOccurs="2" minOccurs="0"/>
* </sequence>
* <attribute name="modalValue" type="{http://www.w3.org/2001/XMLSchema}string" />
* </restriction>
* </complexContent>
* </complexType>
* </element>
* </pre>
*
*
*/
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "", propOrder = {
"extension",
"array"
})
@XmlRootElement(name = "DiscrStats")
public class DiscrStats {
@XmlElement(name = "Extension", namespace = "http://www.dmg.org/PMML-4_1", required = true)
protected List<Extension> extension;
@XmlElement(name = "Array", namespace = "http://www.dmg.org/PMML-4_1", required = true)
protected List<ArrayType> array;
@XmlAttribute
protected String modalValue;
/**
* Gets the value of the extension property.
*
* <p>
* This accessor method returns a reference to the live list,
* not a snapshot. Therefore any modification you make to the
* returned list will be present inside the JAXB object.
* This is why there is not a <CODE>set</CODE> method for the extension property.
*
* <p>
* For example, to add a new item, do as follows:
* <pre>
* getExtension().add(newItem);
* </pre>
*
*
* <p>
* Objects of the following type(s) are allowed in the list
* {@link Extension }
*
*
*/
public List<Extension> getExtension() {
if (extension == null) {
extension = new ArrayList<Extension>();
}
return this.extension;
}
/**
* Gets the value of the array property.
*
* <p>
* This accessor method returns a reference to the live list,
* not a snapshot. Therefore any modification you make to the
* returned list will be present inside the JAXB object.
* This is why there is not a <CODE>set</CODE> method for the array property.
*
* <p>
* For example, to add a new item, do as follows:
* <pre>
* getArray().add(newItem);
* </pre>
*
*
* <p>
* Objects of the following type(s) are allowed in the list
* {@link ArrayType }
*
*
*/
public List<ArrayType> getArray() {
if (array == null) {
array = new ArrayList<ArrayType>();
}
return this.array;
}
/**
* Gets the value of the modalValue property.
*
* @return
* possible object is
* {@link String }
*
*/
public String getModalValue() {
return modalValue;
}
/**
* Sets the value of the modalValue property.
*
* @param value
* allowed object is
* {@link String }
*
*/
public void setModalValue(String value) {
this.modalValue = value;
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.