import org.jscience.physics.amount.Amount; //导入依赖的package包/类
@Override
public Double convert(Double value, MassUnit from, MassUnit to) {
    if (value == null)
        return null;

    if (from.equals(UNSUPPORTED) || to.equals(UNSUPPORTED))
        return null;

    Unit fUnit = get(from);
    Unit tUnit = get(to);

    if (fUnit == null || tUnit == null)
        return null;

    Amount<Mass> m = Amount.valueOf(value, fUnit);
    return m.doubleValue(tUnit);
}
 

import org.jscience.physics.amount.Amount; //导入依赖的package包/类
@Override
public Double convert(Double value, DataAmountUnit from, DataAmountUnit to) {
    if (value == null)
        return null;

    if (from.equals(UNSUPPORTED) || to.equals(UNSUPPORTED))
        return null;

    Unit fUnit = get(from);
    Unit tUnit = get(to);

    if (fUnit == null || tUnit == null)
        return null;

    Amount<DataAmount> m = Amount.valueOf(value, fUnit);
    return m.doubleValue(tUnit);
}
 

import org.jscience.physics.amount.Amount; //导入依赖的package包/类
@Override
public Double convert(Double value, LengthUnit from, LengthUnit to) {
    if (value == null)
        return null;

    if (from.equals(UNSUPPORTED) || to.equals(UNSUPPORTED))
        return null;

    Unit fUnit = get(from);
    Unit tUnit = get(to);

    if (fUnit == null || tUnit == null)
        return null;

    Amount<Length> m = Amount.valueOf(value, fUnit);
    return m.doubleValue(tUnit);
}
 

import org.jscience.physics.amount.Amount; //导入依赖的package包/类
/**
 * @throws IOException  
 */
@Override
protected void doSave(OutputStream outputStream, Map<?, ?> options) throws IOException {
	PrintWriter writer = new PrintWriter(outputStream);
	for (EObject o : getContents()) {
		AmountConstraint c = (AmountConstraint) o;
		String key = c.getKey();
		AmountExtent<?> extent = c.getExtent();
		Amount<?> min = extent.getMin();
		Amount<?> max = extent.getMax();
		boolean waived = c.isWaived();
		StringBuffer buffer = new StringBuffer(key)
			.append(",").append(JScienceFactory.eINSTANCE.convertToString(JSciencePackage.Literals.EAMOUNT, min))
			.append(",").append(JScienceFactory.eINSTANCE.convertToString(JSciencePackage.Literals.EAMOUNT, max))
			.append(",").append(waived);
		writer.println(buffer.toString());	
	}
	writer.close();
}
 

import org.jscience.physics.amount.Amount; //导入依赖的package包/类
public void testSetStartLaterEndComputingDuration() {
	for (EPlanElement element : Util.createTestElements()) {
		TemporalMember member = element.getMember(TemporalMember.class);
		member.setCalculatedVariable(CalculatedVariable.DURATION);
		Date start = new Date();
		member.setStartTime(start);
		Date end = member.getEndTime();
		Amount<Duration> duration = AmountUtils.toAmount(3421, DateUtils.MILLISECONDS);
		Date end2 = DateUtils.add(end, duration);
		NotificationAdapter adapter = new NotificationAdapter(
				Util.setEnd(member, end, end2),
				Util.setDuration(member, DateUtils.ZERO_DURATION, duration)
			);
		member.eAdapters().add(adapter);
		member.setEndTime(end2);
		adapter.assertFinished();
		Util.check(member, start, duration, end2);
	}
}
 

import org.jscience.physics.amount.Amount; //导入依赖的package包/类
/**
 * The [start,end] of activity 1 must occur at or earlier than 
 * the [start,end] of activity 2.
 */
public void testDistanceRequirementTextAnytimeBefore() {
	for (Timepoint timepointA : Timepoint.values()) {
		for (Timepoint timepointB : Timepoint.values()) {
			EPlanElement elementA = activity1;
			EPlanElement elementB = activity2;
			Amount<Duration> minDelta = ZERO;
			Amount<Duration> maxDelta = null;
			String text = constraintViolationPrinter.getDistanceRequirementText(
					ConstraintUtils.createConstraintPoint(elementA, timepointA), 
					ConstraintUtils.createConstraintPoint(elementB, timepointB), 
					minDelta, maxDelta, true);
			trace.debug("testDistanceRequirementTextAnytimeBefore() = " + text);
			String pattern = "";
			pattern += getTimepointPattern(timepointB, elementB);
			pattern += ".* should be no earlier than .*";
			pattern += getTimepointPattern(timepointA, elementA);
			pattern += ".*";
			boolean matches = text.matches(pattern);
			assertTrue("'" + text + "' doesn't match the pattern", matches);
			assertTrue(text.contains(identifiableRegistry.getUniqueId(elementA)));
			assertTrue(text.contains(identifiableRegistry.getUniqueId(elementB)));
		}
	}
}
 

import org.jscience.physics.amount.Amount; //导入依赖的package包/类
@Override
public Amount<F> interpolate(Date point, SortedMap<Date, Amount<F>> pointValues) {
	// Searches exact.
	Amount<F> y = pointValues.get(point);
    if (y != null)
        return y;

    // Searches surrounding points/values.
    SortedMap<Date, Amount<F>> headMap = pointValues.headMap(point);
    Date x1 = headMap.lastKey();
    Amount<F> y1 = headMap.get(x1);
    SortedMap<Date, Amount<F>> tailMap = pointValues.tailMap(point);
    Date x2 = tailMap.firstKey();
    Amount<F> y2 = tailMap.get(x2);

    // Interpolates.
    final Date x = point;
	double pct = (x.getTime() - x1.getTime()) / (float) (x2.getTime() - x1.getTime());
	Amount<F> value = y2.minus(y1).times(pct).plus(y1);
    return value;
}
 

import org.jscience.physics.amount.Amount; //导入依赖的package包/类
@Override
public boolean update() {
	Amount newValue = null;
	for (Dependency d : getPrevious()) {
		if (d instanceof ConditionDependency) {
			ConditionDependency condition = (ConditionDependency) d;
			DataPoint dataPoint = (DataPoint) condition.getValue();
			if (dataPoint != null) {
				Amount v = (Amount) dataPoint.getValue();
				if (v != null) {
					if (newValue == null) {
						newValue = v;
					} else {
						newValue = newValue.plus(v);
					}
				}
			}
		}
	}
	DataPoint<Amount> newDataPoint = JScienceFactory.eINSTANCE.createEDataPoint(conditions.getTime(), newValue); 
	if (!CommonUtils.equals(getValue(), newDataPoint)) {
		setValue(newDataPoint);
		return true;
	}
	return false;
}
 

import org.jscience.physics.amount.Amount; //导入依赖的package包/类
private <T extends Quantity> String convertToExponentialString(Amount<T> amount) {
	Unit unit = amount.getUnit();
	Unit baseUnit = unit.getStandardUnit();
	Unit currentUnit = baseUnit; 
	double currentAmount = amount.doubleValue(currentUnit);
	while (Math.abs(currentAmount) >= 1000) {
		currentUnit = SI.KILO(currentUnit);
		// If next is peta, roll over and play dead
		if (SI.PETA(baseUnit).equals(SI.KILO(currentUnit))) {
			break;
		}
		currentAmount = amount.doubleValue(currentUnit);
	}
	Number value = AmountUtils.getNumericValue(amount.to(currentUnit));
	return formatNumber(value) + " " + UNIT_FORMAT.format(currentUnit);
}
 

import org.jscience.physics.amount.Amount; //导入依赖的package包/类
public void testSetStartEarlierStartComputingDuration() {
	for (EPlanElement element : Util.createTestElements()) {
		TemporalMember member = element.getMember(TemporalMember.class);
		member.setCalculatedVariable(CalculatedVariable.DURATION);
		Date start = new Date();
		member.setStartTime(start);
		Amount<Duration> duration = AmountUtils.toAmount(145, DateUtils.MILLISECONDS);
		Date start2 = DateUtils.subtract(start, duration);
		NotificationAdapter adapter = new NotificationAdapter(
				Util.setStart(member, start, start2),
				Util.setDuration(member, DateUtils.ZERO_DURATION, duration)
			);
		member.eAdapters().add(adapter);
		member.setStartTime(start2);
		adapter.assertFinished();
		Util.check(member, start2, duration, start);
	}
}
 

import org.jscience.physics.amount.Amount; //导入依赖的package包/类
@Override
public String getText(DataPoint facet) {
	EDataType dataType = profile.getDataType();
	Object value = facet.getValue();
	if (value == null) {
		return "";
	}
	if  (dataType.getInstanceClass() == Amount.class || value instanceof Amount) {
		return EnsembleAmountFormat.INSTANCE.formatAmount((Amount) value);
	}
	if (dataType.getInstanceClass() == Date.class) {
		return DATE_STRINGIFIER.getDisplayString((Date) value);
	}
	if (stringifier != null) {
		try {
			return stringifier.getDisplayString(value);
		} catch (Exception e) {
			LogUtil.errorOnce(e.getMessage());
		}
	}
	return value.toString();
}
 

import org.jscience.physics.amount.Amount; //导入依赖的package包/类
public void testSimpleNumericProfileEffect() throws Exception {
	final ProfileMember profileMember = activity.getMember(ProfileMember.class);
	assertNotNull(profileMember);
	assertNotNull(ResourceUtils.getProfile(plan, KEY_TEST_PROFILE));
	final ProfileEffect effect = createProfileEffect(DateUtils.ZERO_DURATION, "10", DateUtils.ZERO_DURATION, "-10");
	TransactionUtils.writing(plan, new Runnable() {
		@Override
		public void run() {
			profileMember.getEffects().add(effect);
		}
	});
	recomputePlan(plan);
	
	assertProfileValue(plan, KEY_TEST_PROFILE, ACTIVITY_START, Amount.valueOf(10, Unit.ONE));
	assertProfileValue(plan, KEY_TEST_PROFILE, ACTIVITY_END  , Amount.valueOf( 0, Unit.ONE));
}
 

import org.jscience.physics.amount.Amount; //导入依赖的package包/类
public Time convertTimeDistanceToNetwork(Amount<Duration> duration) {
	long milliseconds = duration.longValue(SI.MILLI(SI.SECOND));
	// Convert milliseconds to seconds.
	long value = Math.round(milliseconds/((double)CONVERSION_CONSTANT));
	if (value < DistanceGraph.MIN_DISTANCE) {
		if ((milliseconds != Long.MIN_VALUE) && (value != DistanceGraph.NEG_INFINITY)) {
			trace.warn("value (" + value + ") too negative, becoming negative infinity (" + DistanceGraph.NEG_INFINITY + ")");
		}
		value = DistanceGraph.NEG_INFINITY;
	}
	if (value > DistanceGraph.MAX_DISTANCE) {
		if ((milliseconds != Long.MAX_VALUE) && (value != DistanceGraph.POS_INFINITY)) {
			trace.warn("value (" + value + ") too positive, becoming positive infinity (" + DistanceGraph.POS_INFINITY + ")");
		}
		value = DistanceGraph.POS_INFINITY;
	}
	Time distance = getTime(value);
	if (distance != value) {
		trace.warn("time distance " + value + " changed during conversion to time " + distance);
	}
	trace.debug("convertTimeDistanceToNetwork(" + milliseconds + "): " + distance);
	return distance;
}
 

import org.jscience.physics.amount.Amount; //导入依赖的package包/类
@Override
public Map<EPlanElement, TemporalExtent> setEnd(EPlanElement element, Date end, TemporalExtentsCache initialState) {
	Amount<Duration> duration = initialState.getDuration(element);
	IPlanConstraintInfo info = getPlanConstraintInfo();
	ConsistencyProperties properties = info.getConstraintProperties(element);
	ConsistencyBounds bounds = properties.getBounds();
	List<PeriodicTemporalConstraint> constraints = ConstraintUtils.getPeriodicConstraints(element, false);
	end = constrainEnd(duration, end, constraints, bounds);
	Date start = initialState.getStart(element);
	if (start == null) {
		start = end;
	}
	Map<EPlanElement, TemporalExtent> changedTimes = new LinkedHashMap<EPlanElement, TemporalExtent>();
	affectElements(element, start, end, properties, initialState, changedTimes);
	performAnyRegisteredTweaks(changedTimes);
	return changedTimes;
}
 

import org.jscience.physics.amount.Amount; //导入依赖的package包/类
public void testActivitySetEndToNull() {
	for (CalculatedVariable variable : Arrays.asList(CalculatedVariable.DURATION, CalculatedVariable.START)) {
		for (EPlanElement element : Util.createDurativeElements()) {
			TemporalMember member = element.getMember(TemporalMember.class);
			member.setCalculatedVariable(variable);
			Date start = member.getStartTime();
			Amount<Duration> duration = member.getDuration();
			Date end = member.getEndTime();
			NotificationAdapter adapter = new NotificationAdapter(
					Util.setEnd(member, end, null),
					Util.setStart(member, start, null)
				);
			member.eAdapters().add(adapter);
			member.setEndTime(null);
			adapter.assertFinished();
			Util.check(member, null, duration, null);
		}
	}
}
 

import org.jscience.physics.amount.Amount; //导入依赖的package包/类
/**
 * Create a plan with a set of bounds, and 
 * then add a group that spans over the plan end.
 */
public void testOnePlanAddOneLaterSpanGroup() {
	PlanGroupTest test = new PlanGroupTest();
	Date groupStart = DateUtils.add(test.planStart, test.planDuration.divide(2));
	Amount<Duration> groupDuration = test.planDuration;
	test.groupMember.setStartTime(groupStart);
	test.groupMember.setDuration(groupDuration);
	Date groupEnd = DateUtils.add(groupStart, groupDuration);
	NotificationAdapter adapter = test.adapter(
		Util.setStart(test.planMember, test.planStart, groupStart),
		Util.setEnd(test.planMember, test.planEnd, groupEnd),
		Util.addChild(test.plan, test.group)
	);
	test.plan.getChildren().add(test.group);
	adapter.assertFinished();
	Util.check(test.groupMember, groupStart, groupDuration, groupEnd);
	Util.check(test.planMember, groupStart, groupDuration, groupEnd);
}
 

import org.jscience.physics.amount.Amount; //导入依赖的package包/类
public void testSetStartLaterEndComputingStart() {
	for (EPlanElement element : Util.createTestElements()) {
		TemporalMember member = element.getMember(TemporalMember.class);
		member.setCalculatedVariable(CalculatedVariable.START);
		Date start = new Date();
		member.setStartTime(start);
		Date end = member.getEndTime();
		Amount<Duration> duration = AmountUtils.toAmount(3421, DateUtils.MILLISECONDS);
		Date end2 = DateUtils.add(end, duration);
		Date start2 = DateUtils.add(start, duration);
		NotificationAdapter adapter = new NotificationAdapter(
				Util.setEnd(member, end, end2),
				Util.setStart(member, start, start2)
			);
		member.eAdapters().add(adapter);
		member.setEndTime(end2);
		adapter.assertFinished();
		Util.check(member, start2, DateUtils.ZERO_DURATION, end2);
	}
}
 

import org.jscience.physics.amount.Amount; //导入依赖的package包/类
@Test
public void testLateObservable() {
	List<EPlanElement> list = new ArrayList<EPlanElement>();
	final int numActivities = 3;
	final int duration = 1;
	long latestStartTime = Long.MIN_VALUE;
	for (int i=1; i<=numActivities; i++) {
		long startTime = i*hourInMS;
		list.add(getPlanElement(i, new Date(startTime), Amount.valueOf(duration, NonSI.HOUR)));
		latestStartTime = Math.max(latestStartTime, startTime);
	}
	LatestDateObservable observable = new LatestDateObservable(list, TemporalPackage.Literals.TEMPORAL_MEMBER__START_TIME);
	Object val = observable.getValue();
	assertNotNull(val);
	assertTrue(val instanceof Date);
	assertEquals(latestStartTime, ((Date) val).getTime());
}
 

import org.jscience.physics.amount.Amount; //导入依赖的package包/类
private RGB getRgb(Plot plot, Amount amount) {
	RGB rgb;
	if (plot.isAutoAssignRGB()) {
		final RGBMap<String> rgbMap = getRgbMap(plot);
		final String valStr = amount.toString();
		rgb = rgbMap.getCachedRGB(valStr);
		if (rgb == null) {
			rgb = getColorForEntirePlot(plot);
		}
		if (rgb == null) {
			rgb = rgbMap.getRGB(valStr);
		}
	} else {
		rgb = plot.getRgb();
	}
	return rgb;
}
 

import org.jscience.physics.amount.Amount; //导入依赖的package包/类
@Override
protected Object coalesceElements(Collection elements) {
	Amount total = null;
	for (Object o : elements) {
		IObservableValue v = (IObservableValue) o;
		Object value = v.getValue();
		Amount<?> current = null;
		if (value instanceof ComputableAmount) {
			current = ((ComputableAmount)value).getAmount();
		} else if (value instanceof Amount) {
			current = (Amount<?>) value;
		} else {
			continue;
		}
		
		if (current != null) {
			if (total == null) {
				total = current;
			} else {
				total = total.plus(current);
			}
		}
	}
	return total;
}