&lambda;<sub>1</sub> controls the L<sub>1</sub> regularization penalty.
@param lambda1 the L<sub>1</sub> regularization penalty to use
6007
public void setLambda1(double lambda1)
    {
        if(lambda1 < 0 || Double.isNaN(lambda1) || Double.isInfinite(lambda1))
            throw new IllegalArgumentException("Lambda1 must be non-negative, not " + lambda1);
        this.lambda1 = lambda1;
    }
939235
public static List<String> extractParameterNames(Serializable lambda, int lambdaParametersCount) {
        SerializedLambda serializedLambda = serialized(lambda);

        Method lambdaMethod = lambdaMethod(serializedLambda);
        String[] paramNames = paramNameReader.getParamNames(lambdaMethod);
        return asList(Arrays.copyOfRange(paramNames, paramNames.length - lambdaParametersCount, paramNames.length));
    }
643898
public void buildNewReferenceSet1() {
    DoubleSolution individual;
    strengthRawFitness.computeDensityEstimator(getPopulation());
    Collections.sort(getPopulation(), fitnessComparator);

    for (int i = 0; i < referenceSet1Size; i++) {
      individual = getPopulation().get(0);
      getPopulation().remove(0);
      marked.setAttribute(individual, false);
      referenceSet1.add(individual);
    }
  }
1216618
@Pure
	public static Point2d WSG84_L2(double lambda, double phi) {
		final Point2d ntfLambdaPhi = WSG84_NTFLamdaPhi(lambda, phi);
		return NTFLambdaPhi_NTFLambert(
				ntfLambdaPhi.getX(), ntfLambdaPhi.getY(),
				LAMBERT_2_N,
				LAMBERT_2_C,
				LAMBERT_2_XS,
				LAMBERT_2_YS);
	}
407405
public final <U1> Tuple1<U1> map1(Function<? super T1, ? extends U1> function) {
        return Tuple.tuple(function.apply(v1));
    }
54088
public void fill_1(byte[] v, int byteoff, int nbits, int bitoff) {
      if (nbits < 0) throw new NegativeArraySizeException("nbits < 0: " + nbits);
      if (byteoff < 0) throw new IndexOutOfBoundsException("byteoff < 0: "+ byteoff);
      if (bitoff < 0) throw new IndexOutOfBoundsException("bitoff < 0: " + bitoff);
      assert v == null || byteoff + ((nbits-1) >> 3) + 1 <= v.length;
      _val = v;
      _nbits = nbits;
      _bitoff = bitoff;
      _byteoff = byteoff;
    }
1120651
def _internal2external_lambda(bound):
    
    lower, upper = bound

    if lower is None and upper is None:  # no constraints
        return lambda x: x
    elif upper is None:     # only lower bound
        return lambda x: lower - 1. + sqrt(x * x + 1.)
    elif lower is None:     # only upper bound
        return lambda x: upper + 1. - sqrt(x * x + 1.)
    else:
        return lambda x: lower + ((upper - lower) / 2.) * (sin(x) + 1.)
1033029
private void enterMember(ClassSymbol c, Symbol sym) {
        // Synthetic members are not entered -- reason lost to history (optimization?).
        // Lambda methods must be entered because they may have inner classes (which reference them)
        if ((sym.flags_field & (SYNTHETIC|BRIDGE)) != SYNTHETIC || sym.name.startsWith(names.lambda))
            c.members_field.enter(sym);
    }
156843
public static <K> double estimatePenalty(double l1, Map<K, Double> weights) {
        double penalty = 0.0;
        if(l1 > 0.0) {
            double sumAbsWeights = 0.0;
            for(double w : weights.values()) {
                sumAbsWeights += Math.abs(w);
            }
            penalty = l1*sumAbsWeights;
        }
        return penalty;
    }
219532
protected boolean verifyCondition1(IContextMapping<INode> mapping, INode source, INode target) {
        return findRelation(mapping, IMappingElement.LESS_GENERAL, source.getAncestorsList(), target) ||
                findRelation(mapping, IMappingElement.LESS_GENERAL, source, target.getDescendantsList()) ||
                findRelation(mapping, IMappingElement.LESS_GENERAL, source.getAncestorsList(), target.getDescendantsList()) ||

                findRelation(mapping, IMappingElement.EQUIVALENCE, source.getAncestorsList(), target) ||
                findRelation(mapping, IMappingElement.EQUIVALENCE, source, target.getDescendantsList()) ||
                findRelation(mapping, IMappingElement.EQUIVALENCE, source.getAncestorsList(), target.getDescendantsList());
    }
435768
public static double[] minus(final double[] v1, final double s1) {
    final double[] result = new double[v1.length];
    for(int i = 0; i < v1.length; i++) {
      result[i] = v1[i] - s1;
    }
    return result;
  }
504059
public static void lsp_expand_1_2(
	 float  buf[],          /*in/out: LSP parameters  */
	 float  gap             /*input      */
	)
	{
	   int   j;
	   float diff, tmp;

	   for(j=1; j<LD8KConstants.M; j++) {
	      diff = buf[j-1] - buf[j];
	      tmp  = (diff + gap) * (float)0.5;
	      if(tmp >  0) {
	         buf[j-1] -= tmp;
	         buf[j]   += tmp;
	      }
	   }
	   return;
	}
962936
def l1_l2_regularizer(weight_l1=1.0, weight_l2=1.0, scope=None):
  
  def regularizer(tensor):
    with tf.name_scope(scope, 'L1L2Regularizer', [tensor]):
      weight_l1_t = tf.convert_to_tensor(weight_l1,
                                         dtype=tensor.dtype.base_dtype,
                                         name='weight_l1')
      weight_l2_t = tf.convert_to_tensor(weight_l2,
                                         dtype=tensor.dtype.base_dtype,
                                         name='weight_l2')
      reg_l1 = tf.multiply(weight_l1_t, tf.reduce_sum(tf.abs(tensor)),
                      name='value_l1')
      reg_l2 = tf.multiply(weight_l2_t, tf.nn.l2_loss(tensor),
                      name='value_l2')
      return tf.add(reg_l1, reg_l2, name='value')
  return regularizer
1197233
private ArrayList algorithm1(String S, String T) {
    ArrayList candidateList = new ArrayList();
    int bound = (int) (1.0 / tr);
    for (int t = 0; t < S.length(); t++) {
      char chT = S.charAt(t);
      double lastTr = -1;
      for (int u = Math.max(0, t - bound), flag = 0;
           u < Math.min(t + bound + 1, T.length()) && flag == 0; u++) {
        double tr2 = ( (double) Math.abs(t - u));
        if ( (lastTr >= 0.0) && (lastTr < tr2)) {
          flag = 1;
        }
        else {
          char chU = T.charAt(u);
          double charScore = 0.0;
          if(chT==chU){
            charScore = 1.0;
          }
          if (charScore > 0.0) {
            if (charScore == 1.0) {
              lastTr = tr2;
            }
            charScore = charScore - (tr * tr2);
            if (charScore == 1.0) {
              flag = 1;
            }
            candidateList.add(new TagLink.Candidates(t, u, charScore));
          }
        }
      }
    }
    return candidateList;
  }
386070
public void warnf(String format, Object param1) {
        if (isEnabled(Level.WARN)) {
            doLogf(Level.WARN, FQCN, format, new Object[] { param1 }, null);
        }
    }
1164951
public static <A> DecomposableMatchBuilder0<Tuple1<A>> tuple1(MatchesExact<A> a) {
    List<Matcher<Object>> matchers = Lists.of(ArgumentMatchers.eq(a.t));
    return new DecomposableMatchBuilder0<Tuple1<A>>(matchers, new Tuple1FieldExtractor<>());
  }
1203638
public static ExpressionSimplifier lambdaCalculus() {
    List<ExpressionReplacementRule> rules = Lists.newArrayList();
    rules.add(new LambdaApplicationReplacementRule());
    rules.add(new VariableCanonicalizationReplacementRule());
    return new ExpressionSimplifier(rules);
  }