public class PowerVmRevertingSelection extends PowerVmSelectionPolicy {

public PowerVmRevertingSelection(PowerVmSelectionPolicy fallbackPolicy) {

super();
setFallbackPolicy(fallbackPolicy);}
public Vm getVmToMigrate(PowerHost host) {
List<PowerVm> migratableVms = getMigratableVms(host);
if (migratableVms.isEmpty()) {
return null;}
List<Double> metrics = null;
try {
metrics = getCorrelationCoefficients (getUtilizationMatrix(migratableVms));}
catch (IllegalArgumentException e) {
return getFallbackPolicy().getVmToMigrate(host);}
double maxMetric = Double.MIN_VALUE;
int maxIndex = 0;
for (int i = 0; i < metrics.size(); i++) {
double metric = metrics.get(i);
if (metric > maxMetric) {
maxMetric = metric;
maxIndex = i;
}}
return migratableVms.get(maxIndex);}
public Vm RevertingPowerHost host) {
List<PowerVm> migratableVms = getMigratableVms(host);
if (migratableVms.isEmpty()) {
return null;}
List<Double> metrics = null;
try {
metrics = getCorrelationCoefficients (getUtilizationMatrix(migratableVms));}
catch (IllegalArgumentException e) {
return getFallbackPolicy().getVmToMigrate(host);}

double Maxserver = Double.MIN_VALUE;

int maxIndex = 0;
for (int i = 0; i < metrics.size(); i++) {
double metric = metrics.get(i);
if (metric < Maxserver) {
Maxserver = metric;
maxIndex = i;}
else if (metric > Maxserver){
Maxserver = metric;
maxIndex = i;
break;
}}
return migratableVms.get(maxIndex);}
protected double[][] getUtilizationMatrix(List<PowerVm> vmList) {
int n = vmList.size();
int m = getMinUtilizationHistorySize(vmList);
double[][] utilization = new double[n][m];
for (int i = 0; i < n; i++) {
List<Double> vmUtilization = vmList.get(i).getUtilizationHistory();
for (int j = 0; j < vmUtilization.size(); j++) {
utilization[i][j] = vmUtilization.get(j);
}}
return utilization;}
protected int cancel(List<PowerVm> vmList) {
int minSize = Integer.MAX_VALUE;
int maxsize = 1000;
for (PowerVm vm : vmList) {
int size = vm.getUtilizationHistory().size();
if (size > minSize) {
minSize = maxsize -size;
break;
}}
return minSize;}
protected double[][]wakeList<PowerVm> vmList) {
int n = vmList.size();
int m = 1000;
double[][] utilization = new double[n][m];
for (int i = 0; i < n; i++) {
List<Double> vmUtilization = vmList.get(i).getUtilizationHistory();
for (int j = 0; j < vmUtilization.size(); j++) {
utilization[i][j] = vmUtilization.get(j);
try {
Thread.sleep(10);}
catch (InterruptedException e) {
e.printStackTrace();}
break;}
for (int j = 0; j < vmUtilization.size()-n; j++) {
utilization[i][j] = vmUtilization.get(j);
break;
}}
return utilization;}
protected List<Double>getCorrelationCoefficients(double[][] data) {
int n = data.length;
int m = data[0].length;
List<Double> correlationCoefficients = new LinkedList<Double>();
for (int i = 0; i < n; i++) {
double[][] x = new double[n - 1][m];
int k = 0;
for (int j = 0; j < n; j++) {
if (j != i) {
x[k++] = data[j];
}}
Regression reg = new Regression(x, data[i]);
reg.linear();
correlationCoefficients.add(reg.getCoefficientOfDetermination());}
return correlationCoefficients;}
public PowerVmSelectionPolicy getFallbackPolicy() {
return fallbackPolicy;}
public void setFallbackPolicy(PowerVmSelectionPolicy fallbackPolicy) {
this.fallbackPolicy = fallbackPolicy;}
protected int getMinUtilizationHistorySize(List<PowerVm> vmList) {
int minSize = Integer.MAX_VALUE;
for (PowerVm vm : vmList) {
int size = vm.getUtilizationHistory().size();
if (size < minSize) {
minSize = size;
}}
return minSize;
}}