import org.dmg.pmml.Interval; //导入依赖的package包/类
@Test
public void translateInterval(){
	Interval interval = ExpressionTranslator.translateInterval("(-10.0E+0, +10.0E-0]");

	assertEquals(Interval.Closure.OPEN_CLOSED, interval.getClosure());
	assertEquals(new Double("-10.0E0"), interval.getLeftMargin());
	assertEquals(new Double("+10.0E0"), interval.getRightMargin());

	try {
		interval = ExpressionTranslator.translateInterval("(0, NaN)");

		fail();
	} catch(IllegalArgumentException iae){
		// Ignored
	}

	interval = ExpressionTranslator.translateInterval("[-Inf, +Inf]");

	assertEquals(Interval.Closure.CLOSED_CLOSED, interval.getClosure());
	assertEquals(null, interval.getLeftMargin());
	assertEquals(null, interval.getRightMargin());
}
 

import org.dmg.pmml.Interval; //导入依赖的package包/类
static
private RangeMap<Double, String> parseDiscretize(Discretize discretize){
	RangeMap<Double, String> result = TreeRangeMap.create();

	List<DiscretizeBin> discretizeBins = discretize.getDiscretizeBins();
	for(DiscretizeBin discretizeBin : discretizeBins){
		Interval interval = discretizeBin.getInterval();
		if(interval == null){
			throw new MissingAttributeException(discretizeBin, PMMLAttributes.DISCRETIZEBIN_INTERVAL);
		}

		Range<Double> range = toRange(interval);

		String binValue = discretizeBin.getBinValue();
		if(binValue == null){
			throw new MissingAttributeException(discretizeBin, PMMLAttributes.DISCRETIZEBIN_BINVALUE);
		}

		result.put(range, binValue);
	}

	return result;
}
 

import org.dmg.pmml.Interval; //导入依赖的package包/类
@Test
public void unboundedRange(){
	Range<Double> lessThan = toRange(Interval.Closure.OPEN_OPEN, null, 0d);
	assertTrue(lessThan.contains(-Double.MAX_VALUE));
	assertFalse(lessThan.contains(0d));
	assertFalse(lessThan.contains(Double.MAX_VALUE));

	Range<Double> atMost = toRange(Interval.Closure.OPEN_CLOSED, null, 0d);
	assertTrue(atMost.contains(-Double.MAX_VALUE));
	assertTrue(atMost.contains(0d));
	assertFalse(atMost.contains(Double.MAX_VALUE));

	Range<Double> greaterThan = toRange(Interval.Closure.OPEN_OPEN, 0d, null);
	assertFalse(greaterThan.contains(-Double.MAX_VALUE));
	assertFalse(greaterThan.contains(0d));
	assertTrue(greaterThan.contains(Double.MAX_VALUE));

	Range<Double> atLeast = toRange(Interval.Closure.CLOSED_OPEN, 0d, null);
	assertFalse(atLeast.contains(-Double.MAX_VALUE));
	assertTrue(atLeast.contains(0d));
	assertTrue(atLeast.contains(Double.MAX_VALUE));
}
 

import org.dmg.pmml.Interval; //导入依赖的package包/类
static
public Interval parseInterval(String string){

	if(string.length() < 3){
		throw new IllegalArgumentException();
	}

	String bounds = string.substring(0, 1) + string.substring(string.length() - 1, string.length());
	String margins = string.substring(1, string.length() - 1);

	Interval.Closure closure;

	switch(bounds){
		case "[]":
			closure = Interval.Closure.CLOSED_CLOSED;
			break;
		default:
			throw new IllegalArgumentException(string);
	}

	String[] values = margins.split(":");
	if(values.length != 2){
		throw new IllegalArgumentException(margins);
	}

	Double leftMargin = Double.valueOf(values[0]);
	Double rightMargin = Double.valueOf(values[1]);

	Interval interval = new Interval(closure)
		.setLeftMargin(leftMargin)
		.setRightMargin(rightMargin);

	return interval;
}
 

import org.dmg.pmml.Interval; //导入依赖的package包/类
static
private List<Interval> mergeIntervals(List<Interval> left, List<Interval> right){

	if(left.isEmpty() && right.size() > 0){
		return right;
	}

	return left;
}
 

import org.dmg.pmml.Interval; //导入依赖的package包/类
@Override
public void decorate(DataField dataField, MiningField miningField){
	List<Interval> intervals = getIntervals();

	if(intervals.size() > 0){
		PMMLUtil.addIntervals(dataField, intervals);
	}

	super.decorate(dataField, miningField);
}
 

import org.dmg.pmml.Interval; //导入依赖的package包/类
static
private Discretize createDiscretize(FieldName name, List<String> categories){
	Discretize discretize = new Discretize(name);

	for(String category : categories){
		Interval interval = ExpressionTranslator.translateInterval(category);

		DiscretizeBin discretizeBin = new DiscretizeBin(category, interval);

		discretize.addDiscretizeBins(discretizeBin);
	}

	return discretize;
}
 

import org.dmg.pmml.Interval; //导入依赖的package包/类
static
private RangeSet<Double> parseValidRanges(DataField dataField){
	RangeSet<Double> result = TreeRangeSet.create();

	List<Interval> intervals = dataField.getIntervals();
	for(Interval interval : intervals){
		Range<Double> range = DiscretizationUtil.toRange(interval);

		result.add(range);
	}

	return result;
}
 

import org.dmg.pmml.Interval; //导入依赖的package包/类
@Test
public void boundedRange(){
	Range<Double> open = toRange(Interval.Closure.OPEN_OPEN, -1d, 1d);
	assertFalse(open.contains(-Double.MAX_VALUE));
	assertFalse(open.contains(-1d));
	assertTrue(open.contains(0d));
	assertFalse(open.contains(1d));
	assertFalse(open.contains(Double.MAX_VALUE));

	Range<Double> openClosed = toRange(Interval.Closure.OPEN_CLOSED, -1d, 1d);
	assertFalse(openClosed.contains(-Double.MAX_VALUE));
	assertFalse(openClosed.contains(-1d));
	assertTrue(openClosed.contains(0d));
	assertTrue(openClosed.contains(1d));
	assertFalse(openClosed.contains(Double.MAX_VALUE));

	Range<Double> closedOpen = toRange(Interval.Closure.CLOSED_OPEN, -1d, 1d);
	assertFalse(closedOpen.contains(-Double.MAX_VALUE));
	assertTrue(closedOpen.contains(-1d));
	assertTrue(closedOpen.contains(0d));
	assertFalse(closedOpen.contains(1d));
	assertFalse(closedOpen.contains(Double.MAX_VALUE));

	Range<Double> closed = toRange(Interval.Closure.CLOSED_CLOSED, -1d, 1d);
	assertFalse(closed.contains(-Double.MAX_VALUE));
	assertTrue(closed.contains(-1d));
	assertTrue(closed.contains(0d));
	assertTrue(closed.contains(1d));
	assertFalse(closed.contains(Double.MAX_VALUE));
}
 

import org.dmg.pmml.Interval; //导入依赖的package包/类
static
private Interval createInterval(Interval.Closure closure, Double leftMargin, Double rightMargin){
	Interval result = new Interval(closure)
		.setLeftMargin(leftMargin)
		.setRightMargin(rightMargin);

	return result;
}
 

import org.dmg.pmml.Interval; //导入依赖的package包/类
static
private void clearIntervalsAndValues(DataField dataField){
	List<Interval> intervals = dataField.getIntervals();
	intervals.clear();

	List<Value> values = dataField.getValues();
	values.clear();
}
 

import org.dmg.pmml.Interval; //导入依赖的package包/类
static
public void addIntervals(DataField dataField, List<Interval> intervals){
	(dataField.getIntervals()).addAll(intervals);
}
 

import org.dmg.pmml.Interval; //导入依赖的package包/类
public List<Interval> getIntervals(){
	return this.intervals;
}
 

import org.dmg.pmml.Interval; //导入依赖的package包/类
public ValidValueDecorator addIntervals(Interval... intervals){
	getIntervals().addAll(Arrays.asList(intervals));

	return this;
}
 

import org.dmg.pmml.Interval; //导入依赖的package包/类
@Override
public List<Feature> encodeFeatures(List<Feature> features, SkLearnEncoder encoder){
	Boolean withData = getWithData();
	Boolean withStatistics = getWithStatistics();

	List<? extends Number> dataMin = null;
	List<? extends Number> dataMax = null;

	if(withData){
		dataMin = getDataMin();
		dataMax = getDataMax();

		ClassDictUtil.checkSize(features, dataMin, dataMax);
	}

	List<Feature> result = new ArrayList<>();

	for(int i = 0; i < features.size(); i++){
		Feature feature = features.get(i);

		WildcardFeature wildcardFeature = (WildcardFeature)feature;

		if(withData){
			Interval interval = new Interval(Interval.Closure.CLOSED_CLOSED)
				.setLeftMargin(ValueUtil.asDouble(dataMin.get(i)))
				.setRightMargin(ValueUtil.asDouble(dataMax.get(i)));

			ValidValueDecorator validValueDecorator = new ValidValueDecorator()
				.addIntervals(interval);

			feature = wildcardFeature.toContinuousFeature();

			encoder.addDecorator(wildcardFeature.getName(), validValueDecorator);
		} // End if

		if(withStatistics){
			Map<String, ?> counts = extractMap(getCounts(), i);
			Map<String, ?> numericInfo = extractMap(getNumericInfo(), i);

			UnivariateStats univariateStats = new UnivariateStats()
				.setField(wildcardFeature.getName())
				.setCounts(createCounts(counts))
				.setNumericInfo(createNumericInfo(numericInfo));

			encoder.putUnivariateStats(univariateStats);
		}

		result.add(feature);
	}

	return super.encodeFeatures(result, encoder);
}
 

import org.dmg.pmml.Interval; //导入依赖的package包/类
static
public Range<Double> toRange(Interval interval){
	Double leftMargin = interval.getLeftMargin();
	Double rightMargin = interval.getRightMargin();

	// "The leftMargin and rightMargin attributes are optional, but at least one value must be defined"
	if(leftMargin == null && rightMargin == null){
		throw new MissingAttributeException(interval, PMMLAttributes.INTERVAL_LEFTMARGIN);
	} // End if

	if(leftMargin != null && rightMargin != null && (leftMargin).compareTo(rightMargin) > 0){
		throw new InvalidElementException(interval);
	}

	Interval.Closure closure = interval.getClosure();
	if(closure == null){
		throw new MissingAttributeException(interval, PMMLAttributes.INTERVAL_CLOSURE);
	}

	switch(closure){
		case OPEN_OPEN:
			{
				if(leftMargin == null){
					return Range.lessThan(rightMargin);
				} else

				if(rightMargin == null){
					return Range.greaterThan(leftMargin);
				}

				return Range.open(leftMargin, rightMargin);
			}
		case OPEN_CLOSED:
			{
				if(leftMargin == null){
					return Range.atMost(rightMargin);
				} else

				if(rightMargin == null){
					return Range.greaterThan(leftMargin);
				}

				return Range.openClosed(leftMargin, rightMargin);
			}
		case CLOSED_OPEN:
			{
				if(leftMargin == null){
					return Range.lessThan(rightMargin);
				} else

				if(rightMargin == null){
					return Range.atLeast(leftMargin);
				}

				return Range.closedOpen(leftMargin, rightMargin);
			}
		case CLOSED_CLOSED:
			{
				if(leftMargin == null){
					return Range.atMost(rightMargin);
				} else

				if(rightMargin == null){
					return Range.atLeast(leftMargin);
				}

				return Range.closed(leftMargin, rightMargin);
			}
		default:
			throw new UnsupportedAttributeException(interval, closure);
	}
}
 

import org.dmg.pmml.Interval; //导入依赖的package包/类
static
private Range<Double> toRange(Interval.Closure closure, Double leftMargin, Double rightMargin){
	return DiscretizationUtil.toRange(createInterval(closure, leftMargin, rightMargin));
}
 

import org.dmg.pmml.Interval; //导入依赖的package包/类
static
public boolean isOutlier(DataField dataField, Object value){

	if(value == null){
		return false;
	}

	OpType opType = dataField.getOptype();
	switch(opType){
		case CONTINUOUS:
			{
				List<Double> range = null;

				List<Interval> fieldIntervals = dataField.getIntervals();
				for(Interval fieldInterval : fieldIntervals){

					if(range == null){
						range = Lists.newArrayList();
					}

					range.add(fieldInterval.getLeftMargin());
					range.add(fieldInterval.getRightMargin());
				}

				List<Value> fieldValues = dataField.getValues();
				for(Value fieldValue : fieldValues){
					Value.Property property = fieldValue.getProperty();

					switch(property){
						case VALID:
							{
								if(range == null){
									range = Lists.newArrayList();
								}

								range.add((Double)TypeUtil.parseOrCast(DataType.DOUBLE, fieldValue.getValue()));
							}
							break;
						default:
							break;
					}
				}

				if(range == null){
					return false;
				}

				Double doubleValue = (Double)TypeUtil.parseOrCast(DataType.DOUBLE, value);

				Double minValue = Collections.min(range);
				if(TypeUtil.compare(DataType.DOUBLE, doubleValue, minValue) < 0){
					return true;
				}

				Double maxValue = Collections.max(range);
				if(TypeUtil.compare(DataType.DOUBLE, doubleValue, maxValue) > 0){
					return true;
				}
			}
			break;
		case CATEGORICAL:
		case ORDINAL:
			break;
		default:
			throw new UnsupportedFeatureException(dataField, opType);
	}

	return false;
}
 

import org.dmg.pmml.Interval; //导入依赖的package包/类
@Override
public List<Feature> encodeFeatures(SparkMLEncoder encoder){
	Bucketizer transformer = getTransformer();

	Feature feature = encoder.getOnlyFeature(transformer.getInputCol());

	ContinuousFeature continuousFeature = feature.toContinuousFeature();

	Discretize discretize = new Discretize(continuousFeature.getName());

	List<String> categories = new ArrayList<>();

	double[] splits = transformer.getSplits();
	for(int i = 0; i < (splits.length - 1); i++){
		String category = String.valueOf(i);

		categories.add(category);

		Interval interval = new Interval((i < (splits.length - 2)) ? Interval.Closure.CLOSED_OPEN : Interval.Closure.CLOSED_CLOSED)
			.setLeftMargin(formatMargin(splits[i]))
			.setRightMargin(formatMargin(splits[i + 1]));

		DiscretizeBin discretizeBin = new DiscretizeBin(category, interval);

		discretize.addDiscretizeBins(discretizeBin);
	}

	DerivedField derivedField = encoder.createDerivedField(formatName(transformer), OpType.CATEGORICAL, DataType.INTEGER, discretize);

	return Collections.<Feature>singletonList(new CategoricalFeature(encoder, derivedField, categories));
}