Beispiel #1
0
 /**
  * Returns the sum of all elements in this memory.
  *
  * @return the sum of all elements in this memory.
  */
 public double getSum() {
   double sum = 0d;
   for (N value : list) {
     sum += value.doubleValue();
   }
   return sum;
 }
 protected <N extends Number> NumericRangeQuery<?> numericRange(
     Class<N> clazz,
     String field,
     @Nullable N min,
     @Nullable N max,
     boolean minInc,
     boolean maxInc) {
   if (clazz.equals(Integer.class)) {
     return NumericRangeQuery.newIntRange(field, (Integer) min, (Integer) max, minInc, maxInc);
   } else if (clazz.equals(Double.class)) {
     return NumericRangeQuery.newDoubleRange(field, (Double) min, (Double) max, minInc, minInc);
   } else if (clazz.equals(Float.class)) {
     return NumericRangeQuery.newFloatRange(field, (Float) min, (Float) max, minInc, minInc);
   } else if (clazz.equals(Long.class)) {
     return NumericRangeQuery.newLongRange(field, (Long) min, (Long) max, minInc, minInc);
   } else if (clazz.equals(Byte.class) || clazz.equals(Short.class)) {
     return NumericRangeQuery.newIntRange(
         field,
         min != null ? min.intValue() : null,
         max != null ? max.intValue() : null,
         minInc,
         maxInc);
   } else {
     throw new IllegalArgumentException("Unsupported numeric type " + clazz.getName());
   }
 }
 @SuppressWarnings("unchecked")
 private P run(AStarStorage storage, AStarGoal<N> goal, N start, int maxIterations) {
   Preconditions.checkNotNull(goal);
   Preconditions.checkNotNull(start);
   Preconditions.checkNotNull(storage);
   N node;
   int iterations = 0;
   while (true) {
     node = (N) storage.removeBestNode();
     if (node == null) {
       return null;
     }
     if (goal.isFinished(node)) {
       return (P) node.buildPlan();
     }
     storage.close(node);
     for (AStarNode neighbour : node.getNeighbours()) {
       f(goal, node, (N) neighbour);
       if (!storage.shouldExamine(neighbour)) continue;
       storage.open(neighbour);
       neighbour.parent = node;
     }
     if (maxIterations >= 0 && iterations++ >= maxIterations) {
       return null;
     }
   }
 }
 /**
  * Prints the sub-nodes of this object. See QueryTreeNode.java for how tree printing is supposed
  * to work.
  *
  * @param depth The depth to indent the sub-nodes
  */
 public void printSubNodes(int depth) {
   for (int index = 0; index < size(); index++) {
     debugPrint(formatNodeString("[" + index + "]:", depth));
     N elt = get(index);
     elt.treePrint(depth);
   }
 }
Beispiel #5
0
  public DOMHeader(N node) {
    assert node != null;
    this.node = node;

    this.nsUri = fixNull(node.getNamespaceURI());
    this.localName = node.getLocalName();
  }
 @Override
 protected <N, T> void notNeighbor(
     final TypedModelAdapter<N, T> adapter, final T type, final N source, final N target) {
   super.notNeighbor(
       neo4jAdapter,
       type.toString(),
       nodeMapping.get(source.toString()),
       nodeMapping.get(target.toString()));
 }
  private void f(AStarGoal<N> goal, N node, N neighbour) {
    float g = node.g + goal.g(node, neighbour); // estimate the cost from
    // the start additively
    float h = goal.h(neighbour);

    neighbour.f = g + h;
    neighbour.g = g;
    neighbour.h = h;
  }
  protected static <N extends Node> Integer indexInList(N search, List<N> nodes) {
    Preconditions.checkNotNull(search);
    Preconditions.checkNotNull(nodes);

    for (int i = 0; i < nodes.size(); i++) {
      N node = nodes.get(i);
      if (node.equals(search)) return i;
    }
    return null;
  }
    /**
     * @param bottom Lowest value to be included
     * @param top Highest value to be included
     * @param spacing How far apart should the contours be placed?
     * @return List of the contour step values
     */
    public static <N extends Number> List<N> steps(N bottom, N top, double spacing) {
      int stepCount = (int) Math.ceil((top.doubleValue() - bottom.doubleValue()) / spacing);

      ArrayList<N> steps = new ArrayList<>(stepCount);

      for (int i = 0; i < stepCount; i++) {
        steps.add(LocalUtils.addTo(bottom, (i * spacing)));
      }
      return steps;
    }
Beispiel #10
0
    /**
     * @param map1
     * @param map2
     * @return
     */
    public static <
            K1,
            V1,
            K2,
            V2,
            L extends Map<? super K1, ? super V1>,
            R extends Map<? super K2, ? super V2>,
            D extends Map<?, Pair0<V1, V2>>>
        MapDifference<L, R, D> of(Map<K1, V1> map1, Map<K2, V2> map2) {
      final L common = (L) new LinkedHashMap<>();
      final L leftOnly = (L) new LinkedHashMap<>();
      final R rightOnly = (R) new LinkedHashMap<>();
      final Map<Object, Pair0<V1, V2>> diff = new LinkedHashMap<>();

      if (N.isNullOrEmpty(map1)) {
        if (N.isNullOrEmpty(map2)) {
          // Do nothing. All empty.
        } else {
          rightOnly.putAll(map2);
        }
      } else if (N.isNullOrEmpty(map2)) {
        leftOnly.putAll(map1);
      } else {
        V2 val2 = null;
        for (Entry<K1, V1> entry1 : map1.entrySet()) {
          val2 = map2.get(entry1.getKey());

          if (val2 == null) {
            if (map2.containsKey(entry1.getKey())) {
              if (entry1.getValue() == null) {
                common.put(entry1.getKey(), entry1.getValue());
              } else {
                diff.put(entry1.getKey(), Pair0.of(entry1.getValue(), val2));
              }
            } else {
              leftOnly.put(entry1.getKey(), entry1.getValue());
            }
          } else if (N.equals(entry1.getValue(), val2)) {
            common.put(entry1.getKey(), entry1.getValue());
          } else {
            diff.put(entry1.getKey(), Pair0.of(entry1.getValue(), val2));
          }
        }

        for (Entry<K2, V2> entry2 : map2.entrySet()) {
          if (common.containsKey(entry2.getKey()) || diff.containsKey(entry2.getKey())) {
            continue;
          }

          rightOnly.put(entry2.getKey(), entry2.getValue());
        }
      }

      return new MapDifference<L, R, D>(common, leftOnly, rightOnly, (D) diff);
    }
 @Override
 public boolean include(final N namedObject) {
   if (namedObject == null) {
     return false;
   }
   // Schema names may be null
   if (namedObject.getFullName() == null) {
     return false;
   }
   return inclusionRule.include(namedObject.getFullName());
 }
  @Override
  public N getNode(String id) {
    N result = null;

    for (N node : this.getNodes()) {
      if (node.getId().equals(id)) {
        result = node;
        break;
      }
    }

    return result;
  }
Beispiel #13
0
    /**
     * @param entity1
     * @param entity2
     * @return
     */
    public static MapDifference<
            Map<String, Object>, Map<String, Object>, Map<String, Pair0<Object, Object>>>
        of(Object entity1, Object entity2) {
      if (N.isEntity(entity1.getClass()) == false || N.isEntity(entity2.getClass()) == false) {
        throw new IllegalArgumentException(
            entity1.getClass().getCanonicalName()
                + " or "
                + entity2.getClass().getCanonicalName()
                + " is not an entity class");
      }

      return of(N.entity2Map(entity1), N.entity2Map(entity2));
    }
  /**
   * Updates the particle view. This should be called on each draw cycle in order to update the
   * positions of all nodes and edges in the viewer. If you need to update the positions of
   * particles without drawing it (e.g. to speed up movement, call updateParticles() instead.
   */
  public void draw() {
    parent.pushStyle();
    parent.pushMatrix();
    zoomer.transform();
    updateCentroid();
    centroid.tick();

    parent.translate(width / 2, height / 2);
    parent.scale(centroid.getZ());
    parent.translate(-centroid.getX(), -centroid.getY());

    if (!isPaused) {
      updateParticles();
    }

    // Ensure that any selected element is positioned at the mouse location.
    if (selectedNode != null) {
      Particle p = nodes.get(selectedNode);
      p.makeFixed();
      float mX = (zoomer.getMouseCoord().x - (width / 2)) / centroid.getZ() + centroid.getX();
      float mY = (zoomer.getMouseCoord().y - (height / 2)) / centroid.getZ() + centroid.getY();
      p.position().set(mX, mY, 0);
    }

    // Draw edges if we have positive stroke weight.
    if (parent.g.strokeWeight > 0) {
      parent.stroke(0, 180);
      parent.noFill();

      for (Map.Entry<E, Spring> row : edges.entrySet()) {
        E edge = row.getKey();
        Spring spring = row.getValue();
        Vector3D p1 = spring.getOneEnd().position();
        Vector3D p2 = spring.getTheOtherEnd().position();
        edge.draw(parent, p1.x(), p1.y(), p2.x(), p2.y());
      }
    }

    // Draw nodes.
    parent.noStroke();
    parent.fill(120, 50, 50, 180);

    for (Map.Entry<N, Particle> row : nodes.entrySet()) {
      N node = row.getKey();
      Vector3D p = row.getValue().position();
      node.draw(parent, p.x(), p.y());
    }

    parent.popMatrix();
    parent.popStyle();
  }
  public <A, N extends DynamicNetwork<A, N>> DynamicNetwork<A, N> getNetworkFromOrphan(
      IGridTransmitter<A, N> startOrphan) {
    if (startOrphan.isValid() && startOrphan.isOrphan()) {
      OrphanPathFinder<A, N> finder = new OrphanPathFinder<A, N>(startOrphan);
      finder.start();
      N network;

      switch (finder.networksFound.size()) {
        case 0:
          if (MekanismAPI.debug) {
            logger.info(
                "No networks found. Creating new network for "
                    + finder.connectedTransmitters.size()
                    + " transmitters");
          }

          network = startOrphan.createEmptyNetwork();

          break;
        case 1:
          if (MekanismAPI.debug) {
            logger.info(
                "Adding "
                    + finder.connectedTransmitters.size()
                    + " transmitters to single found network");
          }

          network = finder.networksFound.iterator().next();

          break;
        default:
          if (MekanismAPI.debug) {
            logger.info(
                "Merging "
                    + finder.networksFound.size()
                    + " networks with "
                    + finder.connectedTransmitters.size()
                    + " new transmitters");
          }

          network = startOrphan.mergeNetworks(finder.networksFound);
      }

      network.addNewTransmitters(finder.connectedTransmitters);

      return network;
    }

    return null;
  }
  @Override
  public boolean accept(ASTVisitor action) {
    N stack = null;
    ICPPASTIfStatement stmt = this;
    loop:
    for (; ; ) {
      if (action.shouldVisitStatements) {
        switch (action.visit(stmt)) {
          case ASTVisitor.PROCESS_ABORT:
            return false;
          case ASTVisitor.PROCESS_SKIP:
            stmt = null;
            break loop;
          default:
            break;
        }
      }

      if (!((CPPASTIfStatement) stmt).acceptByAttributeSpecifiers(action)) return false;

      IASTNode child = stmt.getConditionExpression();
      if (child != null && !child.accept(action)) return false;
      child = stmt.getConditionDeclaration();
      if (child != null && !child.accept(action)) return false;
      child = stmt.getThenClause();
      if (child != null && !child.accept(action)) return false;
      child = stmt.getElseClause();
      if (child instanceof ICPPASTIfStatement) {
        if (action.shouldVisitStatements) {
          N n = new N(stmt);
          n.fNext = stack;
          stack = n;
        }
        stmt = (ICPPASTIfStatement) child;
      } else {
        if (child != null && !child.accept(action)) return false;
        break loop;
      }
    }

    if (action.shouldVisitStatements) {
      if (stmt != null && action.leave(stmt) == ASTVisitor.PROCESS_ABORT) return false;
      while (stack != null) {
        if (action.leave(stack.fIfStatement) == ASTVisitor.PROCESS_ABORT) return false;
        stack = stack.fNext;
      }
    }
    return true;
  }
  private <N extends InternalTitanVertex> void persist(
      ListMultimap<N, InternalRelation> mutatedEdges,
      Map<TitanType, TypeSignature> signatures,
      InternalTitanTransaction tx,
      StoreMutator mutator)
      throws StorageException {
    assert mutatedEdges != null && !mutatedEdges.isEmpty();

    Collection<N> vertices = mutatedEdges.keySet();
    //		if (sortNodes) {
    //			List<N> sortedvertices = new ArrayList<N>(vertices);
    //			Collections.sort(sortedvertices, new Comparator<N>(){
    //
    //				@Override
    //				public int compare(N o1, N o2) {
    //					assert o1.getID()!=o2.getID();
    //					if (o1.getID()<o2.getID()) return -1;
    //					else return 1;
    //				}
    //
    //			});
    //			vertices=sortedvertices;
    //		}

    for (N node : vertices) {
      List<InternalRelation> edges = mutatedEdges.get(node);
      List<Entry> additions = new ArrayList<Entry>(edges.size());
      List<ByteBuffer> deletions = new ArrayList<ByteBuffer>(Math.max(10, edges.size() / 10));
      List<TitanProperty> properties = new ArrayList<TitanProperty>();
      for (InternalRelation edge : edges) {
        if (edge.isRemoved()) {
          if (edge.isProperty()) {
            deleteIndexEntry((TitanProperty) edge, mutator);
          }
          deletions.add(getEntry(tx, edge, node, signatures, true).getColumn());
        } else {
          assert edge.isNew();
          if (edge.isProperty()) properties.add((TitanProperty) edge);
          additions.add(getEntry(tx, edge, node, signatures));
        }
      }
      mutator.mutateEdges(IDHandler.getKey(node.getID()), additions, deletions);
      // Persist property index for retrieval
      for (TitanProperty prop : properties) {
        addIndexEntry(prop, mutator);
      }
    }
  }
 public N<Boolean> then(N<Boolean> paramN)
 {
   if (!((Boolean)paramN.e()).booleanValue()) {
     return paramN;
   }
   return val$matcher.matchesAsync(val$object, val$db);
 }
Beispiel #19
0
 private Entry _sibling(Entry current, N name) throws StaxNavException {
   if (current != null) {
     Entry element = current;
     while (true) {
       Entry next = element.next();
       if (next != null && next.getElement().getDepth() >= current.getElement().getDepth()) {
         if (next.getElement().getDepth() == current.getElement().getDepth()) {
           if (name == null) {
             current = next;
             return current;
           } else {
             N siblingName = naming.getName(next.getElement().getName());
             if (name.equals(siblingName)) {
               current = next;
               return current;
             } else {
               element = next;
             }
           }
         } else {
           element = next;
         }
       } else {
         break;
       }
     }
   }
   return null;
 }
Beispiel #20
0
 private Entry _current(Entry current, N name) throws StaxNavException {
   if (current != null) {
     if (name == null || name.equals(naming.getName(current.getElement().getName()))) {
       return current;
     }
   }
   return null;
 }
 @Override
 public N getNode(T elkEntity) {
   if (node.contains(elkEntity)) {
     return node;
   } else {
     return null;
   }
 }
  /** {@inheritDoc} */
  @Override
  @SuppressWarnings("unchecked")
  public <N extends Number> Expression<N> sum(N x, Expression<? extends N> y) {
    final TypeImpl<N> type = (TypeImpl<N>) this.metamodel.type(x.getClass());

    return new ArithmeticExression<N>(
        ArithmeticOperation.ADD, new EntityConstantExpression<N>(type, x), y);
  }
Beispiel #23
0
 public int lastIndexOfFifth(N m, int index) {
   try {
     for (int i = index; i >= 0; i--) {
       if ((m == null ? get(i).fifth == null : m.equals(get(i).fifth))) return i;
     }
   } catch (final Exception e) {
   }
   return -1;
 }
 static <T> N<T> callbackOnMainThreadAsync(N<T> paramN, ParseCallback<T> paramParseCallback, boolean paramBoolean)
 {
   if (paramParseCallback == null) {
     return paramN;
   }
   Z localZ = N.a();
   paramN.a(new Parse.6(paramBoolean, localZ, paramParseCallback));
   return localZ.a();
 }
  public void addNode(N node) {
    String namespace = getNamespace(node);
    List<String> pathElements = new ArrayList<String>(Arrays.asList(namespace.split("\\.")));

    if (pathElements.size() == 1 && pathElements.get(0).equals("")) {
      pathElements.remove(0);
    }

    addNode(node, getSubnamespace(myRootNamespace, pathElements, node.getOperationContext()));
  }
Beispiel #26
0
 public boolean find(N name) throws StaxNavException {
   if (name == null) {
     throw new NullPointerException("No null name accepted");
   }
   if (name.equals(naming.getName(current.getElement().getName()))) {
     return true;
   } else {
     return navigate(Axis.FOLLOWING, name);
   }
 }
    @Override
    public Float64 apply(final N value) {
      final double x = value.doubleValue();

      Float64 result = Float64.ZERO;
      if (x >= _min && x <= _max) {
        result = Float64.valueOf(_k * x + _d);
      }

      return result;
    }
Beispiel #28
0
 private Entry _next(Entry current, N name) throws StaxNavException {
   if (current != null) {
     Entry next = current.next(depth);
     if (next != null
         && (name == null || name.equals(naming.getName(next.getElement().getName())))) {
       current = next;
       return current;
     }
   }
   return null;
 }
  /**
   * Returns the next element of this enumeration if this enumeration object has at least one more
   * element to provide.
   *
   * @return the next element of this enumeration.
   * @throws java.util.NoSuchElementException if no more elements exist.
   */
  @Override
  public IndexTreePath<E> nextElement() {
    Enumeration<IndexTreePath<E>> enumeration = queue.peek();
    IndexTreePath<E> nextPath = enumeration.nextElement();

    Enumeration<IndexTreePath<E>> children;
    if (nextPath.getEntry().isLeafEntry()) {
      children = EMPTY_ENUMERATION;
    } else {
      N node = index.getNode(nextPath.getEntry());
      children = node.children(nextPath);
    }

    if (!enumeration.hasMoreElements()) {
      queue.remove();
    }
    if (children.hasMoreElements()) {
      queue.offer(children);
    }
    return nextPath;
  }
  @Override
  @SuppressWarnings({"unchecked"})
  public <N extends Number> Expression<N> diff(N n, Expression<? extends N> expression) {
    if (n == null || expression == null) {
      throw new IllegalArgumentException("arguments to diff() cannot be null");
    }

    final Class resultType =
        BinaryArithmeticOperation.determineResultType(n.getClass(), expression.getJavaType());

    return new BinaryArithmeticOperation<N>(
        this, resultType, BinaryArithmeticOperation.Operation.SUBTRACT, n, expression);
  }