Returns a normalized front
@param front
@return
13130
public Front normalize(Front front) {
    if (front == null) {
      throw new JMetalException("The front is null") ;
    }

    return getNormalizedFront(front, maximumValues, minimumValues);
  }
1282432
public Element<T> getElement( int index , boolean fromFront ) {
		if( index > size || index < 0 ) {
			throw new IllegalArgumentException("index is out of bounds");
		}
		if( fromFront ) {
			Element<T> e = first;
			for( int i = 0; i < index; i++ ) {
				e = e.next;
			}
			return e;
		} else {
			Element<T> e = last;
			for( int i = 0; i < index; i++ ) {
				e = e.previous;
			}
			return e;
		}
	}
103675
public String getNormalizedLocalPart() {
        int i = localPart.indexOf("#");
        if(i!=-1)
            return localPart.substring(0, i);
        else
            return localPart;
    }
32404
public String normalize(CharSequence src) {
        if(src instanceof String) {
            // Fastpath: Do not construct a new String if the src is a String
            // and is already normalized.
            int spanLength=spanQuickCheckYes(src);
            if(spanLength==src.length()) {
                return (String)src;
            }
            StringBuilder sb=new StringBuilder(src.length()).append(src, 0, spanLength);
            return normalizeSecondAndAppend(sb, src.subSequence(spanLength, src.length())).toString();
        }
        return normalize(src, new StringBuilder(src.length())).toString();
    }
91227
public String getAssignedRealNode(Object factor) {
		if(nodes.size() <= 1)return JobContext.getContext().getNodeId();
		Long key = hash(factor.toString());
		SortedMap<Long, String> tailMap = nodes.tailMap(key);
		if (tailMap.isEmpty()) {
			key = nodes.firstKey();
		} else {
			key = tailMap.firstKey();
		}
		return nodes.get(key);
	}
932018
protected Collection<String> normalize(String string, final boolean tokenize) {
        if (string == null) {
            return Collections.emptyList();
        }
        if (tokenize) {
            final Collection<String> result = new LinkedHashSet<>();

            result.addAll(normalize(string, false));

            final Splitter splitter = Splitter.on(' ').omitEmptyStrings();
            final List<String> tokens = splitter.splitToList(string);
            for (final String token : tokens) {
                final Collection<String> normalizedTokens = normalize(token, false);
                result.addAll(normalizedTokens);
            }
            return result;
        } else {
            string = StringUtils.replaceWhitespaces(string, "");
            string = StringUtils.replaceAll(string, "-", "");
            string = StringUtils.replaceAll(string, "_", "");
            string = StringUtils.replaceAll(string, "|", "");
            string = StringUtils.replaceAll(string, "*", "");
            string = string.toUpperCase();
            if (string.isEmpty()) {
                return Collections.emptyList();
            }
            final String withoutNumbers = string.replaceAll("[0-9]", "");
            if (withoutNumbers.equals(string) || withoutNumbers.isEmpty()) {
                return Arrays.asList(string);
            }
            return Arrays.asList(string, withoutNumbers);
        }
    }
226790
public static <C extends Comparable<? super C>>
	Collector<C, ?, ParetoFront<C>> toParetoFront() {
		return toParetoFront(Comparator.naturalOrder());
	}
2877
public static double[][] convertFrontToArray(Front front) {
    if (front == null) {
      throw new NullFrontException();
    }

    double[][] arrayFront = new double[front.getNumberOfPoints()][] ;

    for (int i = 0; i < front.getNumberOfPoints(); i++) {
      arrayFront[i] = new double[front.getPoint(i).getDimension()] ;
      for (int j = 0 ; j < front.getPoint(i).getDimension(); j++) {
        arrayFront[i][j] = front.getPoint(i).getValue(j) ;
      }
    }

    return arrayFront ;
  }
37187
public String normalize(String input, Language language) {
      if (input == null) {
         return null;
      }
      String finalString = input;
      for (TextNormalizer textNormalizer : preprocessors) {
         finalString = textNormalizer.apply(finalString, language);
      }
      return finalString;
   }
482589
def bring_to_front(self):
        """"""
        if not self.parent:
            return
        self.z_order = self.parent._z_ordered_sprites[-1].z_order + 1
985944
public static String normalizeExponents(String input) {
        Matcher m = eExp.matcher(input);
        if (m.find()) {

            Float number = Float.parseFloat(m.group(1));
            int exp = Integer.parseInt(m.group(3));
            boolean negative = m.group(2) != null && m.group(2).equals("-");
            if (negative)
                exp *= -1;

            return FORMATTER.format(number * Math.pow(10, exp));
        }

        // TODO refactor into 1
        m = xExp.matcher(input);
        if (m.find()) {

            Float number = Float.parseFloat(m.group(1));
            int exp = Integer.parseInt(m.group(3));
            boolean negative = m.group(2) != null && m.group(2).equals("-");
            if (negative)
                exp *= -1;

            String s = FORMATTER.format(number * Math.pow(10, exp));
            return s;
        }

        return input;
    }
741880
public static function &getFront($instance)
	{
		static $instances;
		if (!isset($instances)) {
			$instances = array();
		}
		//only create a new plugin instance if it has not been created before
		if (!isset($instances[$instance])) {
			$name = static::getNameFromInstance($instance);

			static::pluginAutoLoad($name);

			$class = '\JFusion\Plugins\\' . $name . '\Front';
			if (!class_exists($class)) {
				$class = '\JFusion\Plugin\Front';
			}
			$instances[$instance] = new $class($instance);
		}
		return $instances[$instance];
	}
400733
@SuppressWarnings("unchecked")
  public static <S extends Solution<?>> List<S> getInvertedFront(List<S> solutionSet) {
    List<S> invertedFront = new ArrayList<>(solutionSet.size());
    int numberOfObjectives = solutionSet.get(0).getNumberOfObjectives();

    for (int i = 0; i < solutionSet.size(); i++) {
      invertedFront.add(i, (S) solutionSet.get(i).copy());
      for (int j = 0; j < numberOfObjectives; j++) {
        if (solutionSet.get(i).getObjective(j) <= 1.0 &&
            solutionSet.get(i).getObjective(j) >= 0.0) {
          invertedFront.get(i).setObjective(j, 1.0 - solutionSet.get(i).getObjective(j));
        } else if (solutionSet.get(i).getObjective(j) > 1.0) {
          invertedFront.get(i).setObjective(j, 0.0);
        } else if (solutionSet.get(i).getObjective(j) < 0.0) {
          invertedFront.get(i).setObjective(j, 1.0);
        }
      }
    }
    return invertedFront;
  }
1343571
private double er(Front front, Front referenceFront) throws JMetalException {
    int numberOfObjectives = referenceFront.getPointDimensions() ;
    double sum = 0;

    for (int i = 0; i < front.getNumberOfPoints(); i++) {
      Point currentPoint = front.getPoint(i);
      boolean thePointIsInTheParetoFront = false;
      for (int j = 0; j < referenceFront.getNumberOfPoints(); j++) {
        Point currentParetoFrontPoint = referenceFront.getPoint(j);
        boolean found = true;
        for (int k = 0; k < numberOfObjectives; k++) {
          if(currentPoint.getValue(k) != currentParetoFrontPoint.getValue(k)){
            found = false;
            break;
          }
        }
        if(found){
          thePointIsInTheParetoFront = true;
          break;
        }
      }
      if(!thePointIsInTheParetoFront){
        sum++;
      }
    }

    return sum / front.getNumberOfPoints();
  }
32764
protected MatchingPart toPart(List<MatchingPart> leadingParts, String part) {
        if (ANY_INDICATOR.equals(part)) {
            return getAnyPart();
        }
        // This part is a constant string
        return createConstantPart(part);
    }
711975
public static String normalize(final String uri) {
        String normalizedUri = null;
        if (uri != null) {
            normalizedUri = uri; // TODO THIS HAS TO BE IMPLEMENTED
        }
        return normalizedUri;
    }
1261999
public static String trimInFront(String buffer) {
        // remove spaces in front
        int count = 0;
        for (int i = 0; i < buffer.length(); i++) {
            if (buffer.charAt(i) == SPACE_CHAR)
                count++;
            else
                break;
        }
        if (count > 0)
            return buffer.substring(count);
        else
            return buffer;
    }