Generate code to load the given double on stack.

@param k the constant
554666
public void addPush(double k) {
        if (k == 0.0) {
            // zero
            add(ByteCode.DCONST_0);
            if (1.0 / k < 0) {
                // Negative zero
                add(ByteCode.DNEG);
            }
        } else if (k == 1.0 || k == -1.0) {
            add(ByteCode.DCONST_1);
            if (k < 0) {
                add(ByteCode.DNEG);
            }
        } else {
            addLoadConstant(k);
        }
    }
1262817
private static int incrementOrOne(@SuppressWarnings("unused") Object k, Integer i) {
        return i == null ? 1 : Math.addExact(i, 1);
    }
333821
void write(ByteCodeWriter out)
    throws IOException
  {
    out.write(ConstantPool.CP_DOUBLE);
    out.writeDouble(_value);
  }
604333
public double getDouble(String key, double defaultValue) {
    if (containsKey(key)) {
      return Double.parseDouble(get(key));
    } else {
      return defaultValue;
    }
  }
241227
private void loadBlankValue(CodeAssembler a, TypeDesc type) {
        switch (type.getTypeCode()) {
        case TypeDesc.OBJECT_CODE:
            a.loadNull();
            break;
        case TypeDesc.LONG_CODE:
            a.loadConstant(0L);
            break;
        case TypeDesc.FLOAT_CODE:
            a.loadConstant(0.0f);
            break;
        case TypeDesc.DOUBLE_CODE:
            a.loadConstant(0.0d);
            break;
        case TypeDesc.INT_CODE: default:
            a.loadConstant(0);
            break;
        }
    }
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;
  }
370848
private void generateCacheHitReturn() {
        // stack:
        generateGetFromCache();
        // stack: <cachedValue>
        insert(new InsnNode(DUP));
        // stack: <cachedValue> :: <cachedValue>
        LabelNode cacheMissLabel = new LabelNode();
        insert(new JumpInsnNode(IFNULL, cacheMissLabel));
        // stack: <cachedValue>
        insert(new InsnNode(ARETURN));
        // stack: <null>
        insert(cacheMissLabel);
        // stack: <null>
        insert(new InsnNode(POP));
        // stack:
    }
1102053
@Override
  public List<DoubleSolution> execute(List<DoubleSolution> parentSolutions) {
    DoubleSolution child;

    int jrand;

    child = (DoubleSolution)currentSolution.copy() ;

    int numberOfVariables = parentSolutions.get(0).getNumberOfVariables();
    jrand = jRandomGenerator.getRandomValue(0, numberOfVariables - 1);

    // STEP 4. Checking the DE variant
    if ((DEFAULT_DE_VARIANT.equals(variant)) ||
            "best/1/bin".equals(variant)) {
      for (int j = 0; j < numberOfVariables; j++) {
        if (crRandomGenerator.getRandomValue(0.0, 1.0) < cr || j == jrand) {
          double value;
          value = parentSolutions.get(2).getVariableValue(j) + f * (parentSolutions.get(0).getVariableValue(
            j) -
            parentSolutions.get(1).getVariableValue(j));

          if (value < child.getLowerBound(j)) {
            value = child.getLowerBound(j);
          }
          if (value > child.getUpperBound(j)) {
            value = child.getUpperBound(j);
          }
          child.setVariableValue(j, value);
        } else {
          double value;
          value = currentSolution.getVariableValue(j);
          child.setVariableValue(j, value);
        }
      }
    } else if ("rand/1/exp".equals(variant) ||
            "best/1/exp".equals(variant)) {
      for (int j = 0; j < numberOfVariables; j++) {
        if (crRandomGenerator.getRandomValue(0.0, 1.0) < cr || j == jrand) {
          double value;
          value = parentSolutions.get(2).getVariableValue(j) + f * (parentSolutions.get(0).getVariableValue(j) -
                  parentSolutions.get(1).getVariableValue(j));

          if (value < child.getLowerBound(j)) {
            value = child.getLowerBound(j);
          }
          if (value > child.getUpperBound(j)) {
            value = child.getUpperBound(j);
          }

          child.setVariableValue(j, value);
        } else {
          cr = 0.0;
          double value;
          value = currentSolution.getVariableValue(j);
          child.setVariableValue(j, value);
        }
      }
    } else if ("current-to-rand/1".equals(variant) ||
            "current-to-best/1".equals(variant)) {
      for (int j = 0; j < numberOfVariables; j++) {
        double value;
        value = currentSolution.getVariableValue(j) + k * (parentSolutions.get(2).getVariableValue(j) -
                currentSolution.getVariableValue(j)) +
                f * (parentSolutions.get(0).getVariableValue(j) - parentSolutions.get(1).getVariableValue(j));

        if (value < child.getLowerBound(j)) {
          value = child.getLowerBound(j);
        }
        if (value > child.getUpperBound(j)) {
          value = child.getUpperBound(j);
        }

        child.setVariableValue(j, value);
      }
    } else if ("current-to-rand/1/bin".equals(variant) ||
            "current-to-best/1/bin".equals(variant)) {
      for (int j = 0; j < numberOfVariables; j++) {
        if (crRandomGenerator.getRandomValue(0.0, 1.0) < cr || j == jrand) {
          double value;
          value = currentSolution.getVariableValue(j) + k * (parentSolutions.get(2).getVariableValue(j) -
                  currentSolution.getVariableValue(j)) +
                  f * (parentSolutions.get(0).getVariableValue(j) - parentSolutions.get(1).getVariableValue(j));

          if (value < child.getLowerBound(j)) {
            value = child.getLowerBound(j);
          }
          if (value > child.getUpperBound(j)) {
            value = child.getUpperBound(j);
          }

          child.setVariableValue(j, value);
        } else {
          double value;
          value = currentSolution.getVariableValue(j);
          child.setVariableValue(j, value);
        }
      }
    } else if ("current-to-rand/1/exp".equals(variant) ||
            "current-to-best/1/exp".equals(variant)) {
      for (int j = 0; j < numberOfVariables; j++) {
        if (crRandomGenerator.getRandomValue(0.0, 1.0) < cr || j == jrand) {
          double value;
          value = currentSolution.getVariableValue(j) + k * (parentSolutions.get(2).getVariableValue(j) -
                  currentSolution.getVariableValue(j)) +
                  f * (parentSolutions.get(0).getVariableValue(j) - parentSolutions.get(1).getVariableValue(j));

          if (value < child.getLowerBound(j)) {
            value = child.getLowerBound(j);
          }
          if (value > child.getUpperBound(j)) {
            value = child.getUpperBound(j);
          }

          child.setVariableValue(j, value);
        } else {
          cr = 0.0;
          double value;
          value = currentSolution.getVariableValue(j);
          child.setVariableValue(j, value);
        }
      }
    } else {
      JMetalLogger.logger.severe("DifferentialEvolutionCrossover.execute: " +
              " unknown DE variant (" + variant + ")");
      Class<String> cls = String.class;
      String name = cls.getName();
      throw new JMetalException("Exception in " + name + ".execute()");
    }

    List<DoubleSolution> result = new ArrayList<>(1) ;
    result.add(child) ;
    return result;
  }
562763
public static void set(
        MutableDoubleArrayND a0, DoubleSupplier s)
    {
        a0.coordinates().parallel().forEach(t ->
        {
            a0.set(t, s.getAsDouble());
        });
    }
938372
@Override
  public DoubleSolution execute(DoubleSolution solution) {
    if (null == solution) {
      throw new JMetalException("Null parameter");
    }

    doMutation(mutationProbability, solution);

    return solution;
  }
1029330
@NonNull
    @Override
    public MutableDictionary setDouble(@NonNull String key, double value) {
        return setValue(key, value);
    }
492041
@PublicEvolving
	public void setDouble(ConfigOption<Double> key, double value) {
		setValueInternal(key.key(), value);
	}
639264
private final boolean doublec(int j) {
		if (j < k0 + 1)
			return false;
		if (b[j] != b[j - 1])
			return false;
		return cons(j);
	}
1127987
final protected function v($d = null, $k = null) {
		$k = $k ?: df_caller_f();
		return $this->cfg(df_const($this, $k, $k), $d);
	}
1229387
@NotNull
    public static DoubleStream generate(@NotNull final DoubleSupplier s) {
        Objects.requireNonNull(s);
        return new DoubleStream(new DoubleGenerate(s));
    }
459711
public static double[] breaks(double[] x, int k) {
        return breaks(Math.min(x), Math.max(x), k);
    }
1175942
public void math(byte opcode) {
        int stackAdjust;
        
        switch(opcode) {
        case Opcode.INEG:
        case Opcode.LNEG:
        case Opcode.FNEG:
        case Opcode.DNEG:
            stackAdjust = 0;
            break;
        case Opcode.IADD:
        case Opcode.ISUB:
        case Opcode.IMUL:
        case Opcode.IDIV:
        case Opcode.IREM:
        case Opcode.IAND:
        case Opcode.IOR:
        case Opcode.IXOR:
        case Opcode.ISHL:
        case Opcode.ISHR:
        case Opcode.IUSHR:
        case Opcode.FADD:
        case Opcode.FSUB:
        case Opcode.FMUL:
        case Opcode.FDIV:
        case Opcode.FREM:
        case Opcode.FCMPG:
        case Opcode.FCMPL:
        case Opcode.LSHL:
        case Opcode.LSHR:
        case Opcode.LUSHR:
            stackAdjust = -1;
            break;
        case Opcode.LADD:
        case Opcode.LSUB:
        case Opcode.LMUL:
        case Opcode.LDIV:
        case Opcode.LREM:
        case Opcode.LAND:
        case Opcode.LOR:
        case Opcode.LXOR:
        case Opcode.DADD:
        case Opcode.DSUB:
        case Opcode.DMUL:
        case Opcode.DDIV:
        case Opcode.DREM:
            stackAdjust = -2;
            break;
        case Opcode.LCMP:
        case Opcode.DCMPG:
        case Opcode.DCMPL:
            stackAdjust = -3;
            break;
        default:
            throw new IllegalArgumentException
                ("Not a math opcode: " + Opcode.getMnemonic(opcode));
        }

        TypeDesc pushed;

        switch(opcode) {
        case Opcode.INEG:
        case Opcode.IADD:
        case Opcode.ISUB:
        case Opcode.IMUL:
        case Opcode.IDIV:
        case Opcode.IREM:
        case Opcode.IAND:
        case Opcode.IOR:
        case Opcode.IXOR:
        case Opcode.ISHL:
        case Opcode.ISHR:
        case Opcode.IUSHR:
        case Opcode.LCMP:
        case Opcode.FCMPG:
        case Opcode.FCMPL:
        case Opcode.DCMPG:
        case Opcode.DCMPL:
            pushed = TypeDesc.INT;
            break;
        case Opcode.LNEG:
        case Opcode.LADD:
        case Opcode.LSUB:
        case Opcode.LMUL:
        case Opcode.LDIV:
        case Opcode.LREM:
        case Opcode.LAND:
        case Opcode.LOR:
        case Opcode.LXOR:
        case Opcode.LSHL:
        case Opcode.LSHR:
        case Opcode.LUSHR:
            pushed = TypeDesc.LONG;
            break;
        case Opcode.FNEG:
        case Opcode.FADD:
        case Opcode.FSUB:
        case Opcode.FMUL:
        case Opcode.FDIV:
        case Opcode.FREM:
            pushed = TypeDesc.FLOAT;
            break;
        case Opcode.DNEG:
        case Opcode.DADD:
        case Opcode.DSUB:
        case Opcode.DMUL:
        case Opcode.DDIV:
        case Opcode.DREM:
            pushed = TypeDesc.DOUBLE;
            break;
        default:
            throw new IllegalArgumentException
                ("Not a math opcode: " + Opcode.getMnemonic(opcode));
        }

        addInstruction(stackAdjust, pushed, opcode);
    }