def setUp(self):
self.dom = Space("adc", n1=10, n2=10)
self.inter = Space("adc", n1=15, n2=15)
self.rng = Space("adc", n1=22, n2=22)
self.L1 = LinearOperator(self.dom, self.inter, adj=False)
self.L2 = LinearOperator(self.inter, self.rng, adj=False)
self.C = CompoundOperator([self.L1, self.L2])
def dwt3( inSpace, type='linear' ):
"""
The Wavelet transform in three dimensions
"""
return CompoundOperator( [dwt( inSpace, type=type ),
dwt( inSpace, axis=2, type=type ),
dwt( inSpace, axis=3, type=type )] )
def applyop(self, other):
if is_oper(other):
return CompoundOperator([self, other])
import pdb
if is_number(other):
new = self.copy()
for i, oper in enumerate(new.flat):
if is_oper(oper):
D = DiagonalWeight(oper.range(), other)
C = CompoundOperator([oper, D])
elif oper is 0:
C = 0
else:
C = oper * other
new.flat[i] = C
return new
n = self.shape[1]
m = 1
if is_array(other): m = other.size
assert m == n, "AugOperator expected an Augment Vector of length %s, got length %s" % (
n, m)
if is_array(other):
other_long_vector = other.reshape([-1, 1])
new = mat(self) * other_long_vector
else: # other is not a augmented vector
new = asarray(self) * other
if is_array(new):
other_cls = AugVector
if new.size == 1:
ret = new.item()
else:
ret = new.view(other_cls)
else: ## assume 1x1 aug oper
ret = new
if is_array(ret):
ret.meta = self.meta_range
return ret
def curl(inSpace, sym=True, opt=False):
"""
C = curl( inSpace )
Curl with respect to hd/d compounding
"""
d = deriv(inSpace)
return CompoundOperator([d])
def grad(inSpace):
"""
G = grad( dom )
Grad with respect to hd/d compounding
"""
d = deriv(inSpace)
return CompoundOperator([d])
def deriv(inSpace):
"""
D = deriv( dom )
A Full Derivative
"""
hd = halfderiv(inSpace)
return CompoundOperator([hd, hd])
def fft2( inSpace, sym=True, opt=False ):
"""
F = fft2( dom, sym=True, opt=False )
The fourier transform in two dimensions
"""
f1 = fft1( inSpace, sym=sym, opt=opt )
f2 = fft( f1.range(), sym=sym, opt=opt, axis=2 )
return CompoundOperator( [f2, f1] )
def fft3( inSpace, sym=True, opt=False ):
"""
F = fft3( dom, sym=True, opt=False )
The fourier transform in three dimensions
"""
f1 = fft1( inSpace, sym=sym, opt=opt )
f2 = fft( f1.outSpace, sym=sym, opt=opt, axis=2 )
f3 = fft( f2.outSpace, sym=sym, opt=opt, axis=3 )
return CompoundOperator( [f3, f2, f1] )
def Normalize(oper, col=True, default=None):
"""
Normalize( oper , col=True, error=False )
"""
weights = Norm(oper, col=col, default=default)
if col:
oper_list = [weights, oper]
else:
oper_list = [oper, weights]
return CompoundOperator(oper_list)
def normalize( self ):
"""
reutrns an AugOper that containing Compound operators
"""
A = self.matrix.A
B = self.norm().matrix.A
C = numpy.empty_like( A )
for i in range( len( A ) ):
for j in range( len( A[i] ) ):
C[i][j] = CompoundOperator( [B[i][j], A[i][j]] )
return aug_oper( C )
class compTester(TestCase):
"""
Test CompoundOperator class
"""
def setUp(self):
self.dom = Space("adc", n1=10, n2=10)
self.inter = Space("adc", n1=15, n2=15)
self.rng = Space("adc", n1=22, n2=22)
self.L1 = LinearOperator(self.dom, self.inter, adj=False)
self.L2 = LinearOperator(self.inter, self.rng, adj=False)
self.C = CompoundOperator([self.L1, self.L2])
def test__init__(self):
self.assertRaises(TypeError, CompoundOperator, self.L1)
# self.assertRaises(TypeError, comp, [ self.L2 ,self.L1 ] )
def test__getitem__(self):
C = self.C
self.assertEqual(C[0], self.L1)
self.assertEqual(C[1], self.L2)
def testdomain(self):
self.assertEqual(self.C.domain(), self.L2.domain())
self.assertEqual(self.C.range(), self.L1.range())
CH = self.C.adj()
self.assertEqual(CH.domain(), self.L1.range())
self.assertEqual(CH.range(), self.L2.domain())