def __init__( self ):
"""
Initialize the class, checks the inSpace and otuSpace and sets them to voidSpace if needed.
"""
# init Structure not necissary but to conserve consistancy
Structure.__init__( self )
# self.isadj = False
if self.command is None:
raise TypeError( "need to define command in operator" )
if self.inSpace is None:
raise TypeError( "need to define inSpace, use voidSpace if unknown" )
if self.outSpace is None:
raise TypeError( "need to define outSpace, use voidSpace if unknown" )
if self.adj_kparams is None:
self.adj_kparams = self.kparams
if self.adj_params is None:
self.adj_params = self.params
if self.adj_command is None:
self.adj_command = self.command
LinearOperator.__init__( self, self.inSpace, self.outSpace , *self.params, **self.kparams )
def __init__(self, arithop, oper1, oper2):
self.oper1 = oper1
self.oper2 = oper2
self.arithop = arithop
domain = VectorAddition([self.oper1.domain(), self.oper2.domain()])
range = VectorAddition([self.oper1.range(), self.oper2.range()])
LinearOperator.__init__(self, domain, range)
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 testadj( self ):
"""
test that the adj method of the linear operator class works
isadj should reflect the adj flag and the donmain and range
should be switched
"""
L = LinearOperator( self.dom, self.rng, "test", foo="bar", adj=False )
Lh = L.adj()
self.assertFalse( L.isadj )
self.assertTrue( Lh.isadj )
self.assertEqual( L.domain(), Lh.range() )
self.assertEqual( Lh.domain(), L.range() )
def test__eq__( self ):
L = self.L
A = LinearOperator( self.dom, self.rng, adj=False )
# B = LinearOperator( self.rng, self.dom , adj=False )
self.assertEqual( L, A )
self.assertNotEqual( L.adj(), L )
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())
def __mul__(self, other):
return LinearOperator.__mul__(self, other)
def __init__(self, data, inSpace, outSpace, *params, **kparams):
ADI.__init__(self, data)
LinearOperator.__init__(self, inSpace, outSpace, *params, **kparams)
def __init__(self, inspace, *params, **kparams):
# init Structure not necissary but to conserve consistancy
Structure.__init__(self)
outspace = inspace.testCommand(self.name, *params, **kparams)
LinearOperator.__init__(self, inspace, outspace, *params, **kparams)
def __init__(self, domain, weight):
self.weight = weight
range = domain
LinearOperator.__init__(self, domain, range)
def __init__( self, mat ):
AugMatrix.__init__( self, mat )
LinearOperator.__init__( self, self.domain(), self.range() )
def setUp( self ):
self.dom = Space( "adc" , n1=10, n2=10)
self.rng = Space( "adc" , n1=15, n2=15 )
self.L = LinearOperator( self.dom, self.rng, adj=False )
class linearoptester( TestCase ):
"""
Test The base linear operator class.
"""
def setUp( self ):
self.dom = Space( "adc" , n1=10, n2=10)
self.rng = Space( "adc" , n1=15, n2=15 )
self.L = LinearOperator( self.dom, self.rng, adj=False )
def tearDown( self ):
pass
def test__init__( self ):
"""
check domain and range are set
"""
self.assertEqual( self.L.range(), self.rng )
self.assertEqual( self.L.range(), self.L.outSpace )
self.assertEqual( self.L.domain(), self.dom )
self.assertEqual( self.L.domain(), self.L.inSpace )
self.assertEqual( self.L.kparams['adj'], False )
def test__eq__( self ):
L = self.L
A = LinearOperator( self.dom, self.rng, adj=False )
# B = LinearOperator( self.rng, self.dom , adj=False )
self.assertEqual( L, A )
self.assertNotEqual( L.adj(), L )
def testcopy( self ):
"""
Test that the copy operator returns a new
instance
"""
L = self.L
A = L.copy()
self.assertEqual( L, A )
def testadj( self ):
"""
test that the adj method of the linear operator class works
isadj should reflect the adj flag and the donmain and range
should be switched
"""
L = LinearOperator( self.dom, self.rng, "test", foo="bar", adj=False )
Lh = L.adj()
self.assertFalse( L.isadj )
self.assertTrue( Lh.isadj )
self.assertEqual( L.domain(), Lh.range() )
self.assertEqual( Lh.domain(), L.range() )
def test__mul__( self ):
"""
Not defined in this class
"""
pass
def test__call__( self ):
"""
Not defined in this class
"""
pass
def testapplyop( self ):
"test applyop mehtod "
pass
def testgetdim( self ):
"test to see if the linear operator shape is working"
dim = self.L.getdim()
realdim = [len( self.dom ), len( self.rng )]
self.assertEqual( dim , realdim )
dim = self.L.adj().getdim()
realdim.reverse()
self.assertEqual( dim , realdim )