'This returns a formula whose columns are the pairwise
product of the columns of self and other.
TO DO: check for nesting relationship. Should not be too difficult.'

def __mul__(self, other, nested=False):

    other = Formula(other)
    selftermnames = self.termnames()
    othertermnames = other.termnames()
    I = len(selftermnames)
    J = len(othertermnames)
    terms = []
    termnames = []
    for i in range(I):
        for j in range(J):
            termname = ('%s*%s' % (str(selftermnames[i]), str(othertermnames[j])))
            pieces = sorted(termname.split('*'))
            termname = '*'.join(pieces)
            termnames.append(termname)
            selfnames = self.terms[i].names()
            othernames = other.terms[j].names()
            if (self.terms[i].name is 'intercept'):
                _term = other.terms[j]
                _term.namespace = other.namespace
            elif (other.terms[j].name is 'intercept'):
                _term = self.terms[i]
                _term.namespace = self.namespace
            else:
                names = []
                d1 = len(selfnames)
                d2 = len(othernames)
                for r in range(d1):
                    for s in range(d2):
                        name = ('%s*%s' % (str(selfnames[r]), str(othernames[s])))
                        pieces = sorted(name.split('*'))
                        name = '*'.join(pieces)
                        names.append(name)
                def product_func(value, d1=d1, d2=d2):
                    out = []
                    for r in range(d1):
                        for s in range(d2):
                            out.append((value[r] * value[(d1 + s)]))
                    return np.array(out)
                cself = copy.copy(self.terms[i])
                cother = copy.copy(other.terms[j])
                sumterms = (cself + cother)
                sumterms.terms = [cself, cother]
                _term = Quantitative(names, func=sumterms, termname=termname, transform=product_func)
                if _namespace_equal(self.namespace, other.namespace):
                    _term.namespace = self.namespace
            terms.append(_term)
    return Formula(terms)
