Determines if the edge uv is a frond ("backedge").
545408
def is_frond(u, v, dfs_data):
    """"""
    d_u = D(u, dfs_data)
    d_v = D(v, dfs_data)
    edge_id = dfs_data['graph'].get_first_edge_id_by_node_ids(u, v)
    return True if dfs_data['edge_lookup'][edge_id] == 'backedge' and d_v < d_u else False
80131
function isSunInWindow(blind, azimuth) {
    var sunInWindow = false;

    /*
     * Checks the sun azimuth is between window orientation +/- offset.
     * Where the range includes ranges each side of north, separate checks
     * need to be performed either side of north
     */
    if (blind.orientation - blind.noffset < 0) {
      if (
        (360 + blind.orientation - blind.noffset <= azimuth) &
          (azimuth <= 360) ||
        (0 <= azimuth && azimuth <= blind.orientation + blind.poffset)
      ) {
        sunInWindow = true;
      }
    } else if (blind.orientation + blind.poffset > 360) {
      if (
        (0 <= azimuth) & (azimuth <= blind.orientation + blind.poffset - 360) ||
        (blind.orientation - blind.noffset <= azimuth && azimuth <= 360)
      ) {
        sunInWindow = true;
      }
    } else {
      if (
        blind.orientation - blind.noffset <= azimuth &&
        azimuth <= blind.orientation + blind.poffset
      ) {
        sunInWindow = true;
      }
    }
    return sunInWindow;
  }
1016750
function indegree(node){
    var degree = 0;
    function check(v){
      if(v === node){
        degree++;
      }
    }
    Object.keys(edges).forEach(function (u){
      edges[u].forEach(check);
    });
    return degree;
  }
139019
def isConjNorthNode(self):
        
        node = self.chart.getObject(const.NORTH_NODE)
        return aspects.hasAspect(self.obj, node, aspList=[0])
649149
static Edge selectClosest( NodeInfo a , NodeInfo b , boolean checkSide ) {

		double bestScore = Double.MAX_VALUE;
		Edge bestEdgeA = null;

		Edge edgeAB = a.findEdge(b);
		double distAB = a.distance(b);

		if( edgeAB == null ) {
			return null;// TODO BUG! FIX!
		}

		for (int i = 0; i < a.edges.size; i++) {
			Edge edgeA = a.edges.get(i);
			NodeInfo aa = a.edges.get(i).target;
			if( aa.marked ) continue;

			for (int j = 0; j < b.edges.size; j++) {
				Edge edgeB = b.edges.get(j);
				NodeInfo bb = b.edges.get(j).target;
				if( bb.marked ) continue;

				if( aa == bb ) {
//					System.out.println("center "+aa.ellipse.center);
					if( checkSide && UtilAngle.distanceCW(edgeAB.angle,edgeA.angle) > Math.PI*0.75 )
						continue;

					double angle = UtilAngle.dist(edgeA.angle,edgeB.angle);

					if( angle < 0.3 )
						continue;

					double da = EllipsesIntoClusters.axisAdjustedDistanceSq(a.ellipse,aa.ellipse);
					double db = EllipsesIntoClusters.axisAdjustedDistanceSq(b.ellipse,aa.ellipse);

					da = Math.sqrt(da);
					db = Math.sqrt(db);

					// see if they are approximately the same distance
					double diffRatio = Math.abs(da-db)/Math.max(da,db);
					if( diffRatio > 0.3 )
						continue;

					// TODO reject if too far
					double d = (da+db)/distAB + 0.1*angle;

					if( d < bestScore ) {
						bestScore = d;
						bestEdgeA = a.edges.get(i);
					}
					break;
				}
			}
		}

		return bestEdgeA;
	}
725524
function isArguments(value) {
        // fallback check is for IE
        return toString.call(value) === '[object Arguments]' || value != null && (typeof value === 'undefined' ? 'undefined' : _typeof(value)) === 'object' && 'callee' in value;
    }
199178
static boolean isBlankNode(Object v) {
        // Note: A value is a blank node if all of these hold true:
        // 1. It is an Object.
        // 2. If it has an @id key its value begins with '_:'.
        // 3. It has no keys OR is not a @value, @set, or @list.
        if (v instanceof Map) {
            final Map<String, Object> map = (Map<String, Object>) v;
            if (map.containsKey("@id")) {
                return ((String) map.get("@id")).startsWith("_:");
            } else {
                return map.isEmpty() || !map.containsKey("@value") || map.containsKey("@set")
                        || map.containsKey("@list");
            }
        }
        return false;
    }
1359446
function isLeftEdgeOf(node, ancestor) {
  while (node && node !== ancestor) {
    if (position(node) !== 0) {
      return false;
    }
    node = node.parentNode;
  }

  return true;
}
823988
public boolean isEdge(final ODocument iRecord) {
    return iRecord != null ? iRecord.getSchemaClass().isSubClassOf(edgeBaseClass) : false;
  }
767627
function isRegl (o) {
	return typeof o === 'function' &&
	o._gl &&
	o.prop &&
	o.texture &&
	o.buffer
}
916274
function computeEdgeDepths(nodes, orient) {
    var keyAttr = orient === 'vertical' ? 'x' : 'y';
    zrUtil.each(nodes, function (node) {
        node.outEdges.sort(function (a, b) {
            return a.node2.getLayout()[keyAttr] - b.node2.getLayout()[keyAttr];
        });
        node.inEdges.sort(function (a, b) {
            return a.node1.getLayout()[keyAttr] - b.node1.getLayout()[keyAttr];
        });
    });
    zrUtil.each(nodes, function (node) {
        var sy = 0;
        var ty = 0;
        zrUtil.each(node.outEdges, function (edge) {
            edge.setLayout({sy: sy}, true);
            sy += edge.getLayout().dy;
        });
        zrUtil.each(node.inEdges, function (edge) {
            edge.setLayout({ty: ty}, true);
            ty += edge.getLayout().dy;
        });
    });
}
754624
public boolean isCovering(Instance inst) {
		boolean isCovering = true;
		for (RuleSplitNode node : nodeList) {
			if (node.evaluate(inst) == false) {
				isCovering = false;
				break;
			}
		}
		return isCovering;
	}
1177651
function hasDotNesting(string) {
  const loc = string.indexOf('.');
  return (loc !== -1) && (loc !== 0) && (loc !== string.length - 1);
}
247571
function backEaseInOut (p) {
    var f;
    if(p < 0.5) {
        f = 2 * p;
        return 0.5 * (f * f * f - f * Math.sin(f * Math.PI));
    } else {
        f = (1 - (2*p - 1));
        return 0.5 * (1 - (f * f * f - f * Math.sin(f * Math.PI))) + 0.5;
    }
}
990371
public boolean isStandardFont() {
		return (family == UNDEFINED && size == UNDEFINED && style == UNDEFINED
				&& color == null && baseFont == null);
	}
162146
boolean isCornerValidOrigin( Node candidate ) {
		candidate.putEdgesIntoList(edgeList);
		if( edgeList.size() != 2 ) {
			throw new RuntimeException("BUG! Should be a corner and have two edges");
		}

		Node a = edgeList.get(0);
		Node b = edgeList.get(1);

		// Find the average angle from the two vectors defined by the two connected nodes
		double dirA = Math.atan2(a.y-candidate.y, a.x-candidate.x);
		double dirB = Math.atan2(b.y-candidate.y, b.x-candidate.x);

		double dirAB = UtilAngle.boundHalf(dirA+UtilAngle.distanceCCW(dirA,dirB)/2.0);

		// Find the acute angle between the corner's orientation and the vector
		double acute = UtilAngle.distHalf(dirAB,candidate.orientation);

		return acute < Math.PI/4.0;
	}
102433
function visibilityCheck() {
    var graphBound = g.node().getBoundingClientRect(),
        containerBound = container[0].getBoundingClientRect();

    if(graphBound.right < containerBound.left ||
      graphBound.bottom < containerBound.top ||
      graphBound.left > containerBound.right ||
      graphBound.top > containerBound.bottom) {
        panX = PADDING;
        panY = PADDING;
        scale = 1;
        transform(true);
    }
  }