Returns a normalized front
@param solutionList
@return
359992
public List<? extends Solution<?>> normalize(List<? extends Solution<?>> solutionList) {
    Front normalizedFront ;
    if (solutionList == null) {
      throw new JMetalException("The front is null") ;
    }

    normalizedFront = getNormalizedFront(new ArrayFront(solutionList), maximumValues, minimumValues);

    return FrontUtils.convertFrontToSolutionList(normalizedFront) ;
  }
968470
public <S extends Solution<?>> void execute(List<S> solutionsList) {
    switch (config.scalarizationType) {
      case ANGLE_UTILITY:
        if (config.extremePoints == null)
          ScalarizationUtils.angleUtility(solutionsList);
        else
          ScalarizationUtils.angleUtility(solutionsList, config.extremePoints);
        break;
      case CHEBYSHEV:
        if (config.idealValues == null)
          ScalarizationUtils.chebyshev(solutionsList);
        else
          ScalarizationUtils.chebyshev(solutionsList, config.idealValues);
        break;
      case NASH:
        if (config.nadirValues == null)
          ScalarizationUtils.nash(solutionsList);
        else
          ScalarizationUtils.nash(solutionsList, config.nadirValues);
        break;
      case SUM_OF_OBJECTIVES:
        ScalarizationUtils.sumOfObjectives(solutionsList);
        break;
      case PRODUCT_OF_OBJECTIVES:
        ScalarizationUtils.productOfObjectives(solutionsList);
        break;
      case TRADEOFF_UTILITY:
        ScalarizationUtils.tradeoffUtility(solutionsList);
        break;
      case UNIFORM:
        ScalarizationUtils.uniform(solutionsList);
        break;
      case WEIGHTED_CHEBYSHEV:
        if (config.idealValues == null)
          ScalarizationUtils.weightedChebyshev(solutionsList, config.weights);
        else
          ScalarizationUtils.weightedChebyshev(solutionsList, config.idealValues, config.weights);
        break;
      case WEIGHTED_PRODUCT:
        ScalarizationUtils.weightedProduct(solutionsList, config.weights);
        break;
      case WEIGHTED_SUM:
        ScalarizationUtils.weightedSum(solutionsList, config.weights);
        break;
    }
  }
863851
private void updateReferencePoint(List<? extends Solution<?>> solutionList) {
    double[] maxObjectives = new double[numberOfObjectives];
    for (int i = 0; i < numberOfObjectives; i++) {
      maxObjectives[i] = 0;
    }

    for (int i = 0; i < solutionList.size(); i++) {
      for (int j = 0; j < numberOfObjectives; j++) {
        if (maxObjectives[j] < solutionList.get(i).getObjective(j)) {
          maxObjectives[j] = solutionList.get(i).getObjective(j) ;
        }
      }
    }

    if (referencePoint == null) {
      referencePoint = new ArrayPoint(numberOfObjectives) ;
      for (int i = 0; i < numberOfObjectives ; i++) {
        referencePoint.setValue(i, Double.MAX_VALUE);
      }
    }

    for (int i = 0; i < referencePoint.getDimension(); i++) {
      referencePoint.setValue(i, maxObjectives[i] + offset);
    }
  }
711519
public static ArgumentPredicate options(List<String> optionList) {
        return regex(Joiner.on("|").join(Lists.transform(optionList, new Function<String, String>() {
            @Override
            public String apply(String s) {
                return Pattern.quote(s);
            }
        })));
    }
873931
public java.util.List<String> getHsmList() {
        if (hsmList == null) {
            hsmList = new com.amazonaws.internal.SdkInternalList<String>();
        }
        return hsmList;
    }
352443
private void updateLimits(List<S> solutionList) {
    for (int obj = 0; obj < numberOfObjectives; obj++) {
      gridLowerLimits[obj] = Double.MAX_VALUE;
      gridUpperLimits[obj] = Double.MIN_VALUE;
    }

    //Find the max and min limits of objetives into the population
    for (int ind = 0; ind < solutionList.size(); ind++) {
      Solution<?> tmpIndividual = solutionList.get(ind);
      for (int obj = 0; obj < numberOfObjectives; obj++) {
        if (tmpIndividual.getObjective(obj) < gridLowerLimits[obj]) {
          gridLowerLimits[obj] = tmpIndividual.getObjective(obj);
        }
        if (tmpIndividual.getObjective(obj) > gridUpperLimits[obj]) {
          gridUpperLimits[obj] = tmpIndividual.getObjective(obj);
        }
      }
    }
  }
1151047
protected void remapFilteredList(final List filteredList) {
        rowNumbers = new HashMap<>(rowMap.size());
        final FacesContext context = FacesContext.getCurrentInstance();
        final Map<String, Object> requestMap = context.getExternalContext().getRequestMap();
        final String var = getVar();
        int row = 0;
        for (final Object value : filteredList) {
            requestMap.put(var, value);
            rowNumbers.put(getRowKeyValueAsString(context), Integer.valueOf(row));
            row++;
        }
        requestMap.remove(var);
    }
1350183
public List<S> execute(List<S> solutionList) {
    if (null == solutionList) {
      throw new JMetalException("The solution list is null") ;
    } else if (solutionList.isEmpty()) {
      throw new JMetalException("The solution list is empty") ;
    } else if (solutionList.size() < numberOfSolutionsToBeReturned) {
      throw new JMetalException("The solution list size (" + solutionList.size() +") is less than "
          + "the number of requested solutions ("+numberOfSolutionsToBeReturned+")") ;
    }

    return SolutionListUtils.selectNRandomDifferentSolutions(numberOfSolutionsToBeReturned, solutionList) ;
  }
291041
@Override
  public List<DoubleSolution> execute(List<DoubleSolution> solutionSet) {
    if (null == solutionSet) {
      throw new JMetalException("Parameter is null") ;
    } else if ((solutionListIndex < 0) || (solutionListIndex > solutionSet.size())) {
      throw new JMetalException(
              "Index value invalid: " + solutionListIndex );
    } else if (solutionSet.size() < 4) {
      throw new JMetalException(
          "The population has less than four solutions: " + solutionSet.size());
    }

    List<DoubleSolution> parents = new ArrayList<>(3);
    int r1, r2, r3;

    do {
      r1 = randomGenerator.getRandomValue(0, solutionSet.size() - 1);
    } while (r1 == solutionListIndex);
    do {
      r2 = randomGenerator.getRandomValue(0, solutionSet.size() - 1);
    } while (r2 == solutionListIndex || r2 == r1);
    do {
      r3 = randomGenerator.getRandomValue(0, solutionSet.size() - 1);
    } while (r3 == solutionListIndex || r3 == r1 || r3 == r2);

    parents.add(solutionSet.get(r1));
    parents.add(solutionSet.get(r2));
    parents.add(solutionSet.get(r3));

    return parents;
  }
966334
public FSArray getSegmentList() {
    if (MMAXAnnotation_Type.featOkTst && ((MMAXAnnotation_Type)jcasType).casFeat_segmentList == null)
      jcasType.jcas.throwFeatMissing("segmentList", "de.julielab.jules.types.mmax.MMAXAnnotation");
    return (FSArray)(jcasType.ll_cas.ll_getFSForRef(jcasType.ll_cas.ll_getRefValue(addr, ((MMAXAnnotation_Type)jcasType).casFeatCode_segmentList)));}
363864
private static <S extends Solution<?>> double[] getNadirValues(List<S> solutionsList) {
    ArrayFront front = new ArrayFront(solutionsList);
    FrontExtremeValues extremeValues = new FrontExtremeValues();
    List<Double> list = extremeValues.findHighestValues(front);
    return toArray(list);
  }
53752
public static <S extends Solution<?>> double[][] distanceMatrix(List<S> solutionSet) {
    double[][] distance = new double[solutionSet.size()][solutionSet.size()];
    for (int i = 0; i < solutionSet.size(); i++) {
      distance[i][i] = 0.0;
      for (int j = i + 1; j < solutionSet.size(); j++) {
        distance[i][j] = SolutionUtils.distanceBetweenObjectives(solutionSet.get(i), solutionSet.get(j));
        distance[j][i] = distance[i][j];
      }
    }
    return distance;
  }
13130
public Front normalize(Front front) {
    if (front == null) {
      throw new JMetalException("The front is null") ;
    }

    return getNormalizedFront(front, maximumValues, minimumValues);
  }
474432
public static <S extends Solution<?>> void sumOfObjectives(List<S> solutionsList) {
    for (S solution : solutionsList) {
      double sum = solution.getObjective(0);
      for (int i = 1; i < solution.getNumberOfObjectives(); i++) {
        sum += solution.getObjective(i);
      }
      setScalarizationValue(solution, sum);
    }
  }
1340859
private Component prepareCategoryFacets(CmsSolrResultList solrResultList, CmsSearchResultWrapper resultWrapper) {

        FacetField categoryFacets = solrResultList.getFacetField(CmsListManager.FIELD_CATEGORIES);
        I_CmsSearchControllerFacetField facetController = resultWrapper.getController().getFieldFacets().getFieldFacetController().get(
            CmsListManager.FIELD_CATEGORIES);
        if ((categoryFacets != null) && (categoryFacets.getValueCount() > 0)) {
            VerticalLayout catLayout = new VerticalLayout();
            for (final Count value : categoryFacets.getValues()) {
                Button cat = new Button(getCategoryLabel(value.getName()) + " (" + value.getCount() + ")");
                cat.addStyleName(ValoTheme.BUTTON_TINY);
                cat.addStyleName(ValoTheme.BUTTON_BORDERLESS);
                Boolean selected = facetController.getState().getIsChecked().get(value.getName());
                if ((selected != null) && selected.booleanValue()) {
                    cat.addStyleName(SELECTED_STYLE);
                }
                cat.addClickListener(new ClickListener() {

                    private static final long serialVersionUID = 1L;

                    public void buttonClick(ClickEvent event) {

                        if (isSelected(event.getComponent())) {
                            resetFacetsAndSearch();
                        } else {
                            selectFieldFacet(CmsListManager.FIELD_CATEGORIES, value.getName());
                        }
                    }
                });
                catLayout.addComponent(cat);
            }
            Panel catPanel = new Panel(CmsVaadinUtils.getMessageText(Messages.GUI_LISTMANAGER_FACET_CATEGORIES_0));
            catPanel.setContent(catLayout);
            return catPanel;
        } else {
            return null;
        }
    }
18507
public List<String> expressionsListToResolve()
    {
        String[] parts = expression.trim().split( "\\s+" );
        List<String> expressionsList = new ArrayList<String>();

        withDots( expressionsList, parts );
        noDots( expressionsList, parts );
        asIs( expressionsList, parts );

        return expressionsList;
    }
217367
public double feasibilityRatio(List<S> solutionSet) {
    double aux = 0.0;
    for (int i = 0; i < solutionSet.size(); i++) {
      if (overallConstraintViolation.getAttribute(solutionSet.get(i)) < 0) {
        aux = aux + 1.0;
      }
    }
    return aux / (double) solutionSet.size();
  }