All Downloads are FREE. Search and download functionalities are using the official Maven repository.

org.jpmml.evaluator.EvaluatorUtil Maven / Gradle / Ivy

Go to download

JPMML class model evaluator

There is a newer version: 1.6.6
Show newest version
/*
 * Copyright (c) 2013 Villu Ruusmann
 *
 * This file is part of JPMML-Evaluator
 *
 * JPMML-Evaluator is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * JPMML-Evaluator 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 Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with JPMML-Evaluator.  If not, see .
 */
package org.jpmml.evaluator;

import java.util.ArrayList;
import java.util.Collection;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

import com.google.common.collect.ArrayListMultimap;
import com.google.common.collect.ListMultimap;
import com.google.common.collect.Multimaps;
import org.dmg.pmml.FieldName;

public class EvaluatorUtil {

	private EvaluatorUtil(){
	}

	static
	public Map encodeKeys(Map map){
		Map result = new LinkedHashMap<>(2 * map.size());

		Collection> entries = map.entrySet();
		for(Map.Entry entry : entries){
			String name = entry.getKey();
			Object value = entry.getValue();

			result.put(name != null ? FieldName.create(name) : null, value);
		}

		return result;
	}

	/**
	 * @see Computable
	 */
	static
	public Object decode(Object object){

		if(object instanceof Computable){
			Computable computable = (Computable)object;

			return computable.getResult();
		} // End if

		if(object instanceof Collection){
			Collection rawValues = (Collection)object;

			Collection decodedValues;

			// Try to preserve the original contract
			if(rawValues instanceof Set){
				decodedValues = new LinkedHashSet<>(rawValues.size());
			} else

			{
				decodedValues = new ArrayList<>(rawValues.size());
			}

			for(Object rawValue : rawValues){
				decodedValues.add(decode(rawValue));
			}

			return decodedValues;
		}

		return object;
	}

	/**
	 * 

	 * Decouples a {@link Map} instance from the current runtime environment by decoding both its keys and values.
	 * 

	 */
	static
	public Map decodeAll(Map map){
		Map result = new LinkedHashMap<>(2 * map.size());

		Collection> entries = map.entrySet();
		for(Map.Entry entry : entries){
			FieldName name = entry.getKey();
			Object value = entry.getValue();

			try {
				value = decode(value);
			} catch(UnsupportedOperationException uoe){
				continue;
			}

			result.put(name != null ? name.getValue() : null, value);
		}

		return result;
	}

	static
	public List> groupRows(HasGroupFields hasGroupFields, List> table){
		List groupFields = hasGroupFields.getGroupFields();

		if(groupFields.size() == 1){
			InputField groupField = groupFields.get(0);

			table = EvaluatorUtil.groupRows(groupField.getName(), table);
		} else

		if(groupFields.size() > 1){
			ModelEvaluator modelEvaluator = (ModelEvaluator)hasGroupFields; // XXX

			throw modelEvaluator.createMiningSchemaException("Expected 0 or 1 group field(s), got " + groupFields.size()  + " group fields");
		}

		return table;
	}

	static
	public  List> groupRows(K groupKey, List> table){
		Map> groupedRows = new LinkedHashMap<>();

		for(int i = 0; i < table.size(); i++){
			Map row = table.get(i);

			Object groupValue = row.get(groupKey);

			ListMultimap groupedRow = groupedRows.get(groupValue);
			if(groupedRow == null){
				groupedRow = ArrayListMultimap.create();

				groupedRows.put(groupValue, groupedRow);
			}

			Collection> entries = row.entrySet();
			for(Map.Entry entry : entries){
				K key = entry.getKey();
				Object value = entry.getValue();

				groupedRow.put(key, value);
			}
		}

		List> resultTable = new ArrayList<>(groupedRows.size());

		Collection>> entries = groupedRows.entrySet();
		for(Map.Entry> entry : entries){
			Map resultRow = new LinkedHashMap<>();
			resultRow.putAll(Multimaps.asMap(entry.getValue()));

			// The value of the "group by" column is a single Object, not a Collection (ie. java.util.List) of Objects
			resultRow.put(groupKey, entry.getKey());

			resultTable.add(resultRow);
		}

		return resultTable;
	}
}    

    

    

            

    

            



    
    






    
© 2015 - 2024 Weber Informatics LLC | Privacy Policy