/[escript]/trunk/escript/test/python/test_pdetools.py
ViewVC logotype

Annotation of /trunk/escript/test/python/test_pdetools.py

Parent Directory Parent Directory | Revision Log Revision Log


Revision 3259 - (hide annotations)
Mon Oct 11 01:48:14 2010 UTC (9 years ago) by jfenwick
File MIME type: text/x-python
File size: 66694 byte(s)
Merging dudley and scons updates from branches

1 ksteube 1809
2     ########################################################
3 ksteube 1312 #
4 jfenwick 2881 # Copyright (c) 2003-2010 by University of Queensland
5 ksteube 1809 # Earth Systems Science Computational Center (ESSCC)
6     # http://www.uq.edu.au/esscc
7 ksteube 1312 #
8 ksteube 1809 # Primary Business: Queensland, Australia
9     # Licensed under the Open Software License version 3.0
10     # http://www.opensource.org/licenses/osl-3.0.php
11 ksteube 1312 #
12 ksteube 1809 ########################################################
13 gross 525
14 jfenwick 2881 __copyright__="""Copyright (c) 2003-2010 by University of Queensland
15 ksteube 1809 Earth Systems Science Computational Center (ESSCC)
16     http://www.uq.edu.au/esscc
17     Primary Business: Queensland, Australia"""
18     __license__="""Licensed under the Open Software License version 3.0
19     http://www.opensource.org/licenses/osl-3.0.php"""
20 jfenwick 2344 __url__="https://launchpad.net/escript-finley"
21 ksteube 1809
22 gross 525 """
23     Test suite for the pdetools module
24    
25     The tests must be linked with a Domain class object in the setUp method:
26    
27 jfenwick 3259 from esys.dudley import Rectangle
28     class Test_LinearPDEOnDudley(Test_LinearPDE):
29 artak 1695 RES_TOL=1.e-8
30 gross 525 def setUp(self):
31     self.domain = Rectangle(10,10,2)
32 gross 798 def tearDown(self):
33     del self.domain
34 gross 525 suite = unittest.TestSuite()
35 jfenwick 3259 suite.addTest(unittest.makeSuite(Test_LinearPDEOnDudley))
36 gross 525 unittest.TextTestRunner(verbosity=2).run(suite)
37    
38 jfenwick 2625 :var __author__: name of author
39     :var __copyright__: copyrights
40     :var __license__: licence agreement
41     :var __url__: url entry point on documentation
42     :var __version__: version
43     :var __date__: date of the version
44 gross 525 """
45    
46     __author__="Lutz Gross, l.gross@uq.edu.au"
47    
48     import unittest
49     from esys.escript import *
50 gross 2100 from esys.escript.pdetools import Locator,Projector,TimeIntegrationManager,NoPDE,PCG, ArithmeticTuple, GMRES, MINRES, TFQMR, HomogeneousSaddlePointProblem
51 gross 1878 from esys.escript.pdetools import Defect, NewtonGMRES
52 jfenwick 2455 from numpy.linalg import solve as solve_linear_equations
53 gross 525
54 gross 855 class Test_pdetools_noLumping(unittest.TestCase):
55 gross 525 DEBUG=False
56     VERBOSE=False
57     def test_TimeIntegrationManager_scalar(self):
58     t=0.
59     dt=0.1
60     tm=TimeIntegrationManager(0.,p=1)
61     while t<1.:
62     t+=dt
63     tm.checkin(dt,t)
64     v_guess=tm.extrapolate(dt)
65 gross 798 self.failUnless(abs(v_guess-(tm.getTime()+dt))<self.RES_TOL,"extrapolation is wrong")
66 gross 525
67     def test_TimeIntegrationManager_vector(self):
68     t=0.
69     dt=0.3
70     tm=TimeIntegrationManager(0.,0.,p=1)
71     while t<1.:
72     t+=dt
73     tm.checkin(dt,t,3*t)
74     v_guess=tm.extrapolate(dt)
75     e=max(abs(v_guess[0]-(tm.getTime()+dt)),abs(v_guess[1]-(tm.getTime()+dt)*3.))
76 gross 798 self.failUnless(e<self.RES_TOL,"extrapolation is wrong")
77 gross 525
78     def test_Locator(self):
79     x=self.domain.getX()
80 jfenwick 2455 l=Locator(self.domain,numpy.ones((self.domain.getDim(),)))
81 gross 525 self.failUnless(ContinuousFunction(self.domain)==l.getFunctionSpace(),"wrong function space from domain")
82    
83 jfenwick 2455 l=Locator(ContinuousFunction(self.domain),numpy.ones((self.domain.getDim(),)))
84 gross 525 self.failUnless(ContinuousFunction(self.domain)==l.getFunctionSpace(),"wrong function space")
85    
86     xx=l.getX()
87 jfenwick 2455 self.failUnless(isinstance(xx,numpy.ndarray),"wrong vector type")
88     self.failUnless(Lsup(xx-numpy.ones((self.domain.getDim(),)))<self.RES_TOL,"location wrong")
89 gross 525 xx=l(x)
90 jfenwick 2455 self.failUnless(isinstance(xx,numpy.ndarray),"wrong vector type")
91     self.failUnless(Lsup(xx-numpy.ones((self.domain.getDim(),)))<self.RES_TOL,"value wrong vector")
92 gross 525 xx=l(x[0]+x[1])
93     self.failUnless(isinstance(xx,float),"wrong scalar type")
94 gross 798 self.failUnless(abs(xx-2.)<self.RES_TOL,"value wrong scalar")
95 gross 2592
96     # now with interpolation:
97     l=Locator(Function(self.domain),numpy.ones((self.domain.getDim(),)))
98     x2=Function(self.domain).getX()
99     xx=l(x)
100     self.failUnless(isinstance(xx,numpy.ndarray),"wrong vector type")
101     self.failUnless(Lsup(xx-l(x2))<self.RES_TOL,"location wrong")
102     xx=l(x[0]+x[1])
103     self.failUnless(isinstance(xx,float),"wrong scalar type")
104     self.failUnless(abs(xx-l(x2[0])-l(x2[1]))<self.RES_TOL,"value wrong scalar")
105 gross 880
106 gross 2592
107 gross 880 def test_Locator_withList(self):
108     x=self.domain.getX()
109 jfenwick 2455 arg=[numpy.ones((self.domain.getDim(),)), numpy.zeros((self.domain.getDim(),))]
110 gross 880 l=Locator(self.domain,arg)
111     self.failUnless(ContinuousFunction(self.domain)==l.getFunctionSpace(),"wrong function space from domain")
112    
113     l=Locator(ContinuousFunction(self.domain),arg)
114     self.failUnless(ContinuousFunction(self.domain)==l.getFunctionSpace(),"wrong function space")
115    
116     xx=l.getX()
117     self.failUnless(isinstance(xx,list),"list expected")
118     for i in range(len(xx)):
119 jfenwick 2455 self.failUnless(isinstance(xx[i],numpy.ndarray),"vector expected for %s item"%i)
120 gross 880 self.failUnless(Lsup(xx[i]-arg[i])<self.RES_TOL,"%s-th location is wrong"%i)
121     xx=l(x)
122     self.failUnless(isinstance(xx,list),"list expected (2)")
123     for i in range(len(xx)):
124 jfenwick 2455 self.failUnless(isinstance(xx[i],numpy.ndarray),"vector expected for %s item (2)"%i)
125 gross 880 self.failUnless(Lsup(xx[i]-arg[i])<self.RES_TOL,"%s-th location is wrong (2)"%i)
126     xx=l(x[0]+x[1])
127     self.failUnless(isinstance(xx,list),"list expected (3)")
128     for i in range(len(xx)):
129     self.failUnless(isinstance(xx[i],float),"wrong scalar type")
130     self.failUnless(abs(xx[i]-(arg[i][0]+arg[i][1]))<self.RES_TOL,"value wrong scalar")
131 gross 2592
132     # now with interpolation:
133     l=Locator(Function(self.domain),arg)
134     self.failUnless(Function(self.domain)==l.getFunctionSpace(),"wrong function space")
135     xx=l(x)
136     x2=Function(self.domain).getX()
137     self.failUnless(isinstance(xx,list),"list expected (2)")
138     for i in range(len(xx)):
139     self.failUnless(isinstance(xx[i],numpy.ndarray),"vector expected for %s item (2)"%i)
140     self.failUnless(Lsup(xx[i]-l(x2)[i])<self.RES_TOL,"%s-th location is wrong (2)"%i)
141     xx=l(x[0]+x[1])
142     self.failUnless(isinstance(xx,list),"list expected (3)")
143     for i in range(len(xx)):
144     self.failUnless(isinstance(xx[i],float),"wrong scalar type")
145     self.failUnless(abs(xx[i]-(l(x2[0])[i]+l(x2[1])[i]))<self.RES_TOL,"value wrong scalar")
146    
147 gross 525
148     def testProjector_rank0(self):
149     x=ContinuousFunction(self.domain).getX()
150     p=Projector(self.domain,reduce=False,fast=False)
151     td_ref=x[0]
152     td=p(td_ref.interpolate(Function(self.domain)))
153 gross 798 self.failUnless(Lsup(td-td_ref)<Lsup(td_ref)*self.RES_TOL,"value wrong")
154 gross 525
155     def testProjector_rank1(self):
156     x=ContinuousFunction(self.domain).getX()
157     p=Projector(self.domain,reduce=False,fast=False)
158     td_ref=x
159     td=p(td_ref.interpolate(Function(self.domain)))
160 gross 798 self.failUnless(Lsup(td-td_ref)<Lsup(td_ref)*self.RES_TOL,"value wrong")
161 gross 525
162     def testProjector_rank2(self):
163     x=ContinuousFunction(self.domain).getX()
164     p=Projector(self.domain,reduce=False,fast=False)
165     td_ref=[[11.,12.],[21,22.]]*(x[0]+x[1])
166     td=p(td_ref.interpolate(Function(self.domain)))
167 gross 798 self.failUnless(Lsup(td-td_ref)<Lsup(td_ref)*self.RES_TOL,"value wrong")
168 gross 525
169     def testProjector_rank3(self):
170     x=ContinuousFunction(self.domain).getX()
171     p=Projector(self.domain,reduce=False,fast=False)
172     td_ref=[[[111.,112.],[121,122.]],[[211.,212.],[221,222.]]]*(x[0]+x[1])
173     td=p(td_ref.interpolate(Function(self.domain)))
174 gross 798 self.failUnless(Lsup(td-td_ref)<Lsup(td_ref)*self.RES_TOL,"value wrong")
175 gross 525
176     def testProjector_rank4(self):
177     x=ContinuousFunction(self.domain).getX()
178     p=Projector(self.domain,reduce=False,fast=False)
179     td_ref=[[[[1111.,1112.],[1121,1122.]],[[1211.,1212.],[1221,1222.]]],[[[2111.,2112.],[2121,2122.]],[[2211.,2212.],[2221,2222.]]]]*(x[0]+x[1])
180     td=p(td_ref.interpolate(Function(self.domain)))
181 gross 798 self.failUnless(Lsup(td-td_ref)<Lsup(td_ref)*self.RES_TOL,"value wrong")
182 gross 525
183    
184     def testProjector_rank0_reduced(self):
185     x=ContinuousFunction(self.domain).getX()
186     p=Projector(self.domain,reduce=True,fast=False)
187     td_ref=x[0]
188     td=p(td_ref.interpolate(Function(self.domain)))
189 gross 798 self.failUnless(Lsup(td-td_ref)<Lsup(td_ref)*self.RES_TOL,"value wrong")
190 gross 525
191     def testProjector_rank1_reduced(self):
192     x=ContinuousFunction(self.domain).getX()
193     p=Projector(self.domain,reduce=True,fast=False)
194     td_ref=x
195     td=p(td_ref.interpolate(Function(self.domain)))
196 gross 798 self.failUnless(Lsup(td-td_ref)<Lsup(td_ref)*self.RES_TOL,"value wrong")
197 gross 525
198     def testProjector_rank2_reduced(self):
199     x=ContinuousFunction(self.domain).getX()
200     p=Projector(self.domain,reduce=True,fast=False)
201     td_ref=[[11.,12.],[21,22.]]*(x[0]+x[1])
202     td=p(td_ref.interpolate(Function(self.domain)))
203 gross 798 self.failUnless(Lsup(td-td_ref)<Lsup(td_ref)*self.RES_TOL,"value wrong")
204 gross 525
205     def testProjector_rank3_reduced(self):
206     x=ContinuousFunction(self.domain).getX()
207     p=Projector(self.domain,reduce=True,fast=False)
208     td_ref=[[[111.,112.],[121,122.]],[[211.,212.],[221,222.]]]*(x[0]+x[1])
209     td=p(td_ref.interpolate(Function(self.domain)))
210 gross 798 self.failUnless(Lsup(td-td_ref)<Lsup(td_ref)*self.RES_TOL,"value wrong")
211 gross 525
212     def testProjector_rank4_reduced(self):
213     x=ContinuousFunction(self.domain).getX()
214     p=Projector(self.domain,reduce=True,fast=False)
215     td_ref=[[[[1111.,1112.],[1121,1122.]],[[1211.,1212.],[1221,1222.]]],[[[2111.,2112.],[2121,2122.]],[[2211.,2212.],[2221,2222.]]]]*(x[0]+x[1])
216     td=p(td_ref.interpolate(Function(self.domain)))
217 gross 798 self.failUnless(Lsup(td-td_ref)<Lsup(td_ref)*self.RES_TOL,"value wrong")
218 gross 525
219 gross 1072 def testProjector_rank0_with_reduced_input(self):
220 gross 525 x=ContinuousFunction(self.domain).getX()
221 gross 1072 p=Projector(self.domain,reduce=False,fast=False)
222 gross 525 td_ref=x[0]
223     td=p(td_ref.interpolate(Function(self.domain)))
224 gross 1072 self.failUnless(Lsup(td-td_ref)<Lsup(td_ref)*self.RES_TOL,"value wrong")
225 gross 525
226 gross 1072 def testProjector_rank1_with_reduced_input(self):
227 gross 525 x=ContinuousFunction(self.domain).getX()
228 gross 1072 p=Projector(self.domain,reduce=False,fast=False)
229 gross 525 td_ref=x
230     td=p(td_ref.interpolate(Function(self.domain)))
231 gross 1072 self.failUnless(Lsup(td-td_ref)<Lsup(td_ref)*self.RES_TOL,"value wrong")
232 gross 525
233 gross 1072 def testProjector_rank2_with_reduced_input(self):
234 gross 525 x=ContinuousFunction(self.domain).getX()
235 gross 1072 p=Projector(self.domain,reduce=False,fast=False)
236 gross 525 td_ref=[[11.,12.],[21,22.]]*(x[0]+x[1])
237     td=p(td_ref.interpolate(Function(self.domain)))
238 gross 1072 self.failUnless(Lsup(td-td_ref)<Lsup(td_ref)*self.RES_TOL,"value wrong")
239 gross 525
240 gross 1072 def testProjector_rank3_with_reduced_input(self):
241 gross 525 x=ContinuousFunction(self.domain).getX()
242 gross 1072 p=Projector(self.domain,reduce=False,fast=False)
243 gross 525 td_ref=[[[111.,112.],[121,122.]],[[211.,212.],[221,222.]]]*(x[0]+x[1])
244     td=p(td_ref.interpolate(Function(self.domain)))
245 gross 1072 self.failUnless(Lsup(td-td_ref)<Lsup(td_ref)*self.RES_TOL,"value wrong")
246 gross 525
247 gross 1072 def testProjector_rank4_with_reduced_input(self):
248 gross 525 x=ContinuousFunction(self.domain).getX()
249 gross 1072 p=Projector(self.domain,reduce=False,fast=False)
250 gross 525 td_ref=[[[[1111.,1112.],[1121,1122.]],[[1211.,1212.],[1221,1222.]]],[[[2111.,2112.],[2121,2122.]],[[2211.,2212.],[2221,2222.]]]]*(x[0]+x[1])
251     td=p(td_ref.interpolate(Function(self.domain)))
252 gross 1072 self.failUnless(Lsup(td-td_ref)<Lsup(td_ref)*self.RES_TOL,"value wrong")
253 gross 525
254 gross 1072
255     def testProjector_rank0_reduced_with_reduced_input(self):
256     x=ContinuousFunction(self.domain).getX()
257     p=Projector(self.domain,reduce=True,fast=False)
258     td_ref=1.
259     td=p(Data(td_ref,ReducedFunction(self.domain)))
260     self.failUnless(Lsup(td-td_ref)<Lsup(td_ref)*self.RES_TOL,"value wrong")
261    
262     def testProjector_rank1_reduced_with_reduced_input(self):
263     x=ContinuousFunction(self.domain).getX()
264     p=Projector(self.domain,reduce=True,fast=False)
265 jfenwick 2455 td_ref=numpy.array([1.,2.,3.])
266 gross 1072 td=p(Data(td_ref,ReducedFunction(self.domain)))
267     self.failUnless(Lsup(td-td_ref)<Lsup(td_ref)*self.RES_TOL,"value wrong")
268    
269     def testProjector_rank2_reduced_with_reduced_input(self):
270     x=ContinuousFunction(self.domain).getX()
271     p=Projector(self.domain,reduce=True,fast=False)
272 jfenwick 2455 td_ref=numpy.array([[11.,12.],[21,22.]])
273 gross 1072 td=p(Data(td_ref,ReducedFunction(self.domain)))
274     self.failUnless(Lsup(td-td_ref)<Lsup(td_ref)*self.RES_TOL,"value wrong")
275    
276     def testProjector_rank3_reduced_with_reduced_input(self):
277     x=ContinuousFunction(self.domain).getX()
278     p=Projector(self.domain,reduce=True,fast=False)
279 jfenwick 2455 td_ref=numpy.array([[[111.,112.],[121,122.]],[[211.,212.],[221,222.]]])
280 gross 1072 td=p(Data(td_ref,ReducedFunction(self.domain)))
281     self.failUnless(Lsup(td-td_ref)<Lsup(td_ref)*self.RES_TOL,"value wrong")
282    
283     def testProjector_rank4_reduced_with_reduced_input(self):
284     x=ContinuousFunction(self.domain).getX()
285     p=Projector(self.domain,reduce=True,fast=False)
286 jfenwick 2455 td_ref=numpy.array([[[[1111.,1112.],[1121,1122.]],[[1211.,1212.],[1221,1222.]]],[[[2111.,2112.],[2121,2122.]],[[2211.,2212.],[2221,2222.]]]])
287 gross 1072 td=p(Data(td_ref,ReducedFunction(self.domain)))
288     self.failUnless(Lsup(td-td_ref)<Lsup(td_ref)*self.RES_TOL,"value wrong")
289    
290    
291 gross 525 def test_NoPDE_scalar_missing_r(self):
292     p=NoPDE(self.domain)
293     x=self.domain.getX()
294     msk=whereZero(x[0])
295     p.setValue(D=1.,Y=1.,q=msk)
296     u=p.getSolution()
297     u_ex=(1.-msk)
298 gross 798 self.failUnless(Lsup(u_ex-u)<Lsup(u_ex)*self.RES_TOL,"value wrong")
299 gross 525
300     def test_NoPDE_scalar_missing_Y(self):
301     p=NoPDE(self.domain)
302     x=self.domain.getX()
303     msk=whereZero(x[0])
304     p.setValue(D=1.,q=msk,r=2.)
305     u=p.getSolution()
306     u_ex=msk*2.
307 gross 798 self.failUnless(Lsup(u_ex-u)<Lsup(u_ex)*self.RES_TOL,"value wrong")
308 gross 525
309     def test_NoPDE_scalar_constant(self):
310     p=NoPDE(self.domain)
311     x=self.domain.getX()
312     msk=whereZero(x[0])
313     p.setValue(D=1.,Y=1.,q=msk,r=2.)
314     u=p.getSolution()
315     u_ex=(1.-msk)+msk*2.
316 gross 798 self.failUnless(Lsup(u_ex-u)<Lsup(u_ex)*self.RES_TOL,"value wrong")
317 gross 525
318     def test_NoPDE_scalar_variable(self):
319     p=NoPDE(self.domain)
320     x=self.domain.getX()
321     msk=whereZero(x[0])
322 jfenwick 2769 p.setValue(D=10,Y=2*10,q=msk,r=2.)
323 gross 525 u=p.getSolution()
324     u_ex=2.
325 gross 798 self.failUnless(Lsup(u_ex-u)<Lsup(u_ex)*self.RES_TOL,"value wrong")
326 gross 525
327     def test_NoPDE_vector_missing_Y(self):
328     p=NoPDE(self.domain)
329     x=self.domain.getX()
330     msk=whereZero(x[0])*[1.,0.]
331 jfenwick 2455 p.setValue(D=numpy.ones([2]),q=msk,r=2.)
332 gross 525 u=p.getSolution()
333     u_ex=msk*2.
334 gross 798 self.failUnless(Lsup(u_ex-u)<Lsup(u_ex)*self.RES_TOL,"value wrong")
335 gross 525
336     def test_NoPDE_vector_missing_r(self):
337     p=NoPDE(self.domain)
338     x=self.domain.getX()
339     msk=whereZero(x[0])*[1.,0.]
340 jfenwick 2455 p.setValue(D=numpy.ones([2]),Y=numpy.ones([2]),q=msk)
341 gross 525 u=p.getSolution()
342     u_ex=(1.-msk)
343 gross 798 self.failUnless(Lsup(u_ex-u)<Lsup(u_ex)*self.RES_TOL,"value wrong")
344 gross 525
345     def test_NoPDE_vector_constant(self):
346     p=NoPDE(self.domain)
347     x=self.domain.getX()
348     msk=whereZero(x[0])*[1.,0.]
349 jfenwick 2455 p.setValue(D=numpy.ones([2]),Y=numpy.ones([2]),q=msk,r=2.)
350 gross 525 u=p.getSolution()
351     u_ex=(1.-msk)+msk*2.
352 gross 798 self.failUnless(Lsup(u_ex-u)<Lsup(u_ex)*self.RES_TOL,"value wrong")
353 gross 525
354     def test_NoPDE_vector_variable(self):
355     p=NoPDE(self.domain)
356     x=self.domain.getX()
357     msk=whereZero(x[0])*[1.,0.]
358 artak 1695 p.setValue(D=x[:2]+1,Y=2*(x[:2]+1),q=msk,r=2.)
359 gross 525 u=p.getSolution()
360     u_ex=2.
361 gross 798 self.failUnless(Lsup(u_ex-u)<Lsup(u_ex)*self.RES_TOL,"value wrong")
362 gross 2156 #=====
363 ksteube 1312 def testPCG(self):
364 jfenwick 2455 from numpy import array, dot, zeros, size, float64
365 ksteube 1312 from math import sqrt
366     A=array([[ 4.752141253159452e+02, -2.391895572674098e-01,
367     5.834798554135237e-01, -3.704394311709722e+00,
368     5.765369186984777e+00, -1.309786358737351e+01,
369     2.522087134507148e+01, -3.393956279045637e+01,
370     1.046856914770830e+02, -2.447764190849540e+02],
371     [ -2.391895572674098e-01, 1.256797283910693e+02,
372     -9.188270412920813e-01, 1.300169538880688e+00,
373     -5.353714719231424e-01, 2.674709444667012e+00,
374     -1.116097841269580e+01, 2.801193427514478e+01,
375     -3.877806125898224e+01, 3.063505753648256e+01],
376     [ 5.834798554135237e-01, -9.188270412920813e-01,
377     6.240841811806843e+01, -8.176289504109282e-01,
378     1.447935098417076e-01, -9.721424148655324e-01,
379     6.713551574117577e-01, -3.656297654168375e+00,
380     7.015141656913973e+00, -4.195525932156250e+01],
381     [ -3.704394311709722e+00, 1.300169538880688e+00,
382     -8.176289504109282e-01, 3.604980536782198e+01,
383     -6.241238423759328e-01, 1.142345320047869e+00,
384     -3.438816797096519e+00, 5.854857481367470e+00,
385     -4.524311288596452e+00, 1.136590280389803e+01],
386     [ 5.765369186984777e+00, -5.353714719231424e-01,
387     1.447935098417076e-01, -6.241238423759328e-01,
388     2.953997190215862e+01, -9.474729233464712e-01,
389     1.883516378345809e+00, -1.906274765704230e+00,
390     4.401859671778645e+00, -1.064573816075257e+01],
391     [ -1.309786358737351e+01, 2.674709444667012e+00,
392     -9.721424148655324e-01, 1.142345320047869e+00,
393     -9.474729233464712e-01, 2.876998216302979e+01,
394     -4.853065259692995e-01, 7.088596468102618e-01,
395     -8.972224295152829e-01, 5.228606946522749e+00],
396     [ 2.522087134507148e+01, -1.116097841269580e+01,
397     6.713551574117577e-01, -3.438816797096519e+00,
398     1.883516378345809e+00, -4.853065259692995e-01,
399     5.121175860935919e+01, -3.523133115905478e-01,
400     1.782136702229135e+00, -1.560849559916187e+00],
401     [ -3.393956279045637e+01, 2.801193427514478e+01,
402     -3.656297654168375e+00, 5.854857481367470e+00,
403     -1.906274765704230e+00, 7.088596468102618e-01,
404     -3.523133115905478e-01, 8.411681423853814e+01,
405     -5.238590858177903e-01, 1.515872114883926e+00],
406     [ 1.046856914770830e+02, -3.877806125898224e+01,
407     7.015141656913973e+00, -4.524311288596452e+00,
408     4.401859671778645e+00, -8.972224295152829e-01,
409     1.782136702229135e+00, -5.238590858177903e-01,
410     1.797889693808014e+02, -8.362340479938084e-01],
411     [ -2.447764190849540e+02, 3.063505753648256e+01,
412     -4.195525932156250e+01, 1.136590280389803e+01,
413     -1.064573816075257e+01, 5.228606946522749e+00,
414     -1.560849559916187e+00, 1.515872114883926e+00,
415     -8.362340479938084e-01, 3.833719335346630e+02]])
416     x_ref=array([ 0.41794207085296, 0.031441086046563, 0.882801683420401,
417     0.807186823427233, 0.48950999450145, 0.995486532098031,
418     0.351243009576568, 0.704352576819321, 0.850648989740204,
419     0.314596738052894])
420     b=array([ 182.911023960262952, -1.048322041992754, 44.181293875206201,
421     30.344553414038817, 15.247917439094513, 24.060664905403492,
422     27.210293789825833, 47.122067744075842, 199.267136417856847,
423     -8.7934289814322 ])
424 gross 855
425 ksteube 1312 def Ap(x):
426 jfenwick 2455 return dot(A,x)
427 ksteube 1312 def Ms(b):
428 jfenwick 2455 out=zeros((b.size,),float64)
429 ksteube 1312 for i in xrange(size(b)):
430     out[i]=b[i]/A[i,i]
431     return out
432    
433     tol=1.e-4
434 gross 2264 x,r,a_norm=PCG(b*1.,Ap,x_ref*0.,Ms,dot, atol=0, rtol=tol, iter_max=12)
435 ksteube 1312 self.failUnless(Lsup(x-x_ref)<=Lsup(x_ref)*tol*10.,"wrong solution")
436 jfenwick 2455 self.failUnless(Lsup(r-(b-dot(A,x)))<=Lsup(b)*EPSILON*100.,"wrong solution")
437 ksteube 1312
438 gross 2100 def testMINRES(self):
439 jfenwick 2455 from numpy import array, dot, zeros, size, float64
440 gross 1468 from math import sqrt
441     A=array([[ 4.752141253159452e+02, -2.391895572674098e-01,
442     5.834798554135237e-01, -3.704394311709722e+00,
443     5.765369186984777e+00, -1.309786358737351e+01,
444     2.522087134507148e+01, -3.393956279045637e+01,
445     1.046856914770830e+02, -2.447764190849540e+02],
446     [ -2.391895572674098e-01, 1.256797283910693e+02,
447     -9.188270412920813e-01, 1.300169538880688e+00,
448     -5.353714719231424e-01, 2.674709444667012e+00,
449     -1.116097841269580e+01, 2.801193427514478e+01,
450     -3.877806125898224e+01, 3.063505753648256e+01],
451     [ 5.834798554135237e-01, -9.188270412920813e-01,
452     6.240841811806843e+01, -8.176289504109282e-01,
453     1.447935098417076e-01, -9.721424148655324e-01,
454     6.713551574117577e-01, -3.656297654168375e+00,
455     7.015141656913973e+00, -4.195525932156250e+01],
456     [ -3.704394311709722e+00, 1.300169538880688e+00,
457     -8.176289504109282e-01, 3.604980536782198e+01,
458     -6.241238423759328e-01, 1.142345320047869e+00,
459     -3.438816797096519e+00, 5.854857481367470e+00,
460     -4.524311288596452e+00, 1.136590280389803e+01],
461     [ 5.765369186984777e+00, -5.353714719231424e-01,
462     1.447935098417076e-01, -6.241238423759328e-01,
463     2.953997190215862e+01, -9.474729233464712e-01,
464     1.883516378345809e+00, -1.906274765704230e+00,
465     4.401859671778645e+00, -1.064573816075257e+01],
466     [ -1.309786358737351e+01, 2.674709444667012e+00,
467     -9.721424148655324e-01, 1.142345320047869e+00,
468     -9.474729233464712e-01, 2.876998216302979e+01,
469     -4.853065259692995e-01, 7.088596468102618e-01,
470     -8.972224295152829e-01, 5.228606946522749e+00],
471     [ 2.522087134507148e+01, -1.116097841269580e+01,
472     6.713551574117577e-01, -3.438816797096519e+00,
473     1.883516378345809e+00, -4.853065259692995e-01,
474     5.121175860935919e+01, -3.523133115905478e-01,
475     1.782136702229135e+00, -1.560849559916187e+00],
476     [ -3.393956279045637e+01, 2.801193427514478e+01,
477     -3.656297654168375e+00, 5.854857481367470e+00,
478     -1.906274765704230e+00, 7.088596468102618e-01,
479     -3.523133115905478e-01, 8.411681423853814e+01,
480     -5.238590858177903e-01, 1.515872114883926e+00],
481     [ 1.046856914770830e+02, -3.877806125898224e+01,
482     7.015141656913973e+00, -4.524311288596452e+00,
483     4.401859671778645e+00, -8.972224295152829e-01,
484     1.782136702229135e+00, -5.238590858177903e-01,
485     1.797889693808014e+02, -8.362340479938084e-01],
486     [ -2.447764190849540e+02, 3.063505753648256e+01,
487     -4.195525932156250e+01, 1.136590280389803e+01,
488     -1.064573816075257e+01, 5.228606946522749e+00,
489     -1.560849559916187e+00, 1.515872114883926e+00,
490     -8.362340479938084e-01, 3.833719335346630e+02]])
491     x_ref=array([ 0.41794207085296, 0.031441086046563, 0.882801683420401,
492     0.807186823427233, 0.48950999450145, 0.995486532098031,
493     0.351243009576568, 0.704352576819321, 0.850648989740204,
494     0.314596738052894])
495     b=array([ 182.911023960262952, -1.048322041992754, 44.181293875206201,
496     30.344553414038817, 15.247917439094513, 24.060664905403492,
497     27.210293789825833, 47.122067744075842, 199.267136417856847,
498     -8.7934289814322 ])
499    
500     def Ap(x):
501 jfenwick 2455 return dot(A,x)
502 gross 1468 def Ms(b):
503 jfenwick 2455 out=zeros((size(b),),float64)
504 gross 1468 for i in xrange(size(b)):
505     out[i]=b[i]/A[i,i]
506     return out
507    
508     tol=1.e-4
509 gross 2156 x=MINRES(b*1.,Ap,x_ref*0,Ms,dot, atol=0, rtol=tol, iter_max=12)
510 gross 1468 self.failUnless(Lsup(x-x_ref)<=Lsup(x_ref)*tol*10.,"wrong solution")
511    
512 gross 2100 def testTFQMR(self):
513 jfenwick 2455 from numpy import array, dot, zeros, size, float64
514 gross 2100 from math import sqrt
515     A=array([[ 4.752141253159452e+02, -2.391895572674098e-01,
516     5.834798554135237e-01, -3.704394311709722e+00,
517     5.765369186984777e+00, -1.309786358737351e+01,
518     2.522087134507148e+01, -3.393956279045637e+01,
519     1.046856914770830e+02, -2.447764190849540e+02],
520     [ -2.391895572674098e-01, 1.256797283910693e+02,
521     -9.188270412920813e-01, 1.300169538880688e+00,
522     -5.353714719231424e-01, 2.674709444667012e+00,
523     -1.116097841269580e+01, 2.801193427514478e+01,
524     -3.877806125898224e+01, 3.063505753648256e+01],
525     [ 5.834798554135237e-01, -9.188270412920813e-01,
526     6.240841811806843e+01, -8.176289504109282e-01,
527     1.447935098417076e-01, -9.721424148655324e-01,
528     6.713551574117577e-01, -3.656297654168375e+00,
529     7.015141656913973e+00, -4.195525932156250e+01],
530     [ -3.704394311709722e+00, 1.300169538880688e+00,
531     -8.176289504109282e-01, 3.604980536782198e+01,
532     -6.241238423759328e-01, 1.142345320047869e+00,
533     -3.438816797096519e+00, 5.854857481367470e+00,
534     -4.524311288596452e+00, 1.136590280389803e+01],
535     [ 5.765369186984777e+00, -5.353714719231424e-01,
536     1.447935098417076e-01, -6.241238423759328e-01,
537     2.953997190215862e+01, -9.474729233464712e-01,
538     1.883516378345809e+00, -1.906274765704230e+00,
539     4.401859671778645e+00, -1.064573816075257e+01],
540     [ -1.309786358737351e+01, 2.674709444667012e+00,
541     -9.721424148655324e-01, 1.142345320047869e+00,
542     -9.474729233464712e-01, 2.876998216302979e+01,
543     -4.853065259692995e-01, 7.088596468102618e-01,
544     -8.972224295152829e-01, 5.228606946522749e+00],
545     [ 2.522087134507148e+01, -1.116097841269580e+01,
546     6.713551574117577e-01, -3.438816797096519e+00,
547     1.883516378345809e+00, -4.853065259692995e-01,
548     5.121175860935919e+01, -3.523133115905478e-01,
549     1.782136702229135e+00, -1.560849559916187e+00],
550     [ -3.393956279045637e+01, 2.801193427514478e+01,
551     -3.656297654168375e+00, 5.854857481367470e+00,
552     -1.906274765704230e+00, 7.088596468102618e-01,
553     -3.523133115905478e-01, 8.411681423853814e+01,
554     -5.238590858177903e-01, 1.515872114883926e+00],
555     [ 1.046856914770830e+02, -3.877806125898224e+01,
556     7.015141656913973e+00, -4.524311288596452e+00,
557     4.401859671778645e+00, -8.972224295152829e-01,
558     1.782136702229135e+00, -5.238590858177903e-01,
559     1.797889693808014e+02, -8.362340479938084e-01],
560     [ -2.447764190849540e+02, 3.063505753648256e+01,
561     -4.195525932156250e+01, 1.136590280389803e+01,
562     -1.064573816075257e+01, 5.228606946522749e+00,
563     -1.560849559916187e+00, 1.515872114883926e+00,
564     -8.362340479938084e-01, 3.833719335346630e+02]])
565     x_ref=array([ 0.41794207085296, 0.031441086046563, 0.882801683420401,
566     0.807186823427233, 0.48950999450145, 0.995486532098031,
567     0.351243009576568, 0.704352576819321, 0.850648989740204,
568     0.314596738052894])
569     b=array([ 182.911023960262952, -1.048322041992754, 44.181293875206201,
570     30.344553414038817, 15.247917439094513, 24.060664905403492,
571     27.210293789825833, 47.122067744075842, 199.267136417856847,
572     -8.7934289814322 ])
573    
574     def Ap(x):
575 jfenwick 2455 out=dot(A,x)
576 gross 2156 for i in xrange(size(x)):
577     out[i]/=A[i,i]
578 gross 2100 return out
579    
580     tol=1.e-5
581 gross 2156 for i in xrange(size(b)): b[i]/=A[i,i]
582     x=TFQMR(b,Ap,x_ref*0,dot, atol=0, rtol=tol, iter_max=12)
583 gross 2100 self.failUnless(Lsup(x-x_ref)<=Lsup(x_ref)*tol*10.,"wrong solution")
584    
585     def testGMRES(self):
586 jfenwick 2455 from numpy import array, dot, zeros, size, float64
587 gross 2100 from math import sqrt
588     A=array([[ 4.752141253159452e+02, -2.391895572674098e-01,
589     5.834798554135237e-01, -3.704394311709722e+00,
590     5.765369186984777e+00, -1.309786358737351e+01,
591     2.522087134507148e+01, -3.393956279045637e+01,
592     1.046856914770830e+02, -2.447764190849540e+02],
593     [ -2.391895572674098e-01, 1.256797283910693e+02,
594     -9.188270412920813e-01, 1.300169538880688e+00,
595     -5.353714719231424e-01, 2.674709444667012e+00,
596     -1.116097841269580e+01, 2.801193427514478e+01,
597     -3.877806125898224e+01, 3.063505753648256e+01],
598     [ 5.834798554135237e-01, -9.188270412920813e-01,
599     6.240841811806843e+01, -8.176289504109282e-01,
600     1.447935098417076e-01, -9.721424148655324e-01,
601     6.713551574117577e-01, -3.656297654168375e+00,
602     7.015141656913973e+00, -4.195525932156250e+01],
603     [ -3.704394311709722e+00, 1.300169538880688e+00,
604     -8.176289504109282e-01, 3.604980536782198e+01,
605     -6.241238423759328e-01, 1.142345320047869e+00,
606     -3.438816797096519e+00, 5.854857481367470e+00,
607     -4.524311288596452e+00, 1.136590280389803e+01],
608     [ 5.765369186984777e+00, -5.353714719231424e-01,
609     1.447935098417076e-01, -6.241238423759328e-01,
610     2.953997190215862e+01, -9.474729233464712e-01,
611     1.883516378345809e+00, -1.906274765704230e+00,
612     4.401859671778645e+00, -1.064573816075257e+01],
613     [ -1.309786358737351e+01, 2.674709444667012e+00,
614     -9.721424148655324e-01, 1.142345320047869e+00,
615     -9.474729233464712e-01, 2.876998216302979e+01,
616     -4.853065259692995e-01, 7.088596468102618e-01,
617     -8.972224295152829e-01, 5.228606946522749e+00],
618     [ 2.522087134507148e+01, -1.116097841269580e+01,
619     6.713551574117577e-01, -3.438816797096519e+00,
620     1.883516378345809e+00, -4.853065259692995e-01,
621     5.121175860935919e+01, -3.523133115905478e-01,
622     1.782136702229135e+00, -1.560849559916187e+00],
623     [ -3.393956279045637e+01, 2.801193427514478e+01,
624     -3.656297654168375e+00, 5.854857481367470e+00,
625     -1.906274765704230e+00, 7.088596468102618e-01,
626     -3.523133115905478e-01, 8.411681423853814e+01,
627     -5.238590858177903e-01, 1.515872114883926e+00],
628     [ 1.046856914770830e+02, -3.877806125898224e+01,
629     7.015141656913973e+00, -4.524311288596452e+00,
630     4.401859671778645e+00, -8.972224295152829e-01,
631     1.782136702229135e+00, -5.238590858177903e-01,
632     1.797889693808014e+02, -8.362340479938084e-01],
633     [ -2.447764190849540e+02, 3.063505753648256e+01,
634     -4.195525932156250e+01, 1.136590280389803e+01,
635     -1.064573816075257e+01, 5.228606946522749e+00,
636     -1.560849559916187e+00, 1.515872114883926e+00,
637     -8.362340479938084e-01, 3.833719335346630e+02]])
638     x_ref=array([ 0.41794207085296, 0.031441086046563, 0.882801683420401,
639     0.807186823427233, 0.48950999450145, 0.995486532098031,
640     0.351243009576568, 0.704352576819321, 0.850648989740204,
641     0.314596738052894])
642     b=array([ 182.911023960262952, -1.048322041992754, 44.181293875206201,
643     30.344553414038817, 15.247917439094513, 24.060664905403492,
644     27.210293789825833, 47.122067744075842, 199.267136417856847,
645     -8.7934289814322 ])
646    
647     def Ap(x):
648 jfenwick 2455 b=dot(A,x)
649 gross 2100 for i in xrange(size(b)):
650     b[i]/=A[i,i]
651     return b
652    
653     tol=1.e-4
654     for i in xrange(size(b)): b[i]/=A[i,i]
655 gross 2156 x=GMRES(b,Ap,x_ref*0,dot,atol=0, rtol=tol, iter_max=12)
656 gross 2100 self.failUnless(Lsup(x-x_ref)<=Lsup(x_ref)*tol*10.,"wrong solution")
657    
658 gross 2264 def testGMRES_P_R(self):
659 jfenwick 2455 from numpy import array, dot, zeros, size, float64
660 gross 2264 from math import sqrt
661     A=array([[ 4.752141253159452e+02, -2.391895572674098e-01,
662     5.834798554135237e-01, -3.704394311709722e+00,
663     5.765369186984777e+00, -1.309786358737351e+01,
664     2.522087134507148e+01, -3.393956279045637e+01,
665     1.046856914770830e+02, -2.447764190849540e+02],
666     [ -2.391895572674098e-01, 1.256797283910693e+02,
667     -9.188270412920813e-01, 1.300169538880688e+00,
668     -5.353714719231424e-01, 2.674709444667012e+00,
669     -1.116097841269580e+01, 2.801193427514478e+01,
670     -3.877806125898224e+01, 3.063505753648256e+01],
671     [ 5.834798554135237e-01, -9.188270412920813e-01,
672     6.240841811806843e+01, -8.176289504109282e-01,
673     1.447935098417076e-01, -9.721424148655324e-01,
674     6.713551574117577e-01, -3.656297654168375e+00,
675     7.015141656913973e+00, -4.195525932156250e+01],
676     [ -3.704394311709722e+00, 1.300169538880688e+00,
677     -8.176289504109282e-01, 3.604980536782198e+01,
678     -6.241238423759328e-01, 1.142345320047869e+00,
679     -3.438816797096519e+00, 5.854857481367470e+00,
680     -4.524311288596452e+00, 1.136590280389803e+01],
681     [ 5.765369186984777e+00, -5.353714719231424e-01,
682     1.447935098417076e-01, -6.241238423759328e-01,
683     2.953997190215862e+01, -9.474729233464712e-01,
684     1.883516378345809e+00, -1.906274765704230e+00,
685     4.401859671778645e+00, -1.064573816075257e+01],
686     [ -1.309786358737351e+01, 2.674709444667012e+00,
687     -9.721424148655324e-01, 1.142345320047869e+00,
688     -9.474729233464712e-01, 2.876998216302979e+01,
689     -4.853065259692995e-01, 7.088596468102618e-01,
690     -8.972224295152829e-01, 5.228606946522749e+00],
691     [ 2.522087134507148e+01, -1.116097841269580e+01,
692     6.713551574117577e-01, -3.438816797096519e+00,
693     1.883516378345809e+00, -4.853065259692995e-01,
694     5.121175860935919e+01, -3.523133115905478e-01,
695     1.782136702229135e+00, -1.560849559916187e+00],
696     [ -3.393956279045637e+01, 2.801193427514478e+01,
697     -3.656297654168375e+00, 5.854857481367470e+00,
698     -1.906274765704230e+00, 7.088596468102618e-01,
699     -3.523133115905478e-01, 8.411681423853814e+01,
700     -5.238590858177903e-01, 1.515872114883926e+00],
701     [ 1.046856914770830e+02, -3.877806125898224e+01,
702     7.015141656913973e+00, -4.524311288596452e+00,
703     4.401859671778645e+00, -8.972224295152829e-01,
704     1.782136702229135e+00, -5.238590858177903e-01,
705     1.797889693808014e+02, -8.362340479938084e-01],
706     [ -2.447764190849540e+02, 3.063505753648256e+01,
707     -4.195525932156250e+01, 1.136590280389803e+01,
708     -1.064573816075257e+01, 5.228606946522749e+00,
709     -1.560849559916187e+00, 1.515872114883926e+00,
710     -8.362340479938084e-01, 3.833719335346630e+02]])
711     x_ref=array([ 0.41794207085296, 0.031441086046563, 0.882801683420401,
712     0.807186823427233, 0.48950999450145, 0.995486532098031,
713     0.351243009576568, 0.704352576819321, 0.850648989740204,
714     0.314596738052894])
715     b=array([ 182.911023960262952, -1.048322041992754, 44.181293875206201,
716     30.344553414038817, 15.247917439094513, 24.060664905403492,
717     27.210293789825833, 47.122067744075842, 199.267136417856847,
718     -8.7934289814322 ])
719    
720     def Ap(x):
721 jfenwick 2455 return dot(A,x)
722 gross 2264 def P_Rp(x):
723 jfenwick 2455 out=zeros(size(x), float64)
724 gross 2265 for i in xrange(size(x)):
725 gross 2264 out[i]=x[i]/A[i,i]
726     return out
727    
728     tol=1.e-4
729     x=GMRES(b,Ap,x_ref*0,dot,atol=0, rtol=tol, iter_max=12,P_R=P_Rp)
730     self.failUnless(Lsup(x-x_ref)<=Lsup(x_ref)*tol*10.,"wrong solution")
731    
732 gross 1878 def testNewtonGMRES(self):
733 jfenwick 2455 from numpy import array, dot, zeros, size, float64
734 gross 1878 from math import sqrt
735     class LL(Defect):
736     def __init__(self,*kwargs):
737     super(LL, self).__init__(*kwargs)
738     self.A=array([[ 4.752141253159452e+02, -2.391895572674098e-01,
739     5.834798554135237e-01, -3.704394311709722e+00,
740     5.765369186984777e+00, -1.309786358737351e+01,
741     2.522087134507148e+01, -3.393956279045637e+01,
742     1.046856914770830e+02, -2.447764190849540e+02],
743     [ -2.391895572674098e-01, 1.256797283910693e+02,
744     -9.188270412920813e-01, 1.300169538880688e+00,
745     -5.353714719231424e-01, 2.674709444667012e+00,
746     -1.116097841269580e+01, 2.801193427514478e+01,
747     -3.877806125898224e+01, 3.063505753648256e+01],
748     [ 5.834798554135237e-01, -9.188270412920813e-01,
749     6.240841811806843e+01, -8.176289504109282e-01,
750     1.447935098417076e-01, -9.721424148655324e-01,
751     6.713551574117577e-01, -3.656297654168375e+00,
752     7.015141656913973e+00, -4.195525932156250e+01],
753     [ -3.704394311709722e+00, 1.300169538880688e+00,
754     -8.176289504109282e-01, 3.604980536782198e+01,
755     -6.241238423759328e-01, 1.142345320047869e+00,
756     -3.438816797096519e+00, 5.854857481367470e+00,
757     -4.524311288596452e+00, 1.136590280389803e+01],
758     [ 5.765369186984777e+00, -5.353714719231424e-01,
759     1.447935098417076e-01, -6.241238423759328e-01,
760     2.953997190215862e+01, -9.474729233464712e-01,
761     1.883516378345809e+00, -1.906274765704230e+00,
762     4.401859671778645e+00, -1.064573816075257e+01],
763     [ -1.309786358737351e+01, 2.674709444667012e+00,
764     -9.721424148655324e-01, 1.142345320047869e+00,
765     -9.474729233464712e-01, 2.876998216302979e+01,
766     -4.853065259692995e-01, 7.088596468102618e-01,
767     -8.972224295152829e-01, 5.228606946522749e+00],
768     [ 2.522087134507148e+01, -1.116097841269580e+01,
769     6.713551574117577e-01, -3.438816797096519e+00,
770     1.883516378345809e+00, -4.853065259692995e-01,
771     5.121175860935919e+01, -3.523133115905478e-01,
772     1.782136702229135e+00, -1.560849559916187e+00],
773     [ -3.393956279045637e+01, 2.801193427514478e+01,
774     -3.656297654168375e+00, 5.854857481367470e+00,
775     -1.906274765704230e+00, 7.088596468102618e-01,
776     -3.523133115905478e-01, 8.411681423853814e+01,
777     -5.238590858177903e-01, 1.515872114883926e+00],
778     [ 1.046856914770830e+02, -3.877806125898224e+01,
779     7.015141656913973e+00, -4.524311288596452e+00,
780     4.401859671778645e+00, -8.972224295152829e-01,
781     1.782136702229135e+00, -5.238590858177903e-01,
782     1.797889693808014e+02, -8.362340479938084e-01],
783     [ -2.447764190849540e+02, 3.063505753648256e+01,
784     -4.195525932156250e+01, 1.136590280389803e+01,
785     -1.064573816075257e+01, 5.228606946522749e+00,
786     -1.560849559916187e+00, 1.515872114883926e+00,
787     -8.362340479938084e-01, 3.833719335346630e+02]])
788     self.x_ref=array([ 0.41794207085296, 0.031441086046563, 0.882801683420401,
789     0.807186823427233, 0.48950999450145, 0.995486532098031,
790     0.351243009576568, 0.704352576819321, 0.850648989740204,
791     0.314596738052894])
792     self.b=array([ 182.911023960262952, -1.048322041992754, 44.181293875206201,
793     30.344553414038817, 15.247917439094513, 24.060664905403492,
794     27.210293789825833, 47.122067744075842, 199.267136417856847,
795     -8.7934289814322 ])
796     def eval(self,x):
797 jfenwick 2455 out=dot(self.A,x)-self.b
798 gross 1878 for i in xrange(size(self.b)):
799     out[i]/=self.A[i,i]
800     return out
801     def bilinearform(self,x0,x1):
802     return dot(x0,x1)
803    
804     tol=1.e-8
805     ll=LL()
806     x=NewtonGMRES(LL(),ll.x_ref*0., iter_max=100, sub_iter_max=20, atol=0,rtol=tol, verbose=self.VERBOSE)
807     self.failUnless(Lsup(x-ll.x_ref)<=Lsup(ll.x_ref)*tol*10.,"wrong solution")
808    
809 gross 2100 def testNewtonGMRES(self):
810 jfenwick 2455 from numpy import array, dot, zeros, size, float64
811 gross 2100 from math import sqrt
812     class LL(Defect):
813     def __init__(self,*kwargs):
814     super(LL, self).__init__(*kwargs)
815     self.A=array([[ 4.752141253159452e+02, -2.391895572674098e-01,
816     5.834798554135237e-01, -3.704394311709722e+00,
817     5.765369186984777e+00, -1.309786358737351e+01,
818     2.522087134507148e+01, -3.393956279045637e+01,
819     1.046856914770830e+02, -2.447764190849540e+02],
820     [ -2.391895572674098e-01, 1.256797283910693e+02,
821     -9.188270412920813e-01, 1.300169538880688e+00,
822     -5.353714719231424e-01, 2.674709444667012e+00,
823     -1.116097841269580e+01, 2.801193427514478e+01,
824     -3.877806125898224e+01, 3.063505753648256e+01],
825     [ 5.834798554135237e-01, -9.188270412920813e-01,
826     6.240841811806843e+01, -8.176289504109282e-01,
827     1.447935098417076e-01, -9.721424148655324e-01,
828     6.713551574117577e-01, -3.656297654168375e+00,
829     7.015141656913973e+00, -4.195525932156250e+01],
830     [ -3.704394311709722e+00, 1.300169538880688e+00,
831     -8.176289504109282e-01, 3.604980536782198e+01,
832     -6.241238423759328e-01, 1.142345320047869e+00,
833     -3.438816797096519e+00, 5.854857481367470e+00,
834     -4.524311288596452e+00, 1.136590280389803e+01],
835     [ 5.765369186984777e+00, -5.353714719231424e-01,
836     1.447935098417076e-01, -6.241238423759328e-01,
837     2.953997190215862e+01, -9.474729233464712e-01,
838     1.883516378345809e+00, -1.906274765704230e+00,
839     4.401859671778645e+00, -1.064573816075257e+01],
840     [ -1.309786358737351e+01, 2.674709444667012e+00,
841     -9.721424148655324e-01, 1.142345320047869e+00,
842     -9.474729233464712e-01, 2.876998216302979e+01,
843     -4.853065259692995e-01, 7.088596468102618e-01,
844     -8.972224295152829e-01, 5.228606946522749e+00],
845     [ 2.522087134507148e+01, -1.116097841269580e+01,
846     6.713551574117577e-01, -3.438816797096519e+00,
847     1.883516378345809e+00, -4.853065259692995e-01,
848     5.121175860935919e+01, -3.523133115905478e-01,
849     1.782136702229135e+00, -1.560849559916187e+00],
850     [ -3.393956279045637e+01, 2.801193427514478e+01,
851     -3.656297654168375e+00, 5.854857481367470e+00,
852     -1.906274765704230e+00, 7.088596468102618e-01,
853     -3.523133115905478e-01, 8.411681423853814e+01,
854     -5.238590858177903e-01, 1.515872114883926e+00],
855     [ 1.046856914770830e+02, -3.877806125898224e+01,
856     7.015141656913973e+00, -4.524311288596452e+00,
857     4.401859671778645e+00, -8.972224295152829e-01,
858     1.782136702229135e+00, -5.238590858177903e-01,
859     1.797889693808014e+02, -8.362340479938084e-01],
860     [ -2.447764190849540e+02, 3.063505753648256e+01,
861     -4.195525932156250e+01, 1.136590280389803e+01,
862     -1.064573816075257e+01, 5.228606946522749e+00,
863     -1.560849559916187e+00, 1.515872114883926e+00,
864     -8.362340479938084e-01, 3.833719335346630e+02]])
865     self.x_ref=array([ 0.41794207085296, 0.031441086046563, 0.882801683420401,
866     0.807186823427233, 0.48950999450145, 0.995486532098031,
867     0.351243009576568, 0.704352576819321, 0.850648989740204,
868     0.314596738052894])
869     self.b=array([ 182.911023960262952, -1.048322041992754, 44.181293875206201,
870     30.344553414038817, 15.247917439094513, 24.060664905403492,
871     27.210293789825833, 47.122067744075842, 199.267136417856847,
872     -8.7934289814322 ])
873     def eval(self,x):
874 jfenwick 2455 out=dot(self.A,x)-self.b
875 gross 2100 for i in xrange(size(self.b)):
876     out[i]/=self.A[i,i]
877     return out
878     def bilinearform(self,x0,x1):
879     return dot(x0,x1)
880    
881     tol=1.e-8
882     ll=LL()
883     x=NewtonGMRES(LL(),ll.x_ref*0., iter_max=100, sub_iter_max=20, atol=0,rtol=tol, verbose=self.VERBOSE)
884     self.failUnless(Lsup(x-ll.x_ref)<=Lsup(ll.x_ref)*tol*10.,"wrong solution")
885    
886     def testHomogeneousSaddlePointProblem_PCG(self):
887 jfenwick 2455 from numpy import array, dot, zeros, size, float64
888 gross 2100 from math import sqrt
889     class LL(HomogeneousSaddlePointProblem):
890     def initialize(self):
891     self.A=array([[ 4.752141253159452e+02, -2.391895572674098e-01,
892     5.834798554135237e-01, -3.704394311709722e+00,
893     5.765369186984777e+00, -1.309786358737351e+01,
894     2.522087134507148e+01, -3.393956279045637e+01,
895     1.046856914770830e+02, -2.447764190849540e+02],
896     [ -2.391895572674098e-01, 1.256797283910693e+02,
897     -9.188270412920813e-01, 1.300169538880688e+00,
898     -5.353714719231424e-01, 2.674709444667012e+00,
899     -1.116097841269580e+01, 2.801193427514478e+01,
900     -3.877806125898224e+01, 3.063505753648256e+01],
901     [ 5.834798554135237e-01, -9.188270412920813e-01,
902     6.240841811806843e+01, -8.176289504109282e-01,
903     1.447935098417076e-01, -9.721424148655324e-01,
904     6.713551574117577e-01, -3.656297654168375e+00,
905     7.015141656913973e+00, -4.195525932156250e+01],
906     [ -3.704394311709722e+00, 1.300169538880688e+00,
907     -8.176289504109282e-01, 3.604980536782198e+01,
908     -6.241238423759328e-01, 1.142345320047869e+00,
909     -3.438816797096519e+00, 5.854857481367470e+00,
910     -4.524311288596452e+00, 1.136590280389803e+01],
911     [ 5.765369186984777e+00, -5.353714719231424e-01,
912     1.447935098417076e-01, -6.241238423759328e-01,
913     2.953997190215862e+01, -9.474729233464712e-01,
914     1.883516378345809e+00, -1.906274765704230e+00,
915     4.401859671778645e+00, -1.064573816075257e+01],
916     [ -1.309786358737351e+01, 2.674709444667012e+00,
917     -9.721424148655324e-01, 1.142345320047869e+00,
918     -9.474729233464712e-01, 2.876998216302979e+01,
919     -4.853065259692995e-01, 7.088596468102618e-01,
920     -8.972224295152829e-01, 5.228606946522749e+00],
921     [ 2.522087134507148e+01, -1.116097841269580e+01,
922     6.713551574117577e-01, -3.438816797096519e+00,
923     1.883516378345809e+00, -4.853065259692995e-01,
924     5.121175860935919e+01, -3.523133115905478e-01,
925     1.782136702229135e+00, -1.560849559916187e+00],
926     [ -3.393956279045637e+01, 2.801193427514478e+01,
927     -3.656297654168375e+00, 5.854857481367470e+00,
928     -1.906274765704230e+00, 7.088596468102618e-01,
929     -3.523133115905478e-01, 8.411681423853814e+01,
930     -5.238590858177903e-01, 1.515872114883926e+00],
931     [ 1.046856914770830e+02, -3.877806125898224e+01,
932     7.015141656913973e+00, -4.524311288596452e+00,
933     4.401859671778645e+00, -8.972224295152829e-01,
934     1.782136702229135e+00, -5.238590858177903e-01,
935     1.797889693808014e+02, -8.362340479938084e-01],
936     [ -2.447764190849540e+02, 3.063505753648256e+01,
937     -4.195525932156250e+01, 1.136590280389803e+01,
938     -1.064573816075257e+01, 5.228606946522749e+00,
939     -1.560849559916187e+00, 1.515872114883926e+00,
940     -8.362340479938084e-01, 3.833719335346630e+02]])
941     self.x_ref=array([ 0.100225501676291, -0.308862704993209, 0.064097238997721,
942     0.253012436539738, -0.346223308561905, 0.2425508275422,
943     -0.194695862196008, 0.09451439391473, 0.302961126826511,
944     -0.236043777597633] )
945    
946     self.Bt=array([[ 0.01627853113636 ,0.06688235764255 , 0.004870689484614],
947     [ 0.062879587145773 ,0.038798770300146, 0.022155850155616],
948     [ 0.09312121957248 ,0.110244632756116, 0.14053347386784 ],
949     [ 0.059000597728388 ,0.090986953740106, 0.035316011834982],
950     [ 0.091209362659698 ,0.13205572801294 , 0.069462874306956],
951     [ 0.077790176986096 ,0.133626423045765, 0.011149969846981],
952     [ 0.01407283482513 ,0.094910926488907, 0.133498532648644],
953     [ 0.025728916673085 ,0.102542818811672, 0.13657268163218 ],
954     [ 0.071254288170748 ,0.071738715618163, 0.078005951991733],
955     [ 0.049463014576779 ,0.103559223780991, 0.003356415647637]])
956     self.p_ref = array([ 2.580984952252628 ,4.054090902056985, 0.935138168128546])
957    
958     self.b=array([ 123.322775367582238, -51.556206655564573 , 16.220697868056913,
959     6.512480714694167 , -5.727371407390975 , 4.802494840775022,
960     -4.171606044721161 , -1.862366353566293 ,74.850226163257105,
961     -118.602464657076439])
962    
963     self.Sinv=array([[ 9313.705360982807179,-5755.536981691270739, 806.289245589733696],
964     [-5755.536981691271649, 4606.321002756208145,-1630.50619635660928 ],
965     [ 806.289245589733468,-1630.506196356609053, 2145.65035816388945 ]])
966 gross 2445 def inner_pBv(self,p,Bv):
967     return dot(p,Bv)
968 gross 2719 def Bv(self,v, tol):
969 jfenwick 2455 return dot(transpose(self.Bt),v)
970 gross 2100 def inner_p(self,p0,p1):
971     return dot(p0,p1)
972 gross 2251 def norm_v(self,v):
973     return sqrt(dot(v,v))
974 gross 2719 def getDV(self,p,v, tol):
975     dv=solve_linear_equations(self.A, self.b-dot(self.Bt,p)-dot(self.A,v))
976     return dv*(1+tol)
977 gross 2445 def norm_Bv(self,Bv):
978     return sqrt(dot(Bv,Bv))
979 gross 2719 def solve_AinvBt(self,p, tol):
980     out=solve_linear_equations(self.A, dot(self.Bt,p))
981     return out*(1.+tol)
982     def solve_prec(self,Bv, tol):
983 gross 2445 out=Bv*1.
984 gross 2251 for i in xrange(size(out)): out[i]*=self.Sinv[i,i]
985 gross 2719 return out*(1-tol)
986 gross 2100
987     tol=1.e-8
988     ll=LL()
989     ll.initialize()
990     ll.setTolerance(tol)
991     # ll.setSubToleranceReductionFactor(0.1)
992 gross 2719 x,p=ll.solve(ll.x_ref*1.20,ll.p_ref*(-2),max_iter=20, verbose=False, usePCG=True, iter_restart=20,max_correction_steps=10)
993 gross 2100 self.failUnless(Lsup(x-ll.x_ref)<=Lsup(ll.x_ref)*tol*10.,"wrong x solution")
994     self.failUnless(Lsup(p-ll.p_ref)<=Lsup(ll.p_ref)*tol*10.,"wrong p solution")
995    
996     def testHomogeneousSaddlePointProblem_GMRES(self):
997 jfenwick 2455 from numpy import array, prod, dot, zeros, size, float64
998 gross 2100 from math import sqrt
999     class LL(HomogeneousSaddlePointProblem):
1000     def initialize(self):
1001     self.A=array([[ 4.752141253159452e+02, -2.391895572674098e-01,
1002     5.834798554135237e-01, -3.704394311709722e+00,
1003     5.765369186984777e+00, -1.309786358737351e+01,
1004     2.522087134507148e+01, -3.393956279045637e+01,
1005     1.046856914770830e+02, -2.447764190849540e+02],
1006     [ -2.391895572674098e-01, 1.256797283910693e+02,
1007     -9.188270412920813e-01, 1.300169538880688e+00,
1008     -5.353714719231424e-01, 2.674709444667012e+00,
1009     -1.116097841269580e+01, 2.801193427514478e+01,
1010     -3.877806125898224e+01, 3.063505753648256e+01],
1011     [ 5.834798554135237e-01, -9.188270412920813e-01,
1012     6.240841811806843e+01, -8.176289504109282e-01,
1013     1.447935098417076e-01, -9.721424148655324e-01,
1014     6.713551574117577e-01, -3.656297654168375e+00,
1015     7.015141656913973e+00, -4.195525932156250e+01],
1016     [ -3.704394311709722e+00, 1.300169538880688e+00,
1017     -8.176289504109282e-01, 3.604980536782198e+01,
1018     -6.241238423759328e-01, 1.142345320047869e+00,
1019     -3.438816797096519e+00, 5.854857481367470e+00,
1020     -4.524311288596452e+00, 1.136590280389803e+01],
1021     [ 5.765369186984777e+00, -5.353714719231424e-01,
1022     1.447935098417076e-01, -6.241238423759328e-01,
1023     2.953997190215862e+01, -9.474729233464712e-01,
1024     1.883516378345809e+00, -1.906274765704230e+00,
1025     4.401859671778645e+00, -1.064573816075257e+01],
1026     [ -1.309786358737351e+01, 2.674709444667012e+00,
1027     -9.721424148655324e-01, 1.142345320047869e+00,
1028     -9.474729233464712e-01, 2.876998216302979e+01,
1029     -4.853065259692995e-01, 7.088596468102618e-01,
1030     -8.972224295152829e-01, 5.228606946522749e+00],
1031     [ 2.522087134507148e+01, -1.116097841269580e+01,
1032     6.713551574117577e-01, -3.438816797096519e+00,
1033     1.883516378345809e+00, -4.853065259692995e-01,
1034     5.121175860935919e+01, -3.523133115905478e-01,
1035     1.782136702229135e+00, -1.560849559916187e+00],
1036     [ -3.393956279045637e+01, 2.801193427514478e+01,
1037     -3.656297654168375e+00, 5.854857481367470e+00,
1038     -1.906274765704230e+00, 7.088596468102618e-01,
1039     -3.523133115905478e-01, 8.411681423853814e+01,
1040     -5.238590858177903e-01, 1.515872114883926e+00],
1041     [ 1.046856914770830e+02, -3.877806125898224e+01,
1042     7.015141656913973e+00, -4.524311288596452e+00,
1043     4.401859671778645e+00, -8.972224295152829e-01,
1044     1.782136702229135e+00, -5.238590858177903e-01,
1045     1.797889693808014e+02, -8.362340479938084e-01],
1046     [ -2.447764190849540e+02, 3.063505753648256e+01,
1047     -4.195525932156250e+01, 1.136590280389803e+01,
1048     -1.064573816075257e+01, 5.228606946522749e+00,
1049     -1.560849559916187e+00, 1.515872114883926e+00,
1050     -8.362340479938084e-01, 3.833719335346630e+02]])
1051     self.x_ref=array([ 0.100225501676291, -0.308862704993209, 0.064097238997721,
1052     0.253012436539738, -0.346223308561905, 0.2425508275422,
1053     -0.194695862196008, 0.09451439391473, 0.302961126826511,
1054     -0.236043777597633] )
1055    
1056     self.Bt=array([[ 0.01627853113636 ,0.06688235764255 , 0.004870689484614],
1057     [ 0.062879587145773 ,0.038798770300146, 0.022155850155616],
1058     [ 0.09312121957248 ,0.110244632756116, 0.14053347386784 ],
1059     [ 0.059000597728388 ,0.090986953740106, 0.035316011834982],
1060     [ 0.091209362659698 ,0.13205572801294 , 0.069462874306956],
1061     [ 0.077790176986096 ,0.133626423045765, 0.011149969846981],
1062     [ 0.01407283482513 ,0.094910926488907, 0.133498532648644],
1063     [ 0.025728916673085 ,0.102542818811672, 0.13657268163218 ],
1064     [ 0.071254288170748 ,0.071738715618163, 0.078005951991733],
1065     [ 0.049463014576779 ,0.103559223780991, 0.003356415647637]])
1066     self.p_ref = array([ 2.580984952252628 ,4.054090902056985, 0.935138168128546])
1067    
1068     self.b=array([ 123.322775367582238, -51.556206655564573 , 16.220697868056913,
1069     6.512480714694167 , -5.727371407390975 , 4.802494840775022,
1070     -4.171606044721161 , -1.862366353566293 ,74.850226163257105,
1071     -118.602464657076439])
1072    
1073     self.Sinv=array([[ 9313.705360982807179,-5755.536981691270739, 806.289245589733696],
1074     [-5755.536981691271649, 4606.321002756208145,-1630.50619635660928 ],
1075     [ 806.289245589733468,-1630.506196356609053, 2145.65035816388945 ]])
1076 gross 2445 def inner_pBv(self,p,Bv):
1077     return dot(p,Bv)
1078 gross 2719 def Bv(self,v, tol):
1079 jfenwick 2455 return dot(transpose(self.Bt),v)
1080 gross 2100 def inner_p(self,p0,p1):
1081     return dot(p0,p1)
1082 gross 2251 def norm_v(self,v):
1083     return sqrt(dot(v,v))
1084 gross 2719 def getDV(self,p,v, tol):
1085     dv=solve_linear_equations(self.A, self.b-dot(self.Bt,p)-dot(self.A,v))
1086     return dv*(1+tol)
1087 gross 2445 def norm_Bv(self,Bv):
1088     return sqrt(dot(Bv,Bv))
1089 gross 2719 def solve_AinvBt(self,p, tol):
1090     out=solve_linear_equations(self.A, dot(self.Bt,p))
1091     return out*(1.+tol)
1092     def solve_prec(self,Bv, tol):
1093 gross 2445 out=Bv*1.
1094 gross 2251 for i in xrange(size(out)): out[i]*=self.Sinv[i,i]
1095 gross 2719 return out*(1-tol)
1096    
1097 gross 2100 tol=1.e-8
1098     ll=LL()
1099     ll.initialize()
1100     ll.setTolerance(tol)
1101     # ll.setSubToleranceReductionFactor(0.1)
1102 gross 2719 x,p=ll.solve(ll.x_ref*1.20,ll.p_ref*(-2),max_iter=20, verbose=False, usePCG=False, iter_restart=20,max_correction_steps=10)
1103 gross 2100 self.failUnless(Lsup(x-ll.x_ref)<=Lsup(ll.x_ref)*tol*10.,"wrong x solution")
1104     self.failUnless(Lsup(p-ll.p_ref)<=Lsup(ll.p_ref)*tol*10.,"wrong p solution")
1105    
1106 gross 1331 def testArithmeticTuple(self):
1107     a=ArithmeticTuple(1.,2.)
1108     self.failUnless(len(a)==2,"wrong length")
1109     self.failUnless(a[0]==1.,"wrong first item")
1110     self.failUnless(a[1]==2.,"wrong second item")
1111     c=a*6.
1112     self.failUnless(isinstance(c,ArithmeticTuple),"c is not an instance of ArithmeticTuple")
1113     self.failUnless(len(c)==2,"c has wrong length")
1114     self.failUnless(c[0]==6.,"c has wrong first item")
1115     self.failUnless(c[1]==12.,"c has wrong second item")
1116     b=5.*a
1117     self.failUnless(isinstance(b,ArithmeticTuple),"b is not an instance of ArithmeticTuple")
1118     self.failUnless(len(b)==2,"b has wrong length")
1119     self.failUnless(b[0]==5.,"b has wrong first item")
1120     self.failUnless(b[1]==10.,"b has wrong second item")
1121     a+=ArithmeticTuple(3.,4.)
1122     self.failUnless(a[0]==4.,"wrong first item of inplace update")
1123     self.failUnless(a[1]==6.,"wrong second item of inplace update")
1124 ksteube 1312
1125 gross 1331
1126    
1127 gross 855 class Test_pdetools(Test_pdetools_noLumping):
1128 gross 1072 def testProjector_rank0_fast_reduced(self):
1129 gross 855 x=ContinuousFunction(self.domain).getX()
1130     h=Lsup(self.domain.getSize())
1131 gross 1072 p=Projector(self.domain,reduce=True,fast=True)
1132 gross 855 td_ref=x[0]
1133     td=p(td_ref.interpolate(Function(self.domain)))
1134     self.failUnless(Lsup(td-td_ref)<Lsup(td_ref)*h,"value wrong")
1135    
1136 gross 1072 def testProjector_rank1_fast_reduced(self):
1137 gross 855 x=ContinuousFunction(self.domain).getX()
1138     h=Lsup(self.domain.getSize())
1139 gross 1072 p=Projector(self.domain,reduce=True,fast=True)
1140 gross 855 td_ref=x
1141 jfenwick 3259 res=td_ref.interpolate(Function(self.domain))
1142     td=p(res)
1143 gross 855 self.failUnless(Lsup(td-td_ref)<Lsup(td_ref)*h,"value wrong")
1144    
1145 gross 1072 def testProjector_rank2_fast_reduced(self):
1146 gross 855 x=ContinuousFunction(self.domain).getX()
1147     h=Lsup(self.domain.getSize())
1148 gross 1072 p=Projector(self.domain,reduce=True,fast=True)
1149 gross 855 td_ref=[[11.,12.],[21,22.]]*(x[0]+x[1])
1150     td=p(td_ref.interpolate(Function(self.domain)))
1151     self.failUnless(Lsup(td-td_ref)<Lsup(td_ref)*h,"value wrong")
1152    
1153 gross 1072 def testProjector_rank3_fast_reduced(self):
1154 gross 855 x=ContinuousFunction(self.domain).getX()
1155     h=Lsup(self.domain.getSize())
1156 gross 1072 p=Projector(self.domain,reduce=True,fast=True)
1157 gross 855 td_ref=[[[111.,112.],[121,122.]],[[211.,212.],[221,222.]]]*(x[0]+x[1])
1158     td=p(td_ref.interpolate(Function(self.domain)))
1159     self.failUnless(Lsup(td-td_ref)<Lsup(td_ref)*h,"value wrong")
1160    
1161 gross 1072 def testProjector_rank4_fast_reduced(self):
1162 gross 855 x=ContinuousFunction(self.domain).getX()
1163     h=Lsup(self.domain.getSize())
1164 gross 1072 p=Projector(self.domain,reduce=True,fast=True)
1165 gross 855 td_ref=[[[[1111.,1112.],[1121,1122.]],[[1211.,1212.],[1221,1222.]]],[[[2111.,2112.],[2121,2122.]],[[2211.,2212.],[2221,2222.]]]]*(x[0]+x[1])
1166     td=p(td_ref.interpolate(Function(self.domain)))
1167     self.failUnless(Lsup(td-td_ref)<Lsup(td_ref)*h,"value wrong")
1168 gross 1072
1169     def testProjector_rank0_fast_reduced_with_reduced_input(self):
1170     x=ContinuousFunction(self.domain).getX()
1171     h=Lsup(self.domain.getSize())
1172     p=Projector(self.domain,reduce=True,fast=True)
1173     td_ref=1.
1174     td=p(Data(td_ref,ReducedFunction(self.domain)))
1175     self.failUnless(Lsup(td-td_ref)<Lsup(td_ref)*h,"value wrong")
1176    
1177     def testProjector_rank1_fast_reduced_with_reduced_input(self):
1178     x=ContinuousFunction(self.domain).getX()
1179     h=Lsup(self.domain.getSize())
1180     p=Projector(self.domain,reduce=True,fast=True)
1181 jfenwick 2455 td_ref=numpy.array([1.,2.,3.])
1182 gross 1072 td=p(Data(td_ref,ReducedFunction(self.domain)))
1183     self.failUnless(Lsup(td-td_ref)<Lsup(td_ref)*h,"value wrong")
1184    
1185     def testProjector_rank2_fast_reduced_with_reduced_input(self):
1186     x=ContinuousFunction(self.domain).getX()
1187     h=Lsup(self.domain.getSize())
1188     p=Projector(self.domain,reduce=True,fast=True)
1189 jfenwick 2455 td_ref=numpy.array([[11.,12.],[21,22.]])
1190 gross 1072 td=p(Data(td_ref,ReducedFunction(self.domain)))
1191     self.failUnless(Lsup(td-td_ref)<Lsup(td_ref)*h,"value wrong")
1192    
1193     def testProjector_rank3_fast_reduced_with_reduced_input(self):
1194     x=ContinuousFunction(self.domain).getX()
1195     h=Lsup(self.domain.getSize())
1196     p=Projector(self.domain,reduce=True,fast=True)
1197 jfenwick 2455 td_ref=numpy.array([[[111.,112.],[121,122.]],[[211.,212.],[221,222.]]])
1198 gross 1072 td=p(Data(td_ref,ReducedFunction(self.domain)))
1199     self.failUnless(Lsup(td-td_ref)<Lsup(td_ref)*h,"value wrong")
1200    
1201     def testProjector_rank4_fast_reduced_with_reduced_input(self):
1202     x=ContinuousFunction(self.domain).getX()
1203     h=Lsup(self.domain.getSize())
1204     p=Projector(self.domain,reduce=True,fast=True)
1205 jfenwick 2455 td_ref=numpy.array([[[[1111.,1112.],[1121,1122.]],[[1211.,1212.],[1221,1222.]]],[[[2111.,2112.],[2121,2122.]],[[2211.,2212.],[2221,2222.]]]])
1206 gross 1072 td=p(Data(td_ref,ReducedFunction(self.domain)))
1207     self.failUnless(Lsup(td-td_ref)<Lsup(td_ref)*h,"value wrong")
1208    

  ViewVC Help
Powered by ViewVC 1.1.26