Returns the mode value of the array of doubles
552133
public static double mode(double[] values) {
        if (values.length == 0)
            throw new IllegalArgumentException("No mode in an empty array");        
        Counter<Double> c = new ObjectCounter<Double>();
        for (double d : values)
            c.count(d);
        return c.max();
    }
1172983
def modes(self):
        
        (self._modes, value) = self.get_cached_attr_set(self._modes, 'modes')
        return value
450235
def read_double(self, little_endian=True):
        
        if little_endian:
            endian = "<"
        else:
            endian = ">"
        return self.unpack("%sd" % endian, 8)
1095466
public double getDouble( int index ) throws OdaException
	{
		Double value = (Double) getFieldValue(index);
		return value==null?0:value;
	}
1123572
public double[] getSingularValues() {
        double ret[] = new double[W.numCols()];

        for (int i = 0; i < ret.length; i++) {
            ret[i] = getSingleValue(i);
        }
        return ret;
    }
938341
def mode(self):
        """"""
        mu = self.mean()
        sigma = self.std()
        ret_val = math.exp(mu - sigma**2)
        if math.isnan(ret_val):
            ret_val = float("inf")
        return ret_val
857608
def mode(data):
    
    c = Counter(data)
    mode, freq = c.most_common(1)[0]
    return mode
567113
@Override
    public double[] toDoubleArray() {
        double[] array = new double[numAttributes()];
        for (int i = 0; i < numValues(); i++) {
            array[index(i)] = valueSparse(i);
        }
        return array;
    }
175561
def parse_mode(m)
      result = 0
      (1..9).each do |i|
        result = 2 * result + ((m[i] == ?-) ? 0 : 1)
      end
      result
    end
1278296
def mode(name, num, minimum=0, maximum=0, ref=None):
    '''
    
    '''
    return calc(
        name=name,
        num=num,
        oper='mode',
        minimum=minimum,
        maximum=maximum,
        ref=ref
    )
298031
private double getParamDouble(String key, double defaultValue) {
        String value = values.get(key);
        if (value==null || value.isEmpty()) {
            return defaultValue;
        }
        try {
            return Double.valueOf(value);
        } catch (NumberFormatException e) {
            throw new RuntimeException("Invalid double value: >>>"+value+"<<<", e);
        }
    }
233207
public double[] toNativeArray() {
        final double[] arr = new double[getNumImplicitEntries()];
        iterate(new FnIntDoubleToVoid() {
            @Override
            public void call(int idx, double val) {
                arr[idx] = val;
            }
        });
        return arr;
    }
306794
def mode_number(self, rows: List[Row], column: NumberColumn) -> Number:
        
        most_frequent_list = self._get_most_frequent_values(rows, column)
        if not most_frequent_list:
            return 0.0  # type: ignore
        most_frequent_value = most_frequent_list[0]
        if not isinstance(most_frequent_value, Number):
            raise ExecutionError(f"Invalid valus for mode_number: {most_frequent_value}")
        return most_frequent_value
489870
private double getDouble(String valueAsStr)
    {
        return StringUtils.isNumeric(valueAsStr) ? Double.parseDouble(valueAsStr) : Double
                .parseDouble(((Integer) valueAsStr.hashCode()).toString());
    }
706154
def find_doubles(in_array)
      result = []
      find_not_uniq_words(in_array).each do |not_uniq_word|
        in_array.each do |url_desc_cont|
          result << url_desc_cont if url_desc_cont[1][0] && url_desc_cont[1][0].include?(not_uniq_word)
        end
      end
      result
    end
871933
public final double getDouble() {
        if (count == 0) {
            return 0.0;
        }

        StringBuffer temp = getStringBuffer();
        temp.append('.');
        temp.append(digits, 0, count);
        temp.append('E');
        temp.append(decimalAt);
        return Double.parseDouble(temp.toString());
    }
380304
protected Double eval(final Object[] _value)
    {
        final Double ret;

        if (_value == null) {
            ret = null;
        } else if ((_value[0] instanceof String) && (((String) _value[0]).length() > 0)) {
            ret = Double.parseDouble((String) _value[0]);
        } else if (_value[0] instanceof Number) {
            ret = ((Number) _value[0]).doubleValue();
        } else  {
            ret = null;
        }

        return ret;
    }