Sets the omega parameter value, which controls the shape of the kernel
@param omega the positive parameter value
2757
public void setOmega(double omega)
    {
        if(omega <= 0 || Double.isNaN(omega) || Double.isInfinite(omega))
            throw new ArithmeticException("omega must be positive, not " + omega);
        this.omega = omega;
        this.cnst = Math.sqrt(Math.pow(2, 1/omega)-1);
    }
957170
public void setTo( ImageType o ) {
		this.family = o.family;
		this.dataType = o.dataType;
		this.numBands = o.numBands;
	}
873907
public void setLambda0(double lambda0)
    {
        if(lambda0 < 0 || Double.isNaN(lambda0) || Double.isInfinite(lambda0))
            throw new IllegalArgumentException("Lambda0 must be non-negative, not " + lambda0);
        this.lambda0 = lambda0;
    }
343720
public void setParameter(String name, String value) {
		// Global Fix by alexvinn for Issue 1010 : Unable to set flag parameter to parameterable header
		if(name == null) {
			throw new NullPointerException("parameter name is null ! ");
		}
		if(value == null) {
			removeParameter(name);
			return;
		}
		if(isModifiable == ModifiableRule.NotModifiable) {
			throw new IllegalStateException("it is forbidden to modify the parameters");
		}
		if(name.equalsIgnoreCase("tag") && (isModifiable == ModifiableRule.From || isModifiable == ModifiableRule.To)) {
			throw new IllegalStateException("it is forbidden to set the tag parameter on To or From Header");
		}
		if(name.equalsIgnoreCase("branch") && isModifiable == ModifiableRule.Via) {
			throw new IllegalStateException("it is forbidden to set the branch parameter on the Via Header");
		}
		//Fix from abondar for Issue 494 and angelo.marletta for Issue 502
		this.parameters.put(name.toLowerCase(), value);
		if(header != null) {
			try {
				if (isQuotableParam(name) && (header instanceof ParametersExt)){
					((ParametersExt) header).setQuotedParameter(name, value);
				}else{
					header.setParameter(name, "".equals(value) ? null : value);
				}
			} catch (ParseException e) {
				throw new IllegalArgumentException("Problem setting parameter",e);
			}
		}
	}
254166
def rotfreq_to_omega(rotfreq, scale=c.R_sun.si.value, solar_units=False):
    
    if solar_units:
        omega = rotfreq / (2*np.pi) / np.sqrt(c.GM_sun.to(u.solRad**3/u.d**2).value/scale**3)
    else:
        # then SI units
        omega = rotfreq / (2*np.pi) / np.sqrt(c.GM_sun.value/scale**3)

    # print "*** rotstar.rotfreq_to_omega", rotfreq, scale, solar_units, omega

    return omega
57865
void set(final long valueIteratedTo, final long valueIteratedFrom, final long countAtValueIteratedTo,
             final long countInThisIterationStep, final long totalCountToThisValue, final long totalValueToThisValue,
             final double percentile, final double percentileLevelIteratedTo, double integerToDoubleValueConversionRatio) {
        this.valueIteratedTo = valueIteratedTo;
        this.valueIteratedFrom = valueIteratedFrom;
        this.countAtValueIteratedTo = countAtValueIteratedTo;
        this.countAddedInThisIterationStep = countInThisIterationStep;
        this.totalCountToThisValue = totalCountToThisValue;
        this.totalValueToThisValue = totalValueToThisValue;
        this.percentile = percentile;
        this.percentileLevelIteratedTo = percentileLevelIteratedTo;
        this.integerToDoubleValueConversionRatio = integerToDoubleValueConversionRatio;
    }
883293
@Override
	public void setMaxZ(double z) {
		double o = this.minz;
		if (o>z) {
			this.maxz = o;
			this.minz = z;
		}
		else {
			this.maxz = z;
		}
	}
328801
public void setZIndex(float zIndex) {
        shape.setZIndex(zIndex);
        for (ShapeMarkers shapeMarkers : shapeMarkersMap.values()) {
            shapeMarkers.setZIndex(zIndex);
        }
    }
771242
public void set(long lowWaterMark, long highWaterMark, long current, double integral,
                    long startTime, long lastSampleTime) {
        this.current = current;
        this.integral = integral;
        this.lowWaterMark = lowWaterMark;
        this.highWaterMark = highWaterMark;
        this.startTime = startTime;
        this.lastSampleTime = lastSampleTime;
    }
111000
public synchronized void setIcon(Object icon, int iIconType)
    {
        if (m_rgIcons == null)
            m_rgIcons = new ImageIcon[CalendarConstants.END_ICON - CalendarConstants.START_ICON + 1];
        m_rgIcons[iIconType - CalendarConstants.START_ICON] = icon;   // Always at location 0
    }
302217
public void setIcon(Image image) {

        m_iconPanel.setVisible(true);
        if (image == null) {
            return;
        }
        m_iconPanel.setWidget(image);
    }
1216311
public void set(double[] dataValue, double lowerBound, double upperBound,
            int calibrationType, boolean[] needCalibration) {
        setStat(dataValue, calibrationType, needCalibration);
        setLowerAndUpperBounds(lowerBound, upperBound);
    }
709823
public void setEta(double eta)
    {
        if(Double.isNaN(eta) || Double.isInfinite(eta) || eta <= 0)
            throw new ArithmeticException("convergence parameter must be a positive value");
        this.eta = eta;
    }
199745
public final void setValue(final Float value) {
        Condition.INSTANCE.ensureAtLeast(value, getMinValue(),
                "The value must be at least the minimum value");
        Condition.INSTANCE.ensureAtMaximum(value, getMaxValue(),
                "The value must be at maximum the maximum value");
        float roundedValue = adaptToStepSize(roundToDecimals(value));

        if (this.value != roundedValue) {
            this.value = roundedValue;
            this.currentValue = roundedValue;
            persistFloat(roundedValue);
            notifyChanged();
        }
    }
784067
public void setLastPoint(double x, double y, double z) {
		if (this.numCoordsProperty.get()>=3) {
			this.coordsProperty[this.numCoordsProperty.get()-3].set(x);
			this.coordsProperty[this.numCoordsProperty.get()-2].set(y);
			this.coordsProperty[this.numCoordsProperty.get()-1].set(z);
			this.graphicalBounds = null;
			this.logicalBounds = null;
		}
	}
77526
private void setBar(final double VALUE) {
        currentValueAngle = (VALUE - minValue) * angleStep;
        thresholdAngle    = (gauge.getThreshold() - minValue) * angleStep;
        double valueAngle = currentValueAngle > thresholdAngle ? thresholdAngle : currentValueAngle;
        dataBarOuterArc.setLargeArcFlag(valueAngle > 180);
        dataBarInnerArc.setLargeArcFlag(valueAngle > 180);

        dataBarOuterArc.setX(centerX + centerX * Math.sin(-Math.toRadians(valueAngle)));
        dataBarOuterArc.setY(centerY + centerX * Math.cos(-Math.toRadians(valueAngle)));
        dataBarLineToInnerArc.setX(centerX + (centerX - barWidth) * Math.sin(-Math.toRadians(valueAngle)));
        dataBarLineToInnerArc.setY(centerY + (centerX - barWidth) * Math.cos(-Math.toRadians(valueAngle)));

        double dataBarThresholdAngle = VALUE > gauge.getThreshold() ? currentValueAngle : thresholdAngle;
        dataBarThresholdOuterArc.setLargeArcFlag(dataBarThresholdAngle > 180 + thresholdAngle);
        dataBarThresholdInnerArc.setLargeArcFlag(dataBarThresholdAngle > 180 + thresholdAngle);

        dataBarThresholdOuterArc.setX(centerX + centerX * Math.sin(-Math.toRadians(dataBarThresholdAngle)));
        dataBarThresholdOuterArc.setY(centerY + centerX * Math.cos(-Math.toRadians(dataBarThresholdAngle)));
        dataBarThresholdLineToInnerArc.setX(centerX + (centerX - barWidth) * Math.sin(-Math.toRadians(dataBarThresholdAngle)));
        dataBarThresholdLineToInnerArc.setY(centerY + (centerX - barWidth) * Math.cos(-Math.toRadians(dataBarThresholdAngle)));
        dataBarThresholdInnerArc.setX(centerX + (centerX - barWidth) * Math.sin(-Math.toRadians(thresholdAngle)));
        dataBarThresholdInnerArc.setY(centerY + (centerX - barWidth) * Math.cos(-Math.toRadians(thresholdAngle)));

        valueText.setText(formatNumber(gauge.getLocale(), gauge.getFormatString(), gauge.getDecimals(), VALUE));
        resizeValueText();
    }
920952
public void setBeta(double beta)
    {
        if(beta <= 0 || beta >= 1 || Double.isNaN(beta))
            throw new IllegalArgumentException("shrinkage term must be in (0, 1), not " +  beta);
        this.beta = beta;
    }