Sets the regularization term, where smaller values indicate a larger
regularization penalty.

@param C the positive regularization term
427647
@WarmParameter(prefLowToHigh = true)
    public void setC(double C)
    {
        if(C <= 0 || Double.isInfinite(C) || Double.isNaN(C))
            throw new IllegalArgumentException("Regularization term C must be a positive value, not " + C);
        this.C = C;
    }
1005594
public void setSigma(double sigma)
    {
        if(sigma <= 0 || Double.isNaN(sigma) || Double.isInfinite(sigma))
            throw new ArithmeticException("sigma must be positive, not " + sigma);
        this.sigma = sigma;
    }
1163656
public static <E, C extends Counter<E>> C L2Normalize(C c) {
    return scale(c, 1.0 / L2Norm(c));
  }
183311
@Override
	public void set(double x, double y, double z, double radius1) {
		this.cx = x;
		this.cy = y;
		this.cz = z;
		this.radius = Math.abs(radius1);
	}
462472
public final boolean addConstraintNoPropagation(Constraint c) {
		this.skipPropagation = true;
		this.addConstraints(c);
		this.skipPropagation = false;
		return true;
	}
61371
protected void perturbCenter( Cluster c , int x , int y ) {
		float best = Float.MAX_VALUE;
		int bestX=0,bestY=0;

		for( int dy = -1; dy <= 1; dy++ ) {
			for( int dx = -1; dx <= 1; dx++ ) {
				float d = gradient(x + dx, y + dy);
				if( d < best ) {
					best = d;
					bestX = dx;
					bestY = dy;
				}
			}
		}

		c.x = x+bestX;
		c.y = y+bestY;
		setColor(c.color,x+bestX,y+bestY);
	}
470691
public Matrix subtract(double c)
    {
        Matrix toReturn = getThisSideMatrix(null);
        toReturn.mutableSubtract(c);
        return toReturn;
    }
1237030
public void set(byte b, Collection c) {
		if ((c != null) && (c.size() > 0)) {
			StringBuilder sb = new StringBuilder();
			Iterator it = c.iterator();
			while (it.hasNext()) {
				String s = (String) it.next();
				sb.append(s);
				if (it.hasNext())
					sb.append(lineSeparator);
			}
			set(b, sb.toString());
		} else
			remove(b);
	}
493272
public void setColumn(ColumnVector cv, int c)
        throws MatrixException
    {
        if ((c < 0) || (c >= nCols)) {
            throw new MatrixException(MatrixException.INVALID_INDEX);
        }
        if (nRows != cv.nRows) {
            throw new MatrixException(
                                MatrixException.INVALID_DIMENSIONS);
        }

        for (int r = 0; r < nRows; ++r) {
            this.values[r][c] = cv.values[r][0];
        }
    }
1206551
public void setMatrix(int[] r, int[] c, Matrix X)
    {
        try
        {
            for (int i = 0; i < r.length; i++)
            {
                for (int j = 0; j < c.length; j++)
                {
                    A[r[i]][c[j]] = X.get(i, j);
                }
            }
        }
        catch (ArrayIndexOutOfBoundsException e)
        {
            throw new ArrayIndexOutOfBoundsException("Submatrix indices");
        }
    }
1217351
private CLClause reduceClause(final CLClause c) {
        int lit;
        int i;
        for (i = 0; i < c.lits().size(); i++) {
            lit = c.lits().get(i);
            if (val(lit) < 0) { break; }
        }
        if (i == c.lits().size()) { return c; }
        assert this.addedlits.empty();
        for (i = 0; i < c.lits().size(); i++) {
            lit = c.lits().get(i);
            if (val(lit) >= 0) { this.addedlits.push(lit); }
        }
        final boolean redundant = c.redundant();
        final int glue = c.glue();
        deleteClause(c);
        final CLClause res = newClause(redundant, glue);
        this.addedlits.clear();
        return res;
    }
986665
@Override
    public void setContract(Contract c) {
        super.setContract(c);
        for (Function f : functions) {
            f.setContract(c);
        }
    }
1317831
void addLimitConstraint(Constraint c)
    {
        // Find any pre-existing LIMIT constraint on the table and remove it
        for (Constraint cst : table.constraintList) {
            if (cst.getConstraintType() == Constraint.LIMIT) {
                OrderedHashSet constraintNameSet = new OrderedHashSet();
                HsqlName name = cst.getName();
                constraintNameSet.add(name);
                updateConstraints(table, constraintNameSet);
                database.schemaManager.removeSchemaObject(name);
                break; // Highlander rules for Constraint.LIMIT
            }
        }

        table.addConstraint(c);
        database.schemaManager.addSchemaObject(c);
    }
442317
@SuppressWarnings("unchecked")
	public void init(FilterConfig c) throws ServletException {

		Properties p = new Properties();
		ServletContext sc = c.getServletContext();
		for (Enumeration e = sc.getInitParameterNames(); e.hasMoreElements();) {
			String key = (String) e.nextElement();
			p.put(key, sc.getInitParameter(key));
		}
		for (Enumeration e = c.getInitParameterNames(); e.hasMoreElements();) {
			String key = (String) e.nextElement();
			p.put(key, c.getInitParameter(key));
		}
		
		String cfgName = INCOMING_PATH;
		String incomingPath = p.getProperty(cfgName);
		if((incomingPath == null) || incomingPath.length() == 0) {
			throw new ServletException("Invalid or missing " + cfgName +
					" configuration");
		}
		incoming = new File(incomingPath);
		tmpIncoming = new File(incoming,"tmp");
		try {
			ensureDir(incoming);
			ensureDir(tmpIncoming);
		} catch (IOException e) {
			throw new ServletException(e);
		}
	}
590518
public void fillRect(int x, int y, int w, int h, Color c) {
        int color = c.getRGB();
        for (int i = x; i < x + w; i++) {
            for (int j = y; j < y + h; j++) {
                setIntColor(i, j, color);
            }
        }
    }
761549
private void setNormalizedMinValue(double value) {
        normalizedMinValue = Math.max(0d, Math.min(1d, Math.min(value, normalizedMaxValue)));
        invalidate();
    }
550281
public void setFunction( GradientLineFunction function , double funcMinValue ) {
		this.function = function;
		this.funcMinValue = funcMinValue;

		lineSearch.setFunction(function,funcMinValue);
		N = function.getN();

		B = new DMatrixRMaj(N,N);
		searchVector = new DMatrixRMaj(N,1);
		g = new DMatrixRMaj(N,1);
		s = new DMatrixRMaj(N,1);
		y = new DMatrixRMaj(N,1);
		x = new DMatrixRMaj(N,1);

		temp0_Nx1 = new DMatrixRMaj(N,1);
		temp1_Nx1 = new DMatrixRMaj(N,1);
	}