def totensor(self):
        sz = self.tsize
        order = numpy.concatenate((self.rindices, self.cindices))
        order = order.tolist()
        data = self.data.reshape(tools.getelts(sz, order))

        data = tensor.tensor(data).ipermute(order).data

        return tensor.tensor(data, sz)

 def convolve(self, h, idx):
     obj = t.tensor(self)
     if isinstance(h, t.tensor): h = h.arr
     N = obj.len(idx)
     obj.transpose([obj.index(idx), 0])
     z = zeros(obj.arr.shape) 
     obj.arr = append(obj.arr, z, axis=0)
     obj.transpose([obj.index(idx), -1],opt=True)
     X = fft.rfft(obj.arr)
     H = fft.rfft(append(h, zeros(2*N - h.size)))
     return t.tensor(fft.irfft(X*H)[0:N], obj.idx, obj.ud)

    def __init__(self,i,n):
        # our inde scheme starts at 0, so subtract 1 from n
        # when naming the momenta
        k = n-1
        il = lorentz_key(i) if (i<0) else i
        p_str = "p{0}[{1}]"
        array = [tensor([c_variable(p_str.format(k,vect_gauge_dict[0]))], None), 
                 tensor([c_variable(p_str.format(k,vect_gauge_dict[1]))], None), 
                 tensor([c_variable(p_str.format(k,vect_gauge_dict[2]))], None), 
                 tensor([c_variable(p_str.format(k,vect_gauge_dict[3]))], None)]

        super(P,self).__init__(array,il)

def ctor(verbose):
    
    dat = numpy.arange(24).reshape([2,3,4]);
    
    t = tensor.tensor(dat);
    print t;
    if (verbose):
        obj = tenmat.tenmat(t, [1,0]);
        print obj;
        print obj.copy();
        
    dat = dat.reshape([4,6]);
    t = tensor.tensor(dat);
    if (verbose):
        obj = tenmat.tenmat(t, [0], [1], [4,6]);
        print obj;

 def tensorProduct(self,other):
     """Add other as a component(s) on the right of self. e.g. (a|b).tensorProduct(c) = a|b|c"""
     if type(other) in [relation.relation,doublyDefined.doublyDefined,coefficient.coefficient, str, float, int, monomial.monomial]:
         return self.tensorProduct(pureTensor(other))
     if not isinstance(other,pureTensor):
         return reduce(lambda x,y: x+y, [self.tensorProduct(z) for z in other], tensor.tensor())
     return pureTensor(self.monomials + other.monomials, self.coefficient * other.coefficient)

 def i_3Inner(pT):
     answer = tensor()
     doublyDefined = pT[1]
     for generator, rel in doublyDefined.leftHandRepresentation:
         rightHandSide = generator * i_2(pureTensor([1,rel,1]),alg)
         answer = answer + pureTensor(1).tensorProduct(rightHandSide)
     return answer

 def m_1Inner(b):
     b = b[1].clean()
     answer = tensor()
     if b.degree() != 0:
         for i in range(b.degree()):
             answer += b.coefficient * pureTensor([b[0:i],b[i],b[i+1:]])
     return answer

 def mov_ave(self, wid, dx, idx, fs):
     f =  fft.rfftfreq(self.len(idx), float(fs))
     L = int(float(wid) / float(dx))
     H = ((sin(pi *  f * L / fs) / sin(pi * f / fs)) * exp(-1j * pi * f * (L-1) / fs)) / L
     H[0] = 1.
     X = self.rfft(idx).arr * H
     return t.tensor(fft.irfft(X), self.idx, self.ud)

def totensorTests(verbose):
    
    dat = numpy.arange(24).reshape([2,3,4]);
    t = tensor.tensor(dat);
    obj = tenmat.tenmat(t,[2,1]);
    if(verbose):
        print obj;
        print obj.totensor();

 def k_4Inner(pT):
     answer= tensor()
     doublyDefined = pT[1]
     for generator, rel in doublyDefined.leftHandRepresentation:
         answer = answer + pureTensor((generator,rel,1)).clean()
     for rel, generator in doublyDefined.rightHandRepresentation:
         answer = answer - pureTensor((1,rel,generator)).clean()
     return answer

 def i_2Inner(pT):
     answer = tensor()
     rel = pT[1]
     for term in rel.leadingMonomial:
         answer = answer + term.coefficient * pureTensor((1,term[0],term[1],1))
     for term in rel.lowerOrderTerms:
         answer = answer - term.coefficient * pureTensor((1,term[0],term[1],1))
     return answer

 def totensor(self):
     """returns a new tensor object that contains the same values"""
     temp = numpy.ndarray(self.shape);
     temp.fill(0);
     
     for i in range(0, len(self.vals)):
         temp.put(tools.sub2ind(self.shape, self.subs[i])[0], self.vals[i][0]);
     
     return tensor.tensor(temp, self.shape);

 def listOfPolysToTensors(ps):
     ps = iter(ps)
     pureTensors = [pureTensor.pureTensor(mono) for mono in next(ps)]
     for poly in ps:
         newPureTensors = []
         for mono in poly:
             newPureTensors.extend([x.tensorProduct(mono) for x in pureTensors])
         pureTensors = newPureTensors
     return tensor.tensor(pureTensors)

def ctorTests(verbose):
    arr = numpy.arange(24).reshape([2,3,4]);
    A = numpy.array([[1,2],[3,4],[5,6]]);
    B = numpy.array([[1,2,3],[4,5,6]]);
    C = numpy.array([[1,2,3,4]]);
    
    obj = ttensor.ttensor(tensor.tensor(arr), [A, B, C]);
    print obj;
    print obj.shape;

def tosptensor(verbose):
    
    dat = numpy.array([1,2,3,4,5,6,7,8,9,10,0,0,13,14,15,16,17,18]);
    siz = numpy.array([3,3,2]);
    
    obj = tensor.tensor(dat, siz);
    if(verbose == 1):
        print obj;
        print (obj.tosptensor());

def test2():
#    A = numpy.array([[1, 4, 7, 10], [2, 5, 8, 11], [3, 6, 9, 12]]);
#    A = numpy.arange(12).reshape([4,3]) + 1;
    A = numpy.arange(1000).reshape([10,10,10])+1;
    (ans1, ans2) = DTA.DTA(tensor.tensor(A), [2,2,2]);
    print ans1;
    for i in range(0, len(ans2)):
        print "{0} th array\n {1}".format(i, ans2[i]);
        
    print ans1.totensor();

 def append(self, obj, idx):
     ## \brief Append a tensor to other tensor.
     self.same_trans(obj)    
     self.transpose([idx,0])
     obj.transpose([idx,0])
     if self.idx != obj.idx:
         raise ValueError, "Index is not much."
     ret = t.tensor(append(self.arr, obj.arr, axis=0), self.idx, self.ud)
     
     return ret

    def mov_grad(self, obj, wid, dx, idx, fs):
        x = obj
        y = self
        xy = x * y
        L = abs(int(float(wid)/float(dx))) 
        h = t.tensor(ones(L), idx, self.gud(idx))

        conv_x = x.convolve(h, idx)
        a = (L * xy.convolve(h, idx) - conv_x * y.convolve(h, idx)) / (L * (x**2).convolve(h, idx) - conv_x ** 2)
        return a

 def k_2Inner(tens):
     assert isinstance(tens,pureTensor)
     answer= tensor()
     rel =tens.monomials[1]
     for i in rel.leadingMonomial:
         answer = answer + i.coefficient * pureTensor((i.submonomial(0,1),i.submonomial(1,2), 1))
         answer = answer + i.coefficient * pureTensor((1,i.submonomial(0,1),i.submonomial(1,2)))
     for i in rel.lowerOrderTerms:
         answer = answer - i.coefficient * pureTensor((i.submonomial(0,1),i.submonomial(1,2), 1))
         answer = answer - i.coefficient * pureTensor((1,i.submonomial(0,1),i.submonomial(1,2)))
     return answer

def ctor(verbose):
    dat = numpy.arange(24);
    dat[10] = 100;
    dat[16] = -1;
    siz = numpy.array([4,3,2]);
    
    obj = tensor.tensor(dat, siz);
    if(verbose == 1):
        print obj;
        print obj.ndims();
    
    obj2 = tensor.tensor(dat.reshape([2,3,4]),siz);
    if(verbose == 1):
        print obj;
        print obj.shape;
    
    dat = numpy.array([1,2,3,4,5,6,7,8,9,10,0,0,13,14,15,16,17,18]);
    obj2 = tensor.tensor(dat);
    if(verbose == 1):
        print obj2;
        print obj2.shape;