Calculates Minimum.

@param flatDataCollection
@return
193077
public static double min(FlatDataCollection flatDataCollection) {
        double min=Double.POSITIVE_INFINITY;
        
        Iterator<Double> it = flatDataCollection.iteratorDouble();
        while(it.hasNext()) {
            Double v = it.next();
            if(v != null && min > v) {
                min=v;
            }
        } 
        
        return min;
    }
271003
function() {
            	var mins = [];

            	for(var i = 1; i <= this.rows(); i++) {
            	    var min = null;
            	    var minIndex = -1;

            	    for(var j = 1; j <= this.cols(); j++) {
            		if(min === null || this.e(i, j) < min) {
            		    min = this.e(i, j);
            		    minIndex = j;
            		}
            	    }

            	    mins.push(minIndex);
            	}

            	return $V(mins);
                }
713504
public static AssociativeArray frequencies(FlatDataCollection flatDataCollection) {
        AssociativeArray frequencies = new AssociativeArray();
        
        for (Object value : flatDataCollection) {
            Object counter = frequencies.get(value);
            if(counter==null) {
                frequencies.put(value, 1);
            }
            else {
                frequencies.put(value, ((Number)counter).intValue()+1);
            }
        }
        
        return frequencies;
    }
249928
public static double sum(FlatDataCollection flatDataCollection) {
        double sum = 0.0;
        
        Iterator<Double> it = flatDataCollection.iteratorDouble();
        while(it.hasNext()) {
            Double value = it.next();
            if(value != null) {
                sum+= value;
            }
        }
        
        return sum;
    }
307871
public static long min(long... numberArray) {
		if (isEmpty(numberArray)) {
			throw new IllegalArgumentException("Number array must not empty !");
		}
		long min = numberArray[0];
		for (int i = 0; i < numberArray.length; i++) {
			if (min > numberArray[i]) {
				min = numberArray[i];
			}
		}
		return min;
	}
654942
@SuppressWarnings("unchecked")
    public NumberExpression<T> min() {
        if (min == null) {
            min = Expressions.numberOperation(getType(), Ops.AggOps.MIN_AGG, mixin);
        }
        return min;
    }
1373926
public static double std(FlatDataCollection flatDataCollection, boolean isSample) {
        double variance = variance(flatDataCollection, isSample);
        double std = Math.sqrt(variance);
        
        return std;
    }
114951
public static double min(double... nums) {
    double min = nums[0];
    for (int i = 1; i < nums.length; i++) {
      if (nums[i] > min) {
        min = nums[i];
      }
    }
    return min;
  }
913054
public static double geometricMean(FlatDataCollection flatDataCollection) {
	    int n = 0;
        double geometricMean = 0.0;

        Iterator<Double> it = flatDataCollection.iteratorDouble();
        while(it.hasNext()) {
            Double v = it.next();
            if(v != null) {
                if(v <= 0.0) {
                    throw new IllegalArgumentException("Negative or zero values are not allowed.");
                }
                ++n;
                geometricMean+= Math.log(v);
            }
        }
        
        geometricMean= Math.exp(geometricMean/n);
        
        return geometricMean;
    }
471641
public static double[] getMinimumValues(Front front) {
    if (front == null) {
      throw new NullFrontException() ;
    } else if (front.getNumberOfPoints() == 0) {
      throw new EmptyFrontException() ;
    }

    int numberOfObjectives = front.getPoint(0).getDimension() ;

    double[] minimumValue = new double[numberOfObjectives];
    for (int i = 0; i < numberOfObjectives; i++) {
      minimumValue[i] = Double.MAX_VALUE;
    }

    for (int i = 0 ; i < front.getNumberOfPoints(); i++) {
      for (int j = 0; j < numberOfObjectives; j++) {
        if (front.getPoint(i).getValue(j) < minimumValue[j]) {
          minimumValue[j] = front.getPoint(i).getValue(j);
        }
      }
    }

    return minimumValue;
  }
1199083
@NotNull
    public OptionalDouble min() {
        return reduce(new DoubleBinaryOperator() {
            @Override
            public double applyAsDouble(double left, double right) {
                return Math.min(left, right);
            }
        });
    }
350120
@Pure
	public static double min(double... values) {
		if (values == null || values.length == 0) {
			return Double.NaN;
		}
		double min = values[0];
		for (final double v : values) {
			if (v < min) {
				min = v;
			}
		}
		return min;
	}
700774
double[] findMinMax(Collection<?> data, DataType dataType) {

    double min = Double.MAX_VALUE;
    double max = -Double.MAX_VALUE;

    for (Object dataPoint : data) {

      if (dataPoint == null) {
        continue;
      }

      double value = 0.0;

      if (dataType == DataType.Number) {
        value = ((Number) dataPoint).doubleValue();
      } else if (dataType == DataType.Date) {
        Date date = (Date) dataPoint;
        value = date.getTime();
      } else if (dataType == DataType.String) {
        return new double[] {Double.NaN, Double.NaN};
      }
      if (value < min) {
        min = value;
      }
      if (value > max) {
        max = value;
      }
    }

    return new double[] {min, max};
  }
638393
public static int min(int[] x) {
        int m = x[0];

        for (int n : x) {
            if (n < m) {
                m = n;
            }
        }

        return m;
    }
132559
public static <T extends Object & Comparable<? super T>> T min(Collection<? extends T> coll) {
		return Collections.min(coll);
	}
211586
static double min(double[] values) {
        double min = values[0];
        for (double value : values)
            if (value < min) min = value;
        return min;
    }
348060
public static double min(DoubleTuple t)
    {
        return DoubleTupleFunctions.reduce(
            t, Double.POSITIVE_INFINITY, Math::min);
    }