Series product with another :class:`SLH` object

        Args:
            other (SLH): An upstream SLH circuit.

        Returns:
            SLH: The combined system.
493982
def series_with_slh(self, other):
        
        new_S = self.S * other.S
        new_L = self.S * other.L + self.L

        def ImAdjoint(m):
            return (m.H - m) * (I / 2)

        delta = ImAdjoint(self.L.adjoint() * self.S * other.L)

        if isinstance(delta, Matrix):
            new_H = self.H + other.H + delta[0, 0]
        else:
            assert delta == 0
            new_H = self.H + other.H

        return SLH(new_S, new_L, new_H)
13260
def is_downstream_of(self, other):
        
        if self.chrom != other.chrom: return None
        if getattr(other, "strand", None) == "-":
            # other feature is on - strand, so this must have higher start
            return self.end <= other.start
        return self.start >= other.end
692872
public void combine(SpdLong other) {
        if (other == null)
            return;
        if (stat.isEnabled() && other.isEnabled())
            stat.combine((CountStatisticImpl) other.getStatistic());
    }
687064
def expand(self):
        
        return SLH(self.S.expand(), self.L.expand(), self.H.expand())
1028465
def get_scalar_product(self, other):
        """"""
        return self.x*other.x+self.y*other.y
1347555
def join(self, other):
        ''' '''
        if self.field == other.field:
            return self, other

        _, f1, f2 = Constructible.join_fields(self.field, other.field)
        return f1(self), f2(other)
199982
def extend(self, other):
        
        def extend_trans(pipe):
            values = list(other.__iter__(pipe)) if use_redis else other
            len_self = pipe.rpush(self.key, *(self._pickle(v) for v in values))
            if self.writeback:
                for i, v in enumerate(values, len_self - len(values)):
                    self.cache[i] = v

        if self._same_redis(other, RedisCollection):
            use_redis = True
            self._transaction(extend_trans, other.key)
        else:
            use_redis = False
            self._transaction(extend_trans)
318486
def union(self, other):
        
        union = Rect()
        lib.SDL_UnionRect(self._ptr, other._ptr, union._ptr)
        return union
1323998
def union(self, *others):
        
        return self.copy(super(NGram, self).union(*others))
400089
def sge(self, other):
        
        self._check_match(other)
        return self.to_sint() >= other.to_sint()
1114466
def dock(self, other):
		'''
			
		'''
		if other.multiplicand != self.multiplicand:
			raise Exception("Can't subtract " + repr(other) + " from " + repr(self))
		return mult(self.multiplicand, self.multiplier - other.multiplier)
1202771
def lub(self, other):
        
        return self.__class__(
            [
                max(self.lower, other.lower),
                max(self.upper, other.upper),
            ],
            lower_inc=self.lower_inc if self < other else other.lower_inc,
            upper_inc=self.upper_inc if self > other else other.upper_inc,
        )
483937
def is_upstream_of(self, other):
        
        if self.chrom != other.chrom: return None
        if getattr(other, "strand", None) == "+":
            return self.end <= other.start
        # other feature is on - strand, so this must have higher start
        return self.start >= other.end
1185489
def combine_first(self, other):
        
        if isinstance(other, SparseSeries):
            other = other.to_dense()

        dense_combined = self.to_dense().combine_first(other)
        return dense_combined.to_sparse(fill_value=self.fill_value)
896300
def sum(self, other):
        """"""
        return TimeSeries.merge(
            [self, other], operation=operations.ignorant_sum
        )
428930
def merge(self, other):
        
        other = self.coerce(other)
        if self.is_equal(other):
            # pick among dependencies
            return self
        elif other.is_entailed_by(self):
            # other is a subset of self
            return self
        elif self.is_entailed_by(other):
            # self is a subset of other.
            self.values = other.values.copy()
        elif self.is_contradictory(other):
            raise Contradiction("Cannot merge set with %s" % (str(other)))
        else:
            # merge mutual information
            if self.values:
                self.values = self.values.intersection(other.values)
            else:
                self.values = other.values.copy()
        return self
1165939
def _merge_expressions(self, other):
        
        new_inputs = tuple(set(self.inputs).union(other.inputs))
        new_self_expr = self._rebind_variables(new_inputs)
        new_other_expr = other._rebind_variables(new_inputs)
        return new_self_expr, new_other_expr, new_inputs