Returns the column as a double.

@param index 1-based
@return column as a double
197960
public double getDouble(int index)
  {
    Object value = _values[index - 1];

    if (value instanceof Double) {
      return (Double) value;
    }
    else if (value instanceof Float) {
      return (Float) value;
    }
    else if (value instanceof Number) {
      return (Double) ((Number) value);
    }
    else {
      return Double.valueOf(value.toString());
    }
  }
1342878
public DoubleBuffer getTransposed(int index, DoubleBuffer buffer) {
        MemUtil.INSTANCE.putTransposed(this, index, buffer);
        return buffer;
    }
583112
@Override
  public final Double getDouble(final String pColumnName) throws Exception {
    int columnIndex = this.resultSet.getColumnIndex(pColumnName);
    Double result = null;
    if (!this.resultSet.isNull(columnIndex)) {
      result = this.resultSet.getDouble(columnIndex);
    }
    return result;
  }
1321448
@Override
    public double value(int indexAttribute) {
        int location = locateIndex(indexAttribute);
        //return location == -1 ? 0 : this.attributeValues[location];
        //      int index = locateIndex(attIndex);
        if ((location >= 0) && (indexValues[location] == indexAttribute)) {
            return attributeValues[location];
        } else {
            return 0.0;
        }
    }
505318
public double getDouble(String columnName, double defaultValue) {
        int index = getColumnIndex(columnName);
        if (isValidIndex(index)) {
            return getDouble(index);
        } else {
            return defaultValue;
        }
    }
439659
public double get(int i) {
		if (i < 0 || i >= N) throw new IllegalArgumentException("Illegal index " + i + " should be > 0 and < " + N);
		if (symbolTable.contains(i)) return symbolTable.get(i);
		else                return 0.0;
	}
1191958
public Double getDouble(String attr) {
		Number n = (Number)attrs.get(attr);
		return n != null ? n.doubleValue() : null;
	}
404415
public BigDecimal getBigDecimal(int index) throws JSONException {
		Object object = this.get(index);
		try {
			return new BigDecimal(object.toString());
		} catch (Exception e) {
			throw new JSONException("JSONArray[" + index +
					"] could not convert to BigDecimal.");
		}
	}
665505
@Override
    public float getFloat(int index) {
        check(index);
        final FLValue flValue = values.get(index);
        return flValue != null ? flValue.asFloat() : 0.0F;
    }
1352660
@CheckForNull
  public Double getDouble(String key) {
    String value = getString(key);
    if (StringUtils.isNotEmpty(value)) {
      try {
        return Double.valueOf(value);
      } catch (NumberFormatException e) {
        throw new IllegalStateException(String.format("The property '%s' is not a double value", key));
      }
    }
    return null;
  }
230860
@Override
    public int getScale( int column ) {
        JcrType typeInfo = getJcrType(column);
        if (typeInfo.getJcrType() == PropertyType.DOUBLE) {
            return 3; // pulled from thin air
        }
        return 0;
    }
342408
public static double stringToDouble(String string) {
        string = string.trim();
        if (Checker.isDecimal(string)) {
            return Double.parseDouble(string);
        }
        return -1;
    }
942591
public double getInternalDouble(ColumnInformation columnInfo) throws SQLException {
    if (lastValueWasNull()) {
      return 0;
    }
    switch (columnInfo.getColumnType()) {
      case BIT:
        return parseBit();
      case TINYINT:
        return getInternalTinyInt(columnInfo);
      case SMALLINT:
      case YEAR:
        return getInternalSmallInt(columnInfo);
      case INTEGER:
      case MEDIUMINT:
        return getInternalMediumInt(columnInfo);
      case BIGINT:
        long valueLong = ((buf[pos] & 0xff)
            + ((long) (buf[pos + 1] & 0xff) << 8)
            + ((long) (buf[pos + 2] & 0xff) << 16)
            + ((long) (buf[pos + 3] & 0xff) << 24)
            + ((long) (buf[pos + 4] & 0xff) << 32)
            + ((long) (buf[pos + 5] & 0xff) << 40)
            + ((long) (buf[pos + 6] & 0xff) << 48)
            + ((long) (buf[pos + 7] & 0xff) << 56)
        );
        if (columnInfo.isSigned()) {
          return valueLong;
        } else {
          return new BigInteger(1, new byte[]{(byte) (valueLong >> 56),
              (byte) (valueLong >> 48), (byte) (valueLong >> 40), (byte) (valueLong >> 32),
              (byte) (valueLong >> 24), (byte) (valueLong >> 16), (byte) (valueLong >> 8),
              (byte) valueLong}).doubleValue();
        }
      case FLOAT:
        return getInternalFloat(columnInfo);
      case DOUBLE:
        long valueDouble = ((buf[pos] & 0xff)
            + ((long) (buf[pos + 1] & 0xff) << 8)
            + ((long) (buf[pos + 2] & 0xff) << 16)
            + ((long) (buf[pos + 3] & 0xff) << 24)
            + ((long) (buf[pos + 4] & 0xff) << 32)
            + ((long) (buf[pos + 5] & 0xff) << 40)
            + ((long) (buf[pos + 6] & 0xff) << 48)
            + ((long) (buf[pos + 7] & 0xff) << 56));
        return Double.longBitsToDouble(valueDouble);
      case DECIMAL:
      case VARSTRING:
      case VARCHAR:
      case STRING:
      case OLDDECIMAL:
        try {
          return Double.valueOf(new String(buf, pos, length, StandardCharsets.UTF_8));
        } catch (NumberFormatException nfe) {
          SQLException sqlException = new SQLException(
              "Incorrect format for getDouble for data field with type "
                  + columnInfo.getColumnType().getJavaTypeName(), "22003", 1264);
          //noinspection UnnecessaryInitCause
          sqlException.initCause(nfe);
          throw sqlException;
        }
      default:
        throw new SQLException("getDouble not available for data field type "
            + columnInfo.getColumnType().getJavaTypeName());
    }
  }
1318648
public Integer getInteger (int index) {
        Long value = getLong (index);
        return (value != null) ? value.intValue () : null;
    }
1192364
public double getDouble(int index, double def) {
        Object tmp = mArray.get(index);
        return tmp != null && tmp instanceof Number ? ((Number) tmp)
                .doubleValue() : def;
    }
51005
private int offset(long index) {
    int offset = (int) (index % buffer.length);
    if (offset < 0) {
      offset += buffer.length;
    }
    return offset;
  }
520916
public static double getDouble(Cursor cursor, String columnName) {
        if (cursor == null) {
            return -1;
        }

        return cursor.getDouble(cursor.getColumnIndex(columnName));
    }