Java AtomicDouble.addAndGet方法代碼示例

import com.google.common.util.concurrent.AtomicDouble; //導入方法依賴的package包/類
private static void visitCompressedTableEntries(Expression compressedTableExpression, AtomicDouble count) {
	if (IfThenElse.isIfThenElse(compressedTableExpression)) {
		visitCompressedTableEntries(IfThenElse.thenBranch(compressedTableExpression), count);
		visitCompressedTableEntries(IfThenElse.elseBranch(compressedTableExpression), count);
	}
	else {
		// We are at a leaf node, therefore increment the count
		count.addAndGet(1);
	}
}
 

import com.google.common.util.concurrent.AtomicDouble; //導入方法依賴的package包/類
@Override
public double evaluate(IChromosome a_subject) {
	EditsChromosome ec = new EditsChromosome(a_subject);
	String key = ec.key();
	if (cache.containsKey(key))
		return cache.get(key);
	try {
		initializator.initialize(algorithm, ec);
		log.debug(AlgorithmInitializator.toString(algorithm));
		final AtomicDouble distd = new AtomicDouble(0);

		EditsThread<AnnotatedEntailmentPair> thread = new EditsThread<AnnotatedEntailmentPair>() {

			@Override
			public void process(AnnotatedEntailmentPair p) throws Exception {
				double score = Double.parseDouble(p.getAttributes().get("score"));
				double ns = 5 * (1 - algorithm.distance(p.getT().get(0), p.getH().get(0), p.getId()));
				distd.addAndGet(Math.abs(score - ns));
			}
		};

		thread.start(training.iterator());

		double dist = 5.0 - distd.get() / training.size();
		GeneticResult r = new GeneticResult(dist, ec);
		log.debug(r.getValue());
		if (result == null || result.getValue() < dist)
			result = r;
		cache.put(key, dist);
		results.add(r);
		return dist;
	} catch (Exception e1) {
		e1.printStackTrace();
		System.exit(1);
	}
	cache.put(key, 0.0);
	return 0;
}
 

import com.google.common.util.concurrent.AtomicDouble; //導入方法依賴的package包/類
public double getProjectionScore(TerminologyService referenceTerminology) {
	AtomicDouble sum = new AtomicDouble(0);
	AtomicDouble total = new AtomicDouble(0);
	List<Term> top100 = topN(100).collect(toList());
	for(Term docTerm :top100) {
		total.addAndGet(docTerm.getSpecificity());
		int baseRank = getBaseRankInRefTermino(referenceTerminology, docTerm);
		if(baseRank > 0 && baseRank < 500)
			sum.addAndGet(docTerm.getSpecificity());
	}
	return sum.doubleValue() / total.doubleValue();
}
 

import com.google.common.util.concurrent.AtomicDouble; //導入方法依賴的package包/類
/**
 * Compute non edge forces using barnes hut
 * @param pointIndex
 * @param theta
 * @param negativeForce
 * @param sumQ
 */
public void computeNonEdgeForces(int pointIndex, double theta, INDArray negativeForce, AtomicDouble sumQ) {
    // Make sure that we spend no time on empty nodes or self-interactions
    if (cumSize == 0 || (isLeaf() && size == 1 && index[0] == pointIndex))
        return;


    // Compute distance between point and center-of-mass
    buf.assign(data.slice(pointIndex)).subi(centerOfMass);

    double D = Nd4j.getBlasWrapper().dot(buf, buf);

    // Check whether we can use this node as a "summary"
    if (isLeaf || FastMath.max(boundary.getHh(), boundary.getHw()) / FastMath.sqrt(D) < theta) {

        // Compute and add t-SNE force between point and current node
        double Q = 1.0 / (1.0 + D);
        double mult = cumSize * Q;
        sumQ.addAndGet(mult);
        mult *= Q;
        negativeForce.addi(buf.mul(mult));

    } else {

        // Recursively apply Barnes-Hut to children
        northWest.computeNonEdgeForces(pointIndex, theta, negativeForce, sumQ);
        northEast.computeNonEdgeForces(pointIndex, theta, negativeForce, sumQ);
        southWest.computeNonEdgeForces(pointIndex, theta, negativeForce, sumQ);
        southEast.computeNonEdgeForces(pointIndex, theta, negativeForce, sumQ);
    }
}
 

import com.google.common.util.concurrent.AtomicDouble; //導入方法依賴的package包/類
/**
 * Compute non edge forces using barnes hut
 * @param pointIndex
 * @param theta
 * @param negativeForce
 * @param sumQ
 */
public void computeNonEdgeForces(int pointIndex, double theta, INDArray negativeForce, AtomicDouble sumQ) {
    // Make sure that we spend no time on empty nodes or self-interactions
    if (cumSize == 0 || (isLeaf() && size == 1 && index[0] == pointIndex))
        return;


    // Compute distance between point and center-of-mass
    buf.assign(data.slice(pointIndex)).subi(centerOfMass);

    double D = Nd4j.getBlasWrapper().dot(buf, buf);
    // Check whether we can use this node as a "summary"
    double maxWidth = boundary.width().max(Integer.MAX_VALUE).getDouble(0);
    // Check whether we can use this node as a "summary"
    if (isLeaf() || maxWidth / Math.sqrt(D) < theta) {

        // Compute and add t-SNE force between point and current node
        double Q = 1.0 / (1.0 + D);
        double mult = cumSize * Q;
        sumQ.addAndGet(mult);
        mult *= Q;
        negativeForce.addi(buf.mul(mult));

    } else {

        // Recursively apply Barnes-Hut to children
        for (int i = 0; i < numChildren; i++) {
            children[i].computeNonEdgeForces(pointIndex, theta, negativeForce, sumQ);
        }

    }
}
 

import com.google.common.util.concurrent.AtomicDouble; //導入方法依賴的package包/類
@Test
public void test() {
	ChronoGraph g = new ChronoGraph("epcis");
	// g.getChronoVertexSet().parallelStream().forEach(v -> System.out.println(v));

	BsonArray contains = new BsonArray();
	contains.add(new BsonString("contains"));

	// 각 중요시간 마다 트럭 안에 있는 물건들의 리스트와 무게를 가져옴

	Iterator<Long> timeSet = g.getChronoVertex("urn:epc:id:sscc:0000001.0000000001")
			.getTimestamps(Direction.OUT, contains, 0l, AC.$gt).iterator();

	while (timeSet.hasNext()) {
		Long t = timeSet.next();
		System.out.println("at " + new Date(t));
		AtomicDouble totalK = new AtomicDouble();
		ConcurrentHashMap<String, String> map = new ConcurrentHashMap<String, String>();

		PipeFunction<EdgeEvent, Boolean> retainIfAdd = new PipeFunction<EdgeEvent, Boolean>() {

			@Override
			public Boolean compute(EdgeEvent ee) {
				if (ee.getProperty("action").equals(new BsonString("ADD"))) {
					return true;
				}
				return false;
			}
		};

		PipeFunction<VertexEvent, Object> listUpFreight = new PipeFunction<VertexEvent, Object>() {
			@Override
			public Object compute(VertexEvent ve) {
				BsonDouble kg = (BsonDouble) ve.getVertex().getProperty("urn:epc:cbv:mda:netWeight");
				totalK.addAndGet(kg.doubleValue());
				map.put(ve.getVertex().toString(), "1");
				return ve;
			}
		};

		TraversalEngine engine = new TraversalEngine(g,
				g.getChronoVertex("urn:epc:id:sscc:0000001.0000000001").setTimestamp(t), false, false,
				VertexEvent.class);
		engine.outEe(contains, TemporalType.TIMESTAMP, AC.$lte, null, null, null, null, null, null)
				.filter(retainIfAdd).inVe().sideEffect(listUpFreight).toList();

		// g.getChronoVertex("urn:epc:id:sscc:0000001.0000000001").getChronoEdgeSet(Direction.OUT,
		// contains)
		// .parallelStream().forEach(e -> {
		// // System.out.println(e);
		//
		// EdgeEvent ee = e.pickFloorTimestamp(t);
		// if (ee != null && ee.getProperty("action").equals(new BsonString("ADD"))) {
		// BsonDouble kg = (BsonDouble)
		// e.getInVertex().getProperty("urn:epc:cbv:mda:netWeight");
		// totalK.addAndGet(kg.doubleValue());
		// map.put(e.getInVertex().toString(), "1");
		// }
		// });

		System.out.println(map.keySet());
		System.out.println(totalK);
	}

	g.shutdown();
}