Raises one vertex to the power of another
    
    :param left: the base vertex
    :param right: the exponent vertex
429442
def IntegerPower(left: vertex_constructor_param_types, right: vertex_constructor_param_types, label: Optional[str]=None) -> Vertex:
    
    return Integer(context.jvm_view().IntegerPowerVertex, label, cast_to_integer_vertex(left), cast_to_integer_vertex(right))
1214826
def new_vertex(self):
    
    vertex = Vertex(len(self.vertices))
    self.vertices.append(vertex)
    return vertex
872215
private function doubleExponentiation($leftOperand, $rightOperand)
    {
        // (x^a)^b -> x^(ab) for a, b numbers
        if ($leftOperand instanceof ExpressionNode && $leftOperand->getOperator() == '^') {

            $factory = new MultiplicationNodeFactory();
            $power = $factory->makeNode($leftOperand->getRight(), $rightOperand);

            $base = $leftOperand->getLeft();
            return self::makeNode($base,  $power);
        }

        // No simplification found
        return null;
    }
491433
def add_vertex(self, v):
        
        self.graph.add_vertex(v)
        self.vs.add(v)
1085742
def IntegerAddition(left: vertex_constructor_param_types, right: vertex_constructor_param_types, label: Optional[str]=None) -> Vertex:
    
    return Integer(context.jvm_view().IntegerAdditionVertex, label, cast_to_integer_vertex(left), cast_to_integer_vertex(right))
844345
def pow(self, *args, **kwargs):
        
        return self._apply(operator.pow, *args, **kwargs)
260768
def bsp_left(node: tcod.bsp.BSP) -> Optional[tcod.bsp.BSP]:
    
    return None if not node.children else node.children[0]
957826
def degree(self, vertex):
        
        try:
            return len(self.vertices[vertex])
        except KeyError:
            raise GraphInsertError("Vertex %s doesn't exist." % (vertex,))
631888
def lnprior(self, X):
        
        if np.any(X < self._lower_left) or np.any(X > self._upper_right):
            return -np.inf
        else:
            return 0.0
421840
def mul(left, right):
    
    from .mv_mul import MvMul
    length = max(left, right)
    if length == 1:
        return Mul(left, right)
    return MvMul(left, right)
261422
function multiply(product, left, right) {
  var leftRows = left.rows;
  var leftColumns = left.columns;
  var rightColumns = right.columns;

  // loop over rows of left
  for (var leftRow = 0; leftRow < leftRows; leftRow++) {
    var leftRowBase = leftColumns * leftRow;
    var rightRowBase = rightColumns * leftRow;
    // loop over cols of right
    for (var rightColumn = 0; rightColumn < rightColumns; rightColumn++) {

      // dot product loop
      var dot = 0;
      //loop over columns of left
      for (var leftColumn = 0; leftColumn < leftColumns; leftColumn++) {
        var rightColumnBase = rightColumns * leftColumn;
        var leftIndex = leftRowBase + leftColumn;
        var rightIndex = rightColumnBase + rightColumn;
        dot += left.weights[leftIndex] * right.weights[rightIndex];
        left.deltas[leftIndex] = 0;
        right.deltas[rightIndex] = 0;
      }
      product.weights[rightRowBase + rightColumn] = dot;
    }
  }
}
1121026
public static Number multiply(Number left, Number right) {
        return NumberMath.multiply(left, right);
    }
103416
def IntegerMax(left: vertex_constructor_param_types, right: vertex_constructor_param_types, label: Optional[str]=None) -> Vertex:
    
    return Integer(context.jvm_view().IntegerMaxVertex, label, cast_to_integer_vertex(left), cast_to_integer_vertex(right))
1045145
def add_vertex(self, vertex):
        
        if vertex not in self._vertices:
            self._vertices.add(vertex)
            return True

        return False
698470
def limited_to(self, left: Set[TLeft], right: Set[TRight]) -> 'BipartiteGraph[TLeft, TRight, TEdgeValue]':
        """"""
        return BipartiteGraph(((n1, n2), v) for (n1, n2), v in self._edges.items() if n1 in left and n2 in right)
696455
private float getHeight(float[] left, float[] right) {
        float max = Float.MIN_VALUE;
        float min = Float.MAX_VALUE;
        for (int i = 0; i < left.length; i += 2) {
            min = Math.min(min, left[i + 1]);
            max = Math.max(max, left[i + 1]);
        }
        for (int i = 0; i < right.length; i += 2) {
            min = Math.min(min, right[i + 1]);
            max = Math.max(max, right[i + 1]);
        }
        return max - min;
    }
1309116
def add_params(param_list_left, param_list_right):
    
    res = []
    for x, y in zip(param_list_left, param_list_right):
        res.append(x + y)
    return res