Returns True if the VG is partial, False otherwise.
491746
def is_partial(self):
        
        self.open()
        part = lvm_vg_is_partial(self.handle)
        self.close()
        return bool(part)
238069
public static boolean isPresentAll(Optional<?>... optionals) {
        for (Optional<?> optional : optionals)
            if (!optional.isPresent())
                return false;
        return true;
    }
829955
public boolean isAdjacent(Marker other)
    {
        checkTypeCompatibility(other);
        if (isUpperUnbounded() || isLowerUnbounded() || other.isUpperUnbounded() || other.isLowerUnbounded()) {
            return false;
        }
        if (type.compareTo(valueBlock.get(), 0, other.valueBlock.get(), 0) != 0) {
            return false;
        }
        return (bound == Bound.EXACTLY && other.bound != Bound.EXACTLY) ||
                (bound != Bound.EXACTLY && other.bound == Bound.EXACTLY);
    }
124256
private boolean isCompletelyCoveredBy(int[] isCovered, List<RuleInterval> intervals) {
    for (RuleInterval i : intervals) {
      for (int j = i.getStart(); j < i.getEnd(); j++) {
          if (isCovered[j] == 0) {
            return false;
          }
      }
    }
    return true;
  }
332726
public static boolean hasPlrselPart(List<SoyMsgPart> msgParts) {
    for (SoyMsgPart origMsgPart : msgParts) {
      if (origMsgPart instanceof SoyMsgPluralPart || origMsgPart instanceof SoyMsgSelectPart) {
        return true;
      }
    }
    return false;
  }
1159375
public static boolean isVarArg(List<? extends XtendParameter> params) {
		assert params != null;
		if (params.size() > 0) {
			final XtendParameter param = params.get(params.size() - 1);
			assert param != null;
			return param.isVarArg();
		}
		return false;
	}
1033409
static <K,V> boolean checkInvariants(TreeNode<K,V> t) {
            TreeNode<K,V> tp = t.parent, tl = t.left, tr = t.right,
                tb = t.prev, tn = (TreeNode<K,V>)t.next;
            if (tb != null && tb.next != t)
                return false;
            if (tn != null && tn.prev != t)
                return false;
            if (tp != null && t != tp.left && t != tp.right)
                return false;
            if (tl != null && (tl.parent != t || tl.hash > t.hash))
                return false;
            if (tr != null && (tr.parent != t || tr.hash < t.hash))
                return false;
            if (t.red && tl != null && tl.red && tr != null && tr.red)
                return false;
            if (tl != null && !checkInvariants(tl))
                return false;
            if (tr != null && !checkInvariants(tr))
                return false;
            return true;
        }
546388
public function isPartiallyApproved()
    {
        if (isset($this->responseObj->partial_approval)) {
            return \Genesis\Utils\Common::stringToBoolean($this->responseObj->partial_approval);
        }

        return null;
    }
764784
protected function _isFixedPrice()
    {
        $dPrice = $this->getDPrice();
        $aVariants = $this->getMdSubvariants();
        foreach ($aVariants as $oVariant) {
            $dVariantPrice = $oVariant->getDPrice();
            if (is_null($dPrice)) {
                $dPrice = $dVariantPrice;
            }
            if (!is_null($dVariantPrice) && $dVariantPrice != $dPrice) {
                return false;
            }
            if (!$oVariant->_isFixedPrice()) {
                return false;
            }
        }

        return true;
    }
179789
function contains(arr, v) {
    var nIndex,
      nLen = arr.length;
    for (nIndex = 0; nIndex < nLen; nIndex++) {
      if (arr[nIndex][1] === v) {
        return true;
      }
    }
    return false;
  }
278244
public static boolean isVoidType(Type type, VisitorState state) {
    if (type == null) {
      return false;
    }
    return type.getKind() == TypeKind.VOID
        || state.getTypes().isSameType(Suppliers.JAVA_LANG_VOID_TYPE.get(state), type);
  }
1257715
def partial(f, x, i):
    
    result = f(*[AdFloat(x_j, j == i) for j, x_j in enumerate(x)])
    return result.dx
601044
public boolean isNotFull()
	{
		return itemStack.isEmpty() || itemStack.getCount() < Math.min(itemStack.getMaxStackSize(), getSlotStackLimit());
	}
1216877
public function has_subparts() {
        foreach ($this->get_variant_nos() as $variantno) {
            if (count($this->get_subpart_ids($variantno)) > 1) {
                return true;
            }
        }
        return false;
    }
598414
public boolean partialCharges(IAtomContainer mol) {

        int[][] adjList = mol.getProperty(MMFF_ADJLIST_CACHE);
        GraphUtil.EdgeToBondMap edgeMap = mol.getProperty(MMFF_EDGEMAP_CACHE);

        if (adjList == null || edgeMap == null)
            throw new IllegalArgumentException("Invoke assignAtomTypes first.");

        effectiveCharges(mol);
        
        for (int v = 0; v < mol.getAtomCount(); v++) {

            IAtom atom = mol.getAtom(v);
            String symbType = atom.getAtomTypeName();
            final int thisType = mmffParamSet.intType(symbType);

            // unknown
            if (thisType == 0)
                continue;

            double pbci = mmffParamSet.getPartialBondChargeIncrement(thisType).doubleValue();

            for (int w : adjList[v]) {

                int otherType = mmffParamSet.intType(mol.getAtom(w).getAtomTypeName());

                // unknown
                if (otherType == 0)
                    continue;

                IBond bond = edgeMap.get(v, w);
                int bondCls = mmffParamSet.getBondCls(thisType, otherType, bond.getOrder().numeric(), bond.getProperty(MMFF_AROM) != null);
                BigDecimal bci = mmffParamSet.getBondChargeIncrement(bondCls, thisType, otherType);
                if (bci != null) {
                    atom.setCharge(atom.getCharge() - bci.doubleValue());
                }
                else {
                    // empirical BCI
                    atom.setCharge(atom.getCharge() + (pbci - mmffParamSet.getPartialBondChargeIncrement(otherType).doubleValue()));
                }
            }
        }

        return true;
    }
1069898
function partial(...args) {
  const fn = args[0]
  const xs = args.slice(1)

  if(!isFunction(fn)) {
    throw new TypeError('partial: Function required for first argument')
  }

  return curry(
    Function.bind.apply(fn, [ null ].concat(xs))
  )
}
1130212
function hasRightSideContent() {
            var walker = new TreeWalker(container, parentBlock), node;
            var nonEmptyElementsMap = editor.schema.getNonEmptyElements();

            while ((node = walker.next())) {
              if (nonEmptyElementsMap[node.nodeName.toLowerCase()] || node.length > 0) {
                return true;
              }
            }
          }