praktikum-holons/src/algorithm/binary/GreedySinglePass.java

package algorithm.binary;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.stream.Collectors;
import java.util.stream.Stream;

import api.AlgorithmFrameworkFlex;
import classes.AbstractCanvasObject;
import classes.Flexibility;
import classes.GroupNode;
import classes.HolonElement;
import classes.HolonObject;
import classes.HolonSwitch;
import ui.model.Model;
import utility.StringFormat;
import utility.Tuple;

public class GreedySinglePass extends AlgorithmFrameworkFlex {

	private int problemSize = 0;
	private boolean moreInformation = false;

	
	
	public GreedySinglePass() {
		super();
		addBooleanParameter("More Information", moreInformation, booleanValue -> moreInformation = booleanValue);
	}
	

	protected List<Integer> generateRandomLayerIndexList() {
		Model model = control.getModel();
		List<AbstractCanvasObject> nodes = (dGroupNode != null) ? dGroupNode.getModel().getNodes()
				: model.getObjectsOnCanvas();
		List<Tuple<AbstractCanvasObject, Integer>> extractedObjects = new ArrayList<>();
		rollOut(nodes.stream(), extractedObjects, 0);
		// Group With Layer
		Map<Integer, List<AbstractCanvasObject>> sortetObjects = extractedObjects.stream().collect(
				Collectors.groupingBy(Tuple::getSecond, Collectors.mapping(Tuple::getFirst, Collectors.toList())));
		
		AtomicInteger count = new AtomicInteger(0);
		List<Integer> indexList = new ArrayList<>();
		//Generate Access and shuffle layer
		sortetObjects.entrySet().stream()
			//ReverseOrder
			.sorted((layer0, layer1) -> -Integer.compare(layer0.getKey(), layer1.getKey()))
			//radomizeIndexes
			.forEach(entry -> {
				List<Integer> indexesInLayer = entry.getValue().stream().map(node -> count.getAndIncrement()).collect(Collectors.toList());
				//Randomize Layer
				Collections.shuffle(indexesInLayer);
				indexList.addAll(indexesInLayer);
				
		});
		//System.out.println(indexList.stream().map(Object::toString).collect(Collectors.joining(", ")));
		return indexList;
	}

	

	protected void rollOut(Stream<AbstractCanvasObject> nodes, List<Tuple<AbstractCanvasObject, Integer>> objects,
			int layer) {

		nodes.forEach(node -> {
			if (node instanceof HolonObject) {
				HolonObject hObject = (HolonObject) node;
				if (this.algoUseKillSwitch) {
					objects.add(new Tuple<>(node, layer));
				}
				if (this.algoUseElements) {
					for (@SuppressWarnings("unused") HolonElement hE : hObject.getElements()) {
						objects.add(new Tuple<>(node, layer));
					}
				}
				if (this.algoUseFlexes) {
					for (HolonElement hE : hObject.getElements()) {
						for(Flexibility flex : hE.flexList) {
							switch(control.getSimManager().getActualFlexManager().getFlexWrapperFromFlexibility(flex).getState()) {
							case IN_USE:
							case ON_COOLDOWN:
								objects.add(new Tuple<>(node, layer));
								break;
							case OFFERED:
								objects.add(new Tuple<>(node, layer));
								break;
							case NOT_OFFERED:
							case UNAVAILABLE:
							default:
								break;
							}
							
						}
					}
				}
			} else if (node instanceof HolonSwitch && algoUseSwitches) {
				objects.add(new Tuple<>(node, layer));
			}else if (node instanceof GroupNode ) {
				GroupNode groupNode = (GroupNode) node;
				rollOut(groupNode.getNodes().stream(), objects, layer +1);
			}
		});
	}


	@Override
	protected Individual executeAlgo() {
		Individual best = new Individual();
		best.position = extractPositionAndAccess();
		println("Bit-Array_length: " + best.position.size());
		best.fitness = evaluatePosition(best.position);
		List<Double> runList = new ArrayList<Double>();
		runList.add(best.fitness);
		println("Start with: " + StringFormat.doubleFixedPlaces(2, best.fitness));
		problemSize = best.position.size();

		Individual bestFound = new Individual(best);
		bestFound.fitness = Float.MAX_VALUE;
		Individual start = new Individual(best);
		List<Integer> radomizedForEachLayerIndexList = generateRandomLayerIndexList();
		
		for (Integer index : radomizedForEachLayerIndexList) {
			boolean actualValue = start.position.get(index);
			start.position.set(index, !actualValue);
			double fitness = evaluatePosition(start.position);
			boolean kicked = fitness < bestFound.fitness;
			if (kicked) {
				bestFound = new Individual(start);
				bestFound.fitness = fitness;
				
			} else {
				start.position.set(index, actualValue);
			}

			if (bestFound.fitness < best.fitness) {
				best = bestFound;
			}
			runList.add(bestFound.fitness);
			if (cancel)
				return null;
			println("Fitness: " + fitness + "\tFlippedIndex = " + index + "(" + problemSize + ")" + kicked);
		}
		console.println("Fitness: " + bestFound.fitness);
		this.runList = runList;
		return best;
	}

	protected void println(String value) {
		if (moreInformation)
			console.println(value);
	}

	@Override
	protected int getProgressBarMaxCount() {
		List<Boolean> best = extractPositionAndAccess();
		problemSize = best.size();
		return problemSize * rounds;
	}
	
	@Override
	protected String algoInformationToPrint() {
		return "NoParameter";
	}

	@Override
	protected String plottFileName() {
		return "plottGreedyRandom.txt";
	}
}