import org.dmg.pmml.Expression; //导入依赖的package包/类
private void handleExpression(int preProcessingStepIndex, DerivedField derivedField) {
    if (derivedField.getExpression() instanceof Apply) {
        for (Expression expression : ((Apply) derivedField.getExpression()).getExpressions()) {
            if (expression instanceof Apply) {
                if (((Apply) expression).getFunction().equals("isMissing")) {
                    // now find the value that is supposed to replace the missing value

                    for (Expression expression2 : ((Apply) derivedField.getExpression()).getExpressions()) {
                        if (expression2 instanceof Constant) {
                            String missingValue = ((Constant) expression2).getValue();
                            preProcessingSteps[preProcessingStepIndex] = new MissingValuePreProcess(derivedField, missingValue);
                            break;
                        }
                    }
                } else {
                    throw new UnsupportedOperationException("So far only if isMissing implemented.");
                }
            }
        }
    } else if (derivedField.getExpression() instanceof NormContinuous) {
        preProcessingSteps[preProcessingStepIndex] = new NormContinousPreProcess((NormContinuous) derivedField
                .getExpression(), derivedField.getName().getValue());
    } else {
        throw new UnsupportedOperationException("So far only Apply expression implemented.");
    }
}
 

import org.dmg.pmml.Expression; //导入依赖的package包/类
static
public Expression createExpression(Number multiplier, FieldRef fieldRef){
	Number one;

	if(multiplier instanceof Float){
		one = 1f;
	} else

	if(multiplier instanceof Double){
		one = 1d;
	} else

	{
		throw new IllegalArgumentException();
	}

	return PMMLUtil.createApply("/", PMMLUtil.createConstant(one), PMMLUtil.createApply("+", PMMLUtil.createConstant(one), PMMLUtil.createApply("exp", PMMLUtil.createApply("*", PMMLUtil.createConstant(multiplier), fieldRef))));
}
 

import org.dmg.pmml.Expression; //导入依赖的package包/类
@Override
public DefineFunction encodeDefineFunction(){
	TfidfTransformer transformer = getTransformer();

	DefineFunction defineFunction = super.encodeDefineFunction();

	Expression expression = defineFunction.getExpression();

	Boolean sublinearTf = transformer.getSublinearTf();
	if(sublinearTf){
		expression = PMMLUtil.createApply("+", PMMLUtil.createApply("log", expression), PMMLUtil.createConstant(1d));
	} // End if

	Boolean useIdf = transformer.getUseIdf();
	if(useIdf){
		ParameterField weight = new ParameterField(FieldName.create("weight"));

		defineFunction.addParameterFields(weight);

		expression = PMMLUtil.createApply("*", expression, new FieldRef(weight.getName()));
	}

	defineFunction.setExpression(expression);

	return defineFunction;
}
 

import org.dmg.pmml.Expression; //导入依赖的package包/类
static
private void inlineLogicalExpressions(Apply apply){
	String function = apply.getFunction();

	List<Expression> expressions = apply.getExpressions();
	for(ListIterator<Expression> expressionIt = expressions.listIterator(); expressionIt.hasNext(); ){
		Expression expression = expressionIt.next();

		if(expression instanceof Apply){
			Apply nestedApply = (Apply)expression;

			if((function).equals(nestedApply.getFunction())){
				expressionIt.remove();

				// Deep inline
				inlineLogicalExpressions(nestedApply);

				List<Expression> nestedExpressions = nestedApply.getExpressions();
				for(Expression nestedExpression : nestedExpressions){
					expressionIt.add(nestedExpression);
				}
			}
		}
	}
}
 

import org.dmg.pmml.Expression; //导入依赖的package包/类
private Schema filter(Schema schema){
	Function<Feature, Feature> function = new Function<Feature, Feature>(){

		@Override
		public Feature apply(Feature feature){
			Expression expression = encodeExpression(feature);

			if(expression == null){
				return feature;
			}

			DerivedField derivedField = createDerivedField(FeatureUtil.createName("preProcess", feature), OpType.CONTINUOUS, DataType.DOUBLE, expression);

			return new ContinuousFeature(PreProcessEncoder.this, derivedField);
		}
	};

	return schema.toTransformedSchema(function);
}
 

import org.dmg.pmml.Expression; //导入依赖的package包/类
static
private boolean checkApply(Apply apply, String function, Class<? extends Expression>... expressionClazzes){

	if((function).equals(apply.getFunction())){
		List<Expression> expressions = apply.getExpressions();

		if(expressionClazzes.length == expressions.size()){

			for(int i = 0; i < expressionClazzes.length; i++){
				Class<? extends Expression> expressionClazz = expressionClazzes[i];
				Expression expression = expressions.get(i);

				if(!(expressionClazz).isInstance(expression)){
					return false;
				}
			}

			return true;
		}
	}

	return false;
}
 

import org.dmg.pmml.Expression; //导入依赖的package包/类
static
private Expression encodeIfElseExpression(FunctionExpression functionExpression, VariableMap expressionFields, RExpEncoder encoder){
	FunctionExpression.Argument testArgument = functionExpression.getArgument("test", 0);

	expressionFields.putAll(testArgument);

	FunctionExpression.Argument yesArgument = functionExpression.getArgument("yes", 1);
	FunctionExpression.Argument noArgument = functionExpression.getArgument("no", 2);

	expressionFields.putAll(yesArgument);
	expressionFields.putAll(noArgument);

	// XXX: "Missing values in test give missing values in the result"
	Apply apply = PMMLUtil.createApply("if")
		.addExpressions(prepareExpression(testArgument, expressionFields, encoder))
		.addExpressions(prepareExpression(yesArgument, expressionFields, encoder), prepareExpression(noArgument, expressionFields, encoder));

	return apply;
}
 

import org.dmg.pmml.Expression; //导入依赖的package包/类
static
private FieldName prepareInputField(FunctionExpression.Argument argument, OpType opType, DataType dataType, RExpEncoder encoder){
	Expression expression = argument.getExpression();

	if(expression instanceof FieldRef){
		FieldRef fieldRef = (FieldRef)expression;

		return fieldRef.getField();
	} else

	if(expression instanceof Apply){
		Apply apply = (Apply)expression;

		DerivedField derivedField = encoder.createDerivedField(FieldName.create((argument.formatExpression()).trim()), opType, dataType, apply);

		return derivedField.getName();
	} else

	{
		throw new IllegalArgumentException();
	}
}
 

import org.dmg.pmml.Expression; //导入依赖的package包/类
static
private Expression prepareExpression(FunctionExpression.Argument argument, VariableMap expressionFields, RExpEncoder encoder){
	Expression expression = argument.getExpression();

	if(expression instanceof FunctionExpression){
		FunctionExpression functionExpression = (FunctionExpression)expression;

		if(functionExpression.hasId("base", "ifelse")){
			return encodeIfElseExpression(functionExpression, expressionFields, encoder);
		}

		throw new IllegalArgumentException();
	}

	return expression;
}
 

import org.dmg.pmml.Expression; //导入依赖的package包/类
static
private Apply createHingeFunction(int dir, Feature feature, double cut){
	Expression expression;

	switch(dir){
		case -1:
			expression = PMMLUtil.createApply("-", PMMLUtil.createConstant(cut), feature.ref());
			break;
		case 1:
			expression = PMMLUtil.createApply("-", feature.ref(), PMMLUtil.createConstant(cut));
			break;
		default:
			throw new IllegalArgumentException();
	}

	return PMMLUtil.createApply("max", expression, PMMLUtil.createConstant(0d));
}
 

import org.dmg.pmml.Expression; //导入依赖的package包/类
@Test
public void translateLogicalExpression(){
	Apply apply = (Apply)ExpressionTranslator.translateExpression("a >= 0.0 & b >= 0.0 | c <= 0.0");

	List<Expression> expressions = checkApply(apply, "or", Apply.class, Apply.class);

	Expression left = expressions.get(0);
	Expression right = expressions.get(1);

	expressions = checkApply((Apply)left, "and", Apply.class, Apply.class);
	checkApply((Apply)right, "lessOrEqual", FieldRef.class, Constant.class);

	left = expressions.get(0);
	right = expressions.get(1);

	checkApply((Apply)left, "greaterOrEqual", FieldRef.class, Constant.class);
	checkApply((Apply)right, "greaterOrEqual", FieldRef.class, Constant.class);
}
 

import org.dmg.pmml.Expression; //导入依赖的package包/类
@Test
public void translateArithmeticExpressionChain(){
	Apply apply = (Apply)ExpressionTranslator.translateExpression("A + B - X + C");

	List<Expression> expressions = checkApply(apply, "+", Apply.class, FieldRef.class);

	Expression left = expressions.get(0);
	Expression right = expressions.get(1);

	expressions = checkApply((Apply)left, "-", Apply.class, FieldRef.class);
	checkFieldRef((FieldRef)right, FieldName.create("C"));

	left = expressions.get(0);
	right = expressions.get(1);

	expressions = checkApply((Apply)left, "+", FieldRef.class, FieldRef.class);
	checkFieldRef((FieldRef)right, FieldName.create("X"));

	left = expressions.get(0);
	right = expressions.get(1);

	checkFieldRef((FieldRef)left, FieldName.create("A"));
	checkFieldRef((FieldRef)right, FieldName.create("B"));
}
 

import org.dmg.pmml.Expression; //导入依赖的package包/类
static
private List<Expression> checkApply(Apply apply, String function, Class<? extends Expression>... expressionClazzes){
	assertEquals(function, apply.getFunction());

	List<Expression> expressions = apply.getExpressions();
	assertEquals(expressionClazzes.length, expressions.size());

	for(int i = 0; i < expressionClazzes.length; i++){
		Class<? extends Expression> expressionClazz = expressionClazzes[i];
		Expression expression = expressions.get(i);

		assertEquals(expressionClazz, expression.getClass());
	}

	return expressions;
}
 

import org.dmg.pmml.Expression; //导入依赖的package包/类
@Test
public void correct(){
	Apply apply = new Apply("substring")
		.addExpressions(new FieldRef(FieldName.create("AnyCInput")), new Constant("1"), new Constant("FMTWIDTH"));

	ExpressionCorrector expressionCorrector = new ExpressionCorrector();
	expressionCorrector.applyTo(apply);

	List<Expression> expressions = apply.getExpressions();

	Expression string = expressions.get(0);
	Expression position = expressions.get(1);
	Expression length = expressions.get(2);

	assertTrue(string instanceof FieldRef);
	assertEquals(FieldName.create("AnyCInput"), ((FieldRef)string).getField());

	assertTrue(position instanceof Constant);
	assertEquals("1", ((Constant)position).getValue());

	assertTrue(length instanceof FieldRef);
	assertEquals(FieldName.create("FMTWIDTH"), ((FieldRef)length).getField());
}
 

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

	List<Feature> features = encoder.getFeatures(transformer.getInputCol());

	DenseMatrix pc = transformer.pc();
	if(pc.numRows() != features.size()){
		throw new IllegalArgumentException();
	}

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

	for(int i = 0; i < transformer.getK(); i++){
		Apply apply = new Apply("sum");

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

			ContinuousFeature continuousFeature = feature.toContinuousFeature();

			Expression expression = continuousFeature.ref();

			Double coefficient = pc.apply(j, i);
			if(!ValueUtil.isOne(coefficient)){
				expression = PMMLUtil.createApply("*", expression, PMMLUtil.createConstant(coefficient));
			}

			apply.addExpressions(expression);
		}

		DerivedField derivedField = encoder.createDerivedField(formatName(transformer, i), OpType.CONTINUOUS, DataType.DOUBLE, apply);

		result.add(new ContinuousFeature(encoder, derivedField));
	}

	return result;
}
 

import org.dmg.pmml.Expression; //导入依赖的package包/类
private static String getReferencedFieldName(DerivedField derivedField) {
    String referencedField = null;
    if (derivedField.getExpression() != null) {
        if (derivedField.getExpression() instanceof Apply) {
            // TODO throw uoe in case the function is not "if missing" - much more to implement!
            for (Expression expression : ((Apply) derivedField.getExpression()).getExpressions()) {
                if (expression instanceof FieldRef) {
                    referencedField = ((FieldRef) expression).getField().getValue();
                }
            }
        } else if (derivedField.getExpression() instanceof NormContinuous) {
            referencedField = ((NormContinuous) derivedField.getExpression()).getField().getValue();
        } else {
            throw new UnsupportedOperationException("So far only Apply expression implemented.");
        }
    } else {
        // there is a million ways in which derived fields can reference other fields.
        // need to implement them all!
        throw new UnsupportedOperationException("So far only implemented if function for derived fields.");
    }

    if (referencedField == null) {
        throw new UnsupportedOperationException("could not find raw field name. Maybe this derived field references another derived " +
                "field? Did not implement that yet.");
    }
    return referencedField;
}
 

import org.dmg.pmml.Expression; //导入依赖的package包/类
static
public Apply createApply(String function, Expression... expressions){
	Apply apply = new Apply(function)
		.addExpressions(expressions);

	return apply;
}
 

import org.dmg.pmml.Expression; //导入依赖的package包/类
public DerivedField createDerivedField(FieldName name, OpType opType, DataType dataType, Expression expression){
	DerivedField derivedField = new DerivedField(opType, dataType)
		.setName(name)
		.setExpression(expression);

	addDerivedField(derivedField);

	return derivedField;
}
 

import org.dmg.pmml.Expression; //导入依赖的package包/类
@Override
public SupportVectorMachineModel encodeModel(Schema schema){
	Transformation outlier = new OutlierTransformation(){

		@Override
		public Expression createExpression(FieldRef fieldRef){
			return PMMLUtil.createApply("lessOrEqual", fieldRef, PMMLUtil.createConstant(0d));
		}
	};

	SupportVectorMachineModel supportVectorMachineModel = super.encodeModel(schema)
		.setOutput(ModelUtil.createPredictedOutput(FieldName.create("decisionFunction"), OpType.CONTINUOUS, DataType.DOUBLE, outlier));

	return supportVectorMachineModel;
}
 

import org.dmg.pmml.Expression; //导入依赖的package包/类
@Override
public List<Feature> encodeFeatures(List<Feature> features, SkLearnEncoder encoder){
	Object func = getFunc();

	if(func == null){
		return features;
	}

	UFunc ufunc = getUFunc();

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

	for(int i = 0; i < features.size(); i++){
		ContinuousFeature continuousFeature = (features.get(i)).toContinuousFeature();

		FieldName name = FeatureUtil.createName(ufunc.getName(), continuousFeature);

		DerivedField derivedField = encoder.getDerivedField(name);
		if(derivedField == null){
			Expression expression = encodeUFunc(ufunc, continuousFeature.ref());

			derivedField = encoder.createDerivedField(name, expression);
		}

		result.add(new ContinuousFeature(encoder, derivedField));
	}

	return result;
}